vibefast-cli 0.1.1

package/recipes/voice-bot/apps/native/src/features/voice-bot/services/use-voice-bot.ts

@@ -0,0 +1,161 @@
+import { useConversation } from '@elevenlabs/react-native';
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import { generateConvexHttpApiUrl } from '@/core/utils/convex-http-api';
+
+import type {
+  ConversationState,
+  VoiceBotCallbacks,
+  VoiceBotConfig,
+} from '../types';
+
+export function useVoiceBot(
+  config: VoiceBotConfig,
+  callbacks?: VoiceBotCallbacks,
+) {
+  const [isStarting, setIsStarting] = useState(false);
+  const [textInput, setTextInput] = useState('');
+  const tokenFetchUrl = useMemo(() => {
+    try {
+      return generateConvexHttpApiUrl('/voice/conversation-token');
+    } catch (error) {
+      console.error(
+        '[useVoiceBot] Failed to compute ElevenLabs token fetch URL',
+        error,
+      );
+      return undefined;
+    }
+  }, []);
+
+  const conversation = useConversation({
+    tokenFetchUrl,
+    onConnect: ({ conversationId }: { conversationId: string }) => {
+      console.log('✅ Connected to conversation', conversationId);
+      callbacks?.onConnect?.(conversationId);
+    },
+    onDisconnect: (details: string) => {
+      console.log('❌ Disconnected from conversation', details);
+      callbacks?.onDisconnect?.(details);
+    },
+    onError: (message: string, context?: Record<string, unknown>) => {
+      console.error('❌ Conversation error:', message, context);
+      callbacks?.onError?.(message, context);
+    },
+    onMessage: ({ message, source }) => {
+      console.log(`💬 Message from ${source}:`, message);
+      callbacks?.onMessage?.({
+        id: Date.now().toString(),
+        content: message.toString(),
+        role: source,
+        timestamp: new Date(),
+      });
+    },
+    onModeChange: ({ mode }: { mode: 'speaking' | 'listening' }) => {
+      console.log(`🔊 Mode: ${mode}`);
+      callbacks?.onModeChange?.(mode);
+    },
+    onStatusChange: ({ status }) => {
+      console.log(`📡 Status: ${status}`);
+      callbacks?.onStatusChange?.(status);
+    },
+    onCanSendFeedbackChange: ({ canSendFeedback }) => {
+      console.log(`🔊 Can send feedback: ${canSendFeedback}`);
+    },
+  });
+
+  const state: ConversationState = {
+    status: conversation.status,
+    conversationId: conversation.getId(),
+    isSpeaking: conversation.isSpeaking,
+    canSendFeedback: conversation.canSendFeedback,
+    isStarting,
+  };
+
+  const startConversation = async () => {
+    if (isStarting) return;
+    setIsStarting(true);
+    try {
+      await conversation.startSession({
+        agentId: config.agentId,
+      });
+    } catch (error) {
+      console.error('Failed to start conversation:', error);
+      callbacks?.onError?.('Failed to start conversation', { error });
+    } finally {
+      setIsStarting(false);
+    }
+  };
+
+  const endConversation = async () => {
+    try {
+      // Idempotent: only end if actually connected
+      if (conversation.status === 'connected') {
+        await conversation.endSession();
+      }
+    } catch (error) {
+      console.error('Failed to end conversation:', error);
+      callbacks?.onError?.('Failed to end conversation', { error });
+    }
+  };
+
+  const sendMessage = (message: string) => {
+    if (message.trim()) {
+      conversation.sendUserMessage(message.trim());
+    }
+  };
+
+  const sendContextualUpdate = (context: string) => {
+    if (context.trim()) {
+      conversation.sendContextualUpdate(context.trim());
+    }
+  };
+
+  const sendFeedback = (isPositive: boolean) => {
+    conversation.sendFeedback(isPositive);
+  };
+
+  const sendUserActivity = () => {
+    conversation.sendUserActivity();
+  };
+
+  // ---- Cleanup only on UNMOUNT (avoid running on every conversation object change)
+
+  // Keep latest refs so unmount cleanup has fresh values
+  const convRef = useRef(conversation);
+  const statusRef = useRef(conversation.status);
+  useEffect(() => {
+    convRef.current = conversation;
+    statusRef.current = conversation.status;
+  }, [conversation, conversation.status]);
+
+  // Guard for React dev StrictMode double-invoke
+  const cleanedUpRef = useRef(false);
+
+  useEffect(() => {
+    return () => {
+      if (cleanedUpRef.current) return;
+      cleanedUpRef.current = true;
+
+      if (statusRef.current === 'connected') {
+        console.log('🧹 Auto-ending conversation due to screen exit');
+        convRef.current.endSession().catch((error: unknown) => {
+          console.error('Failed to auto-end conversation:', error);
+        });
+      }
+    };
+  }, []);
+
+  return {
+    state,
+    actions: {
+      startConversation,
+      endConversation,
+      sendMessage,
+      sendContextualUpdate,
+      sendFeedback,
+      sendUserActivity,
+    },
+    textInput,
+    setTextInput,
+  };
+}

package/recipes/voice-bot/apps/native/src/features/voice-bot/types.ts

@@ -0,0 +1,29 @@
+import type { ConversationStatus, Role } from '@elevenlabs/react-native';
+
+export interface VoiceBotConfig {
+  agentId: string;
+}
+
+export interface ConversationState {
+  status: ConversationStatus;
+  conversationId: string | null;
+  isSpeaking: boolean;
+  canSendFeedback: boolean;
+  isStarting: boolean;
+}
+
+export interface VoiceBotMessage {
+  id: string;
+  content: string;
+  role: Role;
+  timestamp: Date;
+}
+
+export interface VoiceBotCallbacks {
+  onConnect?: (conversationId: string) => void;
+  onDisconnect?: (details: string) => void;
+  onError?: (message: string, context?: Record<string, unknown>) => void;
+  onMessage?: (message: VoiceBotMessage) => void;
+  onModeChange?: (mode: 'speaking' | 'listening') => void;
+  onStatusChange?: (status: ConversationStatus) => void;
+}

package/recipes/voice-bot/recipe.json

@@ -0,0 +1,22 @@
+{
+  "name": "voice-bot",
+  "version": "1.0.0",
+  "description": "Real-time voice conversations with AI",
+  "copy": [
+    {
+      "from": "apps/native/src/app/voice-bot",
+      "to": "apps/native/src/app/(root)/(protected)/voice-bot"
+    },
+    {
+      "from": "apps/native/src/features/voice-bot",
+      "to": "apps/native/src/features/voice-bot"
+    }
+  ],
+  "nav": {
+    "href": "/(root)/(protected)/voice-bot",
+    "label": "Voice Assistant",
+    "icon": "🗣️",
+    "color": "#14B8A6"
+  },
+  "target": "native"
+}

package/scripts/create-recipes.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+import { readdir, stat, mkdir, writeFile, cp } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Feature definitions
+const features = [
+  {
+    name: 'charts',
+    label: 'Charts',
+    icon: '📊',
+    description: 'Beautiful data visualization with charts',
+    color: '#6366F1',
+  },
+  {
+    name: 'chatbot',
+    label: 'AI Chatbot',
+    icon: '💬',
+    description: 'AI-powered chat assistant',
+    color: '#F43F5E',
+  },
+  {
+    name: 'voice-bot',
+    label: 'Voice Assistant',
+    icon: '🗣️',
+    description: 'Real-time voice conversations with AI',
+    color: '#14B8A6',
+  },
+  {
+    name: 'image-generator',
+    label: 'Image Generator',
+    icon: '🎨',
+    description: 'AI-powered image generation',
+    color: '#A855F7',
+  },
+  {
+    name: 'audio-recorder',
+    label: 'Voice Notes',
+    icon: '🎤',
+    description: 'Record and manage voice notes',
+    color: '#EF4444',
+  },
+  {
+    name: 'quiz',
+    label: 'Quiz',
+    icon: '📱',
+    description: 'Interactive quiz feature',
+    color: '#F97316',
+  },
+  {
+    name: 'tracker-app',
+    label: 'Tracker',
+    icon: '🍎',
+    description: 'Track habits and activities',
+    color: '#06B6D4',
+  },
+];
+
+const monorepoPath = join(__dirname, '../../vibefast-monorepo');
+const recipesDir = join(__dirname, '../recipes');
+
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createRecipe(feature) {
+  console.log(`\n📦 Creating recipe for ${feature.name}...`);
+  
+  const recipeDir = join(recipesDir, feature.name);
+  await mkdir(recipeDir, { recursive: true });
+  
+  // Paths to copy
+  const appPath = join(monorepoPath, 'apps/native/src/app/(root)/(protected)', feature.name);
+  const featurePath = join(monorepoPath, 'apps/native/src/features', feature.name);
+  
+  const copySpecs = [];
+  
+  // Check if app route exists
+  if (await exists(appPath)) {
+    const destAppPath = join(recipeDir, 'apps/native/src/app', feature.name);
+    await mkdir(dirname(destAppPath), { recursive: true });
+    await cp(appPath, destAppPath, { recursive: true });
+    copySpecs.push({
+      from: `apps/native/src/app/${feature.name}`,
+      to: `apps/native/src/app/(root)/(protected)/${feature.name}`,
+    });
+    console.log(`  ✓ Copied app route`);
+  }
+  
+  // Check if feature components exist
+  if (await exists(featurePath)) {
+    const destFeaturePath = join(recipeDir, 'apps/native/src/features', feature.name);
+    await mkdir(dirname(destFeaturePath), { recursive: true });
+    await cp(featurePath, destFeaturePath, { recursive: true });
+    copySpecs.push({
+      from: `apps/native/src/features/${feature.name}`,
+      to: `apps/native/src/features/${feature.name}`,
+    });
+    console.log(`  ✓ Copied feature components`);
+  }
+  
+  if (copySpecs.length === 0) {
+    console.log(`  ⚠️  No files found for ${feature.name}, skipping...`);
+    return null;
+  }
+  
+  // Create recipe.json
+  const manifest = {
+    name: feature.name,
+    version: '1.0.0',
+    description: feature.description,
+    copy: copySpecs,
+    nav: {
+      href: `/(root)/(protected)/${feature.name}`,
+      label: feature.label,
+      icon: feature.icon,
+      color: feature.color,
+    },
+    target: 'native',
+  };
+  
+  await writeFile(
+    join(recipeDir, 'recipe.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+  console.log(`  ✓ Created recipe.json`);
+  
+  // Create zip
+  const zipName = `${feature.name}@latest.zip`;
+  const zipPath = join(recipesDir, zipName);
+  
+  await execAsync(`cd "${recipeDir}" && zip -r "../${zipName}" .`);
+  console.log(`  ✓ Created ${zipName}`);
+  
+  return zipPath;
+}
+
+async function main() {
+  console.log('🚀 VibeFast Recipe Generator\n');
+  console.log(`Monorepo: ${monorepoPath}`);
+  console.log(`Output: ${recipesDir}\n`);
+  
+  await mkdir(recipesDir, { recursive: true });
+  
+  const created = [];
+  
+  for (const feature of features) {
+    try {
+      const zipPath = await createRecipe(feature);
+      if (zipPath) {
+        created.push({ name: feature.name, zipPath });
+      }
+    } catch (err) {
+      console.error(`  ✗ Error creating ${feature.name}:`, err.message);
+    }
+  }
+  
+  console.log('\n✅ Recipe creation complete!\n');
+  console.log('Created recipes:');
+  created.forEach(({ name, zipPath }) => {
+    console.log(`  • ${name}@latest.zip`);
+  });
+  
+  console.log('\n📤 Upload to R2 with:');
+  console.log('cd ../recipes');
+  created.forEach(({ name }) => {
+    console.log(`wrangler r2 object put vibefast-recipes/${name}@latest.zip --file=${name}@latest.zip --remote`);
+  });
+  
+  console.log('\n🧪 Test with:');
+  console.log('cd ../../vibefast-monorepo');
+  console.log('export VIBEFAST_WORKER_URL=https://vibefast-cli-worker.mzafar611.workers.dev');
+  created.forEach(({ name }) => {
+    console.log(`vf add ${name}`);
+  });
+}
+
+main().catch(console.error);

package/src/commands/add.ts

@@ -0,0 +1,183 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getPaths } from '../core/paths.js';
+import { validateSignature, validateTarget } from '../core/validate.js';
+import { getToken, getDeviceInfo } from '../core/auth.js';
+import { fetchRecipe, downloadZip } from '../core/http.js';
+import { addEntry, getEntry } from '../core/journal.js';
+import { copyTree, readFileContent } from '../core/fsx.js';
+import { insertNavLinkNative, insertNavLinkWeb } from '../core/codemod.js';
+import { join, resolve } from 'path';
+import { ensureWithinBase } from '../core/pathGuard.js';
+import { extractZipSafe } from '../core/archive.js';
+
+interface RecipeManifest {
+  name: string;
+  version: string;
+  description: string;
+  copy: Array<{ from: string; to: string }>;
+  nav: { href: string; label: string };
+  target: 'native' | 'web';
+}
+
+export const addCommand = new Command('add')
+  .description('Add a VibeFast feature to your project')
+  .argument('<feature>', 'Feature name to install')
+  .option('--target <target>', 'Target platform (native or web)', 'native')
+  .option('--dry-run', 'Preview changes without applying')
+  .option('--force', 'Overwrite existing files')
+  .action(async (feature: string, options) => {
+    try {
+      const paths = getPaths();
+      const target = options.target as 'native' | 'web';
+
+      // Validate setup
+      const config = await validateSignature(paths.signatureFile);
+      validateTarget(target, config.targets);
+
+      // Check auth
+      const token = await getToken();
+      if (!token) {
+        log.error('Not logged in. Run "vf login --token <TOKEN>" first');
+        process.exit(1);
+      }
+
+      // Check if already installed
+      const existing = await getEntry(paths.journalFile, feature, target);
+      if (existing && !options.force) {
+        log.warn(`${feature} is already installed for ${target}`);
+        log.info('Use --force to reinstall');
+        return;
+      }
+
+      if (options.dryRun) {
+        log.info('[DRY RUN] No changes will be made');
+      }
+
+      // Fetch recipe
+      log.info(`Fetching ${feature} for ${target}...`);
+      const device = await getDeviceInfo();
+      const response = await fetchRecipe({
+        token,
+        device,
+        feature,
+        target,
+        starter: { name: config.name, version: config.version },
+      });
+
+      if (!response.ok || (!response.signedUrl && !response.zipData)) {
+        log.error(`Failed to fetch recipe: ${response.error || 'Unknown error'}`);
+        if (response.message) {
+          log.plain(`  ${response.message}`);
+        }
+        process.exit(1);
+      }
+
+      // Download and extract
+      log.info('Downloading recipe...');
+      const zipPath = response.zipData 
+        ? await downloadZip(response.zipData, true)
+        : await downloadZip(response.signedUrl!);
+      
+      const extractDir = zipPath.replace('.zip', '');
+      const extractRoot = resolve(extractDir);
+      const repoRoot = resolve(paths.cwd);
+      await extractZipSafe(zipPath, extractDir);
+
+      // Read manifest
+      const manifestPath = join(extractDir, 'recipe.json');
+      const manifestContent = await readFileContent(manifestPath);
+      const manifest: RecipeManifest = JSON.parse(manifestContent);
+      if (manifest.target !== target) {
+        throw new Error(
+          `Recipe target mismatch: expected ${target}, got ${manifest.target}`
+        );
+      }
+
+      log.info(`Installing ${manifest.name} v${manifest.version}...`);
+
+      // Copy files
+      const copiedFiles: 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 files = await copyTree(srcPath, destPath, {
+          dryRun: options.dryRun,
+          force: options.force,
+        });
+        copiedFiles.push(...files);
+      }
+
+      // 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');
+        }
+      }
+
+      // Update journal
+      if (!options.dryRun) {
+        await addEntry(paths.journalFile, {
+          feature: manifest.name,
+          target: manifest.target,
+          files: copiedFiles,
+          insertedNav: navInserted,
+          navHref,
+          navLabel,
+          ts: Date.now(),
+        });
+      }
+
+      log.success(`${manifest.name} installed successfully!`);
+      log.info(`Files added: ${copiedFiles.length}`);
+      
+      if (options.dryRun) {
+        log.warn('This was a dry run. Run without --dry-run to apply changes.');
+      } else {
+        log.info('Next steps:');
+        log.plain(`  1. Review the changes in your repo`);
+        log.plain(`  2. Run your dev server to test`);
+        log.plain(`  3. Navigate to the new feature`);
+      }
+    } catch (error: any) {
+      log.error(`Installation failed: ${error.message}`);
+      if (error.stack) {
+        log.plain(error.stack);
+      }
+      process.exit(1);
+    }
+  });

package/src/commands/devices.ts

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getToken } from '../core/auth.js';
+import { listDevices, deactivateDevice } from '../core/http.js';
+
+export const devicesCommand = new Command('devices')
+  .description('Manage your device activations')
+  .option('--deactivate <id>', 'Deactivate a device by ID')
+  .action(async (options) => {
+    try {
+      const token = await getToken();
+      if (!token) {
+        log.error('Not logged in. Run "vf login --token <TOKEN>" first');
+        process.exit(1);
+      }
+
+      if (options.deactivate) {
+        await deactivateDevice(token, options.deactivate);
+        log.success(`Device ${options.deactivate} deactivated`);
+        return;
+      }
+
+      const response = await listDevices(token);
+      
+      if (!response.devices || response.devices.length === 0) {
+        log.info('No active devices');
+        return;
+      }
+
+      log.info(`Active devices (${response.devices.length}/${response.maxDevices}):`);
+      response.devices.forEach((device: any) => {
+        log.plain(`  • ${device.id} (${device.os}/${device.arch}) - ${device.lastSeen}`);
+      });
+    } catch (error: any) {
+      log.error(`Failed: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/doctor.ts

@@ -0,0 +1,67 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getPaths } from '../core/paths.js';
+import { validateSignature } from '../core/validate.js';
+import { exists } from '../core/fsx.js';
+import { getToken } from '../core/auth.js';
+
+export const doctorCommand = new Command('doctor')
+  .description('Check your VibeFast setup')
+  .action(async () => {
+    try {
+      const paths = getPaths();
+      let hasErrors = false;
+
+      // Check authentication
+      log.info('Checking authentication...');
+      const token = await getToken();
+      if (!token) {
+        log.error('Not logged in');
+        log.plain('  Run: vf login --token <YOUR_TOKEN>');
+        hasErrors = true;
+      } else {
+        log.success('Authenticated');
+      }
+
+      // Check signature file
+      log.info('Checking repository signature...');
+      try {
+        const config = await validateSignature(paths.signatureFile);
+        log.success(`Found VibeFast repo (v${config.version})`);
+        log.info(`Available targets: ${config.targets.join(', ')}`);
+      } catch (error: any) {
+        log.error(error.message);
+        hasErrors = true;
+      }
+
+      // Check nav markers
+      log.info('Checking navigation markers...');
+      
+      const nativeExists = await exists(paths.nativeNavFile);
+      if (nativeExists) {
+        log.success('Native nav file found');
+      } else {
+        log.warn('Native nav file not found');
+        log.plain(`  Expected: ${paths.nativeNavFile}`);
+      }
+
+      const webExists = await exists(paths.webNavFile);
+      if (webExists) {
+        log.success('Web nav file found');
+      } else {
+        log.warn('Web nav file not found');
+        log.plain(`  Expected: ${paths.webNavFile}`);
+      }
+
+      if (hasErrors) {
+        log.error('Setup incomplete');
+        process.exit(1);
+      } else {
+        log.success('All checks passed! Ready to add features.');
+        log.info('Run "vf list" to see available features');
+      }
+    } catch (error: any) {
+      log.error(`Doctor check failed: ${error.message}`);
+      process.exit(1);
+    }
+  });