vibefast-cli 0.7.7 → 0.7.10

package/src/commands/add.ts

@@ -536,197 +536,231 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
         }
       }
 
-      // Download and extract (or use bundled zip)
-      if (!zipPath) {
-        const result = await withSpinner(
-          'Downloading and extracting recipe...',
-          async () => {
-            const zip = response.zipData 
-              ? await downloadZip(response.zipData, true)
-              : await downloadZip(response.signedUrl!);
-            
-            const dir = join(tmpdir(), 'vibefast', randomUUID());
-            await extractZipSafe(zip, dir);
-            
-            return { zipPath: zip, extractDir: dir };
-          },
-          {
-            successText: '✓ Recipe downloaded',
+      const fallbackZip = await getBundledRecipeZipPath(feature);
+      let attemptedFallback = false;
+      let installedManifest: (RecipeManifest & { files?: { source: string; destination: string }[] }) | null = null;
+      let installedEnvGroups: EnvGroup[] = [];
+      let installedEnvAttention: string[] = [];
+      let installedCopiedFiles: string[] = [];
+      let installedNavInserted = false;
+      let installedNavHref: string | undefined;
+      let installedNavLabel: string | undefined;
+
+      // Everything below runs inside a retry loop so we can fall back to bundled recipes
+      retry_install: while (true) {
+        try {
+          // Download and extract (or use bundled zip)
+          if (!zipPath) {
+            const result = await withSpinner(
+              'Downloading and extracting recipe...',
+              async () => {
+                const zip = response.zipData 
+                  ? await downloadZip(response.zipData, true)
+                  : await downloadZip(response.signedUrl!);
+                
+                const dir = join(tmpdir(), 'vibefast', randomUUID());
+                await extractZipSafe(zip, dir);
+                
+                return { zipPath: zip, extractDir: dir };
+              },
+              {
+                successText: '✓ Recipe downloaded',
+              }
+            );
+            zipPath = result.zipPath;
+            extractDir = result.extractDir;
+          } else {
+            // Bundled zip path - extract to temp location
+            extractDir = join(tmpdir(), 'vibefast', randomUUID());
+            await extractZipSafe(zipPath, extractDir);
           }
-        );
-        zipPath = result.zipPath;
-        extractDir = result.extractDir;
-      } else {
-        // Bundled zip path - extract to temp location
-        extractDir = join(tmpdir(), 'vibefast', randomUUID());
-        await extractZipSafe(zipPath, extractDir);
-      }
       
-      // Locate manifest (some archives may nest recipe.json)
-      const findManifest = async (dir: string): Promise<string | null> => {
-        const entries = await import('fs/promises').then((m) =>
-          m.readdir(dir, { withFileTypes: true }),
-        );
-        for (const entry of entries) {
-          const full = join(dir, entry.name);
-          if (entry.isFile() && entry.name === 'recipe.json') return full;
-          if (entry.isDirectory()) {
-            const found = await findManifest(full);
-            if (found) return found;
+          // Locate manifest (some archives may nest recipe.json)
+          const findManifest = async (dir: string): Promise<string | null> => {
+            const entries = await import('fs/promises').then((m) =>
+              m.readdir(dir, { withFileTypes: true }),
+            );
+            for (const entry of entries) {
+              const full = join(dir, entry.name);
+              if (entry.isFile() && entry.name === 'recipe.json') return full;
+              if (entry.isDirectory()) {
+                const found = await findManifest(full);
+                if (found) return found;
+              }
+            }
+            return null;
+          };
+
+          let manifestPath = join(extractDir, 'recipe.json');
+          if (!(await exists(manifestPath))) {
+            const found = await findManifest(extractDir);
+            if (!found) {
+              throw new Error(`recipe.json not found in ${extractDir}`);
+            }
+            manifestPath = found;
           }
-        }
-        return null;
-      };
-
-      let manifestPath = join(extractDir, 'recipe.json');
-      if (!(await exists(manifestPath))) {
-        const found = await findManifest(extractDir);
-        if (!found) {
-          throw new Error(`recipe.json not found in ${extractDir}`);
-        }
-        manifestPath = found;
-      }
 
-      const manifestContent = await readFileContent(manifestPath);
-      const manifest: RecipeManifest & { files?: { source: string; destination: string }[] } = JSON.parse(manifestContent);
-      if (!manifest.copy && Array.isArray(manifest.files)) {
-        manifest.copy = manifest.files.map((file) => ({
-          from: file.source,
-          to: file.destination,
-        }));
-      }
-      if (!Array.isArray(manifest.copy)) {
-        throw new Error('recipe.json is missing a valid "copy" array');
-      }
-      const extractRoot = resolve(manifestPath, '..');
-      const repoRoot = resolve(paths.cwd);
-      if (manifest.target !== target) {
-        throw new Error(
-          `Recipe target mismatch: expected ${target}, got ${manifest.target}`
-        );
-      }
+          const manifestContent = await readFileContent(manifestPath);
+          const manifest: RecipeManifest & { files?: { source: string; destination: string }[] } = JSON.parse(manifestContent);
+          if (!manifest.copy && Array.isArray(manifest.files)) {
+            manifest.copy = manifest.files.map((file) => ({
+              from: file.source,
+              to: file.destination,
+            }));
+          }
+          if (!Array.isArray(manifest.copy)) {
+            throw new Error('recipe.json is missing a valid "copy" array');
+          }
+          const extractRoot = resolve(manifestPath, '..');
+          const repoRoot = resolve(paths.cwd);
+          if (manifest.target !== target) {
+            throw new Error(
+              `Recipe target mismatch: expected ${target}, got ${manifest.target}`
+            );
+          }
 
-      log.info(`Installing ${manifest.name} v${manifest.version}...`);
-      const envGroups = groupEnvVars(manifest.env, paths.cwd);
-      let envAttention: string[] = [];
+          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[] = [];
-      const allConflicts: string[] = [];
-      const allSkipped: string[] = [];
-      
-      for (const copySpec of manifest.copy) {
-        const srcPath = ensureWithinBase(
-          extractRoot,
-          resolve(extractRoot, copySpec.from),
-          `Recipe file ${copySpec.from}`
-        );
-        const destPath = ensureWithinBase(
-          repoRoot,
-          resolve(repoRoot, copySpec.to),
-          `Destination ${copySpec.to}`
-        );
-        
-        log.info(`Copying ${copySpec.from} → ${copySpec.to}`);
-        const result = await copyTree(srcPath, destPath, {
-          dryRun: options.dryRun,
-          force: options.force,
-          interactive: !options.force && !options.dryRun && !options.yes,
-        });
-        
-        copiedFiles.push(...result.files);
-        allConflicts.push(...result.conflicts);
-        allSkipped.push(...result.skipped);
-      }
-      
-      // Show conflict warnings in dry-run mode
-      if (options.dryRun && allConflicts.length > 0) {
-        log.plain('');
-        log.warn(`⚠ ${allConflicts.length} file(s) will be overwritten:`);
-        allConflicts.slice(0, 5).forEach(f => {
-          const relativePath = f.replace(paths.cwd + '/', '');
-          log.plain(`  • ${relativePath}`);
-        });
-        if (allConflicts.length > 5) {
-          log.plain(`  ... and ${allConflicts.length - 5} more`);
-        }
-        log.warn('⚠ Make sure you have committed your changes to Git!');
-        log.plain('');
-      }
+          // Copy files with interactive confirmation
+          const copiedFiles: string[] = [];
+          const allConflicts: string[] = [];
+          const allSkipped: string[] = [];
+          
+          for (const copySpec of manifest.copy) {
+            const srcPath = ensureWithinBase(
+              extractRoot,
+              resolve(extractRoot, copySpec.from),
+              `Recipe file ${copySpec.from}`
+            );
+            const destPath = ensureWithinBase(
+              repoRoot,
+              resolve(repoRoot, copySpec.to),
+              `Destination ${copySpec.to}`
+            );
+            
+            log.info(`Copying ${copySpec.from} → ${copySpec.to}`);
+            const result = await copyTree(srcPath, destPath, {
+              dryRun: options.dryRun,
+              force: options.force,
+              interactive: !options.force && !options.dryRun && !options.yes,
+            });
+            
+            copiedFiles.push(...result.files);
+            allConflicts.push(...result.conflicts);
+            allSkipped.push(...result.skipped);
+          }
       
-      // Show skipped files
-      if (allSkipped.length > 0) {
-        log.info(`ℹ Skipped ${allSkipped.length} file(s) (you chose not to overwrite)`);
-      }
+          // Show conflict warnings in dry-run mode
+          if (options.dryRun && allConflicts.length > 0) {
+            log.plain('');
+            log.warn(`⚠ ${allConflicts.length} file(s) will be overwritten:`);
+            allConflicts.slice(0, 5).forEach(f => {
+              const relativePath = f.replace(paths.cwd + '/', '');
+              log.plain(`  • ${relativePath}`);
+            });
+            if (allConflicts.length > 5) {
+              log.plain(`  ... and ${allConflicts.length - 5} more`);
+            }
+            log.warn('⚠ Make sure you have committed your changes to Git!');
+            log.plain('');
+          }
+          
+          // Show skipped files
+          if (allSkipped.length > 0) {
+            log.info(`ℹ Skipped ${allSkipped.length} file(s) (you chose not to overwrite)`);
+          }
 
-      // Add watermark if provided
-      if (response.watermark && !options.dryRun) {
-        const { writeFileContent, readFileContent } = await import('../core/fsx.js');
-        for (const file of copiedFiles) {
-          if (file.endsWith('.ts') || file.endsWith('.tsx') || file.endsWith('.js') || file.endsWith('.jsx')) {
-            const content = await readFileContent(file);
-            const watermarked = `// vibefast license: ${response.watermark}\n${content}`;
-            await writeFileContent(file, watermarked, { force: true });
+          // Add watermark if provided
+          if (response.watermark && !options.dryRun) {
+            const { writeFileContent, readFileContent } = await import('../core/fsx.js');
+            for (const file of copiedFiles) {
+              if (file.endsWith('.ts') || file.endsWith('.tsx') || file.endsWith('.js') || file.endsWith('.jsx')) {
+                const content = await readFileContent(file);
+                const watermarked = `// vibefast license: ${response.watermark}\n${content}`;
+                await writeFileContent(file, watermarked, { force: true });
+              }
+            }
           }
-        }
-      }
 
-      // Insert nav link
-      let navInserted = false;
-      let navHref: string | undefined;
-      let navLabel: string | undefined;
-      if (manifest.nav) {
-        log.info('Adding navigation link...');
-        const navFile = target === 'native' ? paths.nativeNavFile : paths.webNavFile;
-        const insertFn = target === 'native' ? insertNavLinkNative : insertNavLinkWeb;
-        navHref = manifest.nav.href;
-        navLabel = manifest.nav.label;
-        
-        navInserted = await insertFn(navFile, manifest.nav, { dryRun: options.dryRun });
-        if (navInserted) {
-          log.success('Navigation link added');
-        } else {
-          log.info('Navigation link already exists');
-        }
-      }
+          // Insert nav link
+          let navInserted = false;
+          let navHref: string | undefined;
+          let navLabel: string | undefined;
+          if (manifest.nav) {
+            log.info('Adding navigation link...');
+            const navFile = target === 'native' ? paths.nativeNavFile : paths.webNavFile;
+            const insertFn = target === 'native' ? insertNavLinkNative : insertNavLinkWeb;
+            navHref = manifest.nav.href;
+            navLabel = manifest.nav.label;
+            
+            navInserted = await insertFn(navFile, manifest.nav, { dryRun: options.dryRun });
+            if (navInserted) {
+              log.success('Navigation link added');
+            } else {
+              log.info('Navigation link already exists');
+            }
+          }
 
-      // Hash files and update journal
-      if (!options.dryRun) {
-        log.info('Computing file hashes...');
-        const fileHashes = await hashFiles(copiedFiles, { showProgress: copiedFiles.length > 20 });
-        
-        const fileEntries: FileEntry[] = Array.from(fileHashes.entries()).map(([path, hash]) => ({
-          path,
-          hash,
-        }));
-        
-        await addEntry(paths.journalFile, {
-          feature: manifest.name,
-          target: manifest.target,
-          files: fileEntries,
-          insertedNav: navInserted,
-          navHref,
-          navLabel,
-          ts: Date.now(),
-          manifest: {
-            version: manifest.version,
-            manualSteps: manifest.manualSteps,
-            env: manifest.env,
-          },
-        });
-      }
+          // Hash files and update journal
+          if (!options.dryRun) {
+            log.info('Computing file hashes...');
+            const fileHashes = await hashFiles(copiedFiles, { showProgress: copiedFiles.length > 20 });
+            
+            const fileEntries: FileEntry[] = Array.from(fileHashes.entries()).map(([path, hash]) => ({
+              path,
+              hash,
+            }));
+            
+            await addEntry(paths.journalFile, {
+              feature: manifest.name,
+              target: manifest.target,
+              files: fileEntries,
+              insertedNav: navInserted,
+              navHref,
+              navLabel,
+              ts: Date.now(),
+              manifest: {
+                version: manifest.version,
+                manualSteps: manifest.manualSteps,
+                env: manifest.env,
+              },
+            });
+          }
 
-      log.success(`${manifest.name} installed successfully!`);
-      log.info(`Files added: ${copiedFiles.length}`);
+          // capture results for post steps outside the loop
+          installedManifest = manifest;
+          installedEnvGroups = envGroups;
+          installedEnvAttention = envAttention;
+          installedCopiedFiles = copiedFiles;
+          installedNavInserted = navInserted;
+          installedNavHref = navHref;
+          installedNavLabel = navLabel;
+
+          log.success(`${manifest.name} installed successfully!`);
+          log.info(`Files added: ${copiedFiles.length}`);
+          break retry_install;
+        } catch (err: any) {
+          if (!attemptedFallback && fallbackZip) {
+            attemptedFallback = true;
+            zipPath = fallbackZip;
+            extractDir = null;
+            log.warn(`⚠ Encountered error "${err.message}". Retrying with bundled recipe...`);
+            continue retry_install;
+          }
+          throw err;
+        }
+      }
       
       // Auto-install dependencies
-      if (manifest.dependencies && !options.dryRun) {
+      if (installedManifest && installedManifest.dependencies && !options.dryRun) {
         log.plain('');
         log.warn('⚠ This feature requires additional packages');
         log.plain('');
         
-        if (manifest.target === 'native' && manifest.dependencies.expo) {
-          const packages = manifest.dependencies.expo;
+        if (installedManifest.target === 'native' && installedManifest.dependencies.expo) {
+          const packages = installedManifest.dependencies.expo;
           
           log.info('📦 Required packages:');
           packages.forEach(pkg => {
@@ -760,8 +794,8 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
             log.info('💡 Expo will automatically pick compatible versions');
           }
           
-        } else if (manifest.target === 'web' && manifest.dependencies.npm) {
-          const packages = manifest.dependencies.npm;
+        } else if (installedManifest.target === 'web' && installedManifest.dependencies.npm) {
+          const packages = installedManifest.dependencies.npm;
           
           log.info('📦 Required packages:');
           packages.forEach(pkg => {
@@ -808,7 +842,7 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
       }
       
       // Auto-setup Vosk model for wake-word
-      if (manifest.name === 'wake-word' && !options.dryRun) {
+      if (installedManifest?.name === 'wake-word' && !options.dryRun) {
         const { setupVoskModel } = await import('../core/vosk.js');
         log.plain('');
         await withSpinner(
@@ -822,20 +856,21 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
         );
       }
 
-      if (manifest.configuration?.env) {
-        await applyEnvConfiguration(paths, manifest.configuration.env, options);
+      if (installedManifest?.configuration?.env) {
+        await applyEnvConfiguration(paths, installedManifest.configuration.env, options);
       }
 
       // Show manual steps with smart detection
-      if (manifest.manualSteps && !options.dryRun) {
+      if (installedManifest?.manualSteps && !options.dryRun) {
         const { readFileContent, exists } = await import('../core/fsx.js');
         const { join } = await import('path');
+        const normalize = (text: string) => text.replace(/\\n/g, '\n');
         
         // Check which steps might already be done
-        const pendingSteps: typeof manifest.manualSteps = [];
+        const pendingSteps: typeof installedManifest.manualSteps = [];
         const completedSteps: string[] = [];
         
-        for (const step of manifest.manualSteps) {
+        for (const step of installedManifest.manualSteps) {
           let alreadyDone = false;
           
           // Check if file modification is already done
@@ -862,12 +897,10 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
           log.plain('');
           log.warn('⚠ MANUAL STEPS REQUIRED:');
           log.plain('');
-          log.plain('This feature requires some manual configuration:');
-          log.plain('');
           
           pendingSteps.forEach((step, index) => {
             log.plain(`Step ${index + 1}: ${step.title}`);
-            log.plain(`  ${step.description}`);
+            log.plain(`  ${normalize(step.description || '')}`);
             if (step.link) {
               log.plain(`  🔗 ${step.link}`);
             }
@@ -875,12 +908,18 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
               log.plain(`  📝 File: ${step.file}`);
             }
             if (step.content) {
-              log.plain(`  Add: ${step.content}`);
+              log.plain('  Add:');
+              log.plain(
+                normalize(step.content)
+                  .split('\n')
+                  .map(line => `    ${line}`)
+                  .join('\n')
+              );
             }
             log.plain('');
           });
           
-          log.info(`💡 Run 'vf checklist ${manifest.name}' to see these steps again`);
+          log.info(`💡 Run 'vf checklist ${installedManifest.name}' to see these steps again`);
           log.plain('');
         }
         
@@ -890,8 +929,8 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
         }
       }
       
-      if (envGroups.length > 0) {
-        const additions = await ensureEnvVarsForGroups(envGroups, options);
+      if (installedEnvGroups.length > 0) {
+        const additions = await ensureEnvVarsForGroups(installedEnvGroups, options);
 
         if (additions.length > 0) {
           log.plain('');
@@ -904,29 +943,29 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
           log.plain('');
         }
 
-        envAttention = await reportEnvStatus(envGroups, options);
+        installedEnvAttention = await reportEnvStatus(installedEnvGroups, options);
       }
       
       // Post-install message
-      if (manifest.postInstall?.message && !options.dryRun) {
+      if (installedManifest?.postInstall?.message && !options.dryRun) {
         log.plain('');
-        log.info(manifest.postInstall.message);
+        log.info(installedManifest.postInstall.message);
       }
       
       // Final summary of what needs user attention
       if (!options.dryRun) {
         const needsAttention: string[] = [];
         
-        if (envGroups.length > 0 && envAttention.length > 0) {
-          needsAttention.push(...envAttention);
+        if (installedEnvGroups.length > 0 && installedEnvAttention.length > 0) {
+          needsAttention.push(...installedEnvAttention);
         }
         
         // Check manual steps
-        if (manifest.manualSteps) {
+        if (installedManifest?.manualSteps) {
           const { readFileContent, exists } = await import('../core/fsx.js');
           const { join } = await import('path');
           
-          for (const step of manifest.manualSteps) {
+          for (const step of installedManifest.manualSteps) {
             let alreadyDone = false;
             
             if (step.file && step.content) {
@@ -958,7 +997,7 @@ async function applyEnvConfiguration(paths: ReturnType<typeof getPaths>, envConf
             log.plain(`  ${index + 1}. ${item}`);
           });
           log.plain('');
-          log.info(`💡 Run 'vf checklist ${manifest.name}' for detailed instructions`);
+          log.info(`💡 Run 'vf checklist ${installedManifest?.name ?? feature}' for detailed instructions`);
           log.plain('');
         } else {
           log.plain('');

package/src/commands/checklist.ts

@@ -106,9 +106,11 @@ export const checklistCommand = new Command('checklist')
       log.info(`Manual setup steps for ${feature}:`);
       log.plain('');
       
+      const normalize = (text: string) => text.replace(/\\n/g, '\n');
+
       entry.manifest.manualSteps.forEach((step: any, index: number) => {
         log.plain(`Step ${index + 1}: ${step.title}`);
-        log.plain(`  ${step.description}`);
+        log.plain(`  ${normalize(step.description || '')}`);
         if (step.link) {
           log.plain(`  🔗 ${step.link}`);
         }
@@ -116,7 +118,13 @@ export const checklistCommand = new Command('checklist')
           log.plain(`  📝 File: ${step.file}`);
         }
         if (step.content) {
-          log.plain(`  Add: ${step.content}`);
+          log.plain('  Add:');
+          log.plain(
+            normalize(step.content)
+              .split('\n')
+              .map((line: string) => `    ${line}`)
+              .join('\n')
+          );
         }
         log.plain('');
       });