vibefast-cli 0.2.4 → 0.3.1

package/2/packages/backend/convex/schema.ts

@@ -0,0 +1,237 @@
+import { authTables } from '@convex-dev/auth/server';
+import { defineSchema, defineTable } from 'convex/server';
+import { v } from 'convex/values';
+
+export default defineSchema({
+  // Include all authTables but we'll override users to extend it
+  ...authTables,
+
+  // Override/extend the users table from authTables with additional fields
+  users: defineTable({
+    // Standard auth fields that would be in authTables.users
+    name: v.optional(v.string()),
+    email: v.optional(v.string()),
+    phone: v.optional(v.string()),
+    image: v.optional(v.string()),
+    emailVerificationTime: v.optional(v.number()),
+    phoneVerificationTime: v.optional(v.number()),
+    isAnonymous: v.optional(v.boolean()),
+    // Add our custom emailVerified field
+    emailVerified: v.optional(v.number()), // timestamp when email was verified
+    // Add credits field for payments
+    credits: v.optional(v.number()),
+    agentRateLimitWindowStart: v.optional(v.number()),
+    agentRateLimitCount: v.optional(v.number()),
+    toolRateLimitWindowStart: v.optional(v.number()),
+    toolRateLimitCount: v.optional(v.number()),
+  })
+    .index('email', ['email'])
+    .index('phone', ['phone']), // Preserve default auth indexes
+
+  passwordResetTokens: defineTable({
+    userId: v.id('users'), // Assuming the users table from authTables is named 'users'
+    token: v.string(),
+    expiresAt: v.number(),
+    used: v.boolean(),
+  })
+    .index('by_token', ['token'])
+    .index('by_userId_and_used', ['userId', 'used'])
+    .index('by_used', ['used']),
+
+  otps: defineTable({
+    email: v.string(), // Could be email or phone number
+    token: v.string(),
+    expires: v.number(),
+  })
+    .index('by_email_and_token', ['email', 'token'])
+    .index('by_email', ['email']), // To easily find/invalidate old OTPs for a user
+
+  // Chatbot tables:
+  conversations: defineTable({
+    userId: v.id('users'),
+    name: v.optional(v.string()),
+  }).index('by_userId', ['userId']),
+
+  messages: defineTable({
+    conversationId: v.id('conversations'),
+    userId: v.id('users'),
+    authorType: v.union(v.literal('user'), v.literal('bot')),
+    text: v.optional(v.string()),
+    aiProvider: v.optional(v.string()),
+    aiModel: v.optional(v.string()),
+    toolCalls: v.optional(
+      v.array(
+        v.object({
+          toolName: v.string(),
+          args: v.any(),
+          result: v.optional(v.any()),
+        }),
+      ),
+    ),
+    metadata: v.optional(
+      v.object({
+        streamId: v.optional(v.string()),
+        usage: v.optional(
+          v.object({
+            promptTokens: v.number(),
+            completionTokens: v.number(),
+            totalTokens: v.number(),
+          }),
+        ),
+        status: v.optional(v.string()),
+      }),
+    ),
+    attachments: v.optional(
+      v.array(
+        v.object({
+          type: v.union(v.literal('image')),
+          storageId: v.id('_storage'),
+          url: v.optional(v.string()),
+          fileName: v.optional(v.string()),
+          mimeType: v.optional(v.string()),
+        }),
+      ),
+    ),
+  }).index('by_conversationId', ['conversationId']),
+
+  knowledgeFiles: defineTable({
+    entryId: v.string(),
+    namespace: v.string(),
+    filename: v.string(),
+    storageId: v.id('_storage'),
+    uploadedBy: v.id('users'),
+    global: v.boolean(),
+    category: v.optional(v.string()),
+    title: v.optional(v.string()),
+    status: v.optional(
+      v.union(v.literal('pending'), v.literal('ready'), v.literal('error')),
+    ),
+    lastError: v.optional(v.string()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index('by_entryId', ['entryId'])
+    .index('by_namespace', ['namespace'])
+    .index('by_storageId', ['storageId']),
+
+  agentSessions: defineTable({
+    conversationId: v.id('conversations'),
+    userId: v.id('users'),
+    agentThreadId: v.string(),
+    activeStreamId: v.optional(v.string()),
+    lastUserMessageId: v.optional(v.id('messages')),
+    lastAssistantMessageId: v.optional(v.id('messages')),
+    preferredModel: v.optional(v.string()),
+    updatedAt: v.number(),
+    lastErrorMessage: v.optional(v.string()),
+    lastErrorAt: v.optional(v.number()),
+    currentStatus: v.optional(
+      v.object({
+        type: v.union(v.literal('thinking'), v.literal('tool')),
+        label: v.optional(v.string()),
+        toolName: v.optional(v.string()),
+        startedAt: v.number(),
+      }),
+    ),
+  })
+    .index('by_conversationId', ['conversationId'])
+    .index('by_agentThreadId', ['agentThreadId']),
+
+  // AI Content Reporting table:
+  reportedAIContent: defineTable({
+    userId: v.id('users'),
+    contentId: v.string(), // Can be messageId or storageId
+    contentType: v.union(
+      v.literal('chat_message'),
+      v.literal('generated_image'),
+    ),
+    relatedImageId: v.optional(v.id('generatedImages')),
+    relatedStorageId: v.optional(v.id('_storage')),
+    reason: v.string(),
+    details: v.optional(v.string()),
+    reportTimestamp: v.number(),
+    status: v.union(
+      v.literal('open'),
+      v.literal('resolved'),
+      v.literal('dismissed'),
+    ),
+  }).index('by_contentType_and_status', ['contentType', 'status']),
+
+  // Voice Notes table:
+  recordings: defineTable({
+    userId: v.id('users'),
+    name: v.optional(v.string()),
+    fileUri: v.string(),
+    duration: v.number(),
+    createdAt: v.number(),
+    status: v.union(v.literal('draft'), v.literal('completed')),
+    metering: v.optional(v.array(v.number())), // <-- ADD THIS LINE
+  })
+    .index('by_userId', ['userId'])
+    .index('by_userId_and_status', ['userId', 'status']),
+
+  imageAnalyses: defineTable({
+    userId: v.id('users'),
+    status: v.union(
+      v.literal('processing'),
+      v.literal('completed'),
+      v.literal('failed'),
+    ),
+    imageStorageIds: v.array(v.id('_storage')),
+    analysisConfigId: v.optional(v.string()), // Links to backend analysis config (optional for backward compatibility)
+    preferences: v.union(
+      v.object({
+        goal: v.string(),
+        feedbackStyle: v.string(),
+      }),
+      v.object({
+        analysisGoal: v.string(), // Legacy field name for backward compatibility
+        feedbackStyle: v.string(),
+      }),
+    ),
+    results: v.optional(v.any()), // JSON results from AI analysis
+    errorMessage: v.optional(v.string()),
+  }).index('by_userId', ['userId']),
+
+  generatedImages: defineTable({
+    userId: v.id('users'),
+    prompt: v.string(),
+    imageUrl: v.optional(v.string()),
+    storageId: v.optional(v.id('_storage')),
+    mimeType: v.optional(v.string()),
+    provider: v.string(), // e.g., 'openai', 'gemini'
+    model: v.string(), // e.g., 'dall-e-3', 'imagen'
+  }).index('by_userId', ['userId']),
+
+  // Purchases table for payment tracking:
+  purchases: defineTable({
+    userId: v.id('users'),
+    productId: v.string(),
+    quantity: v.number(),
+    creditsAdded: v.number(),
+    purchaseDate: v.number(),
+  }).index('by_userId', ['userId']),
+
+  // Device grants table for free tier tracking:
+  deviceGrants: defineTable({
+    deviceId: v.string(),
+    grantType: v.string(), // e.g., 'initial_free_tier'
+    grantedAt: v.number(),
+    userId: v.optional(v.id('users')), // Track which user received the grant
+  })
+    .index('by_deviceId', ['deviceId'])
+    .index('by_deviceId_and_grantType', ['deviceId', 'grantType']),
+
+  pushTokens: defineTable({
+    userId: v.id('users'),
+    token: v.string(),
+    paused: v.boolean(),
+    deviceInfo: v.optional(
+      v.object({
+        platform: v.string(),
+        deviceId: v.string(),
+        appVersion: v.string(),
+      }),
+    ),
+  }).index('by_userId', ['userId']),
+});

package/2/packages/backend/convex/shared/email.ts

@@ -0,0 +1,172 @@
+'use node';
+
+import React from 'react';
+import { v } from 'convex/values';
+import { Resend } from 'resend';
+import { render } from '@react-email/render';
+
+import { internalAction } from '../_generated/server';
+import { APP_CONFIG, EMAIL_CONFIG } from '../lib/config';
+import { PasswordResetEmail } from './templates/PasswordResetEmail';
+import { VerificationCodeEmail } from './templates/VerificationCodeEmail';
+
+type EmailResult =
+  | { success: true; messageId: string }
+  | { success: false; error: string };
+
+async function sendEmailCore({
+  to,
+  subject,
+  html,
+}: {
+  to: string;
+  subject: string;
+  html: string;
+}): Promise<EmailResult> {
+  const apiKey = process.env.AUTH_RESEND_KEY;
+  const fromEmail = process.env.AUTH_EMAIL;
+
+  if (!apiKey) {
+    console.error('AUTH_RESEND_KEY environment variable is not set');
+    return { success: false, error: 'email_service_not_configured' };
+  }
+
+  if (!fromEmail) {
+    console.error('AUTH_EMAIL environment variable is not set');
+    return { success: false, error: 'sender_email_not_configured' };
+  }
+
+  try {
+    const resend = new Resend(apiKey);
+
+    const { data, error } = await resend.emails.send({
+      from: fromEmail,
+      to: [to],
+      subject,
+      html,
+    });
+
+    if (error) {
+      console.error('Resend API error:', error);
+      return { success: false, error: 'email_send_failed' };
+    }
+
+    console.log(`Email sent successfully to ${to}, message ID: ${data?.id}`);
+    return { success: true, messageId: data?.id || 'unknown' };
+  } catch (e: any) {
+    console.error('Exception during email sending:', e.message);
+    return { success: false, error: 'email_send_exception' };
+  }
+}
+
+/**
+ * Sends an email using Resend.
+ * Public action for general email sending.
+ */
+export const sendEmail = internalAction({
+  args: {
+    to: v.string(),
+    subject: v.string(),
+    html: v.string(),
+  },
+  returns: v.union(
+    v.object({ success: v.literal(true), messageId: v.string() }),
+    v.object({ success: v.literal(false), error: v.string() }),
+  ),
+  handler: async (_ctx, { to, subject, html }): Promise<EmailResult> => {
+    return sendEmailCore({ to, subject, html });
+  },
+});
+
+/**
+ * Generates a professional OTP email template.
+ */
+async function generateOtpEmailTemplate(
+  otp: string,
+  name?: string,
+): Promise<string> {
+  const expiresInMinutes = Math.floor(EMAIL_CONFIG.OTP.EXPIRY_SECONDS / 60);
+
+  return render(
+    React.createElement(VerificationCodeEmail, {
+      appName: APP_CONFIG.NAME,
+      code: otp,
+      expiresInMinutes,
+      recipientName: name,
+    }),
+    { pretty: true },
+  );
+}
+
+/**
+ * Internal action to send OTP verification email.
+ * This is used specifically for the authentication flow.
+ */
+export const sendVerificationOtpEmail = internalAction({
+  args: {
+    email: v.string(),
+    otp: v.string(),
+    name: v.optional(v.string()),
+  },
+  returns: v.union(
+    v.object({ success: v.literal(true), messageId: v.string() }),
+    v.object({ success: v.literal(false), error: v.string() }),
+  ),
+  handler: async (_ctx, { email, otp, name }): Promise<EmailResult> => {
+    const htmlTemplate = await generateOtpEmailTemplate(otp, name);
+    return sendEmailCore({
+      to: email,
+      subject: EMAIL_CONFIG.SUBJECTS.EMAIL_VERIFICATION,
+      html: htmlTemplate,
+    });
+  },
+});
+
+/**
+ * Generates a professional password reset email template.
+ */
+async function generatePasswordResetEmailTemplate(
+  resetLink: string,
+  userName?: string,
+): Promise<string> {
+  return render(
+    React.createElement(PasswordResetEmail, {
+      appName: APP_CONFIG.NAME,
+      resetLink,
+      recipientName: userName,
+      supportEmail: APP_CONFIG.SUPPORT_EMAIL,
+    }),
+    { pretty: true },
+  );
+}
+
+/**
+ * Internal action to send password reset email.
+ * This is used specifically for the password reset flow.
+ */
+export const sendPasswordResetEmail = internalAction({
+  args: {
+    email: v.string(),
+    resetLink: v.string(),
+    userName: v.optional(v.string()),
+  },
+  returns: v.union(
+    v.object({ success: v.literal(true), messageId: v.string() }),
+    v.object({ success: v.literal(false), error: v.string() }),
+  ),
+  handler: async (
+    _ctx,
+    { email, resetLink, userName },
+  ): Promise<EmailResult> => {
+    const htmlTemplate = await generatePasswordResetEmailTemplate(
+      resetLink,
+      userName,
+    );
+
+    return sendEmailCore({
+      to: email,
+      subject: EMAIL_CONFIG.SUBJECTS.PASSWORD_RESET,
+      html: htmlTemplate,
+    });
+  },
+});

package/2/packages/backend/convex/shared/files.ts

@@ -0,0 +1,96 @@
+import { v } from 'convex/values';
+
+import { mutation, query } from '../_generated/server';
+
+/**
+ * Generate a temporary upload URL for file uploads to Convex File Storage.
+ *
+ * @returns A URL that clients can use to upload files directly to Convex storage
+ */
+export const generateUploadUrl = mutation({
+  args: {},
+  returns: v.string(),
+  handler: async (ctx) => {
+    return await ctx.storage.generateUploadUrl();
+  },
+});
+
+/**
+ * Get the URL for a stored file by its storage ID.
+ *
+ * Note: This function does not enforce access control directly because:
+ * 1. Storage URLs are temporary and expire automatically
+ * 2. Storage IDs are obtained from parent resources (messages, analyses, knowledge files)
+ *    which already have access control
+ * 3. Storage IDs are effectively unguessable UUIDs
+ *
+ * If you need strict access control, verify ownership of the parent resource
+ * before calling this function.
+ *
+ * @param storageId - The storage ID of the file
+ * @returns The temporary URL to access the file, or null if not found
+ */
+export const getStorageUrl = query({
+  args: {
+    storageId: v.id('_storage'),
+  },
+  returns: v.union(v.string(), v.null()),
+  handler: async (ctx, args) => {
+    try {
+      return await ctx.storage.getUrl(args.storageId);
+    } catch (error) {
+      console.error('Error getting storage URL:', error);
+      return null;
+    }
+  },
+});
+
+/**
+ * Batch fetch URLs for multiple storage IDs to optimize performance.
+ *
+ * @param storageIds - Array of storage IDs to fetch URLs for
+ * @returns Map of storage ID to URL (or null if not found)
+ */
+export const getUrlsForStorageIds = query({
+  args: { storageIds: v.array(v.id('_storage')) },
+  returns: v.record(v.string(), v.union(v.string(), v.null())),
+  handler: async (ctx, { storageIds }) => {
+    const urlPromises = storageIds.map(async (id) => {
+      try {
+        return await ctx.storage.getUrl(id);
+      } catch (error) {
+        console.error(`Error getting storage URL for ${id}:`, error);
+        return null;
+      }
+    });
+
+    const urls = await Promise.all(urlPromises);
+    const urlMap: Record<string, string | null> = {};
+
+    storageIds.forEach((id, index) => {
+      urlMap[id] = urls[index];
+    });
+
+    return urlMap;
+  },
+});
+
+/**
+ * Delete an uploaded file from storage.
+ * Used when user removes an image before sending the message.
+ *
+ * @param storageId - The storage ID of the file to delete
+ */
+export const deleteUploadedFile = mutation({
+  args: {
+    storageId: v.id('_storage'),
+  },
+  handler: async (ctx, { storageId }) => {
+    try {
+      await ctx.storage.delete(storageId);
+    } catch (error) {
+      console.error('Error deleting file from storage:', error);
+      // Don't throw - allow UI to continue even if deletion fails
+    }
+  },
+});

package/2/packages/backend/convex/shared/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared Utilities Domain Aggregator
+ *
+ * Single entry point for all shared utility Convex functions.
+ * Re-exports functions from shared modules to decouple
+ * frontend from internal file structure.
+ */
+
+// Email utilities
+export * from './email';
+// File storage utilities
+export {
+  deleteUploadedFile,
+  generateUploadUrl,
+  getStorageUrl,
+  getUrlsForStorageIds,
+} from './files';

package/2/packages/backend/convex/shared/templates/PasswordResetEmail.tsx

@@ -0,0 +1,72 @@
+import {
+  Button,
+  Container,
+  Head,
+  Heading,
+  Html,
+  Section,
+  Tailwind,
+  Text,
+} from '@react-email/components';
+
+export function PasswordResetEmail({
+  appName,
+  resetLink,
+  recipientName,
+  supportEmail,
+}: {
+  appName: string;
+  resetLink: string;
+  recipientName?: string;
+  supportEmail: string;
+}) {
+  const greeting = recipientName ? `Hi ${recipientName}` : 'Hello';
+
+  return (
+    <Html>
+      <Tailwind>
+        <Head />
+        <Container className="mx-auto max-w-[600px] bg-white p-8 font-sans text-[#1f2937]">
+          <Heading className="mb-2 text-2xl font-semibold text-[#111827]">
+            Reset your password for {appName}
+          </Heading>
+          <Text className="mb-4 text-base leading-relaxed text-[#374151]">
+            {greeting},
+          </Text>
+          <Text className="mb-4 text-base leading-relaxed text-[#374151]">
+            We received a request to reset the password for your {appName} account.
+            If this was you, click the button below to choose a new password.
+          </Text>
+          <Section className="my-6 text-center">
+            <Button
+              href={resetLink}
+              className="inline-block rounded-lg bg-[#2563eb] px-6 py-3 text-base font-semibold text-white no-underline hover:bg-[#1d4ed8]"
+            >
+              Reset password
+            </Button>
+          </Section>
+          <Text className="mb-4 text-sm leading-relaxed text-[#4b5563]">
+            If the button doesn&apos;t work, copy and paste this link into your
+            browser:
+          </Text>
+          <Text className="rounded-md bg-[#f3f4f6] p-3 font-mono text-xs leading-relaxed text-[#374151]">
+            {resetLink}
+          </Text>
+          <Section className="mt-6 rounded-md border-l-4 border-[#f59e0b] bg-[#fef3c7] px-4 py-3 text-sm leading-relaxed text-[#92400e]">
+            <Text className="m-0">
+              This link expires in 1 hour. If you didn&apos;t request a password
+              reset, you can ignore this message and your password will stay the same.
+            </Text>
+          </Section>
+          <Text className="mt-6 text-sm leading-relaxed text-[#6b7280]">
+            Thanks,<br />
+            The {appName} team
+          </Text>
+          <Text className="mt-8 border-t border-[#e5e7eb] pt-4 text-xs leading-relaxed text-[#9ca3af]">
+            Need help? Contact us anytime at {supportEmail}.
+          </Text>
+        </Container>
+      </Tailwind>
+    </Html>
+  );
+}

package/2/packages/backend/convex/shared/templates/VerificationCodeEmail.tsx

@@ -0,0 +1,65 @@
+import {
+  Container,
+  Head,
+  Heading,
+  Html,
+  Section,
+  Tailwind,
+  Text,
+} from '@react-email/components';
+
+export function VerificationCodeEmail({
+  appName,
+  code,
+  expiresInMinutes,
+  recipientName,
+}: {
+  appName: string;
+  code: string;
+  expiresInMinutes: number;
+  recipientName?: string;
+}) {
+  const greeting = recipientName ? `Hi ${recipientName}` : 'Hello';
+
+  return (
+    <Html>
+      <Tailwind>
+        <Head />
+        <Container className="mx-auto max-w-[600px] bg-white p-8 font-sans text-[#1f2937]">
+          <Heading className="mb-2 text-2xl font-semibold text-[#111827]">
+            Verify your email for {appName}
+          </Heading>
+          <Text className="mb-4 text-base leading-relaxed text-[#374151]">
+            {greeting},
+          </Text>
+          <Text className="mb-4 text-base leading-relaxed text-[#374151]">
+            To finish setting up your account, please enter the verification code
+            below. It expires in {expiresInMinutes} minutes.
+          </Text>
+          <Section className="my-6 rounded-lg border border-dashed border-[#d1d5db] bg-[#f9fafb] px-6 py-5 text-center shadow-sm">
+            <Text className="text-sm uppercase tracking-wide text-[#6b7280]">
+              Your verification code
+            </Text>
+            <Text className="mt-3 font-mono text-4xl font-bold tracking-[0.4em] text-[#111827]">
+              {code}
+            </Text>
+          </Section>
+          <Section className="rounded-md border-l-4 border-[#f59e0b] bg-[#fef3c7] px-4 py-3 text-sm leading-relaxed text-[#92400e]">
+            <Text className="m-0">
+              Keep this code private. If you didn&apos;t request it, you can ignore
+              this email safely.
+            </Text>
+          </Section>
+          <Text className="mt-6 text-sm leading-relaxed text-[#6b7280]">
+            Thanks,<br />
+            The {appName} team
+          </Text>
+          <Text className="mt-8 border-t border-[#e5e7eb] pt-4 text-xs leading-relaxed text-[#9ca3af]">
+            You received this email because a sign-in attempt was made with your
+            address. If this wasn&apos;t you, no further action is needed.
+          </Text>
+        </Container>
+      </Tailwind>
+    </Html>
+  );
+}