Initial commit: PodcastYes — AI podcast platform

2026-06-07 03:58:32 -04:00
commit 155507f21a
151 changed files with 19826 additions and 0 deletions
@@ -0,0 +1,329 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { getServerSession } from "@/lib/auth/guards";
+import { prisma } from "@/lib/db";
+import { getEffectivePlan } from "@/lib/billing/subscription";
+import { enforceLimit, LimitExceededError } from "@/lib/usage/limits";
+import { enqueueEpisodeGeneration } from "@/lib/queue/pgboss";
+import { rateLimit, LIMITS } from "@/lib/ratelimit";
+import type { GenerationType } from "@/lib/queue/jobs";
+import type { Prisma } from "@prisma/client";
+
+const speakerSchema = z.object({
+  speakerKey: z.string().min(1).max(40),
+  displayName: z.string().min(1).max(60),
+  elevenVoiceId: z.string().min(1).max(60),
+});
+
+const createSchema = z.object({
+  title: z.string().max(120).optional(),
+  topic: z.string().min(10, "Describe your topic in a bit more detail").max(2000),
+  tone: z.string().min(1),
+  format: z.enum(["SOLO", "INTERVIEW", "MULTI_HOST"]),
+  language: z.string().min(2).max(5),
+  targetLengthMin: z.number().int().min(1).max(180),
+  audience: z.string().max(200).optional(),
+  speakers: z.array(speakerSchema).min(1).max(6),
+});
+
+export type CreateEpisodeInput = z.infer<typeof createSchema>;
+export type CreateEpisodeResult =
+  | { ok: true; episodeId: string }
+  | { ok: false; error: string; limited?: boolean };
+
+export async function createEpisodeAction(input: CreateEpisodeInput): Promise<CreateEpisodeResult> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+
+  const rl = await rateLimit("generation", session.user.id, LIMITS.generation);
+  if (!rl.ok) {
+    return { ok: false, error: `Too many requests. Try again in ${rl.retryAfterSec}s.` };
+  }
+
+  const parsed = createSchema.safeParse(input);
+  if (!parsed.success) {
+    return { ok: false, error: parsed.error.issues[0]?.message ?? "Invalid input." };
+  }
+  const data = parsed.data;
+  const activeOrgId = session.session.activeOrganizationId;
+
+  const { plan } = await getEffectivePlan(session.user.id, activeOrgId);
+  if (data.targetLengthMin > plan.limits.maxEpisodeMinutes) {
+    return {
+      ok: false,
+      error: `The ${plan.name} plan supports episodes up to ${plan.limits.maxEpisodeMinutes} minutes.`,
+      limited: true,
+    };
+  }
+
+  try {
+    await enforceLimit(session.user.id, "script", activeOrgId);
+    await enforceLimit(session.user.id, "audio", activeOrgId);
+  } catch (err) {
+    if (err instanceof LimitExceededError) {
+      return {
+        ok: false,
+        error: `You've reached your monthly ${err.check.metric} limit on the ${err.check.plan} plan. Upgrade to keep creating.`,
+        limited: true,
+      };
+    }
+    throw err;
+  }
+
+  const episode = await prisma.episode.create({
+    data: {
+      userId: session.user.id,
+      organizationId: activeOrgId ?? undefined,
+      title: data.title?.trim() || deriveTitle(data.topic),
+      topic: data.topic,
+      tone: data.tone,
+      format: data.format,
+      language: data.language,
+      targetLengthMin: data.targetLengthMin,
+      audience: data.audience,
+      status: "QUEUED",
+      stage: "Queued for generation",
+      speakers: {
+        create: data.speakers.map((s) => ({
+          speakerKey: s.speakerKey,
+          displayName: s.displayName,
+          elevenVoiceId: s.elevenVoiceId,
+        })),
+      },
+      jobs: { create: { type: "full", status: "queued" } },
+    },
+  });
+
+  await enqueueEpisodeGeneration(
+    { episodeId: episode.id, type: "full" },
+    { priority: plan.features.includes("priority_generation") ? 10 : 0 }
+  );
+
+  revalidatePath("/episodes");
+  revalidatePath("/dashboard");
+  return { ok: true, episodeId: episode.id };
+}
+
+export async function regenerateAction(
+  episodeId: string,
+  type: GenerationType
+): Promise<{ ok: boolean; error?: string }> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+
+  const episode = await prisma.episode.findUnique({
+    where: { id: episodeId },
+    select: { userId: true, organizationId: true },
+  });
+  if (!episode) return { ok: false, error: "Episode not found." };
+  if (episode.userId !== session.user.id && session.user.role !== "admin") {
+    return { ok: false, error: "Not allowed." };
+  }
+
+  // Gate the metrics this regeneration will consume.
+  const metrics: ("script" | "audio" | "art")[] =
+    type === "art" ? ["art"] : type === "audio" ? ["audio"] : ["script", "audio"];
+  try {
+    for (const m of metrics) await enforceLimit(session.user.id, m, session.session.activeOrganizationId);
+  } catch (err) {
+    if (err instanceof LimitExceededError) {
+      return { ok: false, error: `Monthly ${err.check.metric} limit reached on the ${err.check.plan} plan.` };
+    }
+    throw err;
+  }
+
+  await prisma.episode.update({
+    where: { id: episodeId },
+    data: { status: "QUEUED", stage: "Queued for regeneration", errorMessage: null },
+  });
+  await prisma.generationJob.create({ data: { episodeId, type, status: "queued" } });
+  await enqueueEpisodeGeneration({ episodeId, type });
+
+  revalidatePath(`/episodes/${episodeId}`);
+  return { ok: true };
+}
+
+const scriptContentSchema = z.object({
+  title: z.string().min(1),
+  sections: z
+    .array(
+      z.object({
+        id: z.string().min(1),
+        title: z.string().min(1),
+        turns: z.array(z.object({ speakerKey: z.string(), text: z.string() })).min(1),
+      })
+    )
+    .min(1),
+});
+
+export async function updateScriptAction(
+  episodeId: string,
+  content: unknown
+): Promise<{ ok: boolean; error?: string }> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+
+  const episode = await prisma.episode.findUnique({
+    where: { id: episodeId },
+    select: { userId: true },
+  });
+  if (!episode || episode.userId !== session.user.id) return { ok: false, error: "Not allowed." };
+
+  const parsed = scriptContentSchema.safeParse(content);
+  if (!parsed.success) return { ok: false, error: "Invalid script format." };
+
+  await prisma.script.update({
+    where: { episodeId },
+    data: { content: parsed.data as unknown as Prisma.InputJsonValue, version: { increment: 1 } },
+  });
+  revalidatePath(`/episodes/${episodeId}`);
+  return { ok: true };
+}
+
+export async function regenerateSectionAction(
+  episodeId: string,
+  sectionId: string
+): Promise<{ ok: boolean; error?: string; section?: { id: string; title: string; turns: { speakerKey: string; text: string }[] } }> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+
+  const episode = await prisma.episode.findUnique({
+    where: { id: episodeId },
+    include: { speakers: true, script: true },
+  });
+  if (!episode || (episode.userId !== session.user.id && session.user.role !== "admin")) {
+    return { ok: false, error: "Not allowed." };
+  }
+  if (!episode.script) return { ok: false, error: "No script to edit yet." };
+
+  try {
+    await enforceLimit(session.user.id, "script", session.session.activeOrganizationId);
+  } catch (err) {
+    if (err instanceof LimitExceededError) {
+      return { ok: false, error: `Monthly script limit reached on the ${err.check.plan} plan.` };
+    }
+    throw err;
+  }
+
+  // Imported lazily so the AI SDK never reaches client bundles importing this file.
+  const { scriptProvider } = await import("@/lib/ai/providers");
+  const { recordCost, scriptCostUsd } = await import("@/lib/ai/cost");
+  const { incrementUsage } = await import("@/lib/usage/meter");
+
+  const config = {
+    title: episode.title,
+    topic: episode.topic,
+    tone: episode.tone,
+    format: episode.format,
+    language: episode.language,
+    targetLengthMin: episode.targetLengthMin,
+    audience: episode.audience ?? undefined,
+    speakers: episode.speakers.map((s) => ({ speakerKey: s.speakerKey, displayName: s.displayName })),
+  };
+  const current = episode.script.content as unknown as {
+    title: string;
+    sections: { id: string; title: string; turns: { speakerKey: string; text: string }[] }[];
+  };
+
+  const { section, usage } = await scriptProvider().regenerateSection(config, current, sectionId);
+  const updated = {
+    ...current,
+    sections: current.sections.map((s) => (s.id === sectionId ? section : s)),
+  };
+
+  await prisma.script.update({
+    where: { episodeId },
+    data: { content: updated as unknown as Prisma.InputJsonValue, version: { increment: 1 } },
+  });
+
+  const ownerId = episode.organizationId ?? episode.userId;
+  const ownerType = episode.organizationId ? "organization" : "user";
+  await incrementUsage(ownerId, ownerType, "script");
+  await recordCost({
+    provider: "openai",
+    operation: "script",
+    units: usage.inputTokens + usage.outputTokens,
+    costUsd: scriptCostUsd(usage),
+    episodeId,
+    userId: episode.userId,
+  });
+
+  revalidatePath(`/episodes/${episodeId}`);
+  return { ok: true, section };
+}
+
+export async function repurposeAction(
+  episodeId: string,
+  format: "blog" | "social_thread" | "newsletter"
+): Promise<{ ok: boolean; error?: string; content?: { title: string; body: string } }> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+
+  const episode = await prisma.episode.findUnique({
+    where: { id: episodeId },
+    include: { script: true },
+  });
+  if (!episode || (episode.userId !== session.user.id && session.user.role !== "admin")) {
+    return { ok: false, error: "Not allowed." };
+  }
+  if (!episode.script) return { ok: false, error: "Generate the episode first." };
+
+  try {
+    await enforceLimit(session.user.id, "repurpose", session.session.activeOrganizationId);
+  } catch (err) {
+    if (err instanceof LimitExceededError) {
+      return { ok: false, error: `Monthly repurpose limit reached on the ${err.check.plan} plan.` };
+    }
+    throw err;
+  }
+
+  const { repurposeScript } = await import("@/lib/ai/pipeline/repurpose");
+  const { recordCost, scriptCostUsd } = await import("@/lib/ai/cost");
+  const { incrementUsage } = await import("@/lib/usage/meter");
+
+  const { content, usage } = await repurposeScript(
+    episode.script.content as unknown as Parameters<typeof repurposeScript>[0],
+    format
+  );
+
+  await prisma.repurposedContent.create({
+    data: { episodeId, type: format, content: content as unknown as Prisma.InputJsonValue },
+  });
+
+  const ownerId = episode.organizationId ?? episode.userId;
+  const ownerType = episode.organizationId ? "organization" : "user";
+  await incrementUsage(ownerId, ownerType, "repurpose");
+  await recordCost({
+    provider: "openai",
+    operation: "repurpose",
+    units: usage.inputTokens + usage.outputTokens,
+    costUsd: scriptCostUsd(usage),
+    episodeId,
+    userId: episode.userId,
+  });
+
+  revalidatePath(`/episodes/${episodeId}/repurpose`);
+  return { ok: true, content };
+}
+
+export async function deleteEpisodeAction(episodeId: string): Promise<{ ok: boolean; error?: string }> {
+  const session = await getServerSession();
+  if (!session) return { ok: false, error: "You must be signed in." };
+  const episode = await prisma.episode.findUnique({
+    where: { id: episodeId },
+    select: { userId: true },
+  });
+  if (!episode || (episode.userId !== session.user.id && session.user.role !== "admin")) {
+    return { ok: false, error: "Not allowed." };
+  }
+  await prisma.episode.delete({ where: { id: episodeId } });
+  revalidatePath("/episodes");
+  return { ok: true };
+}
+
+function deriveTitle(topic: string): string {
+  const trimmed = topic.trim().replace(/\s+/g, " ");
+  return trimmed.length <= 60 ? trimmed : trimmed.slice(0, 57) + "…";
+}