Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

6.9 KB
Raw Blame
import { serverEnv } from "@cap/env";

interface MediaServerError {
	error: string;
	code: string;
	details?: string;
}

const MAX_RETRIES = 5;
const INITIAL_RETRY_DELAY_MS = 2000;
const DEFAULT_RETRYABLE_STATUSES = new Set([502, 503, 504]);

interface FetchRetryOptions {
	maxRetries?: number;
	retryableStatuses?: Set<number>;
}

function isRetryableStatus(
	status: number,
	retryableStatuses: Set<number>,
): boolean {
	return retryableStatuses.has(status);
}

async function sleep(ms: number): Promise<void> {
	return new Promise((resolve) => setTimeout(resolve, ms));
}

function getMediaServerConfig(): {
	mediaServerUrl: string;
	mediaServerSecret: string;
} {
	const env = serverEnv();
	if (!env.MEDIA_SERVER_URL) {
		throw new Error("MEDIA_SERVER_URL is not configured");
	}
	if (!env.MEDIA_SERVER_WEBHOOK_SECRET) {
		throw new Error("MEDIA_SERVER_WEBHOOK_SECRET is not configured");
	}
	return {
		mediaServerUrl: env.MEDIA_SERVER_URL,
		mediaServerSecret: env.MEDIA_SERVER_WEBHOOK_SECRET,
	};
}

function getMediaServerHeaders(
	mediaServerSecret: string,
): Record<string, string> {
	return {
		"Content-Type": "application/json",
		"x-media-server-secret": mediaServerSecret,
	};
}

async function fetchWithRetry(
	url: string,
	options: RequestInit,
	retryOptions: FetchRetryOptions = {},
): Promise<Response> {
	let lastError: Error | undefined;
	const maxRetries = retryOptions.maxRetries ?? MAX_RETRIES;
	const retryableStatuses =
		retryOptions.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES;

	for (let attempt = 0; attempt <= maxRetries; attempt++) {
		try {
			const response = await fetch(url, options);

			if (!isRetryableStatus(response.status, retryableStatuses)) {
				return response;
			}

			if (attempt < maxRetries) {
				const delay = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
				console.log(
					`[media-client] Got ${response.status}, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`,
				);
				await sleep(delay);
				continue;
			}

			return response;
		} catch (err) {
			lastError = err instanceof Error ? err : new Error(String(err));
			if (attempt < maxRetries) {
				const delay = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
				console.log(
					`[media-client] Request failed: ${lastError.message}, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`,
				);
				await sleep(delay);
			}
		}
	}

	throw lastError || new Error("Request failed after retries");
}

export function isMediaServerConfigured(): boolean {
	const env = serverEnv();
	return !!env.MEDIA_SERVER_URL && !!env.MEDIA_SERVER_WEBHOOK_SECRET;
}

export async function checkMediaServerHealth(): Promise<{
	status: string;
	ffmpeg: { available: boolean; version: string };
}> {
	const mediaServerUrl = serverEnv().MEDIA_SERVER_URL;
	if (!mediaServerUrl) {
		throw new Error("MEDIA_SERVER_URL is not configured");
	}

	const response = await fetch(`${mediaServerUrl}/health`, {
		method: "GET",
	});

	if (!response.ok) {
		throw new Error(`Media server health check failed: ${response.status}`);
	}

	return response.json();
}

export async function checkHasAudioTrackViaMediaServer(
	videoUrl: string,
): Promise<boolean> {
	const { mediaServerUrl, mediaServerSecret } = getMediaServerConfig();

	const response = await fetchWithRetry(`${mediaServerUrl}/audio/check`, {
		method: "POST",
		headers: getMediaServerHeaders(mediaServerSecret),
		body: JSON.stringify({ videoUrl }),
	});

	if (!response.ok) {
		const errorData = (await response.json()) as MediaServerError;
		throw new Error(errorData.error || "Audio check failed");
	}

	const data = (await response.json()) as { hasAudio: boolean };
	return data.hasAudio;
}

export async function extractAudioViaMediaServer(
	videoUrl: string,
): Promise<Buffer> {
	const { mediaServerUrl, mediaServerSecret } = getMediaServerConfig();

	const response = await fetchWithRetry(`${mediaServerUrl}/audio/extract`, {
		method: "POST",
		headers: getMediaServerHeaders(mediaServerSecret),
		body: JSON.stringify({
			videoUrl,
			stream: true,
		}),
	});

	if (!response.ok) {
		let errorData: MediaServerError;
		try {
			errorData = (await response.json()) as MediaServerError;
		} catch {
			throw new Error(
				`Audio extraction failed: ${response.status} ${response.statusText}`,
			);
		}

		if (errorData.code === "NO_AUDIO_TRACK") {
			throw new Error("NO_AUDIO_TRACK");
		}
		throw new Error(
			errorData.details || errorData.error || "Audio extraction failed",
		);
	}

	const arrayBuffer = await response.arrayBuffer();
	return Buffer.from(arrayBuffer);
}

export interface MediaServerProbeResult {
	duration: number;
	width: number;
	height: number;
	fps: number;
	videoCodec: string;
	audioCodec: string | null;
	audioChannels: number | null;
	sampleRate: number | null;
	bitrate: number;
	fileSize: number;
}

export interface ProbeVideoViaMediaServerOptions {
	maxRetries?: number;
}

export async function probeVideoViaMediaServer(
	videoUrl: string,
	options: ProbeVideoViaMediaServerOptions = {},
): Promise<MediaServerProbeResult> {
	const { mediaServerUrl, mediaServerSecret } = getMediaServerConfig();

	const response = await fetchWithRetry(
		`${mediaServerUrl}/video/probe`,
		{
			method: "POST",
			headers: getMediaServerHeaders(mediaServerSecret),
			body: JSON.stringify({ videoUrl }),
		},
		{ maxRetries: options.maxRetries },
	);

	if (!response.ok) {
		let errorData: MediaServerError;
		try {
			errorData = (await response.json()) as MediaServerError;
		} catch {
			throw new Error(
				`Video probe failed: ${response.status} ${response.statusText}`,
			);
		}
		throw new Error(
			errorData.details || errorData.error || "Video probe failed",
		);
	}

	const data = (await response.json()) as { metadata: MediaServerProbeResult };
	return data.metadata;
}

export async function convertAudioToMp3ViaMediaServer(
	audioUrl: string,
): Promise<Buffer> {
	const { mediaServerUrl, mediaServerSecret } = getMediaServerConfig();

	const response = await fetchWithRetry(`${mediaServerUrl}/audio/convert`, {
		method: "POST",
		headers: getMediaServerHeaders(mediaServerSecret),
		body: JSON.stringify({
			audioUrl,
			outputFormat: "mp3",
			bitrate: "128k",
		}),
	});

	if (!response.ok) {
		let errorData: MediaServerError;
		try {
			errorData = (await response.json()) as MediaServerError;
		} catch {
			throw new Error(
				`Audio conversion failed: ${response.status} ${response.statusText}`,
			);
		}
		throw new Error(
			errorData.details || errorData.error || "Audio conversion failed",
		);
	}

	const arrayBuffer = await response.arrayBuffer();
	return Buffer.from(arrayBuffer);
}

export async function fetchConvertedVideoViaMediaServer(
	videoUrl: string,
	inputExtension?: string,
): Promise<Response> {
	const { mediaServerUrl, mediaServerSecret } = getMediaServerConfig();

	return await fetchWithRetry(
		`${mediaServerUrl}/video/convert`,
		{
			method: "POST",
			headers: getMediaServerHeaders(mediaServerSecret),
			body: JSON.stringify({
				videoUrl,
				...(inputExtension ? { inputExtension } : {}),
			}),
		},
		{ maxRetries: 0 },
	);
}