@hed-hog/lms 0.0.353 → 0.0.355

package/dist/course/course-video-conversion.service.js

@@ -26,9 +26,64 @@ const util_1 = require("util");
 exports.LMS_VIDEO_CONVERSION_JOB = 'lms.video.convert';
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 let CourseVideoConversionService = CourseVideoConversionService_1 = class CourseVideoConversionService {
-    constructor(prisma, fileService, registry, queueJob) {
+    async createProgressEvent(queueJobId, message, metadata, notificationContext) {
+        try {
+            await this.prisma.queue_job_event.create({
+                data: Object.assign({ queue_job_id: queueJobId, event_type: 'started', message }, (metadata ? { metadata } : {})),
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Queue job ${queueJobId}: failed to persist progress event "${message}": ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+        if (notificationContext) {
+            const progress = this.resolveNotificationProgress(metadata);
+            await this.updateAsyncNotification(notificationContext, progress, message);
+        }
+    }
+    resolveNotificationProgress(metadata) {
+        var _a, _b, _c;
+        const phase = String((_a = metadata === null || metadata === void 0 ? void 0 : metadata.phase) !== null && _a !== void 0 ? _a : '');
+        if (phase === 'download_original')
+            return 5;
+        if (phase === 'probe_duration')
+            return 10;
+        if (phase === 'convert_profile') {
+            const profileIndex = Number((_b = metadata === null || metadata === void 0 ? void 0 : metadata.profileIndex) !== null && _b !== void 0 ? _b : 0);
+            const profileCount = Number((_c = metadata === null || metadata === void 0 ? void 0 : metadata.profileCount) !== null && _c !== void 0 ? _c : 0);
+            if (profileIndex > 0 && profileCount > 0) {
+                const ratio = Math.min(1, Math.max(0, profileIndex / profileCount));
+                return 10 + Math.round(ratio * 45);
+            }
+            return 40;
+        }
+        if (phase === 'extract_frames')
+            return 65;
+        if (phase === 'extract_frames_done')
+            return 72;
+        if (phase === 'extract_audio')
+            return 80;
+        if (phase === 'queue_transcription')
+            return 88;
+        if (phase === 'queue_transcription_done')
+            return 90;
+        if (phase === 'queue_transcription_skipped')
+            return 100;
+        return 15;
+    }
+    async updateAsyncNotification(context, progress, body, success) {
+        try {
+            await this.notificationService.updateProgress(context.userId, context.notificationId, Object.assign({ progress,
+                body }, (success != null ? { success } : {})));
+        }
+        catch (error) {
+            this.logger.warn(`Failed to update async notification ${context.notificationId} for user ${context.userId}: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    constructor(prisma, fileService, settingService, notificationService, registry, queueJob) {
         this.prisma = prisma;
         this.fileService = fileService;
+        this.settingService = settingService;
+        this.notificationService = notificationService;
         this.registry = registry;
         this.queueJob = queueJob;
         this.logger = new common_1.Logger(CourseVideoConversionService_1.name);
@@ -39,6 +94,11 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
     }
     async enqueueConversion(params) {
         var _a, _b, _c;
+        const settings = await this.settingService.getSettingValues('lms-video-conversion-enabled');
+        const isVideoConversionEnabled = settings['lms-video-conversion-enabled'] !== false;
+        if (!isVideoConversionEnabled) {
+            throw new common_1.BadRequestException('Video conversion queue is disabled by settings');
+        }
         const lesson = await this.prisma.course_lesson.findFirst({
             where: {
                 id: params.lessonId,
@@ -80,6 +140,22 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
             public: false,
             overwrite: true,
         });
+        const asyncNotification = await this.notificationService.create({
+            user_id: params.userId,
+            title: 'Conversão e transcrição de vídeo em andamento',
+            body: 'Preparando pipeline de processamento do vídeo...',
+            type: 'progress',
+            progress: 1,
+            started_at: new Date().toISOString(),
+            auto_remove: false,
+            action_type: 'url',
+            action_url: '/queue/jobs',
+            action_data: {
+                source: 'lms-video-conversion',
+                courseId: params.courseId,
+                lessonId: params.lessonId,
+            },
+        });
         const job = await this.queueJob.enqueue({
             type: exports.LMS_VIDEO_CONVERSION_JOB,
             queueName: exports.LMS_VIDEO_CONVERSION_JOB,
@@ -90,6 +166,8 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
                 originalFileId: params.originalFileId,
                 profiles,
                 overwrite: true,
+                notificationId: asyncNotification.id,
+                notificationUserId: params.userId,
             },
             sourceModule: 'lms',
             sourceEntity: 'course_lesson',
@@ -105,8 +183,18 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
         return { queueJobId: job.id, status: 'queued' };
     }
     async handle(job) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f;
         const { courseId, sessionId, lessonId, originalFileId, profiles, overwrite } = job.payload;
+        const notificationContext = Number.isInteger(Number((_a = job.payload) === null || _a === void 0 ? void 0 : _a.notificationId)) &&
+            Number.isInteger(Number((_b = job.payload) === null || _b === void 0 ? void 0 : _b.notificationUserId))
+            ? {
+                notificationId: Number(job.payload.notificationId),
+                userId: Number(job.payload.notificationUserId),
+            }
+            : undefined;
+        const emitProgress = async (message, metadata) => {
+            await this.createProgressEvent(job.id, message, metadata, notificationContext);
+        };
         if (!courseId || !sessionId || !lessonId || !originalFileId || !(profiles === null || profiles === void 0 ? void 0 : profiles.length)) {
             throw new Error('Invalid LMS video conversion payload');
         }
@@ -117,19 +205,60 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
             throw new Error('Course has no active profiles to process');
         }
         const maxInputBytes = this.getPositiveIntegerEnv('LMS_VIDEO_MAX_INPUT_BYTES');
-        const ffmpegTimeoutMs = (_a = this.getPositiveIntegerEnv('LMS_VIDEO_FFMPEG_TIMEOUT_MS')) !== null && _a !== void 0 ? _a : 1000 * 60 * 60;
+        const ffmpegTimeoutMs = (_c = this.getPositiveIntegerEnv('LMS_VIDEO_FFMPEG_TIMEOUT_MS')) !== null && _c !== void 0 ? _c : 1000 * 60 * 60;
+        const intervalSettings = await this.settingService.getSettingValues([
+            'lms-video-frame-capture-interval-seconds',
+            'lms-image-extraction-enabled',
+            'lms-audio-transcription-enabled',
+        ]);
+        const frameIntervalSeconds = this.resolveFrameIntervalSeconds(intervalSettings['lms-video-frame-capture-interval-seconds']);
+        const imageExtractionEnabled = intervalSettings['lms-image-extraction-enabled'] !== false;
+        const transcriptionEnabled = intervalSettings['lms-audio-transcription-enabled'] !== false;
         const workDir = await fs_1.promises.mkdtemp((0, path_1.join)((0, os_1.tmpdir)(), `lms-video-${job.id}-`));
         const inputPath = (0, path_1.join)(workDir, `original-${originalFileId}.mp4`);
         this.logger.log(`Queue job ${job.id}: starting LMS video conversion (lesson=${lessonId}, profiles=${profilesToProcess.length})`);
+        await emitProgress('Baixando vídeo original...', {
+            phase: 'download_original',
+            lessonId,
+        });
+        this.logger.debug(`Queue job ${job.id}: payload resolved (course=${courseId}, session=${sessionId}, lesson=${lessonId}, originalFileId=${originalFileId}, overwrite=${overwrite !== false}, ffmpegTimeoutMs=${ffmpegTimeoutMs}, frameIntervalSeconds=${frameIntervalSeconds}, profiles=[${profilesToProcess.map((profile) => profile.id).join(', ')}])`);
         const downloadedOriginal = await this.fileService.downloadToPath(originalFileId, inputPath, maxInputBytes ? { maxBytes: maxInputBytes } : undefined);
         this.logger.log(`Queue job ${job.id}: original file downloaded (lesson=${lessonId}, size=${downloadedOriginal.size})`);
+        await emitProgress('Vídeo original baixado. Lendo duração...', {
+            phase: 'probe_duration',
+            lessonId,
+        });
+        let probedDuration = null;
+        try {
+            probedDuration = await this.probeDurationSeconds(inputPath, ffmpegTimeoutMs);
+            if (probedDuration !== null && probedDuration > 0) {
+                await this.prisma.course_lesson.update({
+                    where: { id: lessonId },
+                    data: { duration_seconds: probedDuration },
+                });
+                this.logger.log(`Queue job ${job.id}: probed video duration=${probedDuration}s, updated lesson ${lessonId}`);
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Queue job ${job.id}: failed to probe duration for lesson ${lessonId}: ${(_d = err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : err}`);
+        }
         const jobStartedAt = Date.now();
         const results = [];
+        let frameResults = [];
         try {
             for (const profile of profilesToProcess) {
                 const profileStartedAt = Date.now();
                 const outputPath = (0, path_1.join)(workDir, `${this.slugify(profile.name || String(profile.id))}-${profile.id}.mp4`);
                 this.logger.log(`Queue job ${job.id}: converting profile ${profile.id} for lesson ${lessonId}`);
+                await emitProgress(`Convertendo vídeo para o perfil ${profile.name || profile.id}...`, {
+                    phase: 'convert_profile',
+                    lessonId,
+                    profileId: profile.id,
+                    profileName: profile.name,
+                    profileIndex: results.length + 1,
+                    profileCount: profilesToProcess.length,
+                });
+                this.logger.debug(`Queue job ${job.id}: profile ${profile.id} ffmpeg params="${profile.ffmpeg_params}" outputPath=${outputPath}`);
                 const conversionStartedAt = Date.now();
                 await this.convert(inputPath, outputPath, profile.ffmpeg_params, ffmpegTimeoutMs);
                 const conversionMs = Date.now() - conversionStartedAt;
@@ -147,7 +276,7 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
                     lessonId,
                     type: this.profileResourceType(profile.id),
                     fileId: uploaded.id,
-                    title: (_b = uploaded.filename) !== null && _b !== void 0 ? _b : (0, path_1.basename)(outputPath),
+                    title: (_e = uploaded.filename) !== null && _e !== void 0 ? _e : (0, path_1.basename)(outputPath),
                     public: false,
                     overwrite: overwrite !== false,
                 });
@@ -163,6 +292,190 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
                 });
                 this.logger.log(`Queue job ${job.id}: profile ${profile.id} done for lesson ${lessonId} (fileId=${uploaded.id}, outputBytes=${outputStats.size}, conversionMs=${conversionMs}, conversionMBps=${conversionMBps.toFixed(2)}, uploadMs=${uploadMs}, uploadMBps=${uploadMBps.toFixed(2)}, totalMs=${totalMs})`);
             }
+            if (imageExtractionEnabled) {
+                await emitProgress('Extraindo imagens do vídeo...', {
+                    phase: 'extract_frames',
+                    lessonId,
+                });
+                this.logger.debug(`Queue job ${job.id}: starting frame extraction for lesson ${lessonId}`);
+                frameResults = await this.extractAndUploadLessonFrames({
+                    jobId: job.id,
+                    lessonId,
+                    inputPath,
+                    workDir,
+                    intervalSeconds: frameIntervalSeconds,
+                    timeoutMs: ffmpegTimeoutMs,
+                });
+                this.logger.debug(`Queue job ${job.id}: frame extraction finished for lesson ${lessonId} (frames=${frameResults.length})`);
+                await emitProgress(frameResults.length > 0
+                    ? `Imagens extraídas com sucesso (${frameResults.length}).`
+                    : 'Nenhuma imagem foi extraída do vídeo.', {
+                    phase: 'extract_frames_done',
+                    lessonId,
+                    frames: frameResults.length,
+                });
+            }
+            else {
+                this.logger.debug(`Queue job ${job.id}: skipping frame extraction for lesson ${lessonId} (lms-image-extraction-enabled=false)`);
+            }
+            if (transcriptionEnabled) {
+                await emitProgress('Extraindo áudio do vídeo...', {
+                    phase: 'extract_audio',
+                    lessonId,
+                });
+                this.logger.debug(`Queue job ${job.id}: starting audio extraction for lesson ${lessonId}`);
+                const audioFileId = await this.extractAndUploadLessonAudio({
+                    courseId,
+                    lessonId,
+                    localInputPath: inputPath,
+                    tempDir: workDir,
+                });
+                this.logger.debug(`Queue job ${job.id}: audio extraction finished for lesson ${lessonId} (audioFileId=${audioFileId !== null && audioFileId !== void 0 ? audioFileId : 'null'})`);
+                if (audioFileId) {
+                    await emitProgress('Áudio extraído. Agendando transcrição...', {
+                        phase: 'queue_transcription',
+                        lessonId,
+                        audioFileId,
+                    });
+                    this.logger.debug(`Queue job ${job.id}: enqueueing transcription job for lesson ${lessonId} with audioFileId=${audioFileId}`);
+                    const transcriptionJob = await this.queueJob.enqueue({
+                        type: 'lms.audio.transcribe',
+                        queueName: 'lms.audio.transcribe',
+                        payload: {
+                            courseId,
+                            sessionId,
+                            lessonId,
+                            audioFileId,
+                            parentJobId: job.id,
+                            notificationId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.notificationId,
+                            notificationUserId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.userId,
+                        },
+                        maxAttempts: 3,
+                    });
+                    await emitProgress(`Transcrição em IA agendada no job #${transcriptionJob.id}.`, {
+                        phase: 'queue_transcription_done',
+                        lessonId,
+                        audioFileId,
+                        transcriptionJobId: transcriptionJob.id,
+                    });
+                    return {
+                        lessonId,
+                        probedDurationSeconds: probedDuration !== null && probedDuration !== void 0 ? probedDuration : null,
+                        converted: results.length,
+                        results,
+                        extractedFrames: frameResults.length,
+                        frames: frameResults,
+                        transcriptionJobId: transcriptionJob.id,
+                        metrics: {
+                            totalMs: Date.now() - jobStartedAt,
+                            totalOutputBytes: results.reduce((acc, item) => acc + item.outputBytes, 0),
+                            averageProfileMs: results.length > 0
+                                ? Math.round(results.reduce((acc, item) => acc + item.totalMs, 0) / results.length)
+                                : 0,
+                            averageConversionMBps: results.length > 0
+                                ? Number((results.reduce((acc, item) => acc + item.conversionMBps, 0) / results.length).toFixed(2))
+                                : 0,
+                            averageUploadMBps: results.length > 0
+                                ? Number((results.reduce((acc, item) => acc + item.uploadMBps, 0) / results.length).toFixed(2))
+                                : 0,
+                        },
+                    };
+                }
+                else {
+                    let transcriptionSkipReason = 'audio extraction returned no file id';
+                    try {
+                        const existingAudio = await this.prisma.course_lesson_file.findFirst({
+                            where: {
+                                course_lesson_id: lessonId,
+                                type: 'lesson_audio',
+                                file_id: { not: null },
+                            },
+                            orderBy: { id: 'desc' },
+                            select: { file_id: true },
+                        });
+                        const fallbackAudioFileId = Number((_f = existingAudio === null || existingAudio === void 0 ? void 0 : existingAudio.file_id) !== null && _f !== void 0 ? _f : 0);
+                        if (fallbackAudioFileId > 0) {
+                            transcriptionSkipReason =
+                                'audio extraction returned no file id, using existing lesson_audio fallback';
+                            this.logger.warn(`Queue job ${job.id}: audio extraction returned null for lesson ${lessonId}; enqueueing transcription with existing lesson_audio fileId=${fallbackAudioFileId}`);
+                            await emitProgress('Áudio reutilizado de execução anterior. Agendando transcrição...', {
+                                phase: 'queue_transcription',
+                                lessonId,
+                                audioFileId: fallbackAudioFileId,
+                                fallback: true,
+                            });
+                            const transcriptionJob = await this.queueJob.enqueue({
+                                type: 'lms.audio.transcribe',
+                                queueName: 'lms.audio.transcribe',
+                                payload: {
+                                    courseId,
+                                    sessionId,
+                                    lessonId,
+                                    audioFileId: fallbackAudioFileId,
+                                    parentJobId: job.id,
+                                    notificationId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.notificationId,
+                                    notificationUserId: notificationContext === null || notificationContext === void 0 ? void 0 : notificationContext.userId,
+                                },
+                                maxAttempts: 3,
+                            });
+                            await emitProgress(`Transcrição em IA agendada no job #${transcriptionJob.id}.`, {
+                                phase: 'queue_transcription_done',
+                                lessonId,
+                                audioFileId: fallbackAudioFileId,
+                                transcriptionJobId: transcriptionJob.id,
+                                fallback: true,
+                            });
+                            return {
+                                lessonId,
+                                probedDurationSeconds: probedDuration !== null && probedDuration !== void 0 ? probedDuration : null,
+                                converted: results.length,
+                                results,
+                                extractedFrames: frameResults.length,
+                                frames: frameResults,
+                                transcriptionJobId: transcriptionJob.id,
+                                metrics: {
+                                    totalMs: Date.now() - jobStartedAt,
+                                    totalOutputBytes: results.reduce((acc, item) => acc + item.outputBytes, 0),
+                                    averageProfileMs: results.length > 0
+                                        ? Math.round(results.reduce((acc, item) => acc + item.totalMs, 0) / results.length)
+                                        : 0,
+                                    averageConversionMBps: results.length > 0
+                                        ? Number((results.reduce((acc, item) => acc + item.conversionMBps, 0) / results.length).toFixed(2))
+                                        : 0,
+                                    averageUploadMBps: results.length > 0
+                                        ? Number((results.reduce((acc, item) => acc + item.uploadMBps, 0) / results.length).toFixed(2))
+                                        : 0,
+                                },
+                            };
+                        }
+                    }
+                    catch (fallbackError) {
+                        transcriptionSkipReason = `fallback lookup failed: ${fallbackError instanceof Error ? fallbackError.message : 'unknown error'}`;
+                        this.logger.warn(`Queue job ${job.id}: fallback lookup for lesson_audio failed on lesson ${lessonId}: ${fallbackError instanceof Error ? fallbackError.message : 'unknown error'}`);
+                    }
+                    this.logger.debug(`Queue job ${job.id}: skipping transcription enqueue for lesson ${lessonId} because no audio file was produced (${transcriptionSkipReason})`);
+                    await emitProgress('Áudio não disponível. Encerrando pipeline sem transcrição.', {
+                        phase: 'queue_transcription_skipped',
+                        lessonId,
+                        reason: transcriptionSkipReason,
+                    });
+                    if (notificationContext) {
+                        await this.updateAsyncNotification(notificationContext, 100, 'Pipeline concluído sem transcrição: áudio indisponível para processamento.', true);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Queue job ${job.id}: skipping audio extraction and transcription for lesson ${lessonId} (lms-audio-transcription-enabled=false)`);
+            }
+        }
+        catch (error) {
+            if (notificationContext) {
+                const message = error instanceof Error && error.message
+                    ? error.message
+                    : 'Falha ao processar conversão de vídeo.';
+                await this.updateAsyncNotification(notificationContext, 100, `Falha no pipeline de vídeo: ${message}`, false);
+            }
+            throw error;
         }
         finally {
             await fs_1.promises.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
@@ -171,10 +484,17 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
         const totalMs = Date.now() - jobStartedAt;
         const totalOutputBytes = results.reduce((acc, item) => acc + item.outputBytes, 0);
         this.logger.log(`Queue job ${job.id}: LMS conversion finished (lesson=${lessonId}, profiles=${results.length}, totalMs=${totalMs}, totalOutputBytes=${totalOutputBytes})`);
+        if (notificationContext) {
+            await this.updateAsyncNotification(notificationContext, 100, 'Conversão e transcrição concluídas com sucesso.', true);
+        }
         return {
             lessonId,
+            probedDurationSeconds: probedDuration !== null && probedDuration !== void 0 ? probedDuration : null,
             converted: results.length,
             results,
+            extractedFrames: frameResults.length,
+            frames: frameResults,
+            transcriptionJobId: null,
             metrics: {
                 totalMs,
                 totalOutputBytes,
@@ -190,6 +510,219 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
             },
         };
     }
+    async extractAndUploadLessonFrames(params) {
+        const intervalSeconds = Math.max(1, Math.floor(params.intervalSeconds));
+        const framesDir = (0, path_1.join)(params.workDir, 'frames');
+        await fs_1.promises.mkdir(framesDir, { recursive: true });
+        const pattern = (0, path_1.join)(framesDir, 'frame-%08d.jpg');
+        this.logger.log(`Queue job ${params.jobId}: extracting lesson frames every ${intervalSeconds}s (lesson=${params.lessonId})`);
+        this.logger.debug(`Queue job ${params.jobId}: frame extraction input=${params.inputPath} outputPattern=${pattern} timeoutMs=${params.timeoutMs}`);
+        await this.extractFramesFromVideo(params.inputPath, pattern, intervalSeconds, params.timeoutMs);
+        const frameFiles = (await fs_1.promises.readdir(framesDir))
+            .filter((name) => name.toLowerCase().endsWith('.jpg'))
+            .sort((a, b) => a.localeCompare(b));
+        this.logger.debug(`Queue job ${params.jobId}: frame extraction produced ${frameFiles.length} file(s) in ${framesDir}`);
+        if (frameFiles.length === 0) {
+            this.logger.warn(`Queue job ${params.jobId}: no frames extracted for lesson ${params.lessonId}`);
+            await this.prisma.course_lesson_video_frame.deleteMany({
+                where: { course_lesson_id: params.lessonId },
+            });
+            return [];
+        }
+        const uploads = [];
+        for (let index = 0; index < frameFiles.length; index += 1) {
+            const fileName = frameFiles[index];
+            if (!fileName)
+                continue;
+            const framePath = (0, path_1.join)(framesDir, fileName);
+            const stats = await fs_1.promises.stat(framePath);
+            const uploaded = await this.fileService.uploadFromPath('lms/lessons/frames', framePath, {
+                originalname: fileName,
+                mimetype: 'image/jpeg',
+            });
+            uploads.push({
+                fileId: uploaded.id,
+                timeSeconds: index * intervalSeconds,
+                outputBytes: stats.size,
+            });
+            this.logger.debug(`Queue job ${params.jobId}: uploaded frame ${fileName} -> fileId=${uploaded.id}, timeSeconds=${index * intervalSeconds}, outputBytes=${stats.size}`);
+        }
+        await this.prisma.course_lesson_video_frame.deleteMany({
+            where: { course_lesson_id: params.lessonId },
+        });
+        await this.prisma.course_lesson_video_frame.createMany({
+            data: uploads.map((item) => ({
+                course_lesson_id: params.lessonId,
+                file_id: item.fileId,
+                time_seconds: item.timeSeconds,
+            })),
+        });
+        this.logger.log(`Queue job ${params.jobId}: extracted and uploaded ${uploads.length} lesson frames (lesson=${params.lessonId})`);
+        return uploads;
+    }
+    async extractAndUploadLessonAudio(params) {
+        var _a, _b, _c;
+        const ffmpegCommand = this.getFfmpegCommand();
+        const mp3Path = (0, path_1.join)(params.tempDir, `lesson_${params.lessonId}_audio.mp3`);
+        const mp3LowBitratePath = (0, path_1.join)(params.tempDir, `lesson_${params.lessonId}_audio.low.mp3`);
+        let outputPath = mp3Path;
+        const mimetype = 'audio/mp3';
+        this.logger.debug(`Audio extraction: lesson=${params.lessonId}, input=${params.localInputPath}, preferredOutput=${mp3Path}`);
+        try {
+            await execFileAsync(ffmpegCommand, [
+                '-y',
+                '-i',
+                params.localInputPath,
+                '-vn',
+                '-ar',
+                '16000',
+                '-ac',
+                '1',
+                '-c:a',
+                'libmp3lame',
+                '-b:a',
+                '32k',
+                mp3Path,
+            ], {
+                maxBuffer: 1024 * 1024 * 20,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Audio extraction failed for lesson ${params.lessonId}: ${error instanceof Error ? error.message : 'unknown error'}`);
+            return null;
+        }
+        let uploadedAudioId = null;
+        try {
+            const course = await this.prisma.course.findUnique({
+                where: { id: params.courseId },
+                select: { locale_id: true },
+            });
+            let uploaded;
+            try {
+                uploaded = await this.fileService.uploadFromPath('lms/lessons/audio', outputPath, {
+                    originalname: (0, path_1.basename)(outputPath),
+                    mimetype,
+                });
+            }
+            catch (uploadError) {
+                // Retry with an even smaller bitrate when storage max size is too strict.
+                this.logger.warn(`Audio upload first attempt failed for lesson ${params.lessonId}, retrying with lower bitrate: ${uploadError instanceof Error ? uploadError.message : 'unknown error'}`);
+                outputPath = mp3LowBitratePath;
+                await execFileAsync(ffmpegCommand, [
+                    '-y',
+                    '-i',
+                    params.localInputPath,
+                    '-vn',
+                    '-ar',
+                    '16000',
+                    '-ac',
+                    '1',
+                    '-c:a',
+                    'libmp3lame',
+                    '-b:a',
+                    '16k',
+                    mp3LowBitratePath,
+                ], {
+                    maxBuffer: 1024 * 1024 * 20,
+                    windowsHide: true,
+                });
+                uploaded = await this.fileService.uploadFromPath('lms/lessons/audio', outputPath, {
+                    originalname: (0, path_1.basename)(outputPath),
+                    mimetype,
+                });
+            }
+            uploadedAudioId = uploaded.id;
+            this.logger.debug(`Audio extraction: lesson=${params.lessonId} uploaded audio fileId=${uploaded.id}, mimetype=${mimetype}, outputPath=${outputPath}`);
+            const existingAudio = await this.prisma.course_lesson_file.findFirst({
+                where: {
+                    course_lesson_id: params.lessonId,
+                    type: 'lesson_audio',
+                },
+                select: { id: true, locale_id: true },
+            });
+            const defaultLocale = await this.prisma.locale.findFirst({
+                where: {
+                    OR: [{ code: 'pt-BR' }, { code: 'pt' }],
+                },
+                select: { id: true },
+                orderBy: { id: 'asc' },
+            });
+            const resolvedLocaleId = (_c = (_b = (_a = existingAudio === null || existingAudio === void 0 ? void 0 : existingAudio.locale_id) !== null && _a !== void 0 ? _a : course === null || course === void 0 ? void 0 : course.locale_id) !== null && _b !== void 0 ? _b : defaultLocale === null || defaultLocale === void 0 ? void 0 : defaultLocale.id) !== null && _c !== void 0 ? _c : null;
+            const audioTitle = 'Audio Original.mp3';
+            if (existingAudio) {
+                await this.prisma.course_lesson_file.update({
+                    where: { id: existingAudio.id },
+                    data: {
+                        file_id: uploaded.id,
+                        locale_id: resolvedLocaleId,
+                        title: audioTitle,
+                        type: 'lesson_audio',
+                        is_public: false,
+                    },
+                });
+            }
+            else {
+                await this.prisma.course_lesson_file.create({
+                    data: {
+                        course_lesson_id: params.lessonId,
+                        file_id: uploaded.id,
+                        title: audioTitle,
+                        type: 'lesson_audio',
+                        is_public: false,
+                        locale_id: resolvedLocaleId,
+                    },
+                });
+            }
+            return uploaded.id;
+        }
+        catch (error) {
+            if (uploadedAudioId) {
+                this.logger.warn(`Audio metadata upsert failed for lesson ${params.lessonId}, but audio upload succeeded (fileId=${uploadedAudioId}): ${error instanceof Error ? error.message : 'unknown error'}`);
+                return uploadedAudioId;
+            }
+            this.logger.warn(`Audio upload failed for lesson ${params.lessonId}: ${error instanceof Error ? error.message : 'unknown error'}`);
+            return null;
+        }
+        finally {
+            this.logger.debug(`Audio extraction: lesson=${params.lessonId} cleaning temporary audio files (${mp3Path}, ${mp3LowBitratePath})`);
+            await fs_1.promises.rm(mp3Path, { force: true }).catch(() => undefined);
+            await fs_1.promises.rm(mp3LowBitratePath, { force: true }).catch(() => undefined);
+        }
+    }
+    async extractFramesFromVideo(inputPath, outputPattern, intervalSeconds, timeoutMs) {
+        const ffmpegCommand = this.getFfmpegCommand();
+        const args = [
+            '-y',
+            '-i',
+            inputPath,
+            '-vf',
+            `fps=1/${intervalSeconds}`,
+            '-q:v',
+            '3',
+            '-qmin',
+            '2',
+            '-qmax',
+            '4',
+            outputPattern,
+        ];
+        try {
+            await execFileAsync(ffmpegCommand, args, {
+                maxBuffer: 1024 * 1024 * 20,
+                timeout: timeoutMs,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT') {
+                throw new Error(`FFmpeg binary not found. Configure FFMPEG_PATH or ensure "${ffmpegCommand}" is available in PATH`);
+            }
+            if ((error === null || error === void 0 ? void 0 : error.killed) && (error === null || error === void 0 ? void 0 : error.signal) === 'SIGTERM') {
+                throw new Error(`FFmpeg frame extraction timed out after ${timeoutMs}ms`);
+            }
+            throw error;
+        }
+    }
     async getCourseProfiles(courseId) {
         const rows = await this.prisma.course_video_resolution_profile.findMany({
             where: { course_id: courseId },
@@ -206,11 +739,12 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
         }));
     }
     async upsertLessonFile(params) {
+        const normalizedType = this.normalizeLessonFileType(params.type);
         if (params.overwrite) {
             await this.prisma.course_lesson_file.deleteMany({
                 where: {
                     course_lesson_id: params.lessonId,
-                    tipo: params.type,
+                    type: normalizedType,
                 },
             });
         }
@@ -219,27 +753,197 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
                 course_lesson_id: params.lessonId,
                 file_id: params.fileId,
                 title: params.title,
-                tipo: params.type,
-                publico: params.public,
+                type: normalizedType,
+                is_public: params.public,
             },
         });
     }
+    normalizeLessonFileType(value) {
+        if (value === 'video_original') {
+            return 'video_original';
+        }
+        if (value === null || value === void 0 ? void 0 : value.startsWith('video_profile:')) {
+            return value;
+        }
+        if (value === 'lesson_audio') {
+            return 'lesson_audio';
+        }
+        if (value === 'student_download' || value === 'file' || value === 'download') {
+            return 'student_download';
+        }
+        return 'supplementary_material';
+    }
     async convert(inputPath, outputPath, params, timeoutMs) {
+        const ffmpegCommand = this.getFfmpegCommand();
         const args = ['-y', '-i', inputPath, ...this.splitFfmpegParams(params), outputPath];
         try {
-            await execFileAsync('ffmpeg', args, {
+            await execFileAsync(ffmpegCommand, args, {
                 maxBuffer: 1024 * 1024 * 20,
                 timeout: timeoutMs,
                 windowsHide: true,
             });
         }
         catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) === 'ENOENT') {
+                throw new Error(`FFmpeg binary not found. Configure FFMPEG_PATH or ensure "${ffmpegCommand}" is available in PATH`);
+            }
             if ((error === null || error === void 0 ? void 0 : error.killed) && (error === null || error === void 0 ? void 0 : error.signal) === 'SIGTERM') {
                 throw new Error(`FFmpeg timed out after ${timeoutMs}ms`);
             }
             throw error;
         }
     }
+    getFfmpegCommand() {
+        var _a;
+        const fromEnv = (_a = process.env.FFMPEG_PATH) === null || _a === void 0 ? void 0 : _a.trim();
+        if (fromEnv) {
+            return fromEnv;
+        }
+        if (process.platform === 'win32') {
+            const fromWinget = this.findWindowsWingetFfmpeg();
+            if (fromWinget) {
+                return fromWinget;
+            }
+        }
+        return 'ffmpeg';
+    }
+    getFfprobeCommand() {
+        var _a, _b;
+        const fromEnv = (_a = process.env.FFPROBE_PATH) === null || _a === void 0 ? void 0 : _a.trim();
+        if (fromEnv) {
+            return fromEnv;
+        }
+        const ffmpegEnv = (_b = process.env.FFMPEG_PATH) === null || _b === void 0 ? void 0 : _b.trim();
+        if (ffmpegEnv) {
+            const candidate = ffmpegEnv.replace(/ffmpeg(\.exe)?$/i, (_, ext) => `ffprobe${ext !== null && ext !== void 0 ? ext : ''}`);
+            if ((0, fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+        if (process.platform === 'win32') {
+            const fromWinget = this.findWindowsWingetFfprobe();
+            if (fromWinget) {
+                return fromWinget;
+            }
+        }
+        return 'ffprobe';
+    }
+    findWindowsWingetFfprobe() {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData) {
+            return null;
+        }
+        const wingetPackagesRoot = (0, path_1.join)(localAppData, 'Microsoft', 'WinGet', 'Packages');
+        try {
+            const packageDirs = (0, fs_1.readdirSync)(wingetPackagesRoot, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('Gyan.FFmpeg'))
+                .map((entry) => (0, path_1.join)(wingetPackagesRoot, entry.name))
+                .sort((a, b) => b.localeCompare(a));
+            for (const packageDir of packageDirs) {
+                const executable = this.findFfprobeExecutableInside(packageDir);
+                if (executable) {
+                    return executable;
+                }
+            }
+        }
+        catch (_a) {
+            return null;
+        }
+        return null;
+    }
+    findFfprobeExecutableInside(baseDir) {
+        const directCandidate = (0, path_1.join)(baseDir, 'bin', 'ffprobe.exe');
+        if ((0, fs_1.existsSync)(directCandidate)) {
+            return directCandidate;
+        }
+        try {
+            const versionDirs = (0, fs_1.readdirSync)(baseDir, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.toLowerCase().startsWith('ffmpeg-'))
+                .map((entry) => (0, path_1.join)(baseDir, entry.name))
+                .sort((a, b) => b.localeCompare(a));
+            for (const versionDir of versionDirs) {
+                const candidate = (0, path_1.join)(versionDir, 'bin', 'ffprobe.exe');
+                if ((0, fs_1.existsSync)(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch (_a) {
+            return null;
+        }
+        return null;
+    }
+    async probeDurationSeconds(inputPath, timeoutMs) {
+        var _a;
+        const ffprobeCommand = this.getFfprobeCommand();
+        const args = [
+            '-v', 'error',
+            '-show_entries', 'format=duration',
+            '-of', 'default=noprint_wrappers=1:nokey=1',
+            inputPath,
+        ];
+        try {
+            const { stdout } = await execFileAsync(ffprobeCommand, args, {
+                maxBuffer: 1024 * 1024,
+                timeout: Math.min(timeoutMs, 30000),
+                windowsHide: true,
+            });
+            const parsed = parseFloat(stdout.trim());
+            if (!Number.isFinite(parsed) || parsed <= 0) {
+                return null;
+            }
+            return Math.round(parsed);
+        }
+        catch (error) {
+            this.logger.warn(`FFprobe duration extraction failed: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+            return null;
+        }
+    }
+    findWindowsWingetFfmpeg() {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData) {
+            return null;
+        }
+        const wingetPackagesRoot = (0, path_1.join)(localAppData, 'Microsoft', 'WinGet', 'Packages');
+        try {
+            const packageDirs = (0, fs_1.readdirSync)(wingetPackagesRoot, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('Gyan.FFmpeg'))
+                .map((entry) => (0, path_1.join)(wingetPackagesRoot, entry.name))
+                .sort((a, b) => b.localeCompare(a));
+            for (const packageDir of packageDirs) {
+                const executable = this.findFfmpegExecutableInside(packageDir);
+                if (executable) {
+                    return executable;
+                }
+            }
+        }
+        catch (_a) {
+            return null;
+        }
+        return null;
+    }
+    findFfmpegExecutableInside(baseDir) {
+        const directCandidate = (0, path_1.join)(baseDir, 'bin', 'ffmpeg.exe');
+        if ((0, fs_1.existsSync)(directCandidate)) {
+            return directCandidate;
+        }
+        try {
+            const versionDirs = (0, fs_1.readdirSync)(baseDir, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.toLowerCase().startsWith('ffmpeg-'))
+                .map((entry) => (0, path_1.join)(baseDir, entry.name))
+                .sort((a, b) => b.localeCompare(a));
+            for (const versionDir of versionDirs) {
+                const candidate = (0, path_1.join)(versionDir, 'bin', 'ffmpeg.exe');
+                if ((0, fs_1.existsSync)(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch (_a) {
+            return null;
+        }
+        return null;
+    }
     getPositiveIntegerEnv(name) {
         const raw = process.env[name];
         if (!raw) {
@@ -251,6 +955,18 @@ let CourseVideoConversionService = CourseVideoConversionService_1 = class Course
         }
         return Math.floor(value);
     }
+    resolveFrameIntervalSeconds(value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return Math.max(1, Math.floor(value));
+        }
+        if (typeof value === 'string') {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                return Math.max(1, Math.floor(parsed));
+            }
+        }
+        return 10;
+    }
     calculateMBps(bytes, durationMs) {
         if (!Number.isFinite(bytes) || bytes <= 0) {
             return 0;
@@ -298,10 +1014,14 @@ exports.CourseVideoConversionService = CourseVideoConversionService = CourseVide
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => api_prisma_1.PrismaService))),
     __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.FileService))),
-    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueHandlerRegistry))),
-    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueJobService))),
+    __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.SettingService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.NotificationService))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueHandlerRegistry))),
+    __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => queue_1.QueueJobService))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
         core_1.FileService,
+        core_1.SettingService,
+        core_1.NotificationService,
         queue_1.QueueHandlerRegistry,
         queue_1.QueueJobService])
 ], CourseVideoConversionService);