@agentuity/cli 2.0.12 → 2.0.13

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 {

package/src/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync } from 'node:fs';
-import { chmod, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { basename, extname, join, normalize, resolve } from 'node:path';
+import { basename, dirname, extname, join, normalize, resolve } from 'node:path';
 import { type Logger, StructuredError } from '@agentuity/core';
 import {
 	type BuildMetadata,
@@ -15,6 +15,7 @@ import { z } from 'zod';
 import { clearProfileCache } from './cache';
 import { getCatalystUrl } from './catalyst';
 import { readEnvFile, writeEnvFile } from './env-util';
+import { ErrorCode } from './errors';
 import {
 	deleteAuthFromKeychain,
 	getAuthFromKeychain,
@@ -151,10 +152,12 @@ function expandTilde(path: string): string {
 let cachedConfig: Config | null | undefined;
 // Track the resolved config path so saveConfig writes back to the same file
 let cachedConfigPath: string | undefined;
+const loadedProjectConfigPaths = new Map<string, string>();
 
 export function resetConfigCache(): void {
 	cachedConfig = undefined;
 	cachedConfigPath = undefined;
+	loadedProjectConfigPaths.clear();
 }
 
 export async function loadConfig(
@@ -600,31 +603,76 @@ export function generateYAMLTemplate(name: string): string {
 	return lines.join('\n');
 }
 
-export const ProjectConfigNotFoundException = StructuredError('ProjectConfigNotFoundException');
+export const ProjectConfigNotFoundException = StructuredError('ProjectConfigNotFoundException')<{
+	code?: ErrorCode;
+	configPath?: string;
+	explicit?: boolean;
+}>();
 
 type ProjectConfig = z.infer<typeof ProjectSchema>;
 
-export async function loadProjectConfig(
-	dir: string,
+export type ResolvedProjectConfigPaths = {
+	projectDir: string;
+	configPath: string;
+	explicitConfigFile: boolean;
+};
+
+export async function resolveProjectConfigPaths(
+	path: string,
 	config?: Config | null
-): Promise<ProjectConfig> {
-	let configPath = join(dir, 'agentuity.json');
+): Promise<ResolvedProjectConfigPaths> {
+	const resolvedPath = resolve(expandTilde(path));
+	const pathStats = await stat(resolvedPath).catch(() => null);
+	const isExplicitJsonFile =
+		(pathStats?.isFile() || pathStats === null) && extname(resolvedPath) === '.json';
+
+	if (isExplicitJsonFile) {
+		return {
+			projectDir: dirname(resolvedPath),
+			configPath: resolvedPath,
+			explicitConfigFile: true,
+		};
+	}
+
+	const projectDir = resolvedPath;
+	let configPath = join(projectDir, 'agentuity.json');
 
-	// Check for profile-specific override if config is provided
 	if (config?.name) {
-		const profileConfigPath = join(dir, `agentuity.${config.name}.json`);
+		const profileConfigPath = join(projectDir, `agentuity.${config.name}.json`);
 		if (await Bun.file(profileConfigPath).exists()) {
 			configPath = profileConfigPath;
 		}
 	}
 
+	return {
+		projectDir,
+		configPath,
+		explicitConfigFile: false,
+	};
+}
+
+export async function loadProjectConfig(
+	dir: string,
+	config?: Config | null
+): Promise<ProjectConfig> {
+	const { projectDir, configPath, explicitConfigFile } = await resolveProjectConfigPaths(
+		dir,
+		config
+	);
+
 	const file = Bun.file(configPath);
 	if (!(await file.exists())) {
 		// TODO: check to see if a valid project that was created unauthenticated
 		// and then if so:
 		// 1. if authentication, offer to import the project
 		// 2. tell them that they need to login to use the command and import the project
-		throw new ProjectConfigNotFoundException({ message: 'project config not found' });
+		throw new ProjectConfigNotFoundException({
+			message: explicitConfigFile
+				? `Project config not found at ${configPath}`
+				: 'project config not found',
+			configPath,
+			explicit: explicitConfigFile,
+		});
 	}
 	const text = await file.text();
 	const parsedConfig = parseJSONC(text);
@@ -637,6 +685,7 @@ export async function loadProjectConfig(
 		}
 		process.exit(1);
 	}
+	loadedProjectConfigPaths.set(projectDir, configPath);
 	return result.data;
 }
 
@@ -717,18 +766,19 @@ export async function updateProjectConfig(
 	updates: Partial<z.infer<typeof ProjectSchema>>,
 	config?: Config | null
 ): Promise<void> {
-	let configPath = join(dir, 'agentuity.json');
-
-	if (config?.name) {
-		const profileConfigPath = join(dir, `agentuity.${config.name}.json`);
-		if (await Bun.file(profileConfigPath).exists()) {
-			configPath = profileConfigPath;
-		}
-	}
+	const resolved = await resolveProjectConfigPaths(dir, config);
+	const configPath = resolved.explicitConfigFile
+		? resolved.configPath
+		: (loadedProjectConfigPaths.get(resolved.projectDir) ?? resolved.configPath);
 
 	const file = Bun.file(configPath);
 	if (!(await file.exists())) {
-		throw new Error(`Project config not found at ${configPath}`);
+		throw new ProjectConfigNotFoundException({
+			code: ErrorCode.PROJECT_NOT_FOUND,
+			message: `Project config not found at ${configPath}`,
+			configPath: resolved.configPath,
+			explicit: resolved.explicitConfigFile,
+		});
 	}
 
 	const text = await file.text();