Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

12.1 KB
Raw Blame
import { createHash, timingSafeEqual } from "node:crypto";
import { db } from "@cap/database";
import { videos, videoUploads } from "@cap/database/schema";
import { serverEnv } from "@cap/env";
import type { Video } from "@cap/web-domain";
import { and, eq, isNull, ne, or, sql } from "drizzle-orm";
import { type NextRequest, NextResponse } from "next/server";
import { handleAudioLevelPublication } from "@/lib/audio-level-publication";
import { SourceCommitPendingError } from "@/lib/desktop-recording-jobs";
import { applyDesktopRecordingProgress } from "@/lib/desktop-recording-publication";
import { createVerifiedRecordingReceipt } from "@/lib/desktop-recording-upload-status";
import {
	type RecordingVerification,
	recordingVerificationSchema,
} from "@/lib/desktop-recording-verification";
import { queueDesktopSegmentsFinalization } from "@/lib/desktop-segments-finalization";
import { invalidateGoogleDriveStorageQuotaCache } from "@/lib/google-drive-storage-quota";
import { signalLoomImportFinished } from "@/lib/loom-import-signal";
import {
	queueVideoTranscription,
	shouldQueueTranscriptionAfterMediaComplete,
} from "@/lib/queue-video-transcription";
import { isEditSourceKey } from "@/lib/video-edit-processing";
import { applyEditProgress } from "@/lib/video-edit-progress";

interface ProgressWebhookPayload {
	manifestSha256?: string;
	recordingVerification?: {
		request: RecordingVerification;
		fullDecode: boolean;
		objectIdentity?: string;
	};
	jobId: string;
	videoId: string;
	phase:
		| "queued"
		| "downloading"
		| "probing"
		| "processing"
		| "uploading"
		| "generating_thumbnail"
		| "complete"
		| "error"
		| "cancelled";
	progress: number;
	message?: string;
	error?: string;
	metadata?: {
		duration: number;
		width: number;
		height: number;
		fps: number;
		videoCodec: string;
		audioCodec: string | null;
		audioChannels: number | null;
		sampleRate: number | null;
		bitrate: number;
		fileSize: number;
	};
	deferredSourceKey?: string;
}

const MEDIA_SERVER_SHUTDOWN_MESSAGE = "Server shutting down";

function getValidDuration(duration: number) {
	return Number.isFinite(duration) && duration > 0 ? duration : undefined;
}

function mapPhaseToDbPhase(
	phase: ProgressWebhookPayload["phase"],
): "uploading" | "processing" | "generating_thumbnail" | "complete" | "error" {
	switch (phase) {
		case "queued":
		case "downloading":
		case "probing":
		case "processing":
		case "uploading":
			return "processing";
		case "generating_thumbnail":
			return "generating_thumbnail";
		case "complete":
			return "complete";
		case "error":
		case "cancelled":
			return "error";
		default:
			return "processing";
	}
}

export async function POST(request: NextRequest) {
	try {
		const webhookSecret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
		const authHeader = request.headers.get("x-media-server-secret");
		// Hash both sides to a fixed-length digest before the constant-time
		// compare. This avoids comparing raw inputs whose UTF-8 byte length can
		// differ from their UTF-16 `.length` (which would throw a RangeError) and
		// removes the length pre-check that would otherwise leak the secret size.
		const digest = (value: string) =>
			createHash("sha256").update(value, "utf8").digest();
		if (
			!webhookSecret ||
			!authHeader ||
			!timingSafeEqual(digest(authHeader), digest(webhookSecret))
		) {
			return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
		}

		const body: unknown = await request.json();
		if (
			body &&
			typeof body === "object" &&
			"kind" in body &&
			body.kind === "audio-levels"
		)
			return NextResponse.json(await handleAudioLevelPublication(body));
		const payload = body as ProgressWebhookPayload;
		if (
			await applyEditProgress(
				payload,
				request.nextUrl.searchParams.get("editOperation"),
				request.nextUrl.searchParams.get("editStartedAt"),
			)
		) {
			return NextResponse.json({ success: true });
		}
		const recordingProgress = await applyDesktopRecordingProgress(payload);
		if (recordingProgress.handled) {
			if (recordingProgress.published) {
				try {
					await queueVideoTranscription(payload.videoId as Video.VideoId);
				} catch {
					console.warn(
						"[media-server-webhook] Transcription queue unavailable",
						{
							videoId: payload.videoId,
						},
					);
				}
			}
			return NextResponse.json(
				{
					success: recordingProgress.status === 200,
					...(recordingProgress.recordingWorker
						? { recordingWorker: recordingProgress.recordingWorker }
						: {}),
				},
				{ status: recordingProgress.status ?? 200 },
			);
		}
		const isRetryableWorkflowError =
			request.nextUrl.searchParams.get("retryable") === "true" &&
			(payload.phase === "error" ||
				(payload.phase === "cancelled" &&
					payload.message === MEDIA_SERVER_SHUTDOWN_MESSAGE));

		console.log(
			"[media-server-webhook] Received progress update for video %s: %s (%d%%)",
			payload.videoId,
			payload.phase,
			payload.progress,
		);

		const dbPhase = mapPhaseToDbPhase(payload.phase);

		if (dbPhase === "complete") {
			const [currentVideo] = await db()
				.select()
				.from(videos)
				.where(eq(videos.id, payload.videoId as Video.VideoId));
			const [currentUpload] = await db()
				.select({ rawFileKey: videoUploads.rawFileKey })
				.from(videoUploads)
				.where(eq(videoUploads.videoId, payload.videoId as Video.VideoId));
			const isEditUpload =
				currentVideo &&
				isEditSourceKey({
					ownerId: currentVideo.ownerId,
					videoId: payload.videoId,
					rawFileKey: currentUpload?.rawFileKey,
				});
			const proof = payload.recordingVerification;
			if (
				!isEditUpload &&
				!recordingProgress.allowLegacyProcessing &&
				(currentVideo?.source.type === "desktopSegments" ||
					currentVideo?.source.type === "desktopMP4")
			) {
				try {
					await queueDesktopSegmentsFinalization({
						videoId: currentVideo.id,
						userId: currentVideo.ownerId,
						verification: proof
							? recordingVerificationSchema.parse(proof.request)
							: undefined,
					});
				} catch (error) {
					if (!(error instanceof SourceCommitPendingError)) throw error;
				}
				return NextResponse.json({
					success: true,
					status: "queued-for-verification",
				});
			}
			const receipt = proof
				? currentVideo && payload.metadata
					? await createVerifiedRecordingReceipt(
							currentVideo,
							recordingVerificationSchema.parse(proof.request),
							payload.metadata,
							proof.fullDecode,
							proof.objectIdentity,
						)
					: null
				: undefined;
			if (receipt === null) {
				return NextResponse.json(
					{
						error: "Recording completion is missing required verification data",
					},
					{ status: 503 },
				);
			}
			if (payload.metadata) {
				const duration = getValidDuration(payload.metadata.duration);
				await db()
					.update(videos)
					.set({
						width: payload.metadata.width,
						height: payload.metadata.height,
						fps: payload.metadata.fps,
						...(duration === undefined ? {} : { duration }),
					})
					.where(eq(videos.id, payload.videoId as Video.VideoId));
			}

			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" &&
				payload.deferredSourceKey.startsWith(
					`${currentVideo.ownerId}/${currentVideo.id}/`,
				) &&
				payload.deferredSourceKey.endsWith(".webm")
					? payload.deferredSourceKey
					: undefined;
			const metadataUpdates = [
				...(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
					? [sql`'$.loomDeferredProcessing.status', 'complete'`]
					: []),
				...(deferredSourceKey
					? [
							sql`'$.loomDeferredProcessing', IF(JSON_EXTRACT(${videos.metadata}, '$.loomDeferredProcessing') IS NULL, JSON_OBJECT('rawFileKey', ${deferredSourceKey}, 'status', 'pending'), JSON_EXTRACT(${videos.metadata}, '$.loomDeferredProcessing'))`,
						]
					: []),
			];
			if (currentVideo && metadataUpdates.length > 0) {
				await db()
					.update(videos)
					.set({
						metadata: sql`JSON_SET(COALESCE(${videos.metadata}, JSON_OBJECT()), ${sql.join(metadataUpdates, sql`, `)})`,
					})
					.where(eq(videos.id, currentVideo.id));
			}

			if (receipt) {
				await db()
					.update(videos)
					.set({
						source: { type: "desktopMP4" as const },
						...(receipt
							? {
									metadata: sql`JSON_SET(COALESCE(${videos.metadata}, JSON_OBJECT()), '$.desktopRecordingUpload', JSON_OBJECT('version', ${receipt.version}, 'artifact', JSON_EXTRACT(${JSON.stringify(receipt.artifact)}, '$'), 'fileSize', ${receipt.fileSize}, 'duration', ${receipt.duration}, 'hasAudio', JSON_EXTRACT(${JSON.stringify(receipt.hasAudio)}, '$'), 'fullDecode', JSON_EXTRACT('true', '$'), 'requiredAudioVerified', JSON_EXTRACT(${JSON.stringify(receipt.requiredAudioVerified)}, '$'), 'objectIdentity', ${receipt.objectIdentity}))`,
								}
							: {}),
					})
					.where(eq(videos.id, payload.videoId as Video.VideoId));
			}

			if (isEditUpload) {
				await db()
					.update(videoUploads)
					.set({
						phase: "complete",
						processingProgress: 100,
						processingMessage: payload.message,
						processingError: null,
						updatedAt: new Date(),
					})
					.where(eq(videoUploads.videoId, payload.videoId as Video.VideoId));
			} else {
				await db()
					.delete(videoUploads)
					.where(
						and(
							eq(videoUploads.videoId, payload.videoId as Video.VideoId),
							deferredSourceKey
								? or(
										isNull(videoUploads.rawFileKey),
										ne(videoUploads.rawFileKey, deferredSourceKey),
									)
								: undefined,
						),
					);
			}
			await invalidateGoogleDriveStorageQuotaCache(
				currentVideo?.storageIntegrationId,
			);

			if (
				!transcribeOnView &&
				shouldQueueTranscriptionAfterMediaComplete(
					currentVideo?.source.type,
					Boolean(isEditUpload),
				)
			) {
				try {
					const result = await queueVideoTranscription(
						payload.videoId as Video.VideoId,
					);
					if (!result.success) {
						console.warn(
							"[media-server-webhook] Failed to queue transcription",
							{ videoId: payload.videoId, message: result.message },
						);
					}
				} catch (error) {
					console.warn("[media-server-webhook] Failed to queue transcription", {
						videoId: payload.videoId,
						error,
					});
				}
			}
		} else if (dbPhase === "error") {
			const processingError =
				payload.error || payload.message || "Unknown error";
			if (isRetryableWorkflowError) {
				await db()
					.update(videoUploads)
					.set({
						phase: "processing",
						processingProgress: Math.round(payload.progress),
						processingError,
						processingMessage: "Retrying video processing...",
						updatedAt: new Date(),
					})
					.where(eq(videoUploads.videoId, payload.videoId as Video.VideoId));
			} else {
				await db()
					.update(videoUploads)
					.set({
						phase: "error",
						processingError,
						processingMessage: payload.message,
						updatedAt: new Date(),
					})
					.where(eq(videoUploads.videoId, payload.videoId as Video.VideoId));
			}
		} else {
			await db()
				.update(videoUploads)
				.set({
					phase: dbPhase,
					processingProgress: Math.round(payload.progress),
					processingMessage: payload.message,
					processingError: null,
					updatedAt: new Date(),
				})
				.where(eq(videoUploads.videoId, payload.videoId as Video.VideoId));
		}

		if (dbPhase === "complete" || dbPhase === "error")
			await signalLoomImportFinished(
				request.nextUrl.searchParams.get("signal"),
				payload.videoId,
				payload.phase,
			);

		return NextResponse.json({ success: true });
	} catch (error) {
		console.error("[media-server-webhook] Error processing webhook:", error);
		return NextResponse.json(
			{ error: "Internal server error" },
			{ status: 500 },
		);
	}
}