vibefast-cli 0.7.0 → 0.7.2

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

@@ -3,19 +3,20 @@ import { copyTree, exists } from '../fsx.js';
 import { writeFile, mkdir, rm } from 'fs/promises';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
 
-describe('fsx', () => {
+describe.sequential('fsx', () => {
   let testDir: string;
   let srcDir: string;
   let destDir: string;
 
   beforeEach(async () => {
-    testDir = join(tmpdir(), `vibefast-test-${Date.now()}`);
+    testDir = join(tmpdir(), `vibefast-test-${Date.now()}-${randomUUID()}`);
     srcDir = join(testDir, 'src');
     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 +46,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 +62,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 });

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

@@ -22,48 +22,48 @@ describe('prompt', () => {
   });
 
   describe('promptYesNo', () => {
-    it('should return default value in non-TTY environment', () => {
+    it('should return default value in non-TTY environment', async () => {
       (process.stdin as any).isTTY = false;
 
-      const result = promptYesNo('Continue?', true);
+      const result = await promptYesNo('Continue?', true);
       expect(result).toBe(true);
 
-      const result2 = promptYesNo('Continue?', false);
+      const result2 = await promptYesNo('Continue?', false);
       expect(result2).toBe(false);
     });
 
-    it('should return default value in CI environment', () => {
+    it('should return default value in CI environment', async () => {
       process.env.CI = 'true';
 
-      const result = promptYesNo('Continue?', true);
+      const result = await promptYesNo('Continue?', true);
       expect(result).toBe(true);
 
-      const result2 = promptYesNo('Continue?', false);
+      const result2 = await promptYesNo('Continue?', false);
       expect(result2).toBe(false);
     });
 
-    it('should detect GitHub Actions', () => {
+    it('should detect GitHub Actions', async () => {
       process.env.GITHUB_ACTIONS = 'true';
 
-      const result = promptYesNo('Continue?', false);
+      const result = await promptYesNo('Continue?', false);
       expect(result).toBe(false);
 
       delete process.env.GITHUB_ACTIONS;
     });
 
-    it('should detect GitLab CI', () => {
+    it('should detect GitLab CI', async () => {
       process.env.GITLAB_CI = 'true';
 
-      const result = promptYesNo('Continue?', false);
+      const result = await promptYesNo('Continue?', false);
       expect(result).toBe(false);
 
       delete process.env.GITLAB_CI;
     });
 
-    it('should detect CircleCI', () => {
+    it('should detect CircleCI', async () => {
       process.env.CIRCLECI = 'true';
 
-      const result = promptYesNo('Continue?', false);
+      const result = await promptYesNo('Continue?', false);
       expect(result).toBe(false);
 
       delete process.env.CIRCLECI;

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

@@ -37,11 +37,12 @@ describe('validate', () => {
       await expect(validateSignature(signaturePath)).rejects.toThrow('Not a VibeFast repo');
     });
 
-    it('should throw if name is wrong', async () => {
-      const config = { name: 'wrong', version: '1.0.0', targets: ['native'] };
+    it('should accept any valid name', async () => {
+      const config = { name: 'custom-starter', version: '1.0.0', targets: ['native'] };
       await writeFileContent(signaturePath, JSON.stringify(config));
 
-      await expect(validateSignature(signaturePath)).rejects.toThrow('Invalid starter name');
+      const result = await validateSignature(signaturePath);
+      expect(result.name).toBe('custom-starter');
     });
 
     it('should throw if targets empty', async () => {

package/src/core/auth.ts

@@ -34,6 +34,14 @@ export async function saveToken(token: string): Promise<void> {
   }
   
   await writeFileContent(configPath, JSON.stringify(config, null, 2), { force: true });
+  
+  // Set restrictive permissions (owner read/write only)
+  try {
+    const { chmod } = await import('fs/promises');
+    await chmod(configPath, 0o600);
+  } catch {
+    // Ignore on Windows or if chmod fails
+  }
 }
 
 export async function getToken(): Promise<string | null> {

package/src/core/codemod.ts

@@ -5,6 +5,17 @@ const NATIVE_END = '// --- @vibefast:features:end ---';
 const WEB_START = '{/* @vibefast:nav:start */}';
 const WEB_END = '{/* @vibefast:nav:end */}';
 
+export const ENV_CONSTANTS_START = '// --- @vibefast:env:constants:start ---';
+export const ENV_CONSTANTS_END = '// --- @vibefast:env:constants:end ---';
+export const ENV_CLIENT_SCHEMA_START = '// --- @vibefast:env:client-schema:start ---';
+export const ENV_CLIENT_SCHEMA_END = '// --- @vibefast:env:client-schema:end ---';
+export const ENV_CLIENT_ENV_START = '// --- @vibefast:env:client-env:start ---';
+export const ENV_CLIENT_ENV_END = '// --- @vibefast:env:client-env:end ---';
+export const ENV_BUILD_TIME_SCHEMA_START = '// --- @vibefast:env:buildtime-schema:start ---';
+export const ENV_BUILD_TIME_SCHEMA_END = '// --- @vibefast:env:buildtime-schema:end ---';
+export const ENV_BUILD_TIME_ENV_START = '// --- @vibefast:env:buildtime-env:start ---';
+export const ENV_BUILD_TIME_ENV_END = '// --- @vibefast:env:buildtime-env:end ---';
+
 function escapeTsLiteral(value: string): string {
   return value
     .replace(/\\/g, '\\\\')
@@ -209,3 +220,58 @@ export async function removeNavLinkWeb(
   
   return true;
 }
+
+function normalizeSnippet(snippet: string): string {
+  return snippet.trim();
+}
+
+function hasSnippet(content: string, snippet: string): boolean {
+  const normalized = normalizeSnippet(snippet);
+  if (!normalized) return false;
+  return content.includes(normalized);
+}
+
+export async function insertEnvSnippets(
+  filePath: string,
+  startMarker: string,
+  endMarker: string,
+  snippets: string[],
+  options?: { dryRun?: boolean }
+): Promise<boolean> {
+  if (!snippets.length) {
+    return false;
+  }
+
+  const content = await readFileContent(filePath);
+  if (!content.includes(startMarker) || !content.includes(endMarker)) {
+    throw new Error(`Missing env markers ${startMarker} or ${endMarker} in ${filePath}`);
+  }
+
+  const toInsert: string[] = [];
+  for (const snippet of snippets) {
+    if (hasSnippet(content, snippet)) {
+      continue;
+    }
+    toInsert.push(snippet);
+  }
+
+  if (toInsert.length === 0) {
+    return false;
+  }
+
+  const normalizedLines = toInsert
+    .map(line => line.endsWith('\n') ? line : `${line}\n`)
+    .join('');
+
+  const insertPosition = content.indexOf(endMarker);
+  const before = content.slice(0, insertPosition);
+  const after = content.slice(insertPosition);
+  const addition = `\n${normalizedLines}`;
+  const newContent = `${before}${addition}${after}`;
+
+  if (!options?.dryRun) {
+    await writeFileContent(filePath, newContent, { force: true });
+  }
+
+  return true;
+}

package/src/core/errors.ts

@@ -61,7 +61,7 @@ export function showCommandHint(command: string, missingArg?: string) {
   
   Options:
     --license <key>    Your VibeFast license key
-    --branch <branch>  Branch to clone (clean or main, default: main)
+    --branch <branch>  Branch to clone (clean or main, default: clean)
     --yes              Skip all prompts
     --skip-install     Skip dependency installation
     --help             Show help`,

package/src/core/fsx.ts

@@ -88,7 +88,7 @@ export async function copyTree(
         // If interactive and not dry-run, ask user
         if (options?.interactive && !options?.dryRun) {
           const { promptYesNo } = await import('./prompt.js');
-          const shouldOverwrite = promptYesNo(
+          const shouldOverwrite = await promptYesNo(
             `Overwrite ${destPath}? (y/N): `,
             false
           );

package/src/core/recipes.ts

@@ -37,7 +37,7 @@ export const RECIPES: RecipeInfo[] = [
   {
     name: 'image-analysis',
     category: 'feature',
-    description: 'AI-powered image analysis with trait detection',
+    description: 'AI image analyzer flows (face/dashboard)',
     icon: '🔍',
   },
   {
@@ -46,6 +46,18 @@ export const RECIPES: RecipeInfo[] = [
     description: 'AI-powered image generation',
     icon: '🎨',
   },
+  {
+    name: 'ios-widget',
+    category: 'feature',
+    description: 'iOS Home Screen widgets with Live Activities',
+    icon: '📱',
+  },
+  {
+    name: 'payments',
+    category: 'feature',
+    description: 'In-app purchases and subscriptions with RevenueCat',
+    icon: '💳',
+  },
   {
     name: 'quiz',
     category: 'feature',
@@ -70,26 +82,70 @@ export const RECIPES: RecipeInfo[] = [
     description: 'Wake word detection with Vosk',
     icon: '🎙️',
   },
+
+  // Advanced UI
   {
-    name: 'ios-widget',
-    category: 'feature',
-    description: 'iOS Home Screen widgets with Live Activities',
-    icon: '📱',
+    name: 'animated-chip',
+    category: 'advanced-ui',
+    description: 'Interactive filter chips with animation',
+    icon: '🏷️',
   },
   {
-    name: 'payments',
-    category: 'feature',
-    description: 'In-app purchases and subscriptions with RevenueCat',
-    icon: '💳',
+    name: 'animated-switch',
+    category: 'advanced-ui',
+    description: 'Animated switch control',
+    icon: '🎚️',
   },
-  
-  // Advanced UI
   {
     name: 'glowing-button',
     category: 'advanced-ui',
     description: 'Animated glowing button with presets',
     icon: '✨',
   },
+  {
+    name: 'number-stepper',
+    category: 'advanced-ui',
+    description: 'Stepped numeric input with gestures',
+    icon: '🔢',
+  },
+  {
+    name: 'progress-circle',
+    category: 'advanced-ui',
+    description: 'Animated progress circle + variants',
+    icon: '⭕',
+  },
+  {
+    name: 'swipe-slider',
+    category: 'advanced-ui',
+    description: 'Swipeable slider interactions',
+    icon: '🌀',
+  },
+  {
+    name: 'timeline',
+    category: 'advanced-ui',
+    description: 'Scrollable timeline UI',
+    icon: '🗓️',
+  },
+
+  // Integrations
+  {
+    name: 'posthog',
+    category: 'integration',
+    description: 'Product analytics hooks',
+    icon: '📈',
+  },
+  {
+    name: 'revenuecat',
+    category: 'integration',
+    description: 'RevenueCat config checklist',
+    icon: '💰',
+  },
+  {
+    name: 'sentry',
+    category: 'integration',
+    description: 'Sentry error tracking setup',
+    icon: '🛡️',
+  },
 ];
 
 /**