@agentuity/cli 2.0.12 → 2.0.14

package/src/cmd/project/random-name.ts

@@ -0,0 +1,152 @@
+/**
+ * Generates project-derived suggestions for resource names (DB / S3 bucket).
+ *
+ * The CLI shows these as a dim "press Enter to use ..." default in the create flow.
+ * If the user presses Enter, the suggestion is sent to the server. Otherwise the
+ * server is responsible for assigning a name when none is provided.
+ *
+ * Both suggestions are validated against the same rules the server enforces
+ * (`validateBucketName` / `validateDatabaseName` from `@agentuity/server`) so the
+ * happy path can never produce an invalid suggestion.
+ */
+import { validateBucketName, validateDatabaseName } from '@agentuity/server';
+
+const BUCKET_MAX = 63;
+const BUCKET_MIN = 3;
+const DB_MAX = 63;
+
+/** 3 lowercase alphanumeric chars, e.g. "k7p". */
+function shortSuffix(): string {
+	// toString(36) yields [0-9a-z]; slice 3 chars after the "0." prefix.
+	const s = Math.random().toString(36).slice(2, 5);
+	// Pad in the (extremely unlikely) case the slice is shorter than 3 chars.
+	return s.length === 3 ? s : (s + '000').slice(0, 3);
+}
+
+/**
+ * Sanitize a project name into the bucket-name alphabet:
+ * - lowercase
+ * - spaces / underscores / dots → hyphens
+ * - drop anything else
+ * - collapse and trim hyphens
+ * - strip reserved prefixes (`agentuity*`, `ag-*`, `ago-*`, `xn--`)
+ */
+function sanitizeForBucket(name: string): string {
+	let out = name
+		.toLowerCase()
+		.trim()
+		.replace(/[\s_.]+/g, '-')
+		.replace(/[^a-z0-9-]/g, '')
+		.replace(/-+/g, '-')
+		.replace(/^-+|-+$/g, '');
+
+	// Strip reserved prefixes (rules from validateBucketName).
+	while (
+		out.startsWith('agentuity') ||
+		out.startsWith('ag-') ||
+		out.startsWith('ago-') ||
+		out.startsWith('xn--')
+	) {
+		if (out.startsWith('agentuity')) out = out.slice('agentuity'.length);
+		else if (out.startsWith('ago-')) out = out.slice('ago-'.length);
+		else if (out.startsWith('ag-')) out = out.slice('ag-'.length);
+		else if (out.startsWith('xn--')) out = out.slice('xn--'.length);
+		out = out.replace(/^-+/, '');
+	}
+	return out;
+}
+
+/**
+ * Sanitize a project name into the database-name alphabet:
+ * - lowercase
+ * - non `[a-z0-9_]` → `_`
+ * - collapse and trim underscores
+ * - ensure it starts with a letter or underscore (prepend `p_` otherwise)
+ * - strip reserved `pg_` prefix
+ */
+function sanitizeForDatabase(name: string): string {
+	let out = name
+		.toLowerCase()
+		.trim()
+		.replace(/[^a-z0-9_]+/g, '_')
+		.replace(/_+/g, '_')
+		.replace(/^_+|_+$/g, '');
+
+	if (!/^[a-z_]/.test(out)) {
+		out = out.length > 0 ? `p_${out}` : '';
+	}
+	while (out.startsWith('pg_')) {
+		out = out.slice(3).replace(/^_+/, '');
+		if (!/^[a-z_]/.test(out) && out.length > 0) out = `p_${out}`;
+	}
+	return out;
+}
+
+/**
+ * Truncate so the final string (`<base>-<suffixWithDash>`) fits within `max` chars
+ * while keeping the suffix intact and not ending on a hyphen.
+ */
+function truncateBaseHyphen(base: string, suffixWithDash: string, max: number): string {
+	const room = max - suffixWithDash.length;
+	if (room <= 0) return '';
+	let out = base.slice(0, room);
+	out = out.replace(/-+$/, '');
+	return out;
+}
+
+/** Same as `truncateBaseHyphen` but for underscore-joined names (database). */
+function truncateBaseUnderscore(base: string, suffixWithUnderscore: string, max: number): string {
+	const room = max - suffixWithUnderscore.length;
+	if (room <= 0) return '';
+	let out = base.slice(0, room);
+	out = out.replace(/_+$/, '');
+	return out;
+}
+
+/**
+ * Generate a suggested S3 bucket name derived from the project name.
+ * Format: `<sanitized-project>-storage-<3char>` (≤ 63 chars).
+ *
+ * Falls back to `bucket-<3char><3char>` if the project name produces nothing usable.
+ * Always returns a value that passes `validateBucketName`.
+ */
+export function suggestBucketName(projectName: string): string {
+	const sanitized = sanitizeForBucket(projectName);
+
+	// Try a few times in case sanitization + suffix happens to land on something invalid.
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const suffix = `-storage-${shortSuffix()}`;
+		const base = truncateBaseHyphen(sanitized, suffix, BUCKET_MAX);
+		const candidate = base.length > 0 ? `${base}${suffix}` : `bucket${suffix}`;
+		if (candidate.length >= BUCKET_MIN && validateBucketName(candidate).valid) {
+			return candidate;
+		}
+	}
+
+	// Pure fallback: short, always-valid generic name.
+	const fallback = `bucket-${shortSuffix()}${shortSuffix()}`;
+	return validateBucketName(fallback).valid ? fallback : `bucket-${shortSuffix()}aaa`;
+}
+
+/**
+ * Generate a suggested PostgreSQL database name derived from the project name.
+ * Format: `<sanitized-project>_db_<3char>` (≤ 63 chars).
+ *
+ * Falls back to `db_<3char><3char>` if the project name produces nothing usable.
+ * Always returns a value that passes `validateDatabaseName`.
+ */
+export function suggestDatabaseName(projectName: string): string {
+	const sanitized = sanitizeForDatabase(projectName);
+
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const suffix = `_db_${shortSuffix()}`;
+		const base = truncateBaseUnderscore(sanitized, suffix, DB_MAX);
+		const candidate = base.length > 0 ? `${base}${suffix}` : `db${suffix}`;
+		if (validateDatabaseName(candidate).valid) {
+			return candidate;
+		}
+	}
+
+	const fallback = `db_${shortSuffix()}${shortSuffix()}`;
+	return validateDatabaseName(fallback).valid ? fallback : `db_${shortSuffix()}aaa`;
+}

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

@@ -32,8 +32,13 @@ import { createPrompt, note } from '../../tui';
 import type { AuthData, Config } from '../../types';
 import { getGithubBotIdentity } from '../git/api';
 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;
@@ -281,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 =
@@ -306,13 +311,62 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 	}
 
 	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({
@@ -330,212 +384,174 @@ 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;
+				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);
 			}
 		}
+
+		// 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];
+		}
 	}
 
 	let projectId: string | undefined;
@@ -691,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 {