Getting Started

# Clone the repository
git clone https://github.com/identity-wael/earna-ai.git
cd earna-ai
 
# Install dependencies for all workspaces
pnpm install
 
# Copy environment template
cp .env.example .env.local
 
# Add your Supabase and OpenAI keys to .env.local
# NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
# NEXT_PUBLIC_SUPABASE_ANON_KEY=your_anon_key
# OPENAI_API_KEY=your_openai_key
 
# Start development server (from monorepo root)
pnpm turbo dev --filter=console
 
# Or from the console directory
cd console && pnpm dev

# Clone the repository
git clone https://github.com/identity-wael/earna-ai.git
cd earna-ai/console
 
# Create .env.local with your keys
cp .env.example .env.local
# Edit .env.local with your API keys
 
# Run with Docker Compose
docker-compose up -d
 
# Or with Ollama for local models
docker-compose -f docker-compose.ollama.yml up -d

// app/api/chat/route.ts
// Main chat endpoint supporting all AI providers
export async function POST(req: Request) {
  const { messages, model } = await req.json();
 
  // Get the AI provider and model
  const provider = getProviderFromModel(model);
 
  // Stream the response
  const result = await streamText({
    model: provider(model),
    messages,
    onFinish: async ({ text }) => {
      // Save to database
      await saveMessage(chatId, text);
    }
  });
 
  return result.toDataStreamResponse();
}

// app/api/models/route.ts
// Get available models based on API keys
export async function GET() {
  const models = await getAvailableModels();
  return NextResponse.json(models);
}

// app/api/heygen/create-session/route.ts
// Create a new avatar session
export async function POST(req: Request) {
  const { avatarId, voice } = await req.json();
 
  const response = await fetch(
    'https://api.heygen.com/v1/streaming/new',
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.HEYGEN_API_KEY,
      },
      body: JSON.stringify({
        avatar_id: avatarId,
        voice,
        quality: 'high'
      })
    }
  );
 
  return NextResponse.json(await response.json());
}

// app/api/heygen/list-avatars/route.ts
// Get available avatars
export async function GET() {
  const avatars = await fetchHeyGenAvatars();
  return NextResponse.json(avatars);
}

// app/api/realtime-session/route.ts
// Create GPT-4o Realtime session
export async function POST() {
  const response = await fetch(
    'https://api.openai.com/v1/realtime/sessions',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'gpt-4o-realtime-preview',
        voice: 'alloy'
      })
    }
  );
 
  return NextResponse.json(await response.json());
}

// app/api/tts/route.ts
// Text-to-Speech generation
export async function POST(req: Request) {
  const { text, voice = 'alloy' } = await req.json();
 
  const response = await openai.audio.speech.create({
    model: 'tts-1',
    voice,
    input: text,
  });
 
  const buffer = Buffer.from(await response.arrayBuffer());
  return new Response(buffer, {
    headers: { 'Content-Type': 'audio/mpeg' }
  });
}

// Using Supabase Storage directly in components
import { createClient } from '@/lib/supabase/client';
 
// Upload file
const uploadFile = async (file: File) => {
  const supabase = createClient();
 
  const { data, error } = await supabase.storage
    .from('chat-files')
    .upload(`${Date.now()}-${file.name}`, file);
 
  if (error) throw error;
 
  // Get public URL
  const { data: { publicUrl } } = supabase.storage
    .from('chat-files')
    .getPublicUrl(data.path);
 
  return publicUrl;
};
 
// Delete file
const deleteFile = async (path: string) => {
  const supabase = createClient();
 
  await supabase.storage
    .from('chat-files')
    .remove([path]);
};