Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { timingSafeEqual } from "node:crypto";
import { serverEnv } from "@cap/env";
import {
provideOptionalAuth,
Storage,
Videos,
VideosRepo,
verifyStorageObjectToken,
} from "@cap/web-backend";
import { getRecordingObjectIdentity } from "@cap/web-backend/src/Storage/recording-object-identity";
import { isInternalRecordingKey } from "@cap/web-backend/src/Storage/recording-output";
import { Storage as StorageDomain, Video } from "@cap/web-domain";
import { Effect, Option } from "effect";
import type { NextRequest } from "next/server";
import { isPrivateEditTranscriptObjectKey } from "@/lib/edit-transcript";
import { runPromise } from "@/lib/server";
import { CACHE_CONTROL_HEADERS } from "@/utils/helpers";
export const dynamic = "force-dynamic";
const copyHeader = (
source: Headers,
target: Headers,
sourceName: string,
targetName = sourceName,
) => {
const value = source.get(sourceName);
if (value) target.set(targetName, value);
};
const INLINE_CONTENT_TYPES = new Set([
"video/mp4",
"video/webm",
"video/quicktime",
"video/x-matroska",
"video/x-msvideo",
"video/x-m4v",
"video/mp2t",
"video/mpeg",
"video/ogg",
"video/3gpp",
"audio/mp4",
"audio/mpeg",
"audio/aac",
"audio/webm",
"audio/ogg",
"image/jpeg",
"image/png",
"image/gif",
"image/webp",
"text/vtt",
"application/vnd.apple.mpegurl",
"application/x-mpegurl",
"application/json",
]);
const setObjectContentHeaders = (
headers: Headers,
contentType: string | null | undefined,
) => {
headers.set("X-Content-Type-Options", "nosniff");
headers.set("Content-Security-Policy", "sandbox; default-src 'none'");
const essence = contentType?.split(";")[0]?.trim().toLowerCase();
if (contentType && essence && INLINE_CONTENT_TYPES.has(essence)) {
headers.set("Content-Type", contentType);
return;
}
headers.set("Content-Type", "application/octet-stream");
headers.set("Content-Disposition", "attachment");
};
const asRecord = (value: unknown): Record<string, unknown> | null =>
typeof value === "object" && value !== null
? (value as Record<string, unknown>)
: null;
const getErrorTag = (error: unknown) => {
const record = asRecord(error);
const tag = record?._tag;
return typeof tag === "string" ? tag : null;
};
const getErrorText = (error: unknown): string => {
if (error instanceof Error) {
const record = asRecord(error);
const cause = record?.cause;
if (cause !== undefined && cause !== error) {
return `${error.message} ${getErrorText(cause)}`;
}
return error.message;
}
if (typeof error === "string") return error;
const record = asRecord(error);
const cause = record?.cause;
if (cause !== undefined && cause !== error) return getErrorText(cause);
return String(error);
};
const isStorageError = (error: unknown) =>
error instanceof StorageDomain.StorageError ||
getErrorTag(error) === "StorageError";
const isPolicyDeniedError = (error: unknown) =>
getErrorTag(error) === "PolicyDenied";
const isObjectNotFoundError = (error: unknown) => {
if (error === "not-found") return true;
if (!isStorageError(error)) return false;
const message = getErrorText(error);
return (
message.includes("Storage object not found") ||
message.includes("Google Drive object not found") ||
message.includes("Google Drive request failed: 404")
);
};
const toProxyErrorResponse = (error: unknown) => {
const recordingReadStatus = getRecordingReadStatus(error);
if (recordingReadStatus) {
return new Response(
recordingReadStatus === 412 ? "Object changed" : "Object is unavailable",
{ status: recordingReadStatus },
);
}
if (isObjectNotFoundError(error) || isPolicyDeniedError(error)) {
return new Response("Not found", { status: 404 });
}
if (isStorageError(error)) {
return new Response("Storage upstream error", { status: 502 });
}
return new Response("Internal server error", { status: 500 });
};
const getRecordingReadStatus = (error: unknown): 412 | 503 | undefined => {
const record = asRecord(error);
if (
record?._tag === "RecordingObjectReadError" &&
(record.status === 412 || record.status === 503)
) {
return record.status;
}
return record?.cause && record.cause !== error
? getRecordingReadStatus(record.cause)
: undefined;
};
const getTokenVideo = (videoId: Video.VideoId) =>
Effect.gen(function* () {
const repo = yield* VideosRepo;
const maybeVideo = yield* repo.getById(videoId);
if (Option.isNone(maybeVideo)) return yield* Effect.fail("not-found");
return maybeVideo.value[0];
});
const getPolicyVideo = (videoId: Video.VideoId) =>
Effect.gen(function* () {
const videos = yield* Videos;
const maybeVideo = yield* videos.getByIdForViewing(videoId).pipe(
Effect.flatten,
Effect.catchTag("NoSuchElementException", () =>
Effect.fail("not-found" as const),
),
);
return maybeVideo[0];
});
export async function GET(request: NextRequest) {
const internalDownload =
request.headers.get("x-cap-internal-download") === "1";
if (internalDownload) {
const expected = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
const provided = request.headers.get("x-media-server-secret");
if (
!expected ||
!provided ||
Buffer.byteLength(expected) !== Buffer.byteLength(provided) ||
!timingSafeEqual(Buffer.from(expected), Buffer.from(provided))
) {
return new Response("Unauthorized", { status: 401 });
}
}
const videoIdParam = request.nextUrl.searchParams.get("videoId");
const key = request.nextUrl.searchParams.get("key");
const token = request.nextUrl.searchParams.get("token");
if (!videoIdParam || !key) {
return new Response("Missing videoId or key", { status: 400 });
}
if (isPrivateEditTranscriptObjectKey(key)) {
return new Response("Not found", { status: 404 });
}
const effect = Effect.gen(function* () {
const tokenPayload = token ? verifyStorageObjectToken(token) : null;
const videoId = Video.VideoId.make(videoIdParam);
const video =
tokenPayload?.videoId === videoIdParam && tokenPayload.key === key
? yield* getTokenVideo(videoId)
: yield* getPolicyVideo(videoId);
if (!key.startsWith(`${video.ownerId}/${video.id}/`)) {
return yield* Effect.fail("not-found" as const);
}
if (
isInternalRecordingKey(key) &&
!(tokenPayload?.videoId === videoIdParam && tokenPayload.key === key) &&
!(
key === Video.getAudioLevelOutputKey(video) ||
((video.source.type === "desktopMP4" ||
video.source.type === "webMP4") &&
[
key === video.source.outputKey,
key === video.source.thumbnailKey,
key === video.source.previewKey,
].some(Boolean))
)
) {
return yield* Effect.fail("not-found" as const);
}
const [storage] = yield* Storage.getAccessForVideo(video);
if (!("getObjectResponse" in storage)) {
const url = yield* storage.getSignedObjectUrl(key);
return Response.redirect(url);
}
if (internalDownload) {
if (!("getInternalDownload" in storage))
return new Response("Unsupported storage", { status: 400 });
const target = yield* storage.getInternalDownload(key, {
objectIdentity:
request.headers.get("x-cap-recording-object-identity") ??
request.headers.get("if-match") ??
undefined,
signal: request.signal,
});
return Response.json(target, {
headers: {
"Cache-Control": "private, no-store",
"Vercel-CDN-Cache-Control": "no-store",
Vary: "x-cap-internal-download, x-media-server-secret",
},
});
}
const verificationRequested =
request.headers.get("x-cap-recording-verification") === "1";
const expectedIdentity = request.headers.get("if-match");
const head =
verificationRequested || request.method === "HEAD"
? yield* storage.headObject(key)
: undefined;
const identity =
verificationRequested && head
? getRecordingObjectIdentity(head, expectedIdentity ?? undefined)
: undefined;
if (verificationRequested && !identity) {
return new Response("Object identity is unavailable", { status: 503 });
}
if (
verificationRequested &&
expectedIdentity &&
expectedIdentity !== identity
) {
return new Response("Object changed", { status: 412 });
}
if (request.method === "HEAD" && head) {
const headers = new Headers(CACHE_CONTROL_HEADERS);
if (identity) headers.set("ETag", identity);
headers.set("Accept-Ranges", "bytes");
if (head.ContentLength !== undefined)
headers.set("Content-Length", String(head.ContentLength));
setObjectContentHeaders(headers, head.ContentType);
return new Response(null, { status: 200, headers });
}
const upstream = identity
? yield* storage.getObjectResponse(key, request.headers.get("range"), {
objectIdentity: identity,
signal: request.signal,
})
: yield* storage.getObjectResponse(key, request.headers.get("range"), {
signal: request.signal,
});
const headers = new Headers(CACHE_CONTROL_HEADERS);
if (identity) headers.set("ETag", identity);
setObjectContentHeaders(headers, upstream.headers.get("content-type"));
copyHeader(upstream.headers, headers, "content-length", "Content-Length");
copyHeader(upstream.headers, headers, "content-range", "Content-Range");
copyHeader(upstream.headers, headers, "accept-ranges", "Accept-Ranges");
if (!headers.has("Accept-Ranges")) headers.set("Accept-Ranges", "bytes");
return new Response(upstream.body, {
status: upstream.status,
headers,
});
}).pipe(
provideOptionalAuth,
Effect.catchAll((error) => Effect.succeed(toProxyErrorResponse(error))),
);
try {
return await runPromise(effect);
} catch (error) {
return toProxyErrorResponse(error);
}
}
export const HEAD = GET;