Create polished demo videos without editing skills. Mac/Windows/Linux
// Adapted from Voom (MIT), Copyright (c) 2026 Aritro Paul.
// See ../../LICENSE and ../../../../THIRD_PARTY_NOTICES.md for attribution.
import { limitedJson, MAX_RECORDING_BYTES } from "./hostedUploads.js";
import { errorResponse, jsonResponse } from "./http.js";
import { EXPIRY_DAYS, FREE_EXPIRY_DAYS, finiteNonnegative } from "./video.js";
import { generateSalt, hashRecordingPassword } from "./crypto.js";
export function generateShareCode() {
const bytes = new Uint8Array(32);
crypto.getRandomValues(bytes);
return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
}
export async function handleUpload(request, env, ownerId = null) {
const body = ownerId ? await limitedJson(request, 16384) : await request.json();
const {
title,
duration,
width,
height,
hasWebcam,
fileSize,
password_hash,
cta_url,
cta_text,
} = body;
if (
ownerId &&
(!Number.isSafeInteger(fileSize) || fileSize <= 0 || fileSize > MAX_RECORDING_BYTES)
)
return errorResponse("Free recordings must be between 1 byte and 1 GB", 413);
if (ownerId && (typeof title !== "string" || !title.trim() || title.length > 200))
return errorResponse("Title must be between 1 and 200 characters");
if (
ownerId &&
((cta_url && (typeof cta_url !== "string" || cta_url.length > 2048)) ||
(cta_text && (typeof cta_text !== "string" || cta_text.length > 200)) ||
(password_hash &&
(typeof password_hash !== "string" || !/^[a-f0-9]{64}$/.test(password_hash))))
)
return errorResponse("Invalid recording options");
if (!title) return errorResponse("title is required");
if (password_hash && !env.API_SECRET)
return errorResponse("Password protection is not configured", 503);
// CTA links render as <a href> on the share page — only allow web URLs so a
// stored javascript:/data: URL can never reach that sink.
if (cta_url && !/^https?:\/\//i.test(cta_url)) {
return errorResponse("cta_url must be an http(s) URL");
}
const shareCode = generateShareCode();
const expiresAt = new Date(
Date.now() + (ownerId ? FREE_EXPIRY_DAYS : EXPIRY_DAYS) * 24 * 60 * 60 * 1000,
).toISOString();
// Versioned slow hash of the client digest, with a unique per-record salt.
let storedHash = null;
let salt = null;
if (password_hash) {
salt = generateSalt();
storedHash = await hashRecordingPassword(password_hash, salt);
}
const inserted = await env.DB.prepare(
`INSERT INTO videos (share_code, title, duration, width, height, has_webcam, file_size, expires_at, password_hash, password_salt, cta_url, cta_text, owner_id)
SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
WHERE ? IS NULL OR (SELECT COUNT(*) FROM videos WHERE owner_id = ?) < 5`,
)
.bind(
shareCode,
title,
finiteNonnegative(duration),
finiteNonnegative(width),
finiteNonnegative(height),
hasWebcam ? 1 : 0,
finiteNonnegative(fileSize),
expiresAt,
storedHash,
salt,
cta_url || null,
cta_text || null,
ownerId,
ownerId,
ownerId,
)
.run();
// The count and reservation are one SQLite statement: parallel requests cannot
// claim the sixth slot. Pending and expired rows count until explicitly deleted.
if (inserted.meta.changes === 0)
return errorResponse(
"Free accounts can store up to 5 recordings. Delete one before uploading another.",
409,
);
const baseUrl = new URL(request.url).origin;
return jsonResponse({
shareCode,
uploadURL: `${baseUrl}/api/upload-data/${shareCode}`,
shareURL: `${baseUrl}/s/${shareCode}`,
expiresAt,
});
}
export async function handleUploadData(request, env, shareCode) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
const contentType = request.headers.get("Content-Type") || "video/mp4";
await env.VIDEOS_BUCKET.put(`videos/${shareCode}.mp4`, request.body, {
httpMetadata: { contentType },
});
return jsonResponse({ ok: true });
}
export async function handleUploadThumbnail(request, env, shareCode) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
const contentType = request.headers.get("Content-Type") || "image/jpeg";
await env.VIDEOS_BUCKET.put(`thumbnails/${shareCode}.jpg`, request.body, {
httpMetadata: { contentType },
});
return jsonResponse({ ok: true });
}
export async function handleMultipartStart(request, env, shareCode) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
const key = `videos/${shareCode}.mp4`;
const multipartUpload = await env.VIDEOS_BUCKET.createMultipartUpload(key, {
httpMetadata: { contentType: "video/mp4" },
});
return jsonResponse({ uploadId: multipartUpload.uploadId });
}
export function decodeUploadId(value) {
try {
const decoded = decodeURIComponent(value);
return decoded && decoded.length <= 2048 ? decoded : null;
} catch {
return null;
}
}
export async function handleMultipartPart(request, env, shareCode, uploadId, partNumber) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
if (!Number.isInteger(partNumber) || partNumber < 1 || partNumber > 10000) {
return errorResponse("Invalid multipart part number");
}
const key = `videos/${shareCode}.mp4`;
const multipartUpload = env.VIDEOS_BUCKET.resumeMultipartUpload(key, uploadId);
const part = await multipartUpload.uploadPart(partNumber, request.body);
return jsonResponse({ partNumber: part.partNumber, etag: part.etag });
}
export async function handleMultipartAbort(request, env, shareCode, uploadId) {
const key = `videos/${shareCode}.mp4`;
try {
const multipartUpload = env.VIDEOS_BUCKET.resumeMultipartUpload(key, uploadId);
await multipartUpload.abort();
} catch (_e) {
// Ignore errors — upload may already be completed or expired
}
return jsonResponse({ ok: true });
}
export async function handleMultipartComplete(request, env, shareCode, uploadId) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
const key = `videos/${shareCode}.mp4`;
const multipartUpload = env.VIDEOS_BUCKET.resumeMultipartUpload(key, uploadId);
const body = await request.json();
const parts = body.parts; // [{ partNumber, etag }, ...]
if (!Array.isArray(parts) || parts.length === 0 || parts.length > 10000) {
return errorResponse("Invalid multipart parts");
}
if (
parts.some(
(part) =>
!part ||
!Number.isInteger(part.partNumber) ||
part.partNumber < 1 ||
part.partNumber > 10000 ||
typeof part.etag !== "string" ||
!part.etag,
)
) {
return errorResponse("Invalid multipart parts");
}
await multipartUpload.complete(parts);
return jsonResponse({ ok: true });
}
export async function handleMetadata(request, env, shareCode) {
const video = await env.DB.prepare("SELECT id FROM videos WHERE share_code = ?")
.bind(shareCode)
.first();
if (!video) return errorResponse("Video not found", 404);
const body = await request.json();
const { segments, title, summary, chapters, isMeeting } = body;
// Chunk inserts so a multi-hour transcript can't exceed D1 batch limits.
const BATCH_CHUNK = 100;
if (segments && segments.length > 0) {
const stmt = env.DB.prepare(
"INSERT INTO transcript_segments (video_id, start_time, end_time, text, speaker) VALUES (?, ?, ?, ?, ?)",
);
const batch = segments.map((seg) =>
stmt.bind(video.id, seg.startTime, seg.endTime, seg.text, seg.speaker || null),
);
for (let i = 0; i < batch.length; i += BATCH_CHUNK) {
await env.DB.batch(batch.slice(i, i + BATCH_CHUNK));
}
}
if (chapters && chapters.length > 0) {
const stmt = env.DB.prepare(
"INSERT INTO chapters (video_id, timestamp, title) VALUES (?, ?, ?)",
);
const batch = chapters.map((ch) => stmt.bind(video.id, ch.timestamp, ch.title));
for (let i = 0; i < batch.length; i += BATCH_CHUNK) {
await env.DB.batch(batch.slice(i, i + BATCH_CHUNK));
}
}
// Update title, summary, is_meeting, and mark upload complete
const updateFields = ["upload_completed = 1"];
const updateBinds = [];
if (title) {
updateFields.push("title = ?");
updateBinds.push(title);
}
if (summary !== undefined) {
updateFields.push("summary = ?");
updateBinds.push(summary || null);
}
if (isMeeting !== undefined) {
updateFields.push("is_meeting = ?");
updateBinds.push(isMeeting ? 1 : 0);
}
updateBinds.push(shareCode);
await env.DB.prepare(`UPDATE videos SET ${updateFields.join(", ")} WHERE share_code = ?`)
.bind(...updateBinds)
.run();
return jsonResponse({ ok: true });
}