Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { db } from "@cap/database";
import { agentApiOperations, 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 { and, eq, sql } from "drizzle-orm";
import { Effect } from "effect";
import {
createHook,
FatalError,
getWorkflowMetadata,
RetryableError,
sleep,
} from "workflow";
import {
getLoomDownloadUrl,
getReusableLoomDownloadUrl,
LoomDownloadTemporaryError,
} from "@/lib/loom-download-url";
import { cleanupLoomFileSource } from "@/lib/loom-file-cleanup";
import { getLoomImportSignalToken } from "@/lib/loom-import-signal-token";
import {
LOOM_IMPORT_MAX_BYTES,
type LoomMultipartUploadTarget,
prepareLoomMultipartUploads,
} from "@/lib/loom-import-upload";
import {
isLoomMediaJobFailed,
recordLoomMediaDispatch,
} from "@/lib/loom-media-dispatch";
import {
createMediaServerCapacityError,
isMediaServerCapacityError,
} from "@/lib/media-server-backpressure";
import { isStorageObjectNotFound } from "@/lib/storage-not-found";
import { runWorkflowPromise } from "@/lib/workflow-runtime";
import {
type ProcessedVideoMetadata,
VideoProcessingFailedError,
waitForSignalledVideoProcessing,
} from "./video-processing-status";
interface ImportLoomPayload {
videoId: string;
userId: string;
rawFileKey: string;
bucketId: string | null;
loomVideoId: string;
loomDownloadUrl?: string;
agentOperationId?: string;
reuseExistingRawUpload?: boolean;
cleanupRawUpload?: boolean;
importPriority?: "customer" | "bulk";
}
const MINIMUM_VIDEO_SIZE = 1024;
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 getValidDuration(duration: number) {
return Number.isFinite(duration) && duration > 0 ? duration : undefined;
}
function isStreamingUrl(url: string): boolean {
const path = (url.split("?")[0] ?? "").toLowerCase();
return path.endsWith(".m3u8") || path.endsWith(".mpd");
}
function isMp4Url(url: string): boolean {
return (url.split("?")[0] ?? "").toLowerCase().endsWith(".mp4");
}
type LoomWorker = "importer" | "media";
function getLoomWorkerUrl(worker: LoomWorker): string | undefined {
const env = serverEnv();
return worker === "importer" ? env.LOOM_IMPORTER_URL : env.MEDIA_SERVER_URL;
}
async function fetchFreshLoomDownloadUrl(
loomVideoId: string,
existingUrl?: string,
): Promise<string> {
"use step";
const reusableUrl = getReusableLoomDownloadUrl(existingUrl);
if (reusableUrl) return reusableUrl;
try {
const url = await getLoomDownloadUrl(loomVideoId);
if (url) return url;
} catch (error) {
if (error instanceof LoomDownloadTemporaryError) {
throw new RetryableError(error.message, {
retryAfter: error.retryAfterMs,
});
}
throw error;
}
throw new FatalError(
"Could not retrieve a download URL from Loom. The video may be private, password-protected, or the link may have expired.",
);
}
fetchFreshLoomDownloadUrl.maxRetries = 8;
interface VideoProcessingResult {
success: boolean;
message: string;
metadata?: {
duration: number;
width: number;
height: number;
fps: number;
};
}
interface LoomProcessingInput {
importFromLoom?: boolean;
}
async function requireLoomMediaServerSupport() {
"use step";
const env = serverEnv();
if (!env.MEDIA_SERVER_URL)
throw new FatalError("MEDIA_SERVER_URL is not configured");
await requireLoomWorkerCapabilities(env.MEDIA_SERVER_URL);
if (env.LOOM_IMPORTER_URL)
await requireLoomWorkerCapabilities(env.LOOM_IMPORTER_URL);
}
requireLoomMediaServerSupport.maxRetries = 60;
async function requireLoomWorkerCapabilities(workerUrl: string) {
const env = serverEnv();
const response = await fetch(`${workerUrl}/video/status`, {
headers: env.MEDIA_SERVER_WEBHOOK_SECRET
? { "x-media-server-secret": env.MEDIA_SERVER_WEBHOOK_SECRET }
: undefined,
signal: AbortSignal.timeout(15_000),
});
if (!response.ok)
throw new RetryableError(
"Could not verify Loom import worker capabilities",
{ retryAfter: 60_000 },
);
const capabilities: unknown = await response.json();
if (
typeof capabilities !== "object" ||
capabilities === null ||
!("loomMultipartUploads" in capabilities) ||
capabilities.loomMultipartUploads !== true ||
!("loomImportMaxBytes" in capabilities) ||
capabilities.loomImportMaxBytes !== LOOM_IMPORT_MAX_BYTES
) {
throw new RetryableError(
"The media server must be updated for 10 GB Loom imports",
{ retryAfter: 60_000 },
);
}
}
async function claimAgentImport(operationId: string | undefined) {
"use step";
if (!operationId) return true;
return db().transaction(async (tx) => {
const [operation] = await tx
.select({
kind: agentApiOperations.kind,
state: agentApiOperations.state,
})
.from(agentApiOperations)
.where(eq(agentApiOperations.id, operationId))
.limit(1)
.for("update");
if (!operation || operation.kind !== "import_loom") {
throw new FatalError("Agent Loom import operation not found");
}
if (operation.state !== "queued") return false;
await tx
.update(agentApiOperations)
.set({ state: "running", updatedAt: new Date() })
.where(eq(agentApiOperations.id, operationId));
return true;
});
}
async function completeAgentImport(
operationId: string | undefined,
videoId: string,
) {
"use step";
if (!operationId) return;
const now = new Date();
await db()
.update(agentApiOperations)
.set({
state: "succeeded",
result: { videoId },
updatedAt: now,
completedAt: now,
})
.where(eq(agentApiOperations.id, operationId));
}
async function failAgentImport(
operationId: string | undefined,
message: string,
) {
"use step";
if (!operationId) return;
const now = new Date();
await db()
.update(agentApiOperations)
.set({
state: "failed",
errorCode: "LOOM_IMPORT_FAILED",
errorMessage: message.slice(0, 2_000),
updatedAt: now,
completedAt: now,
})
.where(eq(agentApiOperations.id, operationId));
}
export async function importLoomVideoWorkflow(
payload: ImportLoomPayload,
): Promise<VideoProcessingResult> {
"use workflow";
const { workflowRunId } = getWorkflowMetadata();
if (!(await claimAgentImport(payload.agentOperationId))) {
return { success: true, message: "Loom import is already running" };
}
try {
const reuseExistingRawUpload =
payload.reuseExistingRawUpload && (await hasExistingLoomUpload(payload));
let processingInput: LoomProcessingInput = reuseExistingRawUpload
? {}
: { importFromLoom: true };
await requireLoomMediaServerSupport();
let metadata: ProcessedVideoMetadata;
for (let processingAttempt = 0; ; processingAttempt++) {
const finished = createHook<{ phase: string }>({
token: getLoomImportSignalToken(
payload.videoId,
`${workflowRunId}:${processingAttempt}`,
),
});
try {
let mediaJob: { jobId: string; worker: LoomWorker };
let capacityRetryCount = 0;
let previousSourceUrl =
processingAttempt === 0 ? payload.loomDownloadUrl : undefined;
while (true) {
try {
const loomSourceUrl = processingInput.importFromLoom
? await fetchFreshLoomDownloadUrl(
payload.loomVideoId,
previousSourceUrl,
)
: undefined;
previousSourceUrl = loomSourceUrl;
mediaJob = await processVideoOnMediaServer(
payload,
loomSourceUrl,
`${workflowRunId}:${processingAttempt}`,
workflowRunId,
);
break;
} catch (error) {
if (!isMediaServerCapacityError(error)) throw error;
await markLoomImportWaitingForCapacity(payload.videoId);
await sleep(`${Math.min(180, 30 + capacityRetryCount * 15)}s`);
capacityRetryCount++;
}
}
try {
metadata = await waitForSignalledVideoProcessing(
payload.videoId,
finished,
);
break;
} catch (error) {
if (
!(error instanceof VideoProcessingFailedError) ||
processingAttempt >= 2
) {
throw error;
}
if (
!(await confirmLoomMediaJobFailure(
mediaJob.jobId,
payload.videoId,
mediaJob.worker,
))
) {
throw new FatalError(
"The previous Loom worker must be reconciled before retrying",
);
}
await markLoomImportWaitingForCapacity(payload.videoId);
if (await hasExistingLoomUpload(payload)) processingInput = {};
await sleep(15_000 * (processingAttempt + 1));
}
} finally {
finished.dispose();
}
}
await saveMetadataAndComplete(payload.videoId, metadata);
await completeAgentImport(payload.agentOperationId, payload.videoId);
if (payload.cleanupRawUpload) await cleanupLoomFileSource(payload);
return {
success: true,
message: "Loom video imported successfully",
metadata,
};
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
await setProcessingError(payload.videoId, errorMessage);
await failAgentImport(payload.agentOperationId, errorMessage);
throw new FatalError(errorMessage);
}
}
function getInputExtension(url: string): string | undefined {
const pathname = new URL(url).pathname.toLowerCase();
if (pathname.endsWith(".m3u8")) {
return ".m3u8";
}
if (pathname.endsWith(".mpd")) {
return ".mpd";
}
if (pathname.endsWith(".mp4")) {
return ".mp4";
}
return undefined;
}
async function confirmLoomMediaJobFailure(
jobId: string,
videoId: string,
worker: LoomWorker,
) {
"use step";
return isLoomMediaJobFailed(jobId, videoId, getLoomWorkerUrl(worker));
}
async function hasExistingLoomUpload(
payload: ImportLoomPayload,
): Promise<boolean> {
"use step";
return Effect.gen(function* () {
const [video] = yield* Effect.promise(() =>
db()
.select()
.from(videos)
.where(eq(videos.id, Video.VideoId.make(payload.videoId))),
);
if (!video) return false;
const videoDomain = Video.Video.decodeSync({
...video,
bucketId: video.bucket,
storageIntegrationId: video.storageIntegrationId,
createdAt: video.createdAt.toISOString(),
updatedAt: video.updatedAt.toISOString(),
metadata: video.metadata,
});
const [bucket] = yield* Storage.getAccessForVideo(videoDomain);
const previous = video.metadata?.loomImportUpload;
if (
previous?.ownerId === video.ownerId &&
previous.organizationId === video.orgId &&
previous.output.key === `${video.ownerId}/${video.id}/result.mp4`
) {
const savedOutput = yield* bucket.headObject(previous.output.key).pipe(
Effect.map(
(object) => (object.ContentLength ?? 0) >= MINIMUM_VIDEO_SIZE,
),
Effect.catchIf(isStorageObjectNotFound, () => Effect.succeed(false)),
);
if (savedOutput) return true;
}
return yield* bucket.headObject(payload.rawFileKey).pipe(
Effect.map((object) => (object.ContentLength ?? 0) >= MINIMUM_VIDEO_SIZE),
Effect.catchIf(isStorageObjectNotFound, () => Effect.succeed(false)),
);
}).pipe(runWorkflowPromise);
}
async function waitForRetry(delayMs: number): Promise<void> {
await new Promise((resolve) => setTimeout(resolve, delayMs));
}
class LoomMediaRequestRejectedError extends Error {}
async function startMediaServerProcessJob(
mediaServerUrl: string,
body: {
videoId: string;
userId: string;
videoUrl: string;
sourcePresignedUrl?: string;
sourceUpload?: LoomMultipartUploadTarget;
outputUpload?: LoomMultipartUploadTarget;
originalUpload?: {
key: string;
upload: LoomMultipartUploadTarget | { type: "put"; url: string };
};
existingOutput?: { url: string; objectIdentity: string; fileSize: number };
maxImportBytes: number;
outputPresignedUrl: string;
thumbnailPresignedUrl: string;
previewGifPresignedUrl?: string;
webhookUrl: string;
webhookSecret?: string;
inputExtension?: string;
priority: "bulk";
importPriority?: "customer" | "bulk";
},
recordDispatch: (
state: "accepted" | "rejected" | "uncertain",
jobId?: string,
) => Promise<void>,
importOnly = false,
): 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 endpoint =
importOnly || body.sourcePresignedUrl || body.sourceUpload
? "import"
: "process";
await recordDispatch("uncertain");
const response = await fetch(`${mediaServerUrl}/video/${endpoint}`, {
method: "POST",
headers,
body: JSON.stringify(body),
});
if (response.ok) {
const accepted: unknown = await response.json();
if (
typeof accepted !== "object" ||
accepted === null ||
!("jobId" in accepted) ||
typeof accepted.jobId !== "string" ||
!accepted.jobId
) {
throw new Error("Loom worker acceptance requires job reconciliation");
}
const jobId = accepted.jobId;
await recordDispatch("accepted", jobId).catch((error) => {
console.error("Could not record accepted Loom media dispatch", error);
});
return jobId;
}
const errorData = (await response.json().catch(() => ({}))) as {
error?: string;
code?: string;
details?: string;
};
const errorMessage =
errorData.error ||
errorData.details ||
"Video processing failed to start";
const shouldRetry =
response.status === 503 && errorData.code === "SERVER_BUSY";
if ((response.status >= 400 && response.status < 500) || shouldRetry)
await recordDispatch("rejected");
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,
priority: "bulk",
});
}
if (response.status >= 400 && response.status < 500)
throw new LoomMediaRequestRejectedError(errorMessage);
throw new Error(errorMessage);
}
throw new Error("Video processing failed to start");
}
async function processVideoOnMediaServer(
payload: ImportLoomPayload,
loomSourceUrl: string | undefined,
attemptId: string,
runId: string,
): Promise<{ jobId: string; worker: LoomWorker }> {
"use step";
const { videoId, userId, rawFileKey } = payload;
const worker: LoomWorker =
loomSourceUrl && serverEnv().LOOM_IMPORTER_URL ? "importer" : "media";
const mediaServerUrl = getLoomWorkerUrl(worker);
if (!mediaServerUrl) {
throw new FatalError("MEDIA_SERVER_URL is not configured");
}
const originalKey =
worker === "importer" && loomSourceUrl && !isMp4Url(loomSourceUrl)
? `${userId}/${videoId}/raw-upload.webm`
: undefined;
const webhookBaseUrl =
serverEnv().MEDIA_SERVER_WEBHOOK_URL || serverEnv().WEB_URL;
const {
rawVideoUrl,
originalUpload,
sourcePresignedUrl,
outputPresignedUrl,
thumbnailPresignedUrl,
previewGifPresignedUrl,
sourceUpload,
outputUpload,
existingOutput,
abortUploads,
} = await Effect.gen(function* () {
const [video] = yield* Effect.promise(() =>
db()
.select()
.from(videos)
.where(eq(videos.id, Video.VideoId.make(videoId))),
);
if (!video) {
return yield* Effect.fail(new FatalError("Video does not exist"));
}
if (video.ownerId !== userId) {
return yield* Effect.fail(new FatalError("Loom import owner changed"));
}
const videoDomain = Video.Video.decodeSync({
...video,
bucketId: video.bucket,
storageIntegrationId: video.storageIntegrationId,
createdAt: video.createdAt.toISOString(),
updatedAt: video.updatedAt.toISOString(),
metadata: video.metadata,
});
const [bucket] = yield* Storage.getAccessForVideo(videoDomain);
const outputKey = `${userId}/${videoId}/result.mp4`;
const thumbnailKey = `${userId}/${videoId}/screenshot/screen-capture.jpg`;
const previewGifKey = `${userId}/${videoId}/preview/animated-preview.gif`;
const rawVideoUrl = loomSourceUrl
? loomSourceUrl
: yield* bucket.getInternalSignedObjectUrl(rawFileKey, {
expiresIn: MEDIA_SERVER_PRESIGNED_GET_EXPIRES_SECONDS,
});
const sourcePresignedUrl =
worker === "media" && loomSourceUrl && !isStreamingUrl(loomSourceUrl)
? yield* bucket.getInternalPresignedPutUrl(
rawFileKey,
{ ContentType: "video/mp4" },
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
)
: undefined;
const outputPresignedUrl = yield* bucket.getInternalPresignedPutUrl(
outputKey,
{ ContentType: "video/mp4" },
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
);
const thumbnailPresignedUrl = yield* bucket.getInternalPresignedPutUrl(
thumbnailKey,
{
ContentType: "image/jpeg",
},
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
);
const previewGifPresignedUrl = yield* bucket.getInternalPresignedPutUrl(
previewGifKey,
{
ContentType: "image/gif",
CacheControl: "public, max-age=31536000, immutable",
},
{ expiresIn: MEDIA_SERVER_PRESIGNED_PUT_EXPIRES_SECONDS },
);
if (originalKey)
yield* bucket
.deleteObject(originalKey)
.pipe(Effect.catchAll(() => Effect.void));
const originalPutUrl =
originalKey && bucket.provider !== "s3"
? yield* bucket.getInternalPresignedPutUrl(originalKey, {
ContentType: "video/webm",
})
: undefined;
const multipart = yield* Effect.promise(() =>
prepareLoomMultipartUploads({
video,
bucket,
attemptId,
sourceKey:
worker === "importer"
? originalKey
: loomSourceUrl && !isStreamingUrl(loomSourceUrl)
? rawFileKey
: undefined,
webhookBaseUrl,
webhookSecret: serverEnv().MEDIA_SERVER_WEBHOOK_SECRET || undefined,
}),
);
const originalUpload = originalKey
? multipart.sourceUpload
? { key: originalKey, upload: multipart.sourceUpload }
: originalPutUrl
? {
key: originalKey,
upload: { type: "put" as const, url: originalPutUrl },
}
: undefined
: undefined;
return {
rawVideoUrl: multipart.existingOutput?.url ?? rawVideoUrl,
originalUpload,
sourcePresignedUrl:
multipart.sourceUpload || multipart.existingOutput
? undefined
: sourcePresignedUrl,
outputPresignedUrl,
thumbnailPresignedUrl,
previewGifPresignedUrl,
...multipart,
abortUploads: async () => {
await Promise.all(
[multipart.sourceUpload, multipart.outputUpload]
.filter(
(upload): upload is LoomMultipartUploadTarget =>
upload !== undefined,
)
.map((upload) =>
bucket.multipart.abort(upload.key, upload.uploadId).pipe(
Effect.catchAll(() => Effect.void),
runWorkflowPromise,
),
),
);
},
};
}).pipe(runWorkflowPromise);
const webhookUrl = `${webhookBaseUrl}/api/webhooks/media-server/progress?retryable=true&signal=${encodeURIComponent(getLoomImportSignalToken(videoId, attemptId))}${worker === "importer" ? "&transcription=on-view&preview=on-view" : ""}`;
const webhookSecret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
try {
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));
} catch (error) {
await abortUploads();
throw error;
}
try {
const jobId = await startMediaServerProcessJob(
mediaServerUrl,
{
videoId,
userId,
videoUrl: rawVideoUrl,
sourcePresignedUrl,
sourceUpload: worker === "importer" ? undefined : sourceUpload,
originalUpload,
outputUpload,
existingOutput,
maxImportBytes: LOOM_IMPORT_MAX_BYTES,
outputPresignedUrl,
thumbnailPresignedUrl,
previewGifPresignedUrl:
worker === "importer" ? undefined : previewGifPresignedUrl,
webhookUrl,
webhookSecret: webhookSecret || undefined,
inputExtension: getInputExtension(rawVideoUrl),
priority: "bulk",
importPriority:
worker === "importer"
? (payload.importPriority ?? "customer")
: undefined,
},
(state, jobId) =>
recordLoomMediaDispatch({
videoId,
userId,
runId,
attemptId,
state,
jobId,
worker,
}),
worker === "importer",
);
return { jobId, worker };
} catch (error) {
if (error instanceof LoomMediaRequestRejectedError) await abortUploads();
throw error;
}
}
processVideoOnMediaServer.maxRetries = 0;
async function saveMetadataAndComplete(
videoId: string,
metadata: { duration: number; width: number; height: number; fps: number },
): Promise<void> {
"use step";
await db()
.update(videos)
.set({
width: metadata.width,
height: metadata.height,
fps: metadata.fps,
...(getValidDuration(metadata.duration) === undefined
? {}
: { duration: metadata.duration }),
})
.where(eq(videos.id, videoId as Video.VideoId));
await db()
.delete(videoUploads)
.where(
and(
eq(videoUploads.videoId, videoId as Video.VideoId),
sql`NOT EXISTS (SELECT 1 FROM ${videos} WHERE ${videos.id} = ${videoId} AND JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomDeferredProcessing.status')) = 'started')`,
),
);
}
async function setProcessingError(
videoId: string,
errorMessage: string,
): Promise<void> {
"use step";
await db()
.update(videoUploads)
.set({
phase: "error",
processingProgress: 0,
processingMessage: "Loom import failed",
processingError: errorMessage,
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
}
async function markLoomImportWaitingForCapacity(
videoId: string,
): Promise<void> {
"use step";
await db()
.update(videoUploads)
.set({
processingMessage: "Queued for Loom import processing...",
processingError: null,
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId as Video.VideoId));
}