Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { Effect } from "effect";
import { NextRequest } from "next/server";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { DesktopRecordingJob } from "@/lib/desktop-recording-jobs";
const mocks = vi.hoisted(() => ({
secret: "media-secret" as string | undefined,
rows: [] as unknown[],
getState: vi.fn(),
storage: vi.fn(),
signPart: vi.fn(),
complete: vi.fn(),
abort: vi.fn(),
}));
vi.mock("@cap/database", () => ({
db: () => ({
select: () => ({
from: () => ({ where: async () => mocks.rows }),
}),
}),
}));
vi.mock("@cap/database/schema", () => ({
videos: { id: "videos.id" },
videoProcessingJobs: { videoId: "jobs.videoId" },
videoUploads: { videoId: "uploads.videoId" },
}));
vi.mock("@cap/env", () => ({
serverEnv: () => ({ MEDIA_SERVER_WEBHOOK_SECRET: mocks.secret }),
}));
vi.mock("@cap/web-backend", () => ({
Storage: { getAccessForVideo: mocks.storage },
}));
vi.mock("@cap/web-backend/src/Storage/index", () => ({
Storage: { getAccessForVideo: mocks.storage },
}));
vi.mock("@/lib/desktop-recording-jobs", async (importOriginal) => ({
...(await importOriginal<typeof import("@/lib/desktop-recording-jobs")>()),
getProcessingState: mocks.getState,
}));
vi.mock("@/lib/server", async () => ({
runPromise: (await import("effect")).Effect.runPromise,
}));
vi.mock("@/lib/workflow-runtime", async () => ({
runWorkflowPromise: (await import("effect")).Effect.runPromise,
}));
vi.mock("@/lib/video-storage", () => ({
decodeStorageVideo: (video: unknown) => video,
}));
import { POST } from "@/app/api/webhooks/media-server/multipart/[action]/route";
import { getDesktopRecordingOutputKey } from "@/lib/desktop-recording-source";
const ownerId = "owned-user" as DesktopRecordingJob["ownerId"];
const videoId = "owned-video" as DesktopRecordingJob["videoId"];
const generation = "c9699f1a-fe24-44f9-ac89-63d5744a058c";
const attemptId = "cf9f55f8-4d6d-44b4-a670-30c2f7e51d9b";
const outputKey = getDesktopRecordingOutputKey(
ownerId,
videoId,
generation,
attemptId,
);
function currentJob(): DesktopRecordingJob {
const now = new Date();
return {
videoId,
ownerId,
generation,
attemptId,
state: "processing",
attemptCount: 1,
leaseExpiresAt: new Date(now.getTime() + 60_000),
nextRetryAt: now,
manifestSha256: "a".repeat(64),
remoteJobId: "remote-job",
workflowRunId: "workflow",
source: {
version: 1,
kind: "segments",
manifestSha256: "a".repeat(64),
inventorySha256: "b".repeat(64),
inventoryKey: `${ownerId}/${videoId}/.recording/sources/${generation}/snapshot/inventory.json`,
requiredAudio: true,
},
verification: null,
output: null,
errorCode: null,
errorMessage: null,
createdAt: now,
updatedAt: now,
};
}
function payload() {
return {
videoId,
generation,
attemptId,
key: outputKey,
uploadId: "multipart-upload",
partNumber: 1,
contentLength: 1024,
parts: [
{ partNumber: 2, etag: '"part-2"', size: 1024 },
{ partNumber: 1, etag: '"part-1"', size: 5 * 1024 * 1024 },
],
};
}
async function request(
action: string,
body: unknown = payload(),
secret: string | null = "media-secret",
) {
const headers = new Headers({ "Content-Type": "application/json" });
if (secret !== null) headers.set("x-media-server-secret", secret);
const response = await POST(
new NextRequest(
`https://cap.so/api/webhooks/media-server/multipart/${action}`,
{
method: "POST",
headers,
body: JSON.stringify(body),
},
),
{ params: Promise.resolve({ action }) },
);
if (!response) throw new Error("Multipart route did not return a response");
return response;
}
function useStorage(provider = "s3") {
mocks.storage.mockReturnValue(
Effect.succeed([
{
provider,
multipart: {
getPresignedUploadPartUrl: mocks.signPart,
complete: mocks.complete,
abort: mocks.abort,
},
},
]),
);
}
describe("media-server multipart fencing", () => {
beforeEach(() => {
mocks.secret = "media-secret";
mocks.rows = [
{ id: videoId, ownerId, source: { type: "desktopSegments" } },
];
mocks.getState.mockReset().mockResolvedValue(currentJob());
mocks.signPart
.mockReset()
.mockReturnValue(Effect.succeed("https://storage.test/part"));
mocks.complete.mockReset().mockReturnValue(
Effect.succeed({
Location: "https://storage.test/output",
ETag: '"output-etag"',
}),
);
mocks.abort.mockReset().mockReturnValue(Effect.void);
useStorage();
vi.spyOn(console, "error").mockImplementation(() => undefined);
});
it.each([null, "wrong-secret", "éééééééééééé"])(
"rejects missing or incorrect webhook authentication %s",
async (secret) => {
expect((await request("sign-part", payload(), secret)).status).toBe(401);
expect(mocks.getState).not.toHaveBeenCalled();
expect(mocks.storage).not.toHaveBeenCalled();
},
);
it("does not accept an unset configured secret", async () => {
mocks.secret = undefined;
expect((await request("sign-part")).status).toBe(401);
expect(mocks.storage).not.toHaveBeenCalled();
});
it("signs only the exact current attempt key and part", async () => {
const response = await request("sign-part");
expect(response.status).toBe(200);
expect(await response.json()).toEqual({ url: "https://storage.test/part" });
expect(mocks.getState).toHaveBeenCalledWith({ videoId });
expect(mocks.signPart).toHaveBeenCalledWith(
outputKey,
"multipart-upload",
1,
);
});
it.each([
"owner",
"generation",
"attempt",
"expired",
"unleased",
"state",
"source",
"missing",
])(
"refuses signing and completion for an invalid %s fence",
async (reason) => {
const job = currentJob();
if (reason === "owner") job.ownerId = "other-user" as typeof ownerId;
if (reason === "generation") job.generation = "different-generation";
if (reason === "attempt") job.attemptId = "different-attempt";
if (reason === "expired") job.leaseExpiresAt = new Date(Date.now() - 1);
if (reason === "unleased") job.leaseExpiresAt = null;
if (reason === "state") job.state = "retry";
if (reason === "source") job.source = null;
mocks.getState.mockResolvedValue(reason === "missing" ? null : job);
expect((await request("sign-part")).status).toBe(409);
expect((await request("complete")).status).toBe(409);
expect(mocks.storage).not.toHaveBeenCalled();
expect(mocks.signPart).not.toHaveBeenCalled();
expect(mocks.complete).not.toHaveBeenCalled();
},
);
it.each([
"other-user/owned-video/.recording/outputs/generation/attempt.mp4",
"owned-user/other-video/result.mp4",
"owned-user/owned-video/result.mp4",
"owned-user/owned-video/.recording/outputs/../attempt.mp4",
"owned-user/owned-video/.recording/outputs/%2e%2e/attempt.mp4",
])(
"rejects a foreign, canonical, or traversing fenced key %s",
async (key) => {
for (const action of ["sign-part", "complete", "abort"]) {
expect((await request(action, { ...payload(), key })).status).toBe(400);
}
expect(mocks.storage).not.toHaveBeenCalled();
},
);
it("completes contiguous parts in order without replacing an existing output", async () => {
const response = await request("complete");
expect(response.status).toBe(200);
expect(await response.json()).toEqual({
success: true,
location: "https://storage.test/output",
objectIdentity: '"output-etag"',
});
expect(mocks.complete).toHaveBeenCalledWith(outputKey, "multipart-upload", {
MultipartUpload: {
Parts: [
{ PartNumber: 1, ETag: '"part-1"' },
{ PartNumber: 2, ETag: '"part-2"' },
],
},
IfNoneMatch: "*",
});
});
it.each([[1, 3], [1, 1], [2], []])(
"refuses missing or duplicate multipart sequence %j",
async (...partNumbers) => {
const parts = partNumbers.map((partNumber) => ({
partNumber,
etag: '"part"',
size: 1024,
}));
expect((await request("complete", { ...payload(), parts })).status).toBe(
400,
);
expect(mocks.complete).not.toHaveBeenCalled();
},
);
it("permits aborting the old exact key after the lease or attempt changes", async () => {
mocks.getState.mockResolvedValue({
...currentJob(),
attemptId: "new-attempt",
leaseExpiresAt: new Date(Date.now() - 1),
});
const response = await request("abort");
expect(response.status).toBe(200);
expect(mocks.getState).not.toHaveBeenCalled();
expect(mocks.abort).toHaveBeenCalledWith(outputKey, "multipart-upload");
expect((await request("sign-part")).status).toBe(409);
expect((await request("complete")).status).toBe(409);
});
it("retains the canonical multipart contract for an unfenced legacy worker", async () => {
const body = {
...payload(),
generation: undefined,
attemptId: undefined,
key: `${ownerId}/${videoId}/result.mp4`,
};
expect((await request("sign-part", body)).status).toBe(200);
expect((await request("complete", body)).status).toBe(200);
expect(mocks.getState).not.toHaveBeenCalled();
expect(mocks.complete).toHaveBeenCalledWith(body.key, body.uploadId, {
MultipartUpload: {
Parts: [
{ PartNumber: 1, ETag: '"part-1"' },
{ PartNumber: 2, ETag: '"part-2"' },
],
},
});
});
it.each([
{ generation: undefined },
{ attemptId: undefined },
{ generation: "../elsewhere" },
{ attemptId: 1 },
{ partNumber: 0 },
{ partNumber: 1.5 },
{ contentLength: 0 },
{ uploadId: "" },
])(
"rejects malformed or partially fenced sign requests %#",
async (change) => {
expect(
(await request("sign-part", { ...payload(), ...change })).status,
).toBe(400);
expect(mocks.signPart).not.toHaveBeenCalled();
},
);
it("returns not found for a deleted video and rejects non-S3 storage", async () => {
mocks.rows = [];
expect((await request("complete")).status).toBe(404);
mocks.rows = [
{ id: videoId, ownerId, source: { type: "desktopSegments" } },
];
useStorage("google-drive");
expect((await request("complete")).status).toBe(400);
expect(mocks.complete).not.toHaveBeenCalled();
});
it("does not report success when conditional multipart completion fails", async () => {
mocks.complete.mockReturnValueOnce(
Effect.fail(new Error("Precondition failed")),
);
expect((await request("complete")).status).toBe(500);
});
it("rejects invalid JSON and unknown multipart actions", async () => {
const response = await POST(
new NextRequest(
"https://cap.so/api/webhooks/media-server/multipart/complete",
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-media-server-secret": "media-secret",
},
body: "{",
},
),
{ params: Promise.resolve({ action: "complete" }) },
);
if (!response) throw new Error("Multipart route did not return a response");
expect(response.status).toBe(400);
expect((await request("unexpected")).status).toBe(404);
expect(mocks.storage).not.toHaveBeenCalled();
});
function loomUpload(source = true) {
const sourceKey = `${ownerId}/${videoId}/raw-upload.mp4`;
const resultKey = `${ownerId}/${videoId}/result.mp4`;
const row = {
id: videoId,
ownerId,
orgId: "organization",
metadata: {
loomImportUpload: {
attemptId: "loom-run:0",
ownerId,
organizationId: "organization",
source: { key: sourceKey, uploadId: "source-upload" },
output: { key: resultKey, uploadId: "result-upload" },
},
},
};
mocks.rows = [row];
return {
row,
body: {
videoId,
key: source ? sourceKey : resultKey,
uploadId: source ? "source-upload" : "result-upload",
loomImportAttemptId: "loom-run:0",
partNumber: 1,
contentLength: 64 * 1024 ** 2,
parts: [{ partNumber: 1, etag: '"part-1"', size: 64 * 1024 ** 2 }],
},
};
}
it.each([true, false])(
"signs only the registered Loom upload and preserves existing objects (source=%s)",
async (source) => {
const { body } = loomUpload(source);
expect((await request("sign-part", body)).status).toBe(200);
expect(mocks.signPart).toHaveBeenCalledWith(body.key, body.uploadId, 1, {
ContentLength: body.contentLength,
});
expect((await request("complete", body)).status).toBe(200);
expect(mocks.complete).toHaveBeenCalledWith(
body.key,
body.uploadId,
expect.objectContaining({ IfNoneMatch: "*" }),
);
},
);
it.each([
{ loomImportAttemptId: "old-run:0" },
{ loomImportAttemptId: undefined },
{ uploadId: "unregistered-upload" },
{ key: "other-owner/other-video/raw-upload.mp4" },
])("blocks a stale or substituted Loom upload %#", async (change) => {
const { body } = loomUpload(false);
expect((await request("sign-part", { ...body, ...change })).status).toBe(
409,
);
expect((await request("complete", { ...body, ...change })).status).toBe(
409,
);
expect(mocks.signPart).not.toHaveBeenCalled();
expect(mocks.complete).not.toHaveBeenCalled();
});
it("blocks Loom upload finalization after a destination move", async () => {
const { body, row } = loomUpload();
row.orgId = "another-organization";
expect((await request("complete", body)).status).toBe(409);
expect(mocks.complete).not.toHaveBeenCalled();
});
it("blocks callbacks after a replacement workflow takes ownership", async () => {
const { body, row } = loomUpload();
mocks.rows = [
{
...row,
metadata: {
...row.metadata,
loomImportRun: { runId: "replacement-run", dispatch: "accepted" },
},
},
];
expect((await request("sign-part", body)).status).toBe(409);
expect((await request("complete", body)).status).toBe(409);
expect((await request("abort", body)).status).toBe(409);
expect(mocks.signPart).not.toHaveBeenCalled();
expect(mocks.complete).not.toHaveBeenCalled();
expect(mocks.abort).not.toHaveBeenCalled();
});
it("accepts exactly 10 GB and rejects a further multipart part", async () => {
const { body } = loomUpload();
const parts = Array.from({ length: 160 }, (_, index) => ({
partNumber: index + 1,
etag: `"part-${index + 1}"`,
size: 64 * 1024 ** 2,
}));
expect((await request("complete", { ...body, parts })).status).toBe(200);
mocks.complete.mockClear();
expect(
(await request("sign-part", { ...body, partNumber: 161 })).status,
).toBe(400);
expect(
(await request("complete", { ...body, parts: [...parts, parts[0]] }))
.status,
).toBe(400);
expect(mocks.complete).not.toHaveBeenCalled();
});
});