Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

feat: render Loom preview GIFs on request in the importer

Richie McIlroyb7339ca73bd8
diff --git a/apps/media-server/src/__tests__/loom-importer/preview.test.ts b/apps/media-server/src/__tests__/loom-importer/preview.test.ts
new file mode 100644
index 000000000..005954ee3
--- /dev/null
+++ b/apps/media-server/src/__tests__/loom-importer/preview.test.ts
@@ -0,0 +1,93 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+ createLoomImporter,
+ loadImporterSettings,
+} from "../../loom-importer/app";
+import { renderPreviewGif } from "../../loom-importer/preview";
+
+describe("Loom preview GIF", () => {
+ let root: string;
+ let server: ReturnType<typeof Bun.serve>;
+ const uploads: Array<{ type: string | null; bytes: number }> = [];
+
+ beforeAll(async () => {
+ process.env.MEDIA_SERVER_WEBHOOK_SECRET = "importer-secret";
+ root = await mkdtemp(join(tmpdir(), "loom-preview-"));
+ const result = spawnSync("ffmpeg", [
+ "-hide_banner",
+ "-loglevel",
+ "error",
+ "-f",
+ "lavfi",
+ "-i",
+ "testsrc=size=320x180:rate=30:duration=6",
+ "-c:v",
+ "libx264",
+ "-pix_fmt",
+ "yuv420p",
+ "-movflags",
+ "+faststart",
+ join(root, "result.mp4"),
+ ]);
+ if (result.status !== 0) throw new Error(String(result.stderr));
+ server = Bun.serve({
+ port: 0,
+ hostname: "127.0.0.1",
+ async fetch(request) {
+ const url = new URL(request.url);
+ if (request.method === "PUT") {
+ const body = await request.arrayBuffer();
+ uploads.push({
+ type: request.headers.get("content-type"),
+ bytes: body.byteLength,
+ });
+ return new Response(null, { headers: { ETag: '"gif"' } });
+ }
+ return new Response(Bun.file(join(root, url.pathname.slice(1))));
+ },
+ });
+ });
+
+ afterAll(async () => {
+ server?.stop(true);
+ if (root) await rm(root, { recursive: true, force: true });
+ });
+
+ test("renders a GIF from the finished video and uploads it", async () => {
+ await renderPreviewGif({
+ videoUrl: `http://127.0.0.1:${server.port}/result.mp4`,
+ previewGifPresignedUrl: `http://127.0.0.1:${server.port}/upload/preview.gif`,
+ duration: 6,
+ });
+ expect(uploads).toHaveLength(1);
+ expect(uploads[0]?.type).toBe("image/gif");
+ expect(uploads[0]?.bytes).toBeGreaterThan(1000);
+ });
+
+ test("requires the secret and an HTTPS source", async () => {
+ const { app } = createLoomImporter(
+ loadImporterSettings({ LOOM_IMPORTER_WORK_DIR: root }),
+ );
+ const post = (body: unknown, secret = "importer-secret") =>
+ app.request("/loom-importer/video/preview-gif", {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ "x-media-server-secret": secret,
+ },
+ body: JSON.stringify(body),
+ });
+ const body = {
+ videoUrl: "http://127.0.0.1/result.mp4",
+ previewGifPresignedUrl: "https://storage.example.com/p.gif",
+ duration: 6,
+ };
+ expect((await post(body, "wrong")).status).toBe(401);
+ expect((await post(body)).status).toBe(400);
+ expect((await post({ ...body, duration: 0 })).status).toBe(400);
+ });
+});
diff --git a/apps/media-server/src/loom-importer/app.ts b/apps/media-server/src/loom-importer/app.ts
index 79cac4a38..37a6802e2 100644
--- a/apps/media-server/src/loom-importer/app.ts
+++ b/apps/media-server/src/loom-importer/app.ts
@@ -22,6 +22,7 @@ import {
importRequestSchema,
runLoomImport,
} from "./job";
+import { previewRequestSchema, renderPreviewGif } from "./preview";
function positiveInt(value: string | undefined, fallback: number): number {
const parsed = Number.parseInt(value ?? "", 10);
@@ -53,6 +54,7 @@ export function loadImporterSettings(
settings,
maxActiveJobs: positiveInt(env.LOOM_IMPORTER_MAX_JOBS, 16),
maxQueuedJobs: positiveInt(env.LOOM_IMPORTER_MAX_QUEUED, 400),
+ maxPreviewJobs: positiveInt(env.LOOM_IMPORTER_PREVIEW_JOBS, 4),
};
}
@@ -78,6 +80,7 @@ export function createLoomImporter(
const queue: QueuedImport[] = [];
const running = new Map<string, AbortController>();
let draining = false;
+ const previewSemaphore = new Semaphore(config.maxPreviewJobs);
const startJob = ({ jobId, request }: QueuedImport) =>
createJob(
@@ -188,6 +191,31 @@ export function createLoomImporter(
});
});
+ app.post("/video/preview-gif", async (c) => {
+ if (!validateMediaServerSecret(c))
+ return c.json({ error: "Unauthorized" }, 401);
+ if (draining)
+ return c.json(
+ { error: "Importer is draining", code: "SERVER_BUSY" },
+ 503,
+ );
+ const parsed = previewRequestSchema.safeParse(
+ await c.req.json().catch(() => null),
+ );
+ if (!parsed.success)
+ return c.json({ error: "Invalid request", code: "INVALID_REQUEST" }, 400);
+ try {
+ await previewSemaphore.run(() => renderPreviewGif(parsed.data));
+ return c.json({ ok: true });
+ } catch (error) {
+ console.warn("[loom-importer] Preview GIF failed", error);
+ return c.json(
+ { error: "Preview GIF failed", code: "PREVIEW_FAILED" },
+ 502,
+ );
+ }
+ });
+
app.get("/video/process/:jobId/status", (c) => {
if (!validateMediaServerSecret(c))
return c.json({ error: "Unauthorized" }, 401);
diff --git a/apps/media-server/src/loom-importer/preview.ts b/apps/media-server/src/loom-importer/preview.ts
new file mode 100644
index 000000000..8a76db3bf
--- /dev/null
+++ b/apps/media-server/src/loom-importer/preview.ts
@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { generatePreviewGif, uploadFileToS3 } from "../lib/media-video";
+
+const PREVIEW_TIMEOUT_MS = 120_000;
+
+export const previewRequestSchema = z.object({
+ videoUrl: z
+ .string()
+ .url()
+ .refine((value) => value.startsWith("https://"), "videoUrl must use HTTPS"),
+ previewGifPresignedUrl: z.string().url(),
+ duration: z.number().positive().max(86_400),
+});
+
+export type PreviewRequest = z.infer<typeof previewRequestSchema>;
+
+export async function renderPreviewGif(request: PreviewRequest) {
+ const signal = AbortSignal.timeout(PREVIEW_TIMEOUT_MS);
+ const rendered = await generatePreviewGif(
+ request.videoUrl,
+ request.duration,
+ {},
+ signal,
+ );
+ try {
+ await uploadFileToS3(
+ rendered.path,
+ request.previewGifPresignedUrl,
+ "image/gif",
+ signal,
+ );
+ } finally {
+ await rendered.cleanup();
+ }
+}