vibefast-cli 0.2.4 → 0.3.0

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

@@ -0,0 +1,98 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { v } from 'convex/values';
+
+import { mutation, query } from './_generated/server';
+
+// Create a new recording draft.
+export const createRecordingDraft = mutation({
+  args: {},
+  returns: v.id('recordings'),
+  handler: async (ctx) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+    return await ctx.db.insert('recordings', {
+      userId,
+      fileUri: '',
+      duration: 0,
+      status: 'draft',
+      createdAt: Date.now(),
+      // metering is intentionally omitted on draft creation
+    });
+  },
+});
+
+// Finalize a recording with all its data.
+export const finalizeRecording = mutation({
+  args: {
+    recordingId: v.id('recordings'),
+    duration: v.number(),
+    fileUri: v.string(),
+    metering: v.array(v.number()), // Ensure this argument is defined
+  },
+  handler: async (ctx, { recordingId, duration, fileUri, metering }) => {
+    await ctx.db.patch(recordingId, {
+      status: 'completed',
+      duration,
+      fileUri,
+      metering, // Save the metering data
+    });
+  },
+});
+
+// Delete a recording.
+export const deleteRecording = mutation({
+  args: { recordingId: v.id('recordings') },
+  handler: async (ctx, { recordingId }) => {
+    await ctx.db.delete(recordingId);
+  },
+});
+
+// List all completed recordings for the user with pagination.
+export const listRecordings = query({
+  args: {
+    paginationOpts: v.optional(
+      v.object({
+        numItems: v.number(),
+        cursor: 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('recordings')
+      .withIndex('by_userId_and_status', (q) =>
+        q.eq('userId', userId).eq('status', 'completed'),
+      )
+      .order('desc')
+      .paginate(args.paginationOpts ?? { numItems: 50, cursor: null });
+  },
+});
+
+// Add this new mutation to the file
+
+export const updateRecordingName = mutation({
+  args: {
+    recordingId: v.id('recordings'),
+    newName: v.string(),
+  },
+  handler: async (ctx, { recordingId, newName }) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+    // Optional: Verify the user owns this recording before updating
+    const recording = await ctx.db.get(recordingId);
+    if (recording?.userId !== userId) {
+      throw new Error('Not authorized to edit this recording');
+    }
+
+    await ctx.db.patch(recordingId, { name: newName });
+    return { success: true };
+  },
+});

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

@@ -0,0 +1,344 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { v } from 'convex/values';
+
+import { mutation, query } from './_generated/server';
+
+/**
+ * Report an AI-generated image for inappropriate content
+ */
+export const reportAIGeneratedImage = mutation({
+  args: v.object({
+    prompt: v.string(),
+    provider: v.string(),
+    model: v.string(),
+    reason: v.string(),
+    details: v.optional(v.string()),
+    imageId: v.optional(v.id('generatedImages')),
+    storageId: v.optional(v.id('_storage')),
+  }),
+  returns: v.boolean(),
+  handler: async (
+    ctx,
+    { prompt, provider, model, reason, details, imageId, storageId },
+  ) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    // Prefer actual generatedImages document id for traceability
+    const fallbackId = `generated_image_${Date.now()}_${prompt
+      .slice(0, 20)
+      .replace(/[^a-zA-Z0-9]/g, '_')}`;
+    const contentId = imageId ? imageId.toString() : fallbackId;
+
+    await ctx.db.insert('reportedAIContent', {
+      userId,
+      contentId,
+      contentType: 'generated_image',
+      relatedImageId: imageId ?? undefined,
+      relatedStorageId: storageId ?? undefined,
+      reason,
+      details:
+        details ||
+        `Reported image generated with ${provider}/${model} using prompt: ${prompt}`,
+      reportTimestamp: Date.now(),
+      status: 'open',
+    });
+
+    console.log(
+      `[reportAIGeneratedImage] Report created for image with contentId: ${contentId}`,
+    );
+    return true;
+  },
+});
+
+export const reportChatMessage = mutation({
+  args: {
+    // Use v.id if messageId is a proper Convex ID, otherwise v.string() if it's a generic string ID from AI SDK
+    messageId: v.string(), // Assuming it's the string ID from Vercel AI SDK Message type
+    reason: v.string(),
+    details: v.optional(v.string()),
+  },
+  returns: v.object({ success: v.boolean() }),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      // This case should ideally not happen if identity exists, but good for safety
+      throw new Error(
+        'User ID not found after authentication. Cannot report message.',
+      );
+    }
+
+    // Optional: Could add validation here to check if a message with messageId actually exists,
+    // or if it belongs to the reporting user or a public conversation.
+    // For now, we trust the client to send a valid messageId from the chat.
+
+    await ctx.db.insert('reportedAIContent', {
+      userId,
+      contentId: args.messageId, // This will be the Vercel AI SDK message ID
+      contentType: 'chat_message',
+      reason: args.reason,
+      details: args.details,
+      reportTimestamp: Date.now(),
+      status: 'open', // Default status for a new report
+    });
+
+    console.log(
+      `[reportChatMessage] User ${userId} reported chat message ${args.messageId} for reason: ${args.reason}`,
+    );
+    return { success: true }; // Indicate success to the client
+  },
+});
+
+export const adminDashboardSummary = query({
+  args: {},
+  returns: v.object({
+    stats: v.object({
+      userCount: v.number(),
+      verifiedUsers: v.number(),
+      totalCredits: v.number(),
+      totalPurchases: v.number(),
+      openReports: v.number(),
+      activeConversations: v.number(),
+    }),
+    analysisStatus: v.object({
+      completed: v.number(),
+      processing: v.number(),
+      failed: v.number(),
+    }),
+    recentPurchases: v.array(
+      v.object({
+        _id: v.id('purchases'),
+        productId: v.string(),
+        creditsAdded: v.number(),
+        quantity: v.number(),
+        purchaseDate: v.number(),
+        userId: v.id('users'),
+      }),
+    ),
+    recentAnalyses: v.array(
+      v.object({
+        _id: v.id('imageAnalyses'),
+        status: v.union(
+          v.literal('completed'),
+          v.literal('processing'),
+          v.literal('failed'),
+        ),
+        userId: v.id('users'),
+        _creationTime: v.number(),
+      }),
+    ),
+    reportHighlights: v.array(
+      v.object({
+        _id: v.id('reportedAIContent'),
+        status: v.union(
+          v.literal('open'),
+          v.literal('resolved'),
+          v.literal('dismissed'),
+        ),
+        reason: v.string(),
+        reportTimestamp: v.number(),
+      }),
+    ),
+    generatedAt: v.number(),
+  }),
+  handler: async (ctx) => {
+    const users = await ctx.db.query('users').collect();
+    const purchases = await ctx.db.query('purchases').collect();
+    const analyses = await ctx.db.query('imageAnalyses').collect();
+    const reports = await ctx.db.query('reportedAIContent').collect();
+    const conversations = await ctx.db.query('conversations').collect();
+
+    const totalCredits = users.reduce((sum, user) => {
+      const credits = (user as any).credits ?? 0;
+      return sum + credits;
+    }, 0);
+    const verifiedUsers = users.filter(
+      (user) => Boolean(user.emailVerificationTime || user.emailVerified),
+    ).length;
+
+    const analysisStatus = analyses.reduce(
+      (acc, analysis) => {
+        if (analysis.status === 'completed') {
+          acc.completed += 1;
+        } else if (analysis.status === 'processing') {
+          acc.processing += 1;
+        } else if (analysis.status === 'failed') {
+          acc.failed += 1;
+        }
+        return acc;
+      },
+      { completed: 0, processing: 0, failed: 0 },
+    );
+
+    const sortedPurchases = [...purchases].sort(
+      (a, b) => b.purchaseDate - a.purchaseDate,
+    );
+    const sortedAnalyses = [...analyses].sort(
+      (a, b) => (b._creationTime ?? 0) - (a._creationTime ?? 0),
+    );
+    const sortedReports = [...reports].sort(
+      (a, b) => b.reportTimestamp - a.reportTimestamp,
+    );
+
+    return {
+      stats: {
+        userCount: users.length,
+        verifiedUsers,
+        totalCredits,
+        totalPurchases: purchases.length,
+        openReports: reports.filter((report) => report.status === 'open').length,
+        activeConversations: conversations.length,
+      },
+      analysisStatus,
+      recentPurchases: sortedPurchases.slice(0, 4),
+      recentAnalyses: sortedAnalyses.slice(0, 3),
+      reportHighlights: sortedReports.slice(0, 3),
+      generatedAt: Date.now(),
+    };
+  },
+});
+
+export const adminListUsers = query({
+  args: {},
+  returns: v.object({
+    users: v.array(
+      v.object({
+        _id: v.id("users"),
+        name: v.optional(v.string()),
+        email: v.optional(v.string()),
+        phone: v.optional(v.string()),
+        credits: v.number(),
+        joinedAt: v.optional(v.number()),
+        verified: v.boolean(),
+        purchaseCount: v.number(),
+        reportCount: v.number(),
+        status: v.union(
+          v.literal("premium"),
+          v.literal("attention"),
+          v.literal("free"),
+        ),
+        lastPurchaseAt: v.optional(v.number()),
+        recentReport: v.optional(
+          v.object({
+            reason: v.string(),
+            status: v.union(
+              v.literal("open"),
+              v.literal("resolved"),
+              v.literal("dismissed"),
+            ),
+            reportTimestamp: v.number(),
+          }),
+        ),
+      }),
+    ),
+    summaryTime: v.number(),
+  }),
+  handler: async (ctx) => {
+    const callerId = await getAuthUserId(ctx);
+    if (!callerId) {
+      throw new Error("Not authenticated");
+    }
+
+    const [users, purchases, reports] = await Promise.all([
+      ctx.db.query("users").collect(),
+      ctx.db.query("purchases").collect(),
+      ctx.db.query("reportedAIContent").collect(),
+    ]);
+
+    const purchaseStats = new Map<
+      string,
+      { count: number; lastPurchaseAt: number | null }
+    >();
+    for (const purchase of purchases) {
+      const userId = purchase.userId.toString();
+      const entry = purchaseStats.get(userId) ?? { count: 0, lastPurchaseAt: null };
+      entry.count += 1;
+      if (typeof purchase.purchaseDate === "number") {
+        entry.lastPurchaseAt = Math.max(entry.lastPurchaseAt ?? 0, purchase.purchaseDate);
+      }
+      purchaseStats.set(userId, entry);
+    }
+
+    const reportStats = new Map<
+      string,
+      {
+        count: number;
+        recent?: {
+          reason: string;
+          status: "open" | "resolved" | "dismissed";
+          reportTimestamp: number;
+        };
+      }
+    >();
+    for (const report of reports) {
+      const userId = report.userId.toString();
+      const entry = reportStats.get(userId) ?? { count: 0 };
+      entry.count += 1;
+      const existing = entry.recent;
+      if (!existing || report.reportTimestamp > existing.reportTimestamp) {
+        entry.recent = {
+          reason: report.reason,
+          status: report.status as "open" | "resolved" | "dismissed",
+          reportTimestamp: report.reportTimestamp,
+        };
+      }
+      reportStats.set(userId, entry);
+    }
+
+    const rows = users
+      .map((user) => {
+        const userId = user._id.toString();
+        const credits = (user as any).credits ?? 0;
+        const { count: purchaseCount = 0, lastPurchaseAt = null } =
+          purchaseStats.get(userId) ?? {};
+        const reportEntry = reportStats.get(userId);
+        const reportCount = reportEntry?.count ?? 0;
+        const recentReport = reportEntry?.recent;
+        const status: "premium" | "attention" | "free" =
+          reportCount > 0
+            ? "attention"
+            : purchaseCount > 0 || credits > 0
+            ? "premium"
+            : "free";
+
+        return {
+          _id: user._id,
+          name: user.name ?? null,
+          email: user.email ?? null,
+          phone: user.phone ?? null,
+          credits,
+          joinedAt:
+            typeof user._creationTime === "number" ? user._creationTime : null,
+          verified: Boolean(user.emailVerificationTime || user.emailVerified),
+          purchaseCount,
+          reportCount,
+          status,
+          lastPurchaseAt,
+          recentReport,
+        };
+      })
+      .sort((a, b) => (b.joinedAt ?? 0) - (a.joinedAt ?? 0));
+
+    return {
+      users: rows,
+      summaryTime: Date.now(),
+    };
+  },
+});
+
+export const adminDeleteUser = mutation({
+  args: {
+    userId: v.id("users"),
+  },
+  returns: v.boolean(),
+  handler: async (ctx, { userId }) => {
+    const callerId = await getAuthUserId(ctx);
+    if (!callerId) {
+      throw new Error("Not authenticated");
+    }
+    await ctx.db.delete(userId);
+    return true;
+  },
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Reporting Domain Aggregator
+ *
+ * Single entry point for all reporting Convex functions.
+ * Re-exports functions from reportFunctions.ts to decouple
+ * frontend from internal file structure.
+ */
+
+export { reportAIGeneratedImage, reportChatMessage } from '../reportFunctions';

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

@@ -0,0 +1,81 @@
+import { httpRouter } from 'convex/server';
+
+import { httpAction } from './_generated/server';
+
+const http = httpRouter();
+
+const ELEVENLABS_TOKEN_ENDPOINT =
+  'https://api.elevenlabs.io/v1/convai/conversation/token';
+
+const fetchElevenLabsConversationToken = httpAction(
+  async (_ctx, request): Promise<Response> => {
+    const apiKey = process.env.ELEVENLABS_API_KEY;
+    if (!apiKey) {
+      return new Response(
+        JSON.stringify({
+          error: 'ELEVENLABS_API_KEY is not configured on the backend',
+        }),
+        {
+          status: 500,
+          headers: { 'content-type': 'application/json' },
+        },
+      );
+    }
+
+    const url = new URL(request.url);
+    const agentId = url.searchParams.get('agent_id');
+    if (!agentId) {
+      return new Response(
+        JSON.stringify({ error: 'agent_id query parameter is required' }),
+        {
+          status: 400,
+          headers: { 'content-type': 'application/json' },
+        },
+      );
+    }
+
+    const upstreamUrl = new URL(ELEVENLABS_TOKEN_ENDPOINT);
+    url.searchParams.forEach((value, key) => {
+      upstreamUrl.searchParams.set(key, value);
+    });
+
+    try {
+      const upstreamResponse = await fetch(upstreamUrl, {
+        method: 'GET',
+        headers: {
+          'xi-api-key': apiKey,
+          accept: 'application/json',
+        },
+      });
+
+      const payload = await upstreamResponse.text();
+      return new Response(payload, {
+        status: upstreamResponse.status,
+        headers: {
+          'content-type':
+            upstreamResponse.headers.get('content-type') || 'application/json',
+        },
+      });
+    } catch (error) {
+      console.error(
+        '[voice.token] Failed to fetch ElevenLabs conversation token',
+        error,
+      );
+      return new Response(
+        JSON.stringify({ error: 'Failed to fetch ElevenLabs token' }),
+        {
+          status: 502,
+          headers: { 'content-type': 'application/json' },
+        },
+      );
+    }
+  },
+);
+
+http.route({
+  path: '/voice/conversation-token',
+  method: 'GET',
+  handler: fetchElevenLabsConversationToken,
+});
+
+export default http;