vibefast-cli 1.1.5 → 1.2.1

package/recipes/chatbot-supabase/packages/backend/src/services/messages.ts

@@ -0,0 +1,327 @@
+/**
+ * Messages Service
+ *
+ * Handles message operations including storeMessage, listMessages,
+ * deleteUserMessage, and clearConversationMessages.
+ *
+ * Requirements: 4.3, 4.4, 4.5, 4.6, 4.7
+ */
+
+import type { SupabaseClientType } from '../lib/supabase';
+import type { Message } from '../types';
+import type { Json } from '../types/database';
+
+export interface StoreMessageInput {
+  conversationId: string;
+  authorType: 'user' | 'bot';
+  text?: string | null;
+  attachments?: Json | null;
+  aiProvider?: string | null;
+  aiModel?: string | null;
+  toolCalls?: Json | null;
+  metadata?: Json | null;
+}
+
+export interface StoreMessageResult {
+  success: boolean;
+  message?: Message;
+  error?: string;
+}
+
+export interface ListMessagesResult {
+  success: boolean;
+  messages?: Message[];
+  hasMore?: boolean;
+  error?: string;
+}
+
+export interface DeleteMessageResult {
+  success: boolean;
+  error?: string;
+}
+
+export interface ClearMessagesResult {
+  success: boolean;
+  deletedCount?: number;
+  error?: string;
+}
+
+const DEFAULT_PAGE_SIZE = 50;
+const BATCH_DELETE_SIZE = 100;
+
+/**
+ * Store a new message in a conversation
+ *
+ * Validates that the message has either text or attachments (not both empty).
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param input - Message data to store
+ * @returns The created message
+ *
+ * Requirements: 4.3, 4.4
+ */
+export async function storeMessage(
+  supabase: SupabaseClientType,
+  input: StoreMessageInput
+): Promise<StoreMessageResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const userId = authData.user.id;
+
+  // Validate input
+  if (!input.conversationId) {
+    return { success: false, error: 'Conversation ID is required' };
+  }
+
+  // Check if text is empty/whitespace and no attachments
+  const hasText = input.text && input.text.trim().length > 0;
+  const hasAttachments = input.attachments && 
+    (Array.isArray(input.attachments) ? input.attachments.length > 0 : true);
+
+  if (!hasText && !hasAttachments) {
+    return { success: false, error: 'Message must have text or attachments' };
+  }
+
+  // Verify user owns the conversation
+  const { data: conversation, error: convError } = await supabase
+    .from('conversations')
+    .select('id')
+    .eq('id', input.conversationId)
+    .eq('user_id', userId)
+    .single();
+
+  if (convError || !conversation) {
+    return { success: false, error: 'Conversation not found or access denied' };
+  }
+
+  // Create the message
+  const { data: message, error: createError } = await supabase
+    .from('messages')
+    .insert({
+      conversation_id: input.conversationId,
+      user_id: userId,
+      author_type: input.authorType,
+      text: input.text || null,
+      attachments: input.attachments || null,
+      ai_provider: input.aiProvider || null,
+      ai_model: input.aiModel || null,
+      tool_calls: input.toolCalls || null,
+      metadata: input.metadata || null,
+    })
+    .select()
+    .single();
+
+  if (createError) {
+    return { success: false, error: `Failed to store message: ${createError.message}` };
+  }
+
+  return { success: true, message };
+}
+
+
+/**
+ * List messages for a conversation with pagination
+ *
+ * Returns messages ordered by creation time (oldest first for chat display).
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param conversationId - The conversation to list messages from
+ * @param options - Pagination options
+ * @returns Paginated list of messages
+ *
+ * Requirements: 4.5
+ */
+export async function listMessages(
+  supabase: SupabaseClientType,
+  conversationId: string,
+  options?: {
+    limit?: number;
+    cursor?: string; // created_at timestamp for cursor-based pagination
+  }
+): Promise<ListMessagesResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!conversationId) {
+    return { success: false, error: 'Conversation ID is required' };
+  }
+
+  const limit = options?.limit || DEFAULT_PAGE_SIZE;
+
+  // Build query
+  let query = supabase
+    .from('messages')
+    .select('*')
+    .eq('conversation_id', conversationId)
+    .order('created_at', { ascending: true })
+    .limit(limit + 1); // Fetch one extra to check if there are more
+
+  // Apply cursor if provided
+  if (options?.cursor) {
+    query = query.gt('created_at', options.cursor);
+  }
+
+  const { data: messages, error: listError } = await query;
+
+  if (listError) {
+    return { success: false, error: `Failed to list messages: ${listError.message}` };
+  }
+
+  // Check if there are more results
+  const hasMore = messages && messages.length > limit;
+  const resultMessages = hasMore ? messages.slice(0, limit) : (messages || []);
+
+  return {
+    success: true,
+    messages: resultMessages,
+    hasMore,
+  };
+}
+
+/**
+ * Delete a single user message
+ *
+ * Only allows deletion if the user owns the message.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param messageId - The ID of the message to delete
+ * @returns Success or error
+ *
+ * Requirements: 4.7
+ */
+export async function deleteUserMessage(
+  supabase: SupabaseClientType,
+  messageId: string
+): Promise<DeleteMessageResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!messageId) {
+    return { success: false, error: 'Message ID is required' };
+  }
+
+  // Delete the message (RLS + user_id check ensures ownership)
+  const { data, error: deleteError } = await supabase
+    .from('messages')
+    .delete()
+    .eq('id', messageId)
+    .eq('user_id', authData.user.id)
+    .select('id')
+    .single();
+
+  if (deleteError) {
+    if (deleteError.code === 'PGRST116') {
+      return { success: false, error: 'Message not found or access denied' };
+    }
+    return { success: false, error: `Failed to delete message: ${deleteError.message}` };
+  }
+
+  if (!data) {
+    return { success: false, error: 'Message not found or access denied' };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Clear all messages in a conversation
+ *
+ * Deletes messages in batches to handle large conversations.
+ * The conversation itself is preserved.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param conversationId - The conversation to clear
+ * @returns Success with count of deleted messages
+ *
+ * Requirements: 4.6
+ */
+export async function clearConversationMessages(
+  supabase: SupabaseClientType,
+  conversationId: string
+): Promise<ClearMessagesResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!conversationId) {
+    return { success: false, error: 'Conversation ID is required' };
+  }
+
+  const userId = authData.user.id;
+
+  // Verify user owns the conversation
+  const { data: conversation, error: convError } = await supabase
+    .from('conversations')
+    .select('id')
+    .eq('id', conversationId)
+    .eq('user_id', userId)
+    .single();
+
+  if (convError || !conversation) {
+    return { success: false, error: 'Conversation not found or access denied' };
+  }
+
+  let totalDeleted = 0;
+  let hasMore = true;
+
+  // Delete in batches
+  while (hasMore) {
+    // Get batch of message IDs
+    const { data: messagesToDelete, error: fetchError } = await supabase
+      .from('messages')
+      .select('id')
+      .eq('conversation_id', conversationId)
+      .limit(BATCH_DELETE_SIZE);
+
+    if (fetchError) {
+      return { success: false, error: `Failed to fetch messages: ${fetchError.message}` };
+    }
+
+    if (!messagesToDelete || messagesToDelete.length === 0) {
+      hasMore = false;
+      break;
+    }
+
+    const idsToDelete = messagesToDelete.map((m) => m.id);
+
+    // Delete the batch
+    const { error: deleteError } = await supabase
+      .from('messages')
+      .delete()
+      .in('id', idsToDelete);
+
+    if (deleteError) {
+      return { success: false, error: `Failed to delete messages: ${deleteError.message}` };
+    }
+
+    totalDeleted += idsToDelete.length;
+
+    // Check if we got a full batch (might be more)
+    hasMore = messagesToDelete.length === BATCH_DELETE_SIZE;
+  }
+
+  return { success: true, deletedCount: totalDeleted };
+}
+
+export const messagesService = {
+  storeMessage,
+  listMessages,
+  deleteUserMessage,
+  clearConversationMessages,
+};

package/recipes/chatbot-supabase/packages/backend/supabase/functions/chat-stream/index.ts

@@ -0,0 +1,347 @@
+/**
+ * Chat Stream Edge Function
+ *
+ * Handles AI chat with real-time streaming via Supabase Realtime Broadcast.
+ * Broadcasts chunks as they arrive, client subscribes to channel.
+ */
+
+import 'jsr:@supabase/functions-js/edge-runtime.d.ts';
+import { createClient } from 'npm:@supabase/supabase-js@2';
+import { streamText } from 'npm:ai@5.0.98';
+import { createOpenAI } from 'npm:@ai-sdk/openai@2.0.71';
+import { createGoogleGenerativeAI } from 'npm:@ai-sdk/google@2.0.40';
+
+const corsHeaders = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Headers':
+    'authorization, x-client-info, apikey, content-type',
+  'Access-Control-Allow-Methods': 'POST, OPTIONS',
+};
+
+interface ChatStreamRequest {
+  conversationId: string;
+  message: string;
+  attachments?: Array<{
+    type: string;
+    url?: string;
+    data?: string;
+    mimeType?: string;
+  }>;
+  preferredModel?: string;
+  preferredProvider?: 'openai' | 'google';
+  streamId?: string; // Client-provided channel ID for broadcast
+}
+
+interface Message {
+  id: string;
+  author_type: 'user' | 'bot';
+  text: string | null;
+  created_at: string;
+}
+
+Deno.serve(async (req: Request) => {
+  if (req.method === 'OPTIONS') {
+    return new Response('ok', { headers: corsHeaders });
+  }
+
+  if (req.method !== 'POST') {
+    return new Response(JSON.stringify({ error: 'Method not allowed' }), {
+      status: 405,
+      headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const authHeader = req.headers.get('Authorization');
+    if (!authHeader) {
+      return new Response(JSON.stringify({ error: 'Missing authorization header' }), {
+        status: 401,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      });
+    }
+
+    const token = authHeader.replace('Bearer ', '');
+    const supabaseUrl = Deno.env.get('SUPABASE_URL')!;
+    const supabaseAnonKey = Deno.env.get('SUPABASE_ANON_KEY')!;
+    const supabaseServiceKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!;
+    
+    // User client for auth verification
+    const supabaseUser = createClient(supabaseUrl, supabaseAnonKey, {
+      global: { headers: { Authorization: `Bearer ${token}` } },
+    });
+    
+    // Service client for DB operations (bypasses RLS)
+    const supabase = createClient(supabaseUrl, supabaseServiceKey);
+
+    const { data: { user }, error: authError } = await supabaseUser.auth.getUser();
+    if (authError || !user) {
+      return new Response(JSON.stringify({ error: 'Invalid or expired token' }), {
+        status: 401,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      });
+    }
+
+    const body: ChatStreamRequest = await req.json();
+    const { conversationId, message, attachments, preferredModel, preferredProvider, streamId } = body;
+
+    if (!conversationId || !message) {
+      return new Response(
+        JSON.stringify({ error: 'conversationId and message are required' }),
+        {
+          status: 400,
+          headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Verify user owns the conversation
+    const { data: conversation, error: convError } = await supabase
+      .from('conversations')
+      .select('id, user_id')
+      .eq('id', conversationId)
+      .single();
+
+    if (convError || !conversation) {
+      return new Response(JSON.stringify({ error: 'Conversation not found' }), {
+        status: 404,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      });
+    }
+
+    if (conversation.user_id !== user.id) {
+      return new Response(JSON.stringify({ error: 'Access denied to conversation' }), {
+        status: 403,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      });
+    }
+
+    // Retrieve conversation history
+    const { data: messages, error: msgError } = await supabase
+      .from('messages')
+      .select('id, author_type, text, created_at')
+      .eq('conversation_id', conversationId)
+      .order('created_at', { ascending: true })
+      .limit(50);
+
+    if (msgError) {
+      console.error('Error fetching messages:', msgError);
+    }
+
+    // Build conversation history for AI - filter out empty messages
+    const conversationHistory = (messages || [])
+      .filter((msg: Message) => msg.text && msg.text.trim().length > 0)
+      .map((msg: Message) => ({
+        role: msg.author_type === 'user' ? 'user' : 'assistant',
+        content: msg.text!,
+      }));
+
+    // Add the current user message (include attachments as multimodal parts)
+    const userParts: Array<
+      | { type: 'text'; text: string }
+      | { type: 'image'; image: string; mimeType?: string }
+    > = [{ type: 'text', text: message }];
+
+    (attachments || [])
+      .filter((att) => att?.url)
+      .forEach((att) => {
+        userParts.push({
+          type: 'image',
+          image: att.url!,
+          mimeType: att.mimeType || 'image/jpeg',
+        });
+      });
+
+    conversationHistory.push({
+      role: 'user',
+      content: userParts,
+    });
+    
+    console.log('Filtered conversation history:', conversationHistory.length, 'messages');
+
+    // Model mapping
+    const modelMapping: Record<string, { provider: 'openai' | 'google'; model: string }> = {
+      'gpt-5': { provider: 'openai', model: 'gpt-4o' },
+      'gpt-5-mini': { provider: 'openai', model: 'gpt-4o-mini' },
+      'gpt-5-nano': { provider: 'openai', model: 'gpt-4o-mini' },
+      'gpt-4o': { provider: 'openai', model: 'gpt-4o' },
+      'gpt-4o-mini': { provider: 'openai', model: 'gpt-4o-mini' },
+      'gemini-2.0-flash': { provider: 'google', model: 'gemini-2.0-flash' },
+      'gemini-2.5-flash': { provider: 'google', model: 'gemini-2.0-flash' },
+      'gemini-2.5-pro': { provider: 'google', model: 'gemini-1.5-pro' },
+    };
+
+    const mappedModel = preferredModel ? modelMapping[preferredModel] : null;
+    const provider = mappedModel?.provider || preferredProvider || 'openai';
+    let model;
+    let aiProvider: string;
+    let aiModel: string;
+
+    if (provider === 'google') {
+      const googleApiKey = Deno.env.get('GEMINI_API_KEY');
+      if (!googleApiKey) {
+        return new Response(JSON.stringify({ error: 'Google AI not configured' }), {
+          status: 500,
+          headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+        });
+      }
+      const google = createGoogleGenerativeAI({ apiKey: googleApiKey });
+      aiModel = mappedModel?.model || preferredModel || 'gemini-2.0-flash';
+      model = google(aiModel);
+      aiProvider = 'google';
+    } else {
+      const openaiApiKey = Deno.env.get('OPENAI_API_KEY');
+      if (!openaiApiKey) {
+        return new Response(JSON.stringify({ error: 'OpenAI not configured' }), {
+          status: 500,
+          headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+        });
+      }
+      const openai = createOpenAI({ apiKey: openaiApiKey });
+      aiModel = mappedModel?.model || preferredModel || 'gpt-4o-mini';
+      model = openai(aiModel);
+      aiProvider = 'openai';
+    }
+
+    // CREATE BOT MESSAGE IMMEDIATELY with is_streaming = true
+    const { data: botMessage, error: createError } = await supabase
+      .from('messages')
+      .insert({
+        conversation_id: conversationId,
+        user_id: user.id,
+        author_type: 'bot',
+        text: null,
+        streaming_content: '',
+        is_streaming: true,
+        ai_provider: aiProvider,
+        ai_model: aiModel,
+      })
+      .select('id')
+      .single();
+
+    if (createError || !botMessage) {
+      console.error('Error creating bot message:', createError);
+      return new Response(JSON.stringify({ error: 'Failed to create message' }), {
+        status: 500,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      });
+    }
+
+    const messageId = botMessage.id;
+    console.log('Created streaming message:', messageId);
+
+    // Create broadcast channel using client-provided streamId
+    const channelName = streamId ? `stream:${streamId}` : `chat:${messageId}`;
+    console.log('Using broadcast channel:', channelName);
+    const channel = supabase.channel(channelName);
+    
+    // Subscribe to channel (required before sending)
+    await new Promise<void>((resolve) => {
+      channel.subscribe((status) => {
+        if (status === 'SUBSCRIBED') {
+          console.log('Broadcast channel ready:', channelName);
+          resolve();
+        }
+      });
+    });
+
+    let fullResponse = '';
+
+    try {
+      console.log('Starting AI stream with model:', aiModel, 'provider:', aiProvider);
+      console.log('Conversation history:', JSON.stringify(conversationHistory));
+      
+      const result = streamText({
+        model,
+        messages: conversationHistory as any,
+        system: 'You are a helpful AI assistant. Be concise and helpful.',
+      });
+
+      console.log('streamText called, iterating textStream...');
+      
+      // Stream chunks and broadcast each one
+      let chunkCount = 0;
+      for await (const chunk of result.textStream) {
+        chunkCount++;
+        fullResponse += chunk;
+        console.log(`Chunk ${chunkCount}: "${chunk.substring(0, 20)}..." (total: ${fullResponse.length})`);
+        
+        // Broadcast chunk to client
+        await channel.send({
+          type: 'broadcast',
+          event: 'chunk',
+          payload: { chunk, accumulated: fullResponse },
+        });
+      }
+
+      console.log('Stream completed, chunks:', chunkCount, 'total length:', fullResponse.length);
+      
+      if (fullResponse.length === 0) {
+        fullResponse = 'I apologize, but I was unable to generate a response. Please try again.';
+      }
+
+      // Broadcast completion
+      await channel.send({
+        type: 'broadcast',
+        event: 'done',
+        payload: { content: fullResponse, msgId: messageId },
+      });
+
+      // Final DB update
+      await supabase
+        .from('messages')
+        .update({
+          text: fullResponse,
+          streaming_content: fullResponse,
+          is_streaming: false,
+        })
+        .eq('id', messageId);
+
+      // Cleanup channel
+      await supabase.removeChannel(channel);
+
+      return new Response(
+        JSON.stringify({ success: true, messageId, content: fullResponse }),
+        { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+      );
+    } catch (error) {
+      console.error('AI error:', error);
+      console.error('Error name:', (error as Error)?.name);
+      console.error('Error message:', (error as Error)?.message);
+      console.error('Error stack:', (error as Error)?.stack);
+      
+      // Broadcast error
+      await channel.send({
+        type: 'broadcast',
+        event: 'error',
+        payload: { error: String(error) },
+      });
+      
+      await supabase.removeChannel(channel);
+      
+      await supabase
+        .from('messages')
+        .update({
+          text: 'Sorry, an error occurred.',
+          streaming_content: null,
+          is_streaming: false,
+        })
+        .eq('id', messageId);
+
+      return new Response(
+        JSON.stringify({ success: false, messageId, error: String(error) }),
+        { status: 500, headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+      );
+    }
+  } catch (error) {
+    console.error('Chat stream error:', error);
+    return new Response(
+      JSON.stringify({
+        error: error instanceof Error ? error.message : 'Internal server error',
+      }),
+      {
+        status: 500,
+        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+      }
+    );
+  }
+});