Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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 },
);
}
}