Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { db } from "@cap/database";
import { users, videos, videoUploads } from "@cap/database/schema";
import { serverEnv } from "@cap/env";
import { Storage } from "@cap/web-backend/src/Storage/index";
import { Video } from "@cap/web-domain";
import { eq } from "drizzle-orm";
import { FatalError, sleep } from "workflow";
import { isAiGenerationEnabledForUser } from "@/lib/ai-generation-entitlement";
import {
createMediaServerCapacityError,
isMediaServerCapacityError,
} from "@/lib/media-server-backpressure";
import { transcribeVideo } from "@/lib/transcribe";
import { decodeStorageVideo } from "@/lib/video-storage";
import { runWorkflowPromise } from "@/lib/workflow-runtime";
import {
type ProcessedVideoMetadata,
VideoProcessingFailedError,
waitForVideoProcessing,
} from "./video-processing-status";
interface ProcessVideoWorkflowPayload {
videoId: string;
userId: string;
rawFileKey: string;
bucketId: string | null;
}
interface VideoProcessingResult {
success: boolean;
message: string;
metadata?: {
duration: number;
width: number;
height: number;
fps: number;
};
}
function getValidDuration(duration: number) {
return Number.isFinite(duration) && duration > 0 ? duration : undefined;
}
export async function processVideoWorkflow(
payload: ProcessVideoWorkflowPayload,
): Promise<VideoProcessingResult> {
"use workflow";
const { videoId, userId, rawFileKey, bucketId } = payload;
try {
await validateProcessingRequest(videoId, rawFileKey);
let metadata: ProcessedVideoMetadata;
for (let processingAttempt = 0; ; processingAttempt++) {
let capacityRetryCount = 0;
while (true) {
try {
await processVideoOnMediaServer(
videoId,
userId,
rawFileKey,
bucketId,
);
break;
} catch (error) {
if (!isMediaServerCapacityError(error)) throw error;
await markVideoWaitingForCapacity(videoId);
await sleep(`${Math.min(120, 15 + capacityRetryCount * 15)}s`);
capacityRetryCount++;
}
}
try {
metadata = await waitForVideoProcessing(videoId);
break;
} catch (error) {
if (
!(error instanceof VideoProcessingFailedError) ||
processingAttempt >= 2
) {
throw error;
}
await markVideoWaitingForCapacity(videoId);
await sleep(15_000 * (processingAttempt + 1));
}
}
await saveMetadataAndComplete(videoId, metadata);
const outputKey = `${userId}/${videoId}/result.mp4`;
if (rawFileKey !== outputKey) {
await cleanupRawUpload(videoId, rawFileKey);
}
await queueProcessedVideoTranscription(videoId);
return {
success: true,
message: "Video processing completed",
metadata,
};
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
await setProcessingError(videoId, errorMessage);
throw new FatalError(errorMessage);
}
}
async function validateProcessingRequest(
videoId: string,
rawFileKey: string,
): Promise<void> {
"use step";
const mediaServerUrl = serverEnv().MEDIA_SERVER_URL;
if (!mediaServerUrl) {
throw new FatalError("MEDIA_SERVER_URL is not configured");
}
const [video] = await db()
.select()
.from(videos)
.where(eq(videos.id, videoId as Video.VideoId));
if (!video) {
throw new FatalError("Video does not exist");
}
const [upload] = await db()
.select()
.from(videoUploads)
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
if (!upload) {
throw new FatalError("Upload does not exist");
}
if (upload.rawFileKey !== rawFileKey) {
throw new FatalError("Upload raw file key does not match");
}
if (upload.phase !== "processing") {
throw new FatalError("Upload is not ready for processing");
}
}
const MEDIA_SERVER_START_MAX_ATTEMPTS = 2;
const MEDIA_SERVER_START_RETRY_BASE_MS = 250;
const MEDIA_SERVER_PRESIGNED_GET_EXPIRES_SECONDS = 3 * 60 * 60;
const MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS = 3 * 60 * 60;
function getInputExtension(rawFileKey: string): string {
const parts = rawFileKey.split(".");
const extension = parts.at(-1)?.toLowerCase();
if (!extension) {
return ".mp4";
}
return `.${extension}`;
}
async function waitForRetry(delayMs: number): Promise<void> {
await new Promise((resolve) => setTimeout(resolve, delayMs));
}
async function startMediaServerProcessJob(
mediaServerUrl: string,
body: {
videoId: string;
userId: string;
videoUrl: string;
outputPresignedUrl: string;
thumbnailPresignedUrl: string;
previewGifPresignedUrl: string;
webhookUrl: string;
webhookSecret?: string;
inputExtension: string;
audioLevels?: boolean;
importedOriginal?: boolean;
},
): Promise<string> {
for (let attempt = 0; attempt < MEDIA_SERVER_START_MAX_ATTEMPTS; attempt++) {
const headers: Record<string, string> = {
"Content-Type": "application/json",
};
if (body.webhookSecret) {
headers["x-media-server-secret"] = body.webhookSecret;
}
const response = await fetch(`${mediaServerUrl}/video/process`, {
method: "POST",
headers,
body: JSON.stringify(body),
});
if (response.ok) {
const { jobId } = (await response.json()) as { jobId: string };
return jobId;
}
const errorData = (await response.json().catch(() => ({}))) as {
error?: string;
code?: string;
details?: string;
instanceId?: string;
pid?: number;
activeVideoProcesses?: number;
maxConcurrentVideoProcesses?: number;
jobCount?: number;
};
const baseErrorMessage =
errorData.error ||
errorData.details ||
"Video processing failed to start";
const busyDiagnostics =
errorData.code === "SERVER_BUSY"
? [
errorData.instanceId ? `instance=${errorData.instanceId}` : null,
typeof errorData.pid === "number" ? `pid=${errorData.pid}` : null,
typeof errorData.activeVideoProcesses === "number" &&
typeof errorData.maxConcurrentVideoProcesses === "number"
? `active=${errorData.activeVideoProcesses}/${errorData.maxConcurrentVideoProcesses}`
: null,
typeof errorData.jobCount === "number"
? `jobCount=${errorData.jobCount}`
: null,
]
.filter(Boolean)
.join(", ")
: "";
const errorMessage = busyDiagnostics
? `${baseErrorMessage} (${busyDiagnostics})`
: baseErrorMessage;
const shouldRetry =
response.status === 503 &&
(errorData.code === "SERVER_BUSY" ||
errorMessage.includes("Server is busy"));
if (shouldRetry && attempt < MEDIA_SERVER_START_MAX_ATTEMPTS - 1) {
await waitForRetry(MEDIA_SERVER_START_RETRY_BASE_MS * 2 ** attempt);
continue;
}
if (shouldRetry) {
throw createMediaServerCapacityError({
response,
message: errorMessage,
videoId: body.videoId,
});
}
throw new Error(errorMessage);
}
throw new Error("Video processing failed to start");
}
async function processVideoOnMediaServer(
videoId: string,
userId: string,
rawFileKey: string,
_bucketId: string | null,
): Promise<void> {
"use step";
const mediaServerUrl = serverEnv().MEDIA_SERVER_URL;
const webhookBaseUrl =
serverEnv().MEDIA_SERVER_WEBHOOK_URL || serverEnv().WEB_URL;
if (!mediaServerUrl) {
throw new FatalError("MEDIA_SERVER_URL is not configured");
}
const [video] = await db()
.select()
.from(videos)
.where(eq(videos.id, Video.VideoId.make(videoId)));
if (!video) {
throw new FatalError("Video does not exist");
}
const videoDomain = decodeStorageVideo(video);
const [bucket] =
await Storage.getAccessForVideo(videoDomain).pipe(runWorkflowPromise);
const rawVideoUrl = await bucket
.getInternalSignedObjectUrl(rawFileKey, {
expiresIn: MEDIA_SERVER_PRESIGNED_GET_EXPIRES_SECONDS,
})
.pipe(runWorkflowPromise);
const outputKey = `${userId}/${videoId}/result.mp4`;
const thumbnailKey = `${userId}/${videoId}/screenshot/screen-capture.jpg`;
const previewGifKey = `${userId}/${videoId}/preview/animated-preview.gif`;
const outputPresignedUrl = await bucket
.getInternalPresignedPutUrl(
outputKey,
{
ContentType: "video/mp4",
},
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
)
.pipe(runWorkflowPromise);
const thumbnailPresignedUrl = await bucket
.getInternalPresignedPutUrl(
thumbnailKey,
{
ContentType: "image/jpeg",
},
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
)
.pipe(runWorkflowPromise);
const previewGifPresignedUrl = await bucket
.getInternalPresignedPutUrl(
previewGifKey,
{
ContentType: "image/gif",
CacheControl: "public, max-age=31536000, immutable",
},
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
)
.pipe(runWorkflowPromise);
const webhookUrl = `${webhookBaseUrl}/api/webhooks/media-server/progress?retryable=true`;
const webhookSecret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
await db()
.update(videoUploads)
.set({
phase: "processing",
processingProgress: 0,
processingMessage: "Starting video processing...",
processingError: null,
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
await startMediaServerProcessJob(mediaServerUrl, {
audioLevels: video.source.type === "webMP4",
videoId,
userId,
videoUrl: rawVideoUrl,
outputPresignedUrl,
thumbnailPresignedUrl,
previewGifPresignedUrl,
webhookUrl,
webhookSecret: webhookSecret || undefined,
inputExtension: getInputExtension(rawFileKey),
importedOriginal:
video.metadata?.loomDeferredProcessing?.rawFileKey === rawFileKey ||
undefined,
});
}
async function saveMetadataAndComplete(
videoId: string,
metadata: { duration: number; width: number; height: number; fps: number },
): Promise<void> {
"use step";
const duration = getValidDuration(metadata.duration);
await db()
.update(videos)
.set({
width: metadata.width,
height: metadata.height,
fps: metadata.fps,
...(duration === undefined ? {} : { duration }),
})
.where(eq(videos.id, videoId as Video.VideoId));
await db()
.delete(videoUploads)
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
}
async function cleanupRawUpload(
videoId: string,
rawFileKey: string,
): Promise<void> {
"use step";
try {
const [video] = await db()
.select()
.from(videos)
.where(eq(videos.id, Video.VideoId.make(videoId)));
if (!video) return;
const videoDomain = decodeStorageVideo(video);
const [bucket] =
await Storage.getAccessForVideo(videoDomain).pipe(runWorkflowPromise);
await bucket.deleteObject(rawFileKey).pipe(runWorkflowPromise);
} catch (error) {
console.error("[process-video] Failed to delete raw upload", error);
}
}
async function queueProcessedVideoTranscription(
videoId: string,
): Promise<void> {
"use step";
try {
const [owner] = await db()
.select({
id: videos.ownerId,
stripeSubscriptionStatus: users.stripeSubscriptionStatus,
thirdPartyStripeSubscriptionId: users.thirdPartyStripeSubscriptionId,
})
.from(videos)
.innerJoin(users, eq(videos.ownerId, users.id))
.where(eq(videos.id, Video.VideoId.make(videoId)));
if (!owner) return;
const result = await transcribeVideo(
Video.VideoId.make(videoId),
owner.id,
isAiGenerationEnabledForUser(owner),
);
if (!result.success) {
console.warn("[process-video] Failed to queue transcription", {
videoId,
message: result.message,
});
}
} catch (error) {
console.warn("[process-video] Failed to queue transcription", {
videoId,
error,
});
}
}
async function setProcessingError(
videoId: string,
errorMessage: string,
): Promise<void> {
"use step";
await db()
.update(videoUploads)
.set({
phase: "error",
processingProgress: 0,
processingMessage: "Video processing failed",
processingError: errorMessage,
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
}
async function markVideoWaitingForCapacity(videoId: string): Promise<void> {
"use step";
await db()
.update(videoUploads)
.set({
processingMessage: "Queued for video processing...",
processingError: null,
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
}