vibefast-cli 0.6.2 → 0.7.1

package/src/commands/add.ts

@@ -5,8 +5,23 @@ import { validateSignature, validateTarget } from '../core/validate.js';
 import { getToken, getDeviceInfo } from '../core/auth.js';
 import { fetchRecipe, downloadZip } from '../core/http.js';
 import { addEntry, getEntry, FileEntry } from '../core/journal.js';
-import { copyTree, readFileContent } from '../core/fsx.js';
-import { insertNavLinkNative, insertNavLinkWeb } from '../core/codemod.js';
+import { copyTree, readFileContent, exists } from '../core/fsx.js';
+import { addEnvVars, hasEnvKey, type EnvVar as CoreEnvVar } from '../core/env.js';
+import {
+  insertEnvSnippets,
+  insertNavLinkNative,
+  insertNavLinkWeb,
+  ENV_BUILD_TIME_ENV_END,
+  ENV_BUILD_TIME_ENV_START,
+  ENV_BUILD_TIME_SCHEMA_END,
+  ENV_BUILD_TIME_SCHEMA_START,
+  ENV_CLIENT_ENV_END,
+  ENV_CLIENT_ENV_START,
+  ENV_CLIENT_SCHEMA_END,
+  ENV_CLIENT_SCHEMA_START,
+  ENV_CONSTANTS_END,
+  ENV_CONSTANTS_START,
+} from '../core/codemod.js';
 import { join, resolve } from 'path';
 import { ensureWithinBase } from '../core/pathGuard.js';
 import { extractZipSafe } from '../core/archive.js';
@@ -16,6 +31,22 @@ import { detectTarget } from '../core/detect.js';
 import { withSpinner } from '../core/spinner.js';
 import { showCommandHint } from '../core/errors.js';
 
+interface EnvSchema {
+  constants?: string[];
+  client?: {
+    schema?: string[];
+    env?: string[];
+  };
+  buildTime?: {
+    schema?: string[];
+    env?: string[];
+  };
+}
+
+interface RecipeConfiguration {
+  env?: EnvSchema;
+}
+
 interface RecipeManifest {
   name: string;
   version: string;
@@ -32,6 +63,9 @@ interface RecipeManifest {
     description: string;
     example: string;
     link?: string;
+    file?: string;
+    value?: string;
+    required?: boolean;
   }>;
   manualSteps?: Array<{
     title: string;
@@ -43,12 +77,13 @@ interface RecipeManifest {
   postInstall?: {
     message?: string;
   };
+  configuration?: RecipeConfiguration;
 }
 
 export const addCommand = new Command('add')
   .description('Add VibeFast features, UI components, or integrations')
   .argument('[feature]', 'Feature name to install (optional - will show interactive menu if omitted)')
-  .option('--target <target>', 'Target platform (native or web)', 'native')
+  .option('--target <target>', 'Target platform (native or web)')
   .option('--dry-run', 'Preview changes without applying')
   .option('--force', 'Overwrite existing files without asking')
   .option('--yes', 'Answer yes to all prompts (for automation)')
@@ -186,8 +221,180 @@ async function installFeature(feature: string, options: any, paths: any) {
           log.error('Could not auto-detect target (native/web)');
           log.info('Please specify with --target native or --target web');
           process.exit(1);
-        }
+  }
+}
+
+type EnvGroup = {
+  path: string;
+  relativePath: string;
+  vars: NonNullable<RecipeManifest['env']>;
+};
+
+function groupEnvVars(env: RecipeManifest['env'] | undefined, cwd: string): EnvGroup[] {
+  if (!env?.length) {
+    return [];
+  }
+
+  const groups = new Map<string, EnvGroup>();
+
+  for (const envVar of env) {
+    const relativePath = envVar.file ?? 'apps/native/.env.local';
+    const resolvedPath = resolve(cwd, relativePath);
+    const existing = groups.get(resolvedPath);
+
+    if (existing) {
+      existing.vars.push(envVar);
+    } else {
+      groups.set(resolvedPath, {
+        path: resolvedPath,
+        relativePath,
+        vars: [envVar],
+      });
+    }
+  }
+
+  return [...groups.values()];
+}
+
+async function ensureEnvVarsForGroups(
+  envGroups: EnvGroup[],
+  options: any,
+): Promise<Array<{ relativePath: string; added: string[] }>> {
+  const summary: Array<{ relativePath: string; added: string[] }> = [];
+
+  for (const group of envGroups) {
+    const vars: CoreEnvVar[] = group.vars.map(envVar => ({
+      key: envVar.key,
+      value: envVar.value ?? envVar.example ?? '',
+      comment: envVar.description?.replace(/\s+/g, ' ').trim() || undefined,
+    }));
+
+    const result = await addEnvVars(group.path, vars, { dryRun: options.dryRun });
+
+    if (result.added.length > 0) {
+      summary.push({
+        relativePath: group.relativePath,
+        added: result.added,
+      });
+    }
+  }
+
+  return summary;
+}
+
+async function reportEnvStatus(envGroups: EnvGroup[], options: any): Promise<string[]> {
+  const attention: string[] = [];
+
+  for (const group of envGroups) {
+    const missing: typeof group.vars = [];
+    const existing: string[] = [];
+
+    for (const envVar of group.vars) {
+      const hasKey = await hasEnvKey(group.path, envVar.key);
+      if (hasKey) {
+        existing.push(envVar.key);
+      } else {
+        missing.push(envVar);
       }
+    }
+
+    if (missing.length > 0) {
+      log.plain('');
+      log.warn(`⚠ REQUIRED ENVIRONMENT VARIABLES (${group.relativePath}):`);
+      log.plain('');
+
+      missing.forEach(envVar => {
+        log.plain(`  ${envVar.key}`);
+        log.plain(`    ${envVar.description}`);
+        log.plain(`    Example: ${envVar.example}`);
+        if (envVar.link) {
+          log.plain(`    Get it: ${envVar.link}`);
+        }
+        log.plain('');
+        attention.push(`Add ${envVar.key} to ${group.relativePath}`);
+      });
+
+      log.info(`Add these to ${group.relativePath}`);
+      log.plain('');
+    }
+
+    if (existing.length > 0) {
+      log.success(`✓ Already configured (${group.relativePath}): ${existing.join(', ')}`);
+      log.plain('');
+    }
+  }
+
+  return attention;
+}
+
+async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConfig: EnvSchema, options: any) {
+  const envPath = join(paths.cwd, 'apps', 'native', 'env.js');
+
+  if (!(await exists(envPath))) {
+    return;
+  }
+
+  const suffix = options.dryRun ? ' (dry run)' : '';
+
+  if (envConfig.constants?.length) {
+    const inserted = await insertEnvSnippets(envPath, ENV_CONSTANTS_START, ENV_CONSTANTS_END, envConfig.constants, options);
+    if (inserted) {
+      log.info(`Updated env.js constants${suffix}.`);
+    }
+  }
+
+  if (envConfig.client?.schema?.length) {
+    const inserted = await insertEnvSnippets(
+      envPath,
+      ENV_CLIENT_SCHEMA_START,
+      ENV_CLIENT_SCHEMA_END,
+      envConfig.client.schema,
+      options,
+    );
+    if (inserted) {
+      log.info(`Updated env.js client schema definitions${suffix}.`);
+    }
+  }
+
+  if (envConfig.client?.env?.length) {
+    const inserted = await insertEnvSnippets(
+      envPath,
+      ENV_CLIENT_ENV_START,
+      ENV_CLIENT_ENV_END,
+      envConfig.client.env,
+      options,
+    );
+    if (inserted) {
+      log.info(`Updated env.js client env exports${suffix}.`);
+    }
+  }
+
+  if (envConfig.buildTime?.schema?.length) {
+    const inserted = await insertEnvSnippets(
+      envPath,
+      ENV_BUILD_TIME_SCHEMA_START,
+      ENV_BUILD_TIME_SCHEMA_END,
+      envConfig.buildTime.schema,
+      options,
+    );
+    if (inserted) {
+      log.info(`Updated env.js build-time schema${suffix}.`);
+    }
+  }
+
+  if (envConfig.buildTime?.env?.length) {
+    const inserted = await insertEnvSnippets(
+      envPath,
+      ENV_BUILD_TIME_ENV_START,
+      ENV_BUILD_TIME_ENV_END,
+      envConfig.buildTime.env,
+      options,
+    );
+    if (inserted) {
+      log.info(`Updated env.js build-time exports${suffix}.`);
+    }
+  }
+}
 
       // Validate setup
       const config = await validateSignature(paths.signatureFile);
@@ -348,6 +555,8 @@ async function installFeature(feature: string, options: any, paths: any) {
       }
 
       log.info(`Installing ${manifest.name} v${manifest.version}...`);
+      const envGroups = groupEnvVars(manifest.env, paths.cwd);
+      let envAttention: string[] = [];
 
       // Copy files with interactive confirmation
       const copiedFiles: string[] = [];
@@ -561,6 +770,10 @@ async function installFeature(feature: string, options: any, paths: any) {
         );
       }
 
+      if (manifest.configuration?.env) {
+        await applyEnvConfiguration(paths, manifest.configuration.env, options);
+      }
+
       // Show manual steps with smart detection
       if (manifest.manualSteps && !options.dryRun) {
         const { readFileContent, exists } = await import('../core/fsx.js');
@@ -625,48 +838,21 @@ async function installFeature(feature: string, options: any, paths: any) {
         }
       }
       
-      // Show environment variables with smart detection
-      if (manifest.env && !options.dryRun) {
-        const { hasEnvKey } = await import('../core/env.js');
-        const { join } = await import('path');
-        const envPath = join(paths.cwd, '.env');
-        
-        const missing: typeof manifest.env = [];
-        const existing: string[] = [];
-        
-        // Check which vars already exist
-        for (const envVar of manifest.env) {
-          const exists = await hasEnvKey(envPath, envVar.key);
-          if (exists) {
-            existing.push(envVar.key);
-          } else {
-            missing.push(envVar);
-          }
-        }
-        
-        if (missing.length > 0) {
-          log.plain('');
-          log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
+      if (envGroups.length > 0) {
+        const additions = await ensureEnvVarsForGroups(envGroups, options);
+
+        if (additions.length > 0) {
           log.plain('');
-          
-          missing.forEach(envVar => {
-            log.plain(`  ${envVar.key}`);
-            log.plain(`    ${envVar.description}`);
-            log.plain(`    Example: ${envVar.example}`);
-            if (envVar.link) {
-              log.plain(`    Get it: ${envVar.link}`);
-            }
-            log.plain('');
+          const suffix = options.dryRun ? ' (dry run)' : '';
+          log.info(`✅ Placeholder environment variables added${suffix}:`);
+          additions.forEach(({ relativePath, added }) => {
+            log.plain(`  • ${relativePath}: ${added.join(', ')}`);
           });
-          
-          log.info('Add these to your .env file');
-          log.plain('');
-        }
-        
-        if (existing.length > 0) {
-          log.success(`✓ Already configured: ${existing.join(', ')}`);
+          log.info('Update those files with your real API keys or secrets.');
           log.plain('');
         }
+
+        envAttention = await reportEnvStatus(envGroups, options);
       }
       
       // Post-install message
@@ -679,18 +865,8 @@ async function installFeature(feature: string, options: any, paths: any) {
       if (!options.dryRun) {
         const needsAttention: string[] = [];
         
-        // Check env vars
-        if (manifest.env) {
-          const { hasEnvKey } = await import('../core/env.js');
-          const { join } = await import('path');
-          const envPath = join(paths.cwd, '.env');
-          
-          for (const envVar of manifest.env) {
-            const exists = await hasEnvKey(envPath, envVar.key);
-            if (!exists) {
-              needsAttention.push(`Add ${envVar.key} to .env`);
-            }
-          }
+        if (envGroups.length > 0 && envAttention.length > 0) {
+          needsAttention.push(...envAttention);
         }
         
         // Check manual steps

package/src/commands/init.ts

@@ -21,7 +21,7 @@ interface InitOptions {
 export const initCommand = new Command('init')
   .description('Initialize a new VibeFast project')
   .option('--license <key>', 'Your VibeFast license key')
-  .option('--branch <branch>', 'Branch to clone (clean or main)')
+  .option('--branch <branch>', 'Branch to clone (clean or main, default: clean)')
   .option('--yes', 'Skip all prompts and use defaults')
   .option('--skip-install', 'Skip dependency installation')
   .action(async (options: InitOptions) => {
@@ -93,8 +93,12 @@ export const initCommand = new Command('init')
         log.plain('');
       }
       
-      // Always use clean branch for cloning
-      const branch = 'clean';
+      // Validate branch option and default to clean
+      const branch = options.branch === 'main' ? 'main' : 'clean';
+      if (options.branch && options.branch !== 'clean' && options.branch !== 'main') {
+        log.error('Invalid branch. Use "clean" or "main".');
+        process.exit(1);
+      }
 
       // Step 1.5: Choose platforms
       let platforms: string[] = ['native', 'web'];
@@ -146,6 +150,15 @@ export const initCommand = new Command('init')
           'Project name: '
         ) || defaultName;
       }
+      projectName = (projectName || defaultName).trim();
+      if (!projectName) {
+        projectName = defaultName;
+      }
+      
+      if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
+        log.error('Project name must use only letters, numbers, hyphens, and underscores.');
+        process.exit(1);
+      }
 
       // Validate project name
       if (existsSync(projectName)) {
@@ -165,13 +178,13 @@ export const initCommand = new Command('init')
       const repoUrl = 'https://github.com/mzafarr/vibefast-pro.git';
       
       await withSpinner(
-        `Cloning VibeFast monorepo (clean starter)...`,
+        `Cloning VibeFast monorepo (${branch} branch)...`,
         async () => {
           const git = simpleGit();
           const cloneOptions = ['--depth', '1'];
           
-          // Always use clean branch
-          cloneOptions.unshift('--branch', 'clean', '--single-branch');
+          // Use selected branch (default: clean)
+          cloneOptions.unshift('--branch', branch, '--single-branch');
           
           try {
             await git.clone(repoUrl, projectName, cloneOptions);
@@ -430,109 +443,112 @@ export const initCommand = new Command('init')
         log.plain('');
         
         // We need to be in the project directory for feature installation
+        const originalCwd = process.cwd();
         process.chdir(projectPath);
         
-        for (const featureName of selectedFeatures) {
-          try {
-            log.plain('');
-            log.plain('━'.repeat(60));
-            log.info(`Installing ${featureName}...`);
-            log.plain('');
-            
-            // Import and use the add command logic
-            const { getToken } = await import('../core/auth.js');
-            const { fetchRecipe, downloadZip } = await import('../core/http.js');
-            const { extractZipSafe } = await import('../core/archive.js');
-            const { copyTree, readFileContent } = await import('../core/fsx.js');
-            const { addEntry } = await import('../core/journal.js');
-            const { hashFiles } = await import('../core/hash.js');
-            const { insertNavLinkNative } = await import('../core/codemod.js');
-            const { getDeviceInfo } = await import('../core/auth.js');
-            const { validateSignature } = await import('../core/validate.js');
-            const { getPaths } = await import('../core/paths.js');
-            
-            const paths = getPaths();
-            const token = await getToken();
-            const device = await getDeviceInfo();
-            const config = await validateSignature(paths.signatureFile);
-            
-            // Fetch recipe
-            const response = await fetchRecipe({
-              token: token!,
-              device,
-              feature: featureName,
-              target: 'native',
-              starter: { name: config.name, version: config.version },
-            });
-            
-            if (!response.ok || (!response.signedUrl && !response.zipData)) {
-              log.warn(`⚠ Could not fetch ${featureName}: ${response.error || 'Unknown error'}`);
+        try {
+          for (const featureName of selectedFeatures) {
+            try {
+              log.plain('');
+              log.plain('━'.repeat(60));
+              log.info(`Installing ${featureName}...`);
+              log.plain('');
+              
+              // Import and use the add command logic
+              const { getToken } = await import('../core/auth.js');
+              const { fetchRecipe, downloadZip } = await import('../core/http.js');
+              const { extractZipSafe } = await import('../core/archive.js');
+              const { copyTree, readFileContent } = await import('../core/fsx.js');
+              const { addEntry } = await import('../core/journal.js');
+              const { hashFiles } = await import('../core/hash.js');
+              const { insertNavLinkNative } = await import('../core/codemod.js');
+              const { getDeviceInfo } = await import('../core/auth.js');
+              const { validateSignature } = await import('../core/validate.js');
+              const { getPaths } = await import('../core/paths.js');
+              
+              const paths = getPaths();
+              const token = await getToken();
+              const device = await getDeviceInfo();
+              const config = await validateSignature(paths.signatureFile);
+              
+              // Fetch recipe
+              const response = await fetchRecipe({
+                token: token!,
+                device,
+                feature: featureName,
+                target: 'native',
+                starter: { name: config.name, version: config.version },
+              });
+              
+              if (!response.ok || (!response.signedUrl && !response.zipData)) {
+                log.warn(`⚠ Could not fetch ${featureName}: ${response.error || 'Unknown error'}`);
+                log.info(`You can install it later with: vf add ${featureName}`);
+                continue;
+              }
+              
+              // Download and extract
+              const zipPath = response.zipData 
+                ? await downloadZip(response.zipData, true)
+                : await downloadZip(response.signedUrl!);
+              
+              const extractDir = zipPath.replace('.zip', '');
+              await extractZipSafe(zipPath, extractDir);
+              
+              // Read manifest
+              const manifestPath = join(extractDir, 'recipe.json');
+              const manifestContent = await readFileContent(manifestPath);
+              const manifest = JSON.parse(manifestContent);
+              
+              // Copy files
+              const copiedFiles: string[] = [];
+              const { resolve: resolvePath } = await import('path');
+              for (const copySpec of manifest.copy) {
+                const srcPath = resolvePath(extractDir, copySpec.from);
+                const destPath = resolvePath(projectPath, copySpec.to);
+                const result = await copyTree(srcPath, destPath, { force: true });
+                copiedFiles.push(...result.files);
+              }
+              
+              // Add navigation
+              let navInserted = false;
+              if (manifest.nav) {
+                navInserted = await insertNavLinkNative(paths.nativeNavFile, manifest.nav, {});
+              }
+              
+              // Hash and journal
+              const fileHashes = await hashFiles(copiedFiles);
+              const fileEntries = Array.from(fileHashes.entries()).map(([path, hash]) => ({
+                path,
+                hash,
+              }));
+              
+              await addEntry(paths.journalFile, {
+                feature: manifest.name,
+                target: manifest.target,
+                files: fileEntries,
+                insertedNav: navInserted,
+                navHref: manifest.nav?.href,
+                navLabel: manifest.nav?.label,
+                ts: Date.now(),
+                manifest: {
+                  version: manifest.version,
+                  manualSteps: manifest.manualSteps,
+                  env: manifest.env,
+                },
+              });
+              
+              log.success(`✓ ${featureName} installed successfully!`);
+              
+            } catch (error: any) {
+              log.warn(`⚠ Failed to install ${featureName}: ${error.message}`);
               log.info(`You can install it later with: vf add ${featureName}`);
-              continue;
-            }
-            
-            // Download and extract
-            const zipPath = response.zipData 
-              ? await downloadZip(response.zipData, true)
-              : await downloadZip(response.signedUrl!);
-            
-            const extractDir = zipPath.replace('.zip', '');
-            await extractZipSafe(zipPath, extractDir);
-            
-            // Read manifest
-            const manifestPath = join(extractDir, 'recipe.json');
-            const manifestContent = await readFileContent(manifestPath);
-            const manifest = JSON.parse(manifestContent);
-            
-            // Copy files
-            const copiedFiles: string[] = [];
-            const { resolve: resolvePath } = await import('path');
-            for (const copySpec of manifest.copy) {
-              const srcPath = resolvePath(extractDir, copySpec.from);
-              const destPath = resolvePath(projectPath, copySpec.to);
-              const result = await copyTree(srcPath, destPath, { force: true });
-              copiedFiles.push(...result.files);
-            }
-            
-            // Add navigation
-            let navInserted = false;
-            if (manifest.nav) {
-              navInserted = await insertNavLinkNative(paths.nativeNavFile, manifest.nav, {});
             }
-            
-            // Hash and journal
-            const fileHashes = await hashFiles(copiedFiles);
-            const fileEntries = Array.from(fileHashes.entries()).map(([path, hash]) => ({
-              path,
-              hash,
-            }));
-            
-            await addEntry(paths.journalFile, {
-              feature: manifest.name,
-              target: manifest.target,
-              files: fileEntries,
-              insertedNav: navInserted,
-              navHref: manifest.nav?.href,
-              navLabel: manifest.nav?.label,
-              ts: Date.now(),
-              manifest: {
-                version: manifest.version,
-                manualSteps: manifest.manualSteps,
-                env: manifest.env,
-              },
-            });
-            
-            log.success(`✓ ${featureName} installed successfully!`);
-            
-          } catch (error: any) {
-            log.warn(`⚠ Failed to install ${featureName}: ${error.message}`);
-            log.info(`You can install it later with: vf add ${featureName}`);
           }
+        } finally {
+          // Go back to original directory even if installation fails
+          process.chdir(originalCwd);
         }
         
-        // Go back to original directory
-        process.chdir('..');
-        
         log.plain('');
         log.plain('━'.repeat(60));
         log.success(`✓ Installed ${selectedFeatures.length} feature(s)`);

package/src/commands/remove.ts

@@ -123,7 +123,7 @@ export const removeCommand = new Command('remove')
           log.plain('');
           
           if (!options.yes) {
-            const shouldContinue = promptYesNo(
+            const shouldContinue = await promptYesNo(
               'Continue with removal? (y/N): ',
               false
             );

package/src/core/__tests__/fsx.test.ts

@@ -15,7 +15,7 @@ describe('fsx', () => {
     destDir = join(testDir, 'dest');
     
     await mkdir(srcDir, { recursive: true });
-    await mkdir(destDir, { recursive: true });
+    // Don't create destDir - let copyTree create it
   });
 
   afterEach(async () => {
@@ -45,6 +45,7 @@ describe('fsx', () => {
       const destFile = join(destDir, 'file.txt');
       
       await writeFile(srcFile, 'new content');
+      await mkdir(destDir, { recursive: true });
       await writeFile(destFile, 'existing content');
 
       try {
@@ -60,6 +61,7 @@ describe('fsx', () => {
       await writeFile(join(srcDir, 'file.txt'), 'new content');
       
       // Create existing destination file
+      await mkdir(destDir, { recursive: true });
       await writeFile(join(destDir, 'file.txt'), 'existing content');
 
       const result = await copyTree(srcDir, destDir, { force: true });