@epic-web/workshop-utils 6.56.0 → 6.58.0

package/dist/offline-videos.server.d.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'node:events';
 import { Readable } from 'node:stream';
 type OfflineVideoEntryStatus = 'ready' | 'downloading' | 'error';
 export type OfflineVideoDownloadState = {
@@ -58,6 +59,18 @@ export type OfflineVideoAsset = {
         end: number;
     }) => Readable;
 };
+export type VideoDownloadProgress = {
+    playbackId: string;
+    bytesDownloaded: number;
+    totalBytes: number | null;
+    status: 'downloading' | 'complete' | 'error';
+};
+export declare const DOWNLOAD_PROGRESS_EVENTS: {
+    readonly PROGRESS: "progress";
+};
+declare class DownloadProgressEmitter extends EventEmitter {
+}
+export declare const downloadProgressEmitter: DownloadProgressEmitter;
 export declare function getOfflineVideoDownloadState(): OfflineVideoDownloadState;
 export declare function getOfflineVideoSummary({ request, }?: {
     request?: Request;
@@ -72,10 +85,13 @@ export declare function downloadOfflineVideo({ playbackId, title, url, }: {
     url: string;
 }): Promise<{
     readonly status: "error";
+    readonly message: string;
 } | {
     readonly status: "ready";
+    readonly message?: undefined;
 } | {
     readonly status: "downloaded";
+    readonly message?: undefined;
 }>;
 export declare function deleteOfflineVideo(playbackId: string, options?: {
     workshopId?: string;

package/dist/offline-videos.server.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
 import { createReadStream, createWriteStream, promises as fs } from 'node:fs';
 import path from 'node:path';
 import { Readable, Transform } from 'node:stream';
@@ -25,6 +26,15 @@ const log = logger('epic:offline-videos');
 const offlineVideoDirectoryName = 'offline-videos';
 const offlineVideoIndexFileName = 'index.json';
 const offlineVideoConfigFileName = 'offline-video-config.json';
+export const DOWNLOAD_PROGRESS_EVENTS = {
+    PROGRESS: 'progress',
+};
+class DownloadProgressEmitter extends EventEmitter {
+}
+export const downloadProgressEmitter = new DownloadProgressEmitter();
+function emitDownloadProgress(progress) {
+    downloadProgressEmitter.emit(DOWNLOAD_PROGRESS_EVENTS.PROGRESS, progress);
+}
 let downloadState = {
     status: 'idle',
     startedAt: null,
@@ -213,6 +223,16 @@ function createSliceTransform({ skipBytes, takeBytes, }) {
         },
     });
 }
+function createProgressTrackingTransform({ onProgress, }) {
+    let totalBytes = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            totalBytes += chunk.length;
+            onProgress(totalBytes);
+            callback(null, chunk);
+        },
+    });
+}
 function createOfflineVideoReadStream({ filePath, size, key, iv, range, }) {
     if (!range) {
         const decipher = createOfflineVideoDecipher({ key, iv });
@@ -331,27 +351,83 @@ async function isOfflineVideoReady(index, playbackId, keyId, cryptoVersion, work
 async function downloadMuxVideo({ playbackId, filePath, key, iv, resolution, }) {
     const urls = getMuxMp4Urls(playbackId, resolution);
     let lastError = null;
+    emitDownloadProgress({
+        playbackId,
+        bytesDownloaded: 0,
+        totalBytes: null,
+        status: 'downloading',
+    });
     for (const url of urls) {
+        log.info('Attempting mux download', { playbackId, url });
         const response = await fetch(url).catch((error) => {
             lastError = error;
+            log.warn('Mux download request failed', {
+                playbackId,
+                url,
+                message: lastError.message,
+            });
             return null;
         });
         if (!response)
             continue;
         if (!response.ok || !response.body) {
             lastError = new Error(`Failed to download ${playbackId} from ${url} (${response.status})`);
+            log.warn('Mux download response not ok', {
+                playbackId,
+                url,
+                status: response.status,
+                hasBody: Boolean(response.body),
+            });
             continue;
         }
+        // Get content-length if available for progress tracking
+        const contentLengthHeader = response.headers.get('content-length');
+        const totalBytes = contentLengthHeader
+            ? parseInt(contentLengthHeader, 10)
+            : null;
+        emitDownloadProgress({
+            playbackId,
+            bytesDownloaded: 0,
+            totalBytes,
+            status: 'downloading',
+        });
         await ensureOfflineVideoDir();
         const tmpPath = `${filePath}.tmp-${randomUUID()}`;
         const stream = createWriteStream(tmpPath, { mode: 0o600 });
         const cipher = createOfflineVideoCipher({ key, iv });
+        const progressTracker = createProgressTrackingTransform({
+            onProgress: (bytesDownloaded) => {
+                emitDownloadProgress({
+                    playbackId,
+                    bytesDownloaded,
+                    totalBytes,
+                    status: 'downloading',
+                });
+            },
+        });
         const webStream = response.body;
-        await pipeline(Readable.from(webStream), cipher, stream);
+        await pipeline(Readable.from(webStream), progressTracker, cipher, stream);
         await fs.rename(tmpPath, filePath);
         const stat = await fs.stat(filePath);
+        emitDownloadProgress({
+            playbackId,
+            bytesDownloaded: stat.size,
+            totalBytes: stat.size,
+            status: 'complete',
+        });
+        log.info('Mux download complete', {
+            playbackId,
+            url,
+            size: stat.size,
+        });
         return { size: stat.size };
     }
+    emitDownloadProgress({
+        playbackId,
+        bytesDownloaded: 0,
+        totalBytes: null,
+        status: 'error',
+    });
     throw lastError ?? new Error(`Unable to download video ${playbackId}`);
 }
 async function runOfflineVideoDownloads({ videos, index, keyInfo, workshop, resolution, }) {
@@ -362,6 +438,10 @@ async function runOfflineVideoDownloads({ videos, index, keyInfo, workshop, reso
             title: video.title,
         };
         downloadState.updatedAt = updatedAt;
+        log.info('Downloading offline video', {
+            playbackId: video.playbackId,
+            title: video.title,
+        });
         const iv = createOfflineVideoIv();
         const entry = {
             playbackId: video.playbackId,
@@ -492,6 +572,10 @@ export async function startOfflineVideoDownload({ request, } = {}) {
         allowUserIdUpdate: true,
     });
     if (!keyInfo) {
+        log.warn('Offline video download unavailable: missing key info', {
+            available: videos.length,
+            unavailable,
+        });
         return {
             state: downloadState,
             available: videos.length,
@@ -531,6 +615,11 @@ export async function startOfflineVideoDownload({ request, } = {}) {
         current: null,
         errors: [],
     };
+    log.info('Offline video downloads queued', {
+        queued: downloads.length,
+        skipped: alreadyDownloaded,
+        unavailable,
+    });
     if (downloads.length > 0) {
         const resolution = await getOfflineVideoDownloadResolution();
         void runOfflineVideoDownloads({
@@ -554,6 +643,7 @@ export async function startOfflineVideoDownload({ request, } = {}) {
     };
 }
 export async function downloadOfflineVideo({ playbackId, title, url, }) {
+    log.info('Offline video download requested', { playbackId, title, url });
     const workshop = getWorkshopIdentity();
     const index = await readOfflineVideoIndex();
     const authInfo = await getAuthInfo();
@@ -561,8 +651,16 @@ export async function downloadOfflineVideo({ playbackId, title, url, }) {
         userId: authInfo?.id ?? null,
         allowUserIdUpdate: true,
     });
-    if (!keyInfo)
-        return { status: 'error' };
+    if (!keyInfo) {
+        log.warn('Offline video download failed: missing key info', {
+            playbackId,
+        });
+        const message = `Unable to download "${title}". Try again later.`;
+        return {
+            status: 'error',
+            message,
+        };
+    }
     const resolution = await getOfflineVideoDownloadResolution();
     const existing = index[playbackId];
     if (existing?.status === 'ready' &&
@@ -606,18 +704,21 @@ export async function downloadOfflineVideo({ playbackId, title, url, }) {
             updatedAt: new Date().toISOString(),
         };
         await writeOfflineVideoIndex(index);
+        log.info('Offline video download complete', { playbackId, size });
         return { status: 'downloaded' };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Download failed';
+        const detailedMessage = error instanceof Error ? error.message : 'Download failed';
+        const message = `Failed to download "${title}". Please try again.`;
+        log.error(`Offline video download failed for ${playbackId}`, error);
         index[playbackId] = {
             ...entry,
             status: 'error',
-            error: message,
+            error: detailedMessage,
             updatedAt: new Date().toISOString(),
         };
         await writeOfflineVideoIndex(index);
-        return { status: 'error' };
+        return { status: 'error', message };
     }
 }
 export async function deleteOfflineVideo(playbackId, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.56.0",
+  "version": "6.58.0",
   "publishConfig": {
     "access": "public"
   },