@agentuity/cli 2.0.11 → 2.0.13

package/dist/cmd/project/template-flow.js

@@ -11,11 +11,13 @@ import { playSound } from '../../sound';
 import * as tui from '../../tui';
 import { createPrompt, note } from '../../tui';
 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 } 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}$/;
 export async function runCreateFlow(options) {
-    const { projectName: initialProjectName, dir: targetDir, template: initialTemplate, templateDir, templateBranch, skipPrompts, logger, auth, config, orgId: selectedOrgId, region, apiClient, domains, database: databaseOption, storage: storageOption, enableAuth: enableAuthOption, } = options;
+    const { projectName: initialProjectName, dir: targetDir, template: initialTemplate, templateDir, templateBranch, skipPrompts, logger, auth, config, orgId: selectedOrgId, region, apiClient, domains, database: databaseOption, storage: storageOption, } = options;
     const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
     const isInteractive = !skipPrompts && !isHeadless;
     // Fetch available templates
@@ -188,7 +190,7 @@ export async function runCreateFlow(options) {
             error: 'Project setup completed with errors',
         };
     }
-    // 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 = (databaseOption !== undefined && databaseOption.toLowerCase() !== 'skip') ||
@@ -204,17 +206,57 @@ export async function runCreateFlow(options) {
         logger.fatal('Cannot provision database/storage without being authenticated and registering the project.\n' +
             'Remove --no-register or omit --database/--storage flags.', ErrorCode.VALIDATION_FAILED);
     }
-    // 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)
+        // 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 = [];
+            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({
+                    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;
-        const needResources = isInteractive ||
-            (databaseOption && databaseOption !== 'skip' && databaseOption !== 'new') ||
-            (storageOption && storageOption !== 'skip' && storageOption !== 'new');
+        const needResources = (isInteractive && (wantDb || wantStorage)) ||
+            (databaseOption !== undefined &&
+                dbFlagAction !== 'Create New' &&
+                dbFlagAction !== 'Skip') ||
+            (storageOption !== undefined &&
+                storageFlagAction !== 'Create New' &&
+                storageFlagAction !== 'Skip');
         if (needResources) {
             resources = await tui.spinner({
                 message: 'Fetching resources',
@@ -227,301 +269,162 @@ export async function runCreateFlow(options) {
             logger.debug(`Resources for org ${orgId} in region ${region}: ${resources.db.length} databases, ${resources.s3.length} storage buckets`);
             logger.debug(`Database names: ${resources.db.map((d) => d.name).join(', ') || '(none)'}`);
             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;
-        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';
+            // 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 {
-                // 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;
+            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) {
-            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;
-        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);
+        // === 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({
+                        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';
                 }
-                s3_action = storageOption;
-            }
-        }
-        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) => 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];
             }
-        }
-        // Process storage action
-        switch (s3_action) {
-            case 'Create New': {
-                let bucketName;
-                let bucketDescription;
-                // Only prompt for name/description in interactive mode
+            if (dbAction === 'Create New') {
+                let dbName;
+                let dbDescription;
                 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) => {
                             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) {
+                if (created[0]?.env)
                     Object.assign(resourceEnvVars, created[0].env);
-                }
-                break;
             }
-            case 'Skip': {
-                break;
+            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({
+                        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;
-                let dbDescription;
-                // Only prompt for name/description in interactive mode
+            if (s3Action === 'Create New') {
+                let bucketName;
+                let bucketDescription;
                 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) => {
                             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) {
+                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;
-    let authDatabaseUrl;
-    // 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;
             }
-            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);
-                }
-            }
-        }
-        // 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');
+            else if (s3Action && s3Action !== 'Skip') {
+                const selectedBucket = resources?.s3.find((b) => b.bucket_name === s3Action);
+                if (selectedBucket?.env)
+                    Object.assign(resourceEnvVars, selectedBucket.env);
             }
         }
-        // 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) => val === ''
+                    ? 'Domain is required (or go back and uncheck Custom Domain)'
+                    : DOMAIN_REGEX.test(val)
+                        ? true
+                        : 'Invalid domain',
             });
+            if (customDns)
+                _domains = [customDns];
         }
     }
     let projectId;
@@ -558,24 +461,9 @@ export async function runCreateFlow(options) {
                 });
             },
         });
-        // 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
         if (projectId) {
@@ -659,10 +547,6 @@ export async function runCreateFlow(options) {
             await promptForDNS(projectId, _domains, cloudRegion, config);
         }
     }
-    // Print auth integration examples if auth was enabled (skip for auth template - already set up)
-    if (authEnabled && !templateHasAuth) {
-        printIntegrationExamples();
-    }
     return {
         projectId,
         orgId,
@@ -676,6 +560,27 @@ export async function runCreateFlow(options) {
         error: setupResult.success ? undefined : 'Project setup completed with errors',
     };
 }
+/**
+ * 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, _kind) {
+    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