Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

9.4 KB
Raw Blame
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;