v0 Platform API: Automate AI App Generation with REST API

import { V0 } from 'v0-sdk';

async function promptToDeployment(userPrompt: string) {
  const client = new V0();

  try {
    // Step 1: Create project
    console.log('Creating project...');
    const project = await client.projects.create({
      name: 'AI Generated App',
      description: 'Generated from prompt via API'
    });

    // Step 2: Generate code from prompt
    console.log('Generating code from prompt...');
    const chat = await client.chats.create({
      messages: [
        {
          role: 'system',
          content: 'You are an expert React/Next.js developer. Generate production-ready code.'
        },
        {
          role: 'user',
          content: userPrompt
        }
      ],
      projectId: project.id,
      modelConfig: {
        temperature: 0.7,
        maxTokens: 8000
      }
    });

    // Step 3: Parse generated code
    console.log('Parsing generated files...');
    const files = chat.generatedCode.files;
    console.log(`Generated ${files.length} files`);

    // Step 4: Validate code
    console.log('Validating code...');
    const validation = await client.code.validate({
      files,
      projectId: project.id
    });

    if (!validation.valid) {
      console.log('Fixing validation errors...');
      // API automatically fixes common errors
      const fixed = await client.code.fix({
        files,
        errors: validation.errors
      });
    }

    // Step 5: Create deployment
    console.log('Deploying to Vercel...');
    const deployment = await client.deployments.create({
      chatId: chat.id,
      projectId: project.id,
      environment: 'production'
    });

    // Step 6: Wait for deployment to complete
    console.log('Waiting for deployment...');
    let deploymentStatus = deployment;
    while (deploymentStatus.status === 'building') {
      await new Promise(resolve => setTimeout(resolve, 5000));
      deploymentStatus = await client.deployments.get({
        deploymentId: deployment.id
      });
      console.log(`Status: ${deploymentStatus.status}`);
    }

    // Step 7: Return results
    if (deploymentStatus.status === 'ready') {
      console.log('✅ Deployment successful!');
      return {
        success: true,
        webUrl: deploymentStatus.webUrl,
        inspectorUrl: deploymentStatus.inspectorUrl,
        chatId: chat.id,
        projectId: project.id,
        deploymentId: deployment.id,
        files: files.map(f => f.path)
      };
    } else {
      throw new Error(`Deployment failed: ${deploymentStatus.status}`);
    }

  } catch (error) {
    console.error('Workflow failed:', error);
    throw error;
  }
}

// Usage
const result = await promptToDeployment(
  'Build a modern landing page with hero section, features grid, testimonials, and contact form. Use Tailwind CSS and shadcn/ui components.'
);

console.log('Live URL:', result.webUrl);
console.log('Inspector:', result.inspectorUrl);
console.log('Generated files:', result.files);

#!/usr/bin/env node
import { Command } from 'commander';
import { V0 } from 'v0-sdk';
import ora from 'ora';
import chalk from 'chalk';

const program = new Command();

program
  .name('v0-cli')
  .description('CLI tool for v0 Platform API')
  .version('1.0.0');

program
  .command('generate <prompt>')
  .description('Generate code from a prompt')
  .option('-d, --deploy', 'Deploy after generation')
  .option('-o, --output <dir>', 'Output directory for files')
  .action(async (prompt, options) => {
    const spinner = ora('Generating code...').start();
    const client = new V0();

    try {
      const chat = await client.chats.create({
        messages: [{ role: 'user', content: prompt }]
      });

      spinner.succeed('Code generated!');

      // Save files locally
      if (options.output) {
        const fs = await import('fs/promises');
        for (const file of chat.generatedCode.files) {
          const filePath = `${options.output}/${file.path}`;
          await fs.mkdir(path.dirname(filePath), { recursive: true });
          await fs.writeFile(filePath, file.content);
        }
        console.log(chalk.green(`✓ Files saved to ${options.output}`));
      }

      // Deploy if requested
      if (options.deploy) {
        const deploySpinner = ora('Deploying...').start();
        const deployment = await client.deployments.create({
          chatId: chat.id
        });

        // Wait for deployment
        let status = deployment;
        while (status.status === 'building') {
          await new Promise(r => setTimeout(r, 3000));
          status = await client.deployments.get({
            deploymentId: deployment.id
          });
        }

        deploySpinner.succeed('Deployed!');
        console.log(chalk.blue('🌐 Live URL:', status.webUrl));
        console.log(chalk.gray('📝 Edit:', `https://v0.dev/chat/${chat.id}`));
      }

    } catch (error) {
      spinner.fail('Generation failed');
      console.error(chalk.red(error.message));
      process.exit(1);
    }
  });

program
  .command('deploy <chatId>')
  .description('Deploy an existing chat')
  .action(async (chatId) => {
    const spinner = ora('Deploying...').start();
    const client = new V0();

    try {
      const deployment = await client.deployments.create({ chatId });
      spinner.succeed('Deployed!');
      console.log(chalk.blue('🌐', deployment.webUrl));
    } catch (error) {
      spinner.fail('Deployment failed');
      console.error(chalk.red(error.message));
    }
  });

program.parse();

// Usage:
// v0-cli generate "Build a blog with posts list and detail pages" --deploy
// v0-cli deploy chat_123abc --output ./my-app

# .github/workflows/v0-deploy.yml
name: V0 Auto Deploy

on:
  issues:
    types: [labeled]

jobs:
  generate-and-deploy:
    if: github.event.label.name == 'v0-generate'
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install dependencies
        run: npm install v0-sdk

      - name: Generate and Deploy
        env:
          V0_API_KEY: ${{ secrets.V0_API_KEY }}
        run: |
          node <<'EOF'
          const { V0 } = require('v0-sdk');
          const client = new V0();

          async function deploy() {
            const issueBody = process.env.GITHUB_EVENT_ISSUE_BODY;

            const result = await promptToDeployment(issueBody);

            // Comment on issue with results
            await fetch(
              `https://api.github.com/repos/${process.env.GITHUB_REPOSITORY}/issues/${process.env.GITHUB_EVENT_ISSUE_NUMBER}/comments`,
              {
                method: 'POST',
                headers: {
                  'Authorization': `token ${process.env.GITHUB_TOKEN}`,
                  'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                  body: `## ✅ Deployed!\n\n🌐 Live: ${result.webUrl}\n📝 Edit: https://v0.dev/chat/${result.chatId}`
                })
              }
            );
          }

          deploy().catch(console.error);
          EOF

import { V0, V0Error } from 'v0-sdk';

class V0ApiService {
  private client: V0;
  private maxRetries = 3;

  constructor() {
    this.client = new V0();
  }

  async generateWithRetry(prompt: string, retryCount = 0): Promise<any> {
    try {
      const chat = await this.client.chats.create({
        messages: [{ role: 'user', content: prompt }]
      });

      // Validate response
      if (!chat.generatedCode?.files?.length) {
        throw new Error('No code generated');
      }

      return chat;

    } catch (error) {
      if (error instanceof V0Error) {
        // Handle specific API errors
        if (error.code === 'rate_limit_exceeded') {
          if (retryCount < this.maxRetries) {
            const delay = Math.pow(2, retryCount) * 1000; // Exponential backoff
            console.log(`Rate limited. Retrying in ${delay}ms...`);
            await new Promise(resolve => setTimeout(resolve, delay));
            return this.generateWithRetry(prompt, retryCount + 1);
          }
        }

        if (error.code === 'invalid_request') {
          throw new Error(`Invalid prompt: ${error.message}`);
        }

        if (error.code === 'insufficient_credits') {
          throw new Error('Out of v0 credits. Please add more credits.');
        }
      }

      // Log unexpected errors
      console.error('V0 API Error:', {
        error,
        prompt: prompt.substring(0, 100),
        retryCount,
        timestamp: new Date().toISOString()
      });

      throw error;
    }
  }

  async safeDeployment(chatId: string): Promise<any> {
    try {
      const deployment = await this.client.deployments.create({ chatId });

      // Poll for completion with timeout
      const timeout = 300000; // 5 minutes
      const startTime = Date.now();

      while (Date.now() - startTime < timeout) {
        const status = await this.client.deployments.get({
          deploymentId: deployment.id
        });

        if (status.status === 'ready') {
          return status;
        }

        if (status.status === 'error') {
          const logs = await this.client.deployments.findLogs({
            deploymentId: deployment.id
          });
          throw new Error(`Deployment failed: ${logs.entries[0]?.message}`);
        }

        await new Promise(resolve => setTimeout(resolve, 5000));
      }

      throw new Error('Deployment timeout');

    } catch (error) {
      console.error('Deployment Error:', error);
      throw error;
    }
  }
}