Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

feat: process imported Loom originals and transcripts when first viewed

Richie McIlroyac6904e692a5
diff --git a/apps/web/__tests__/unit/media-server-progress.test.ts b/apps/web/__tests__/unit/media-server-progress.test.ts
index ff6a9a157..1da5dc8c6 100644
--- a/apps/web/__tests__/unit/media-server-progress.test.ts
+++ b/apps/web/__tests__/unit/media-server-progress.test.ts
@@ -1,3 +1,5 @@
+import type { SQL } from "drizzle-orm";
+import { MySqlDialect } from "drizzle-orm/mysql-core";
import { Effect } from "effect";
import { NextRequest } from "next/server";
import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -810,3 +812,98 @@ describe("media-server recording progress webhook", () => {
]);
});
});
+
+describe("Loom importer completions", () => {
+ const complete = (extra: Record<string, unknown> = {}) => ({
+ jobId: "importer-1",
+ videoId,
+ phase: "complete",
+ progress: 100,
+ metadata,
+ ...extra,
+ });
+ const metadataWrites = (mutations: Mutation[]) =>
+ mutations
+ .filter(
+ ({ table, values }) =>
+ table === mocks.tables.videos && values?.metadata !== undefined,
+ )
+ .map(({ values }) =>
+ new MySqlDialect().sqlToQuery(values?.metadata as SQL),
+ );
+
+ beforeEach(() => {
+ mocks.transcribe.mockReset().mockResolvedValue({ success: true });
+ mocks.queue.mockReset();
+ vi.spyOn(console, "log").mockImplementation(() => undefined);
+ });
+
+ function loomVideo() {
+ const database = databaseFixture(null);
+ database.video.source = { type: "webMP4" };
+ return database;
+ }
+
+ it("leaves transcription for the first view of importer completions", async () => {
+ const database = loomVideo();
+ const response = await request(
+ complete(),
+ "media-secret",
+ "?retryable=true&transcription=on-view",
+ );
+ expect(response.status).toBe(200);
+ expect(mocks.transcribe).not.toHaveBeenCalled();
+ const [write] = metadataWrites(database.mutations);
+ expect(write?.sql).toContain(
+ "'$.transcribeOnView', JSON_EXTRACT('true', '$')",
+ );
+ expect(write?.sql).not.toContain("loomDeferredProcessing");
+ expect(database.mutations).toContainEqual({
+ operation: "delete",
+ table: mocks.tables.uploads,
+ });
+ });
+
+ it("records an imported original that still needs processing", async () => {
+ const database = loomVideo();
+ const key = `${ownerId}/${videoId}/raw-upload.webm`;
+ await request(
+ complete({ deferredSourceKey: key }),
+ "media-secret",
+ "?retryable=true&transcription=on-view",
+ );
+ const [write] = metadataWrites(database.mutations);
+ expect(write?.sql).toContain("'$.loomDeferredProcessing', JSON_OBJECT(");
+ expect(write?.params).toContain(key);
+ });
+
+ it.each([
+ `other-user/${videoId}/raw-upload.webm`,
+ `${ownerId}/other-video/raw-upload.webm`,
+ `${ownerId}/${videoId}/result.mp4`,
+ ])("ignores the deferred original %s", async (key) => {
+ const database = loomVideo();
+ await request(
+ complete({ deferredSourceKey: key }),
+ "media-secret",
+ "?retryable=true&transcription=on-view",
+ );
+ for (const write of metadataWrites(database.mutations))
+ expect(write.sql).not.toContain("loomDeferredProcessing");
+ });
+
+ it("keeps queueing transcription for media server completions", async () => {
+ const database = loomVideo();
+ await request(
+ complete({ deferredSourceKey: `${ownerId}/${videoId}/raw-upload.webm` }),
+ "media-secret",
+ "?retryable=true",
+ );
+ expect(mocks.transcribe).toHaveBeenCalledWith(videoId);
+ expect(
+ metadataWrites(database.mutations).some(({ sql }) =>
+ sql.includes("transcribeOnView"),
+ ),
+ ).toBe(false);
+ });
+});
diff --git a/apps/web/app/api/webhooks/media-server/progress/route.ts b/apps/web/app/api/webhooks/media-server/progress/route.ts
index 35233e295..4c455ad68 100644
--- a/apps/web/app/api/webhooks/media-server/progress/route.ts
+++ b/apps/web/app/api/webhooks/media-server/progress/route.ts
@@ -56,6 +56,7 @@ interface ProgressWebhookPayload {
bitrate: number;
fileSize: number;
};
+ deferredSourceKey?: string;
}
const MEDIA_SERVER_SHUTDOWN_MESSAGE = "Server shutting down";
@@ -232,6 +233,36 @@ export async function POST(request: NextRequest) {
.where(eq(videos.id, payload.videoId as Video.VideoId));
}
+ const transcribeOnView =
+ request.nextUrl.searchParams.get("transcription") === "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', '$')`]
+ : []),
+ ...(deferredSourceKey
+ ? [
+ sql`'$.loomDeferredProcessing', JSON_OBJECT('rawFileKey', ${deferredSourceKey}, 'status', 'pending')`,
+ ]
+ : []),
+ ];
+ 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)
@@ -267,6 +298,7 @@ export async function POST(request: NextRequest) {
);
if (
+ !transcribeOnView &&
shouldQueueTranscriptionAfterMediaComplete(
currentVideo?.source.type,
Boolean(isEditUpload),
diff --git a/apps/web/app/embed/[videoId]/page.tsx b/apps/web/app/embed/[videoId]/page.tsx
index 0ba5dd33c..73bb3cd29 100644
--- a/apps/web/app/embed/[videoId]/page.tsx
+++ b/apps/web/app/embed/[videoId]/page.tsx
@@ -27,6 +27,10 @@ import { Effect, Option } from "effect";
import type { Metadata } from "next";
import Link from "next/link";
import { notFound } from "next/navigation";
+import {
+ getPendingLoomProcessing,
+ startDeferredLoomProcessing,
+} from "@/lib/loom-deferred-processing";
import { resolveDefaultPlaybackSpeed } from "@/lib/playback-speed";
import * as EffectRuntime from "@/lib/server";
import { getSharePageBranding } from "@/lib/share-branding";
@@ -270,6 +274,22 @@ async function EmbedContent({
}
const currentMetadata = (video.metadata as VideoMetadata) || {};
+ const deferredLoomRawFileKey = video.hasActiveUpload
+ ? null
+ : getPendingLoomProcessing(currentMetadata, video.ownerId, video.id);
+ if (deferredLoomRawFileKey) {
+ startDeferredLoomProcessing({
+ videoId: video.id,
+ ownerId: video.ownerId,
+ bucketId: video.bucket,
+ rawFileKey: deferredLoomRawFileKey,
+ }).catch((error) => {
+ console.error(
+ `[EmbedVideoPage] Error starting deferred processing for ${video.id}:`,
+ error,
+ );
+ });
+ }
let initialAiData = null;
if (
diff --git a/apps/web/app/s/[videoId]/page.tsx b/apps/web/app/s/[videoId]/page.tsx
index d54403b87..878eb1853 100644
--- a/apps/web/app/s/[videoId]/page.tsx
+++ b/apps/web/app/s/[videoId]/page.tsx
@@ -47,6 +47,10 @@ import {
} from "@/app/(org)/dashboard/dashboard-data";
import { isAiConfigured } from "@/lib/ai/provider";
import { completeDesktopSegmentsManifestAndQueue } from "@/lib/desktop-segments-recovery";
+import {
+ getPendingLoomProcessing,
+ startDeferredLoomProcessing,
+} from "@/lib/loom-deferred-processing";
import { createNotification } from "@/lib/Notification";
import {
canManageOrganizationSettings,
@@ -873,6 +877,22 @@ async function AuthorizedContent({
}
const metadata = (video.metadata as VideoMetadata) || {};
+ const deferredLoomRawFileKey = hasActiveUpload
+ ? null
+ : getPendingLoomProcessing(metadata, video.owner.id, videoId);
+ if (deferredLoomRawFileKey) {
+ startDeferredLoomProcessing({
+ videoId,
+ ownerId: video.owner.id,
+ bucketId: video.bucket,
+ rawFileKey: deferredLoomRawFileKey,
+ }).catch((error) => {
+ console.error(
+ `[ShareVideoPage] Error starting deferred processing for ${videoId}:`,
+ error,
+ );
+ });
+ }
const aiGenerationStatus = metadata.aiGenerationStatus || null;
const initialAiData = {
diff --git a/apps/web/lib/loom-deferred-processing.ts b/apps/web/lib/loom-deferred-processing.ts
new file mode 100644
index 000000000..e0dc3deed
--- /dev/null
+++ b/apps/web/lib/loom-deferred-processing.ts
@@ -0,0 +1,72 @@
+import { db } from "@cap/database";
+import { videos, videoUploads } from "@cap/database/schema";
+import type { VideoMetadata } from "@cap/database/types";
+import type { Video } from "@cap/web-domain";
+import { and, eq, sql } from "drizzle-orm";
+import { startVideoProcessingWorkflow } from "@/lib/video-processing";
+
+function getAffectedRows(result: unknown) {
+ const header = Array.isArray(result) ? result[0] : result;
+ return (header as { affectedRows?: number } | undefined)?.affectedRows ?? 0;
+}
+
+export function getPendingLoomProcessing(
+ metadata: VideoMetadata | null | undefined,
+ ownerId: string,
+ videoId: string,
+) {
+ const deferred = metadata?.loomDeferredProcessing;
+ if (
+ deferred?.status !== "pending" ||
+ typeof deferred.rawFileKey !== "string" ||
+ !deferred.rawFileKey.startsWith(`${ownerId}/${videoId}/`)
+ )
+ return null;
+ return deferred.rawFileKey;
+}
+
+export async function startDeferredLoomProcessing({
+ videoId,
+ ownerId,
+ bucketId,
+ rawFileKey,
+}: {
+ videoId: Video.VideoId;
+ ownerId: string;
+ bucketId: string | null;
+ rawFileKey: string;
+}) {
+ const claim = await db()
+ .update(videos)
+ .set({
+ metadata: sql`JSON_SET(${videos.metadata}, '$.loomDeferredProcessing.status', 'started', '$.loomDeferredProcessing.startedAt', ${new Date().toISOString()})`,
+ })
+ .where(
+ and(
+ eq(videos.id, videoId),
+ sql`JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomDeferredProcessing.status')) = 'pending'`,
+ sql`JSON_UNQUOTE(JSON_EXTRACT(${videos.metadata}, '$.loomDeferredProcessing.rawFileKey')) = ${rawFileKey}`,
+ ),
+ );
+ if (getAffectedRows(claim) !== 1) return "already-started" as const;
+
+ await db()
+ .insert(videoUploads)
+ .values({
+ videoId,
+ mode: "singlepart",
+ phase: "uploading",
+ rawFileKey,
+ processingMessage: "Optimizing imported video...",
+ })
+ .onDuplicateKeyUpdate({ set: { rawFileKey } });
+
+ return startVideoProcessingWorkflow({
+ videoId,
+ userId: ownerId,
+ rawFileKey,
+ bucketId,
+ processingMessage: "Optimizing imported video...",
+ startFailureMessage: "Imported video could not be optimized",
+ });
+}
diff --git a/apps/web/lib/video-pipeline-recovery.ts b/apps/web/lib/video-pipeline-recovery.ts
index 67b2fda08..4deef1a19 100644
--- a/apps/web/lib/video-pipeline-recovery.ts
+++ b/apps/web/lib/video-pipeline-recovery.ts
@@ -394,7 +394,10 @@ export async function recoverStalledVideoPipeline({
gte(videos.createdAt, recentBefore),
lte(videos.updatedAt, staleBefore),
or(
- isNull(videos.transcriptionStatus),
+ and(
+ isNull(videos.transcriptionStatus),
+ sql`JSON_EXTRACT(${videos.metadata}, '$.transcribeOnView') IS NULL`,
+ ),
eq(videos.transcriptionStatus, "PROCESSING"),
),
),
diff --git a/packages/database/types/metadata.ts b/packages/database/types/metadata.ts
index 882832b5e..c0794bb9f 100644
--- a/packages/database/types/metadata.ts
+++ b/packages/database/types/metadata.ts
@@ -23,6 +23,12 @@ export interface VideoMetadata {
source?: { key: string; uploadId: string };
output: { key: string; uploadId: string };
};
+ loomDeferredProcessing?: {
+ rawFileKey: string;
+ status: "pending" | "started";
+ startedAt?: string;
+ };
+ transcribeOnView?: boolean;
editProcessing?: {
token: string;
startedAt: string;