Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

feat: create Loom import preview GIFs on first view

Richie McIlroyf30be5fc4f56
diff --git a/apps/web/__tests__/unit/loom-preview-gif.test.ts b/apps/web/__tests__/unit/loom-preview-gif.test.ts
new file mode 100644
index 000000000..94beb30f2
--- /dev/null
+++ b/apps/web/__tests__/unit/loom-preview-gif.test.ts
@@ -0,0 +1,134 @@
+import { Option } from "effect";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ updates: [] as unknown[],
+ affectedRows: [] as number[],
+ env: {
+ LOOM_IMPORTER_URL: "https://media.example.com/loom-importer",
+ MEDIA_SERVER_WEBHOOK_SECRET: "media-secret",
+ } as Record<string, string | undefined>,
+ fetch: vi.fn(),
+}));
+
+vi.mock("server-only", () => ({}));
+vi.mock("@cap/database", () => ({
+ db: () => ({
+ update: () => ({
+ set: (values: unknown) => ({
+ where: async () => {
+ mocks.updates.push(values);
+ return [{ affectedRows: mocks.affectedRows.shift() ?? 1 }];
+ },
+ }),
+ }),
+ }),
+}));
+vi.mock("@cap/database/schema", () => ({
+ videos: { id: "v.id", metadata: "v.metadata" },
+}));
+vi.mock("@cap/env", () => ({ serverEnv: () => mocks.env }));
+
+import {
+ isLoomPreviewDue,
+ LOOM_PREVIEW_RETRY_MS,
+ startLoomPreviewGif,
+} from "@/lib/loom-preview-gif";
+
+const now = new Date("2026-10-24T12:00:00Z");
+const video = {
+ id: "videoaaaaaaaaaa",
+ ownerId: "owneraaaaaaaaaa",
+ duration: Option.some(42),
+} as never;
+const run = (overrides: Record<string, unknown> = {}) =>
+ startLoomPreviewGif({
+ video,
+ getVideoUrl: async (key, expiresIn) =>
+ `https://storage.example.com/${key}?get=${expiresIn}`,
+ getPreviewPutUrl: async (key, expiresIn) =>
+ `https://storage.example.com/${key}?put=${expiresIn}`,
+ now,
+ ...overrides,
+ });
+
+beforeEach(() => {
+ mocks.updates = [];
+ mocks.affectedRows = [];
+ mocks.env.LOOM_IMPORTER_URL = "https://media.example.com/loom-importer";
+ mocks.fetch.mockReset().mockResolvedValue(Response.json({ ok: true }));
+ vi.stubGlobal("fetch", mocks.fetch);
+});
+
+describe("isLoomPreviewDue", () => {
+ it.each([
+ [{ loomPreviewGif: { status: "pending" } }, true],
+ [{ loomPreviewGif: { status: "complete" } }, false],
+ [{}, false],
+ [null, false],
+ [
+ {
+ loomPreviewGif: {
+ status: "started",
+ startedAt: new Date(now.getTime() - 60_000).toISOString(),
+ },
+ },
+ false,
+ ],
+ [
+ {
+ loomPreviewGif: {
+ status: "started",
+ startedAt: new Date(
+ now.getTime() - LOOM_PREVIEW_RETRY_MS - 1,
+ ).toISOString(),
+ },
+ },
+ true,
+ ],
+ ])("%o -> %s", (metadata, expected) => {
+ expect(isLoomPreviewDue(metadata, now.getTime())).toBe(expected);
+ });
+});
+
+describe("startLoomPreviewGif", () => {
+ it("asks the importer for one preview of the finished video", async () => {
+ await expect(run()).resolves.toBe("complete");
+ expect(mocks.fetch).toHaveBeenCalledOnce();
+ const [url, init] = mocks.fetch.mock.calls[0] ?? [];
+ expect(url).toBe(
+ "https://media.example.com/loom-importer/video/preview-gif",
+ );
+ expect(init.headers["x-media-server-secret"]).toBe("media-secret");
+ expect(JSON.parse(init.body)).toEqual({
+ videoUrl:
+ "https://storage.example.com/owneraaaaaaaaaa/videoaaaaaaaaaa/result.mp4?get=900",
+ previewGifPresignedUrl:
+ "https://storage.example.com/owneraaaaaaaaaa/videoaaaaaaaaaa/preview/animated-preview.gif?put=900",
+ duration: 42,
+ });
+ expect(mocks.updates).toHaveLength(2);
+ });
+
+ it("does nothing when another view already started it", async () => {
+ mocks.affectedRows = [0];
+ await expect(run()).resolves.toBe("already-started");
+ expect(mocks.fetch).not.toHaveBeenCalled();
+ });
+
+ it("waits before retrying a failed preview", async () => {
+ mocks.fetch.mockResolvedValue(new Response("busy", { status: 502 }));
+ await expect(run()).resolves.toBe("failed");
+ expect(mocks.updates).toHaveLength(1);
+ });
+
+ it("skips videos it cannot preview", async () => {
+ await expect(
+ run({ video: { ...video, duration: Option.none() } }),
+ ).resolves.toBe("unavailable");
+ mocks.env.LOOM_IMPORTER_URL = undefined;
+ await expect(run()).resolves.toBe("unavailable");
+ expect(mocks.updates).toEqual([]);
+ expect(mocks.fetch).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/web/__tests__/unit/media-processing-workflows.test.ts b/apps/web/__tests__/unit/media-processing-workflows.test.ts
index a5dc6faad..540bd7b26 100644
--- a/apps/web/__tests__/unit/media-processing-workflows.test.ts
+++ b/apps/web/__tests__/unit/media-processing-workflows.test.ts
@@ -277,8 +277,10 @@ describe("media processing workflows", () => {
expect(body).toMatchObject({
videoUrl: "https://luna.loom.com/id/x/playlist.m3u8",
webhookUrl:
- "https://cap.example.com/api/webhooks/media-server/progress?retryable=true&transcription=on-view",
+ "https://cap.example.com/api/webhooks/media-server/progress?retryable=true&transcription=on-view&preview=on-view",
});
+ expect(body.previewGifPresignedUrl).toBeUndefined();
+ expect(body.thumbnailPresignedUrl).toBeDefined();
expect(body.sourcePresignedUrl).toBeUndefined();
expect(body.sourceUpload).toBeUndefined();
});
@@ -328,9 +330,10 @@ describe("media processing workflows", () => {
expect(mocks.fetch.mock.calls[0]?.[0]).toBe(
"https://worker.example.com/video/process",
);
- expect(
- JSON.parse(mocks.fetch.mock.calls[0]?.[1].body).webhookUrl,
- ).not.toContain("transcription=on-view");
+ const body = JSON.parse(mocks.fetch.mock.calls[0]?.[1].body);
+ expect(body.webhookUrl).not.toContain("transcription=on-view");
+ expect(body.webhookUrl).not.toContain("preview=on-view");
+ expect(body.previewGifPresignedUrl).toBeDefined();
});
it("waits for the importer when it cannot confirm Loom support", async () => {
diff --git a/apps/web/__tests__/unit/media-server-progress.test.ts b/apps/web/__tests__/unit/media-server-progress.test.ts
index ed15fdca8..6ff04f4f7 100644
--- a/apps/web/__tests__/unit/media-server-progress.test.ts
+++ b/apps/web/__tests__/unit/media-server-progress.test.ts
@@ -922,6 +922,30 @@ describe("Loom importer completions", () => {
expect(mocks.transcribe).toHaveBeenCalledWith(videoId);
});
+ it("leaves the preview GIF for the first view of importer completions", async () => {
+ const database = loomVideo();
+ await request(
+ complete(),
+ "media-secret",
+ "?retryable=true&transcription=on-view&preview=on-view",
+ );
+ const [write] = metadataWrites(database.mutations);
+ expect(write?.sql).toContain(
+ "'$.loomPreviewGif', COALESCE(JSON_EXTRACT(?, '$.loomPreviewGif'), JSON_OBJECT('status', 'pending'))",
+ );
+ });
+
+ it("does not wait for a preview view when the original still needs processing", async () => {
+ const database = loomVideo();
+ await request(
+ complete({ deferredSourceKey: `${ownerId}/${videoId}/raw-upload.webm` }),
+ "media-secret",
+ "?retryable=true&transcription=on-view&preview=on-view",
+ );
+ for (const write of metadataWrites(database.mutations))
+ expect(write.sql).not.toContain("loomPreviewGif");
+ });
+
it("keeps queueing transcription for media server completions", async () => {
const database = loomVideo();
await request(
diff --git a/apps/web/app/api/video/preview/route.ts b/apps/web/app/api/video/preview/route.ts
index efd6a9664..17b39fe82 100644
--- a/apps/web/app/api/video/preview/route.ts
+++ b/apps/web/app/api/video/preview/route.ts
@@ -1,7 +1,8 @@
import { provideOptionalAuth, Storage, Videos } from "@cap/web-backend";
import { Video } from "@cap/web-domain";
import { Effect, Option } from "effect";
-import { type NextRequest, NextResponse } from "next/server";
+import { after, type NextRequest, NextResponse } from "next/server";
+import { isLoomPreviewDue, startLoomPreviewGif } from "@/lib/loom-preview-gif";
import { runPromise } from "@/lib/server";
export const dynamic = "force-dynamic";
@@ -46,7 +47,35 @@ export async function GET(request: NextRequest) {
Effect.catchAll(() => Effect.succeed(false)),
);
- if (!hasPreview) return null;
+ if (!hasPreview) {
+ if (isLoomPreviewDue(Option.getOrNull(video.metadata)))
+ after(() =>
+ startLoomPreviewGif({
+ video,
+ getVideoUrl: (key, expiresIn) =>
+ runPromise(
+ bucket.getInternalSignedObjectUrl(key, { expiresIn }),
+ ),
+ getPreviewPutUrl: (key, expiresIn) =>
+ runPromise(
+ bucket.getInternalPresignedPutUrl(
+ key,
+ {
+ ContentType: "image/gif",
+ CacheControl: "public, max-age=31536000, immutable",
+ },
+ { expiresIn },
+ ),
+ ),
+ }).catch((error) => {
+ console.warn(
+ "[video/preview] Failed to create Loom preview GIF:",
+ error,
+ );
+ }),
+ );
+ return null;
+ }
return yield* bucket.getSignedObjectUrl(previewKey, {
expiresIn: PREVIEW_GIF_EXPIRES_SECONDS,
diff --git a/apps/web/app/api/webhooks/media-server/progress/route.ts b/apps/web/app/api/webhooks/media-server/progress/route.ts
index bde5992d2..9abb8f3a2 100644
--- a/apps/web/app/api/webhooks/media-server/progress/route.ts
+++ b/apps/web/app/api/webhooks/media-server/progress/route.ts
@@ -235,6 +235,8 @@ export async function POST(request: NextRequest) {
const transcribeOnView =
request.nextUrl.searchParams.get("transcription") === "on-view";
+ const previewOnView =
+ request.nextUrl.searchParams.get("preview") === "on-view";
const deferredSourceKey =
currentVideo &&
typeof payload.deferredSourceKey === "string" &&
@@ -248,6 +250,11 @@ export async function POST(request: NextRequest) {
...(transcribeOnView
? [sql`'$.transcribeOnView', JSON_EXTRACT('true', '$')`]
: []),
+ ...(previewOnView && !payload.deferredSourceKey
+ ? [
+ sql`'$.loomPreviewGif', COALESCE(JSON_EXTRACT(${videos.metadata}, '$.loomPreviewGif'), JSON_OBJECT('status', 'pending'))`,
+ ]
+ : []),
...(currentVideo?.metadata?.loomDeferredProcessing &&
currentUpload?.rawFileKey ===
currentVideo.metadata.loomDeferredProcessing.rawFileKey
diff --git a/apps/web/lib/loom-preview-gif.ts b/apps/web/lib/loom-preview-gif.ts
new file mode 100644
index 000000000..d6f42ae3d
--- /dev/null
+++ b/apps/web/lib/loom-preview-gif.ts
@@ -0,0 +1,102 @@
+import "server-only";
+
+import { db } from "@cap/database";
+import { videos } from "@cap/database/schema";
+import { serverEnv } from "@cap/env";
+import type { Video } from "@cap/web-domain";
+import { and, eq, sql } from "drizzle-orm";
+import { Option } from "effect";
+
+export const LOOM_PREVIEW_RETRY_MS = 10 * 60 * 1000;
+const PREVIEW_URL_EXPIRES_SECONDS = 15 * 60;
+
+export function isLoomPreviewDue(
+ metadata: Record<string, unknown> | null | undefined,
+ now = Date.now(),
+) {
+ const preview = metadata?.loomPreviewGif as
+ | { status?: string; startedAt?: string }
+ | undefined;
+ if (preview?.status === "pending") return true;
+ if (preview?.status !== "started") return false;
+ const startedAt = Date.parse(preview.startedAt ?? "");
+ return !Number.isFinite(startedAt) || now - startedAt > LOOM_PREVIEW_RETRY_MS;
+}
+
+function getAffectedRows(result: unknown) {
+ const header = Array.isArray(result) ? result[0] : result;
+ return (header as { affectedRows?: number } | undefined)?.affectedRows ?? 0;
+}
+
+export async function startLoomPreviewGif({
+ video,
+ getVideoUrl,
+ getPreviewPutUrl,
+ now = new Date(),
+}: {
+ video: Video.Video;
+ getVideoUrl: (key: string, expiresIn: number) => Promise<string>;
+ getPreviewPutUrl: (key: string, expiresIn: number) => Promise<string>;
+ now?: Date;
+}) {
+ const env = serverEnv();
+ const duration = Option.getOrUndefined(video.duration);
+ if (
+ !env.LOOM_IMPORTER_URL ||
+ !env.MEDIA_SERVER_WEBHOOK_SECRET ||
+ !duration ||
+ duration <= 0
+ )
+ return "unavailable" as const;
+ const startedAt = now.toISOString();
+ const retryBefore = new Date(
+ now.getTime() - LOOM_PREVIEW_RETRY_MS,
+ ).toISOString();
+ const claim = await db()
+ .update(videos)
+ .set({
+ metadata: sql`JSON_SET(${videos.metadata}, '$.loomPreviewGif', JSON_OBJECT('status', 'started', 'startedAt', ${startedAt}))`,
+ })
+ .where(
+ and(
+ eq(videos.id, video.id),
+ sql`(JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomPreviewGif.status')) = 'pending' OR (JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomPreviewGif.status')) = 'started' AND COALESCE(JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomPreviewGif.startedAt')), '') < ${retryBefore}))`,
+ ),
+ );
+ if (getAffectedRows(claim) !== 1) return "already-started" as const;
+
+ const prefix = `${video.ownerId}/${video.id}`;
+ const response = await fetch(`${env.LOOM_IMPORTER_URL}/video/preview-gif`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "x-media-server-secret": env.MEDIA_SERVER_WEBHOOK_SECRET,
+ },
+ body: JSON.stringify({
+ videoUrl: await getVideoUrl(
+ `${prefix}/result.mp4`,
+ PREVIEW_URL_EXPIRES_SECONDS,
+ ),
+ previewGifPresignedUrl: await getPreviewPutUrl(
+ `${prefix}/preview/animated-preview.gif`,
+ PREVIEW_URL_EXPIRES_SECONDS,
+ ),
+ duration,
+ }),
+ signal: AbortSignal.timeout(150_000),
+ });
+ await response.body?.cancel();
+ if (!response.ok) return "failed" as const;
+ await db()
+ .update(videos)
+ .set({
+ metadata: sql`JSON_SET(${videos.metadata}, '$.loomPreviewGif.status', 'complete')`,
+ })
+ .where(
+ and(
+ eq(videos.id, video.id),
+ sql`JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomPreviewGif.startedAt')) = ${startedAt}`,
+ ),
+ );
+ return "complete" as const;
+}
diff --git a/apps/web/workflows/import-loom-video.ts b/apps/web/workflows/import-loom-video.ts
index e7409bb6d..c936f6517 100644
--- a/apps/web/workflows/import-loom-video.ts
+++ b/apps/web/workflows/import-loom-video.ts
@@ -407,7 +407,7 @@ async function startMediaServerProcessJob(
maxImportBytes: number;
outputPresignedUrl: string;
thumbnailPresignedUrl: string;
- previewGifPresignedUrl: string;
+ previewGifPresignedUrl?: string;
webhookUrl: string;
webhookSecret?: string;
inputExtension?: string;
@@ -654,7 +654,7 @@ async function processVideoOnMediaServer(
};
}).pipe(runWorkflowPromise);
- const webhookUrl = `${webhookBaseUrl}/api/webhooks/media-server/progress?retryable=true${worker === "importer" ? "&transcription=on-view" : ""}`;
+ const webhookUrl = `${webhookBaseUrl}/api/webhooks/media-server/progress?retryable=true${worker === "importer" ? "&transcription=on-view&preview=on-view" : ""}`;
const webhookSecret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
try {
@@ -688,7 +688,8 @@ async function processVideoOnMediaServer(
maxImportBytes: LOOM_IMPORT_MAX_BYTES,
outputPresignedUrl,
thumbnailPresignedUrl,
- previewGifPresignedUrl,
+ previewGifPresignedUrl:
+ worker === "importer" ? undefined : previewGifPresignedUrl,
webhookUrl,
webhookSecret: webhookSecret || undefined,
inputExtension: getInputExtension(rawVideoUrl),
diff --git a/packages/database/types/metadata.ts b/packages/database/types/metadata.ts
index 921c149a4..697001872 100644
--- a/packages/database/types/metadata.ts
+++ b/packages/database/types/metadata.ts
@@ -29,6 +29,10 @@ export interface VideoMetadata {
startedAt?: string;
};
transcribeOnView?: boolean;
+ loomPreviewGif?: {
+ status: "pending" | "started" | "complete";
+ startedAt?: string;
+ };
editProcessing?: {
token: string;
startedAt: string;