vibefast-cli 0.2.4 → 0.3.0

package/2/packages/backend/convex/lib/config.ts

@@ -0,0 +1,111 @@
+/**
+ * Convex Backend Configuration
+ *
+ * This file centralizes all configuration constants used across the Convex backend.
+ * It provides a single source of truth for app settings, URLs, and other constants.
+ */
+
+/**
+ * App branding and identity configuration
+ */
+export const APP_CONFIG = {
+  NAME: 'VibeFast',
+  SCHEME: 'vibefast://',
+  SUPPORT_EMAIL: 'support@vibefast.pro',
+  NOREPLY_EMAIL: 'noreply@vibefast.pro',
+} as const;
+
+/**
+ * OAuth and authentication configuration
+ */
+export const AUTH_CONFIG = {
+  // Allowed redirect URLs for OAuth flows
+  // These are the final redirect URLs AFTER Convex processes the OAuth callback
+  ALLOWED_REDIRECTS: [
+    'vibefast://', // Mobile app deep link
+    'http://localhost:3000', // Local dev web (default Next.js port)
+    'http://localhost:3002', // Local dev web (alternative port)
+    // Add production URLs when deploying:
+    // 'https://yourdomain.com',
+  ] as string[],
+
+  // Determines if OTP verification is required for new email/password sign-ups
+  SEND_OTP_ON_SIGNUP: process.env.SEND_OTP_ON_SIGNUP === 'true',
+} as const;
+
+/**
+ * Email configuration
+ */
+export const EMAIL_CONFIG = {
+  // Email provider type
+  PROVIDER: 'resend',
+
+  // Default email settings
+  DEFAULT_FROM_EMAIL:
+    process.env.AUTH_EMAIL ||
+    `${APP_CONFIG.NAME} <${APP_CONFIG.NOREPLY_EMAIL}>`,
+
+  // OTP settings
+  OTP: {
+    LENGTH: 6,
+    EXPIRY_SECONDS: 600, // 10 minutes
+  },
+
+  // Email subjects
+  SUBJECTS: {
+    EMAIL_VERIFICATION: `Verify your email address - ${APP_CONFIG.NAME}`,
+    PASSWORD_RESET: `Reset your password - ${APP_CONFIG.NAME}`,
+  },
+} as const;
+
+/**
+ * File upload configuration
+ */
+export const FILE_CONFIG = {
+  // Image processing settings
+  MAX_IMAGE_DIMENSION: 1024,
+  COMPRESSION_QUALITY: 0.7,
+  MAX_FILE_SIZE_MB: 2,
+  MAX_FILE_SIZE_BYTES: 2 * 1024 * 1024, // 2MB
+} as const;
+
+/**
+ * External API configuration
+ */
+export const API_CONFIG = {
+  // Tavily Search API
+  TAVILY: {
+    BASE_URL: 'https://api.tavily.com/search',
+  },
+} as const;
+
+/**
+ * Push notification configuration
+ */
+export const NOTIFICATION_CONFIG = {
+  TEST_MESSAGE: {
+    title: 'Test Notification',
+    body: `This is a test notification from ${APP_CONFIG.NAME}! If you received this, push notifications are working correctly.`,
+  },
+} as const;
+
+/**
+ * Deep link configuration
+ */
+/**
+ * Environment and deployment configuration
+ */
+export const DEPLOYMENT_CONFIG = {
+  CONVEX_SITE_URL: process.env.CONVEX_SITE_URL,
+  CONVEX_URL: process.env.CONVEX_URL,
+} as const;
+
+/**
+ * Helper functions for configuration access
+ */
+export const getAppScheme = () => APP_CONFIG.SCHEME;
+
+export const getDefaultFromEmail = () => EMAIL_CONFIG.DEFAULT_FROM_EMAIL;
+
+export const getAllowedRedirects = (): string[] =>
+  AUTH_CONFIG.ALLOWED_REDIRECTS;

package/2/packages/backend/convex/lib/rateLimit.ts

@@ -0,0 +1,100 @@
+import type { Id } from '../_generated/dataModel';
+import type { MutationCtx } from '../_generated/server';
+
+const AGENT_WINDOW_MS = 60 * 1000; // 1 minute
+const AGENT_LIMIT = 12; // max agent calls per window
+
+const TOOL_WINDOW_MS = 60 * 1000;
+const TOOL_LIMIT = 20;
+
+type RateLimitFields =
+  | [
+      'agentRateLimitWindowStart',
+      'agentRateLimitCount',
+      typeof AGENT_WINDOW_MS,
+      typeof AGENT_LIMIT,
+    ]
+  | [
+      'toolRateLimitWindowStart',
+      'toolRateLimitCount',
+      typeof TOOL_WINDOW_MS,
+      typeof TOOL_LIMIT,
+    ];
+
+const getNow = () => Date.now();
+
+async function enforceRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+  [windowField, countField, windowMs, limit]: RateLimitFields,
+  friendlyName: string,
+) {
+  const userDoc = await db.get(userId);
+  if (!userDoc) {
+    throw new Error('User not found while enforcing rate limit.');
+  }
+
+  const nowMs = getNow();
+  const record = userDoc as unknown as Record<string, number | undefined>;
+  const windowStart = record[windowField] ?? 0;
+  const currentCount = record[countField] ?? 0;
+
+  const withinWindow = nowMs - windowStart < windowMs;
+  const nextCount = withinWindow ? currentCount + 1 : 1;
+
+  if (withinWindow && nextCount > limit) {
+    const retrySeconds = Math.ceil((windowMs - (nowMs - windowStart)) / 1000);
+    const message = `${friendlyName} limit reached. Please wait ${retrySeconds}s before trying again.`;
+    const error = new Error(message);
+    (error as Error & { code?: string }).code = 'RATE_LIMIT';
+    throw error;
+  }
+
+  await db.patch(userId, {
+    [windowField]: withinWindow ? windowStart : nowMs,
+    [countField]: nextCount,
+  });
+}
+
+export function enforceAgentRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+) {
+  return enforceRateLimit(
+    db,
+    userId,
+    [
+      'agentRateLimitWindowStart',
+      'agentRateLimitCount',
+      AGENT_WINDOW_MS,
+      AGENT_LIMIT,
+    ],
+    'Chat agent',
+  );
+}
+
+export function enforceToolRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+) {
+  return enforceRateLimit(
+    db,
+    userId,
+    [
+      'toolRateLimitWindowStart',
+      'toolRateLimitCount',
+      TOOL_WINDOW_MS,
+      TOOL_LIMIT,
+    ],
+    'Tool usage',
+  );
+}
+
+export function resetRateLimits(db: MutationCtx['db'], userId: Id<'users'>) {
+  return db.patch(userId, {
+    agentRateLimitWindowStart: undefined,
+    agentRateLimitCount: undefined,
+    toolRateLimitWindowStart: undefined,
+    toolRateLimitCount: undefined,
+  });
+}

package/2/packages/backend/convex/lib/telemetry.ts

@@ -0,0 +1,29 @@
+export type TelemetryMode = 'off' | 'sample' | 'debug';
+
+function normalizeMode(raw: string | undefined): TelemetryMode {
+  if (raw === 'sample' || raw === 'debug') {
+    return raw;
+  }
+  return 'off';
+}
+
+export function getChatTelemetryMode(): TelemetryMode {
+  return normalizeMode(process.env.CHAT_LATENCY_TELEMETRY_MODE);
+}
+
+export function isChatTelemetryEnabled(): boolean {
+  return getChatTelemetryMode() !== 'off';
+}
+
+export function shouldSampleChatTelemetry(probability = 0.1): boolean {
+  const mode = getChatTelemetryMode();
+  if (mode === 'off') {
+    return false;
+  }
+  if (mode === 'debug') {
+    return true;
+  }
+
+  const clampedProbability = Math.min(Math.max(probability, 0), 1);
+  return Math.random() < clampedProbability;
+}

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

@@ -0,0 +1,119 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { v } from 'convex/values';
+
+import { mutation, query } from './_generated/server';
+
+/**
+ * Record a consumable purchase (like credits) in the database
+ */
+export const recordConsumablePurchase = mutation({
+  args: {
+    productId: v.string(),
+    quantity: v.number(),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    newCredits: v.number(),
+    totalCredits: v.number(),
+  }),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+    // Get current user to check existing credits
+    const user = await ctx.db.get(userId);
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    // Calculate new credits based on product
+    let creditsToAdd = args.quantity;
+
+    // You can customize credit amounts based on productId
+    if (args.productId.includes('premium')) {
+      creditsToAdd = args.quantity * 2; // Premium products give 2x credits
+    }
+
+    // Update user credits - safely access credits field
+    const currentCredits = (user as any).credits || 0;
+    const newTotalCredits = currentCredits + creditsToAdd;
+
+    await ctx.db.patch(userId, {
+      credits: newTotalCredits,
+    });
+
+    // Log the purchase
+    await ctx.db.insert('purchases', {
+      userId,
+      productId: args.productId,
+      quantity: args.quantity,
+      creditsAdded: creditsToAdd,
+      purchaseDate: Date.now(),
+    });
+
+    return {
+      success: true,
+      newCredits: creditsToAdd,
+      totalCredits: newTotalCredits,
+    };
+  },
+});
+
+/**
+ * Get user's current credit balance
+ */
+export const getUserCredits = query({
+  args: {},
+  returns: v.union(v.number(), v.null()),
+  handler: async (ctx) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+    const user = await ctx.db.get(userId);
+
+    return (user as any)?.credits || 0;
+  },
+});
+
+/**
+ * Get user's purchase history with pagination
+ */
+export const getPurchaseHistory = query({
+  args: {
+    paginationOpts: v.optional(
+      v.object({
+        numItems: v.number(),
+        cursor: v.union(v.string(), v.null()),
+      }),
+    ),
+  },
+  returns: v.object({
+    page: v.array(
+      v.object({
+        _id: v.id('purchases'),
+        _creationTime: v.number(),
+        productId: v.string(),
+        quantity: v.number(),
+        creditsAdded: v.number(),
+        purchaseDate: v.number(),
+      }),
+    ),
+    isDone: v.boolean(),
+    continueCursor: v.string(),
+    pageStatus: v.optional(v.union(v.string(), v.null())),
+    splitCursor: v.optional(v.union(v.string(), v.null())),
+  }),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+    return await ctx.db
+      .query('purchases')
+      .withIndex('by_userId', (q) => q.eq('userId', userId))
+      .order('desc')
+      .paginate(args.paginationOpts ?? { numItems: 50, cursor: null });
+  },
+});

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

@@ -0,0 +1,13 @@
+/**
+ * Payments Domain Aggregator
+ *
+ * Single entry point for all payment-related Convex functions.
+ * Re-exports functions from paymentFunctions.ts to decouple
+ * frontend from internal file structure.
+ */
+
+export {
+  getPurchaseHistory,
+  getUserCredits,
+  recordConsumablePurchase,
+} from '../paymentFunctions';

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

@@ -0,0 +1,342 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { v } from 'convex/values';
+
+import { internal } from './_generated/api';
+import { action, internalQuery, mutation, query } from './_generated/server';
+import { NOTIFICATION_CONFIG } from './lib/config';
+
+/**
+ * Records a push notification token for the authenticated user
+ */
+export const recordPushToken = mutation({
+  args: {
+    token: v.string(),
+    deviceInfo: v.optional(
+      v.object({
+        platform: v.string(),
+        deviceId: v.string(),
+        appVersion: v.string(),
+      }),
+    ),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('User must be authenticated to record push token');
+    }
+
+    try {
+      // Check if token already exists for this user
+      const existing = await ctx.db
+        .query('pushTokens')
+        .withIndex('by_userId', (q) => q.eq('userId', userId))
+        .first();
+
+      if (existing) {
+        // Update existing token
+        await ctx.db.patch(existing._id, {
+          token: args.token,
+          deviceInfo: args.deviceInfo,
+        });
+        console.log(`Updated push token for user ${userId}`);
+      } else {
+        // Create new token record
+        await ctx.db.insert('pushTokens', {
+          userId,
+          token: args.token,
+          paused: false, // Default to enabled
+          deviceInfo: args.deviceInfo,
+        });
+        console.log(`Recorded new push token for user ${userId}`);
+      }
+    } catch (error) {
+      console.error('Error recording push token:', error);
+      throw new Error('Failed to record push token');
+    }
+  },
+});
+
+/**
+ * Gets the current push notification status for the authenticated user
+ */
+export const getNotificationStatus = query({
+  args: {},
+  returns: v.object({
+    hasToken: v.boolean(),
+    paused: v.boolean(),
+  }),
+  handler: async (ctx) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      // Return default state instead of throwing to handle race conditions gracefully
+      console.log('getNotificationStatus called without authentication');
+      return {
+        hasToken: false,
+        paused: true,
+      };
+    }
+
+    try {
+      const tokenRecord = await ctx.db
+        .query('pushTokens')
+        .withIndex('by_userId', (q) => q.eq('userId', userId))
+        .first();
+
+      if (!tokenRecord) {
+        return {
+          hasToken: false,
+          paused: true,
+        };
+      }
+
+      return {
+        hasToken: true,
+        paused: tokenRecord.paused,
+      };
+    } catch (error) {
+      console.error('Error getting notification status:', error);
+      return {
+        hasToken: false,
+        paused: true,
+      };
+    }
+  },
+});
+
+/**
+ * Toggles push notifications on/off for the authenticated user
+ */
+export const togglePushNotifications = mutation({
+  args: { paused: v.boolean() },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('User must be authenticated to toggle notifications');
+    }
+
+    try {
+      const tokenRecord = await ctx.db
+        .query('pushTokens')
+        .withIndex('by_userId', (q) => q.eq('userId', userId))
+        .first();
+
+      if (!tokenRecord) {
+        throw new Error(
+          'No push token found for user. Please register for notifications first.',
+        );
+      }
+
+      await ctx.db.patch(tokenRecord._id, {
+        paused: args.paused,
+      });
+
+      console.log(
+        `${args.paused ? 'Paused' : 'Unpaused'} push notifications for user ${userId}`,
+      );
+    } catch (error) {
+      console.error('Error toggling push notifications:', error);
+      throw new Error('Failed to toggle push notifications');
+    }
+  },
+});
+
+/**
+ * Gets a user's push token (for actions to use)
+ * Internal only - should not be exposed to clients
+ */
+export const getUserPushToken = internalQuery({
+  args: { userId: v.id('users') },
+  returns: v.union(
+    v.null(),
+    v.object({
+      token: v.string(),
+      paused: v.boolean(),
+    }),
+  ),
+  handler: async (ctx, args) => {
+    const tokenRecord = await ctx.db
+      .query('pushTokens')
+      .withIndex('by_userId', (q) => q.eq('userId', args.userId))
+      .first();
+
+    if (!tokenRecord) {
+      return null;
+    }
+
+    return {
+      token: tokenRecord.token,
+      paused: tokenRecord.paused,
+    };
+  },
+});
+
+/**
+ * Deep link data schema for push notifications
+ */
+const deepLinkDataSchema = v.union(
+  v.object({
+    type: v.literal('deep_link'),
+    url: v.string(),
+    screen: v.optional(v.string()),
+    params: v.optional(
+      v.record(v.string(), v.union(v.string(), v.number(), v.boolean())),
+    ),
+  }),
+  v.object({
+    type: v.literal('external_url'),
+    url: v.string(),
+  }),
+  v.object({
+    type: v.literal('action'),
+    action: v.string(),
+    params: v.optional(
+      v.record(v.string(), v.union(v.string(), v.number(), v.boolean())),
+    ),
+  }),
+);
+
+/**
+ * Sends an immediate push notification to a specific user
+ */
+export const sendPushNotification = action({
+  args: {
+    toUserId: v.id('users'),
+    title: v.string(),
+    body: v.string(),
+    data: v.optional(deepLinkDataSchema),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    try {
+      // Get user's push token via query
+      const tokenRecord = await ctx.runQuery(
+        internal.pushNotificationFunctions.getUserPushToken,
+        {
+          userId: args.toUserId,
+        },
+      );
+
+      if (!tokenRecord || tokenRecord.paused) {
+        console.log(
+          `User ${args.toUserId} has no token or notifications paused`,
+        );
+        return;
+      }
+
+      // Validate deep link data if provided
+      let notificationData = args.data || {};
+      if (args.data?.type === 'deep_link' && args.data.url) {
+        // Basic URL validation
+        try {
+          new URL(args.data.url, 'vibefast://');
+        } catch (error) {
+          console.error('Invalid deep link URL:', args.data.url);
+          throw new Error(`Invalid deep link URL: ${args.data.url}`);
+        }
+      }
+
+      // Send to Expo's push notification service
+      const response = await fetch('https://exp.host/--/api/v2/push/send', {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Accept-encoding': 'gzip, deflate',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          to: tokenRecord.token,
+          title: args.title,
+          body: args.body,
+          data: notificationData,
+          sound: 'default',
+          priority: 'normal',
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Expo push service responded with ${response.status}`);
+      }
+
+      const result = await response.json();
+      console.log('Push notification sent successfully:', {
+        userId: args.toUserId,
+        title: args.title,
+        hasDeepLink: !!args.data,
+        deepLinkType: args.data?.type,
+        result,
+      });
+    } catch (error) {
+      console.error(
+        `Failed to send push notification to user ${args.toUserId}:`,
+        error,
+      );
+      // Graceful degradation - don't throw to avoid breaking caller flow
+    }
+  },
+});
+
+/**
+ * Sends a test notification to the currently authenticated user
+ */
+export const sendTestNotification = action({
+  args: {},
+  returns: v.null(),
+  handler: async (ctx) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('User must be authenticated to send test notification');
+    }
+
+    try {
+      // Get user's push token via query
+      const tokenRecord = await ctx.runQuery(
+        internal.pushNotificationFunctions.getUserPushToken,
+        {
+          userId,
+        },
+      );
+
+      if (!tokenRecord || tokenRecord.paused) {
+        console.log(`User ${userId} has no token or notifications paused`);
+        return;
+      }
+
+      // Send to Expo's push notification service
+      const response = await fetch('https://exp.host/--/api/v2/push/send', {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Accept-encoding': 'gzip, deflate',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          to: tokenRecord.token,
+          title: NOTIFICATION_CONFIG.TEST_MESSAGE.title,
+          body: NOTIFICATION_CONFIG.TEST_MESSAGE.body,
+          data: {
+            type: 'deep_link',
+            url: '/settings',
+            screen: 'settings',
+          },
+          sound: 'default',
+          priority: 'normal',
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Expo push service responded with ${response.status}`);
+      }
+
+      const result = await response.json();
+      console.log('Test push notification sent successfully:', result);
+    } catch (error) {
+      console.error(
+        `Failed to send test push notification for user ${userId}:`,
+        error,
+      );
+      throw new Error('Failed to send test notification');
+    }
+  },
+});