@apocaliss92/scrypted-reolink-native 0.1.33 → 0.1.36

package/src/utils.ts

@@ -1,10 +1,32 @@
-import type { DeviceCapabilities, EnrichedRecordingFile, RecordingFile, ReolinkBaichuanApi, ReolinkDeviceInfo } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { DeviceCapabilities, EnrichedRecordingFile, ParsedRecordingFileName, RecordingFile, ReolinkBaichuanApi, ReolinkDeviceInfo, VodFile, VodSearchResponse } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { DeviceBase, HttpRequest, HttpResponse, MediaObject, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, VideoClip, VideoClips } from "@scrypted/sdk";
 import { spawn } from "node:child_process";
+import { Readable } from "stream";
+import http from "http";
+import https from "https";
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
 import { CommonCameraMixin } from "./common";
+/**
+ * Sanitize FFmpeg output or URLs to avoid leaking credentials
+ */
+export function sanitizeFfmpegOutput(text: string): string {
+    if (!text)
+        return text;
+
+    let sanitized = text;
+
+    // Remove user/password query parameters from URLs: ?user=xxx&password=yyy
+    sanitized = sanitized.replace(/(\buser=)[^&\s]*/gi, '$1***');
+    sanitized = sanitized.replace(/(\bpassword=)[^&\s]*/gi, '$1***');
+
+    // Remove credentials from URLs like rtmp://user:pass@host/...
+    sanitized = sanitized.replace(/(rtmp:\/\/)([^:@\/\s]+):([^@\/\s]+)@/gi, '$1$2:***@');
+
+    return sanitized;
+}
+
 
 /**
  * Enumeration of operation types that may require specific channel assignments
@@ -173,58 +195,92 @@ export async function recordingFileToVideoClip(
     let videoHref: string | undefined = providedVideoHref;
     let thumbnailHref: string | undefined;
 
+    logger?.debug(`[recordingFileToVideoClip] URL generation: useWebhook=${useWebhook}, hasPlugin=${!!plugin}, deviceId=${deviceId}, providedVideoHref=${providedVideoHref || 'none'}, hasApi=${!!api}`);
+
     // If webhook is enabled, generate webhook URLs
     if (useWebhook && plugin && deviceId) {
+        logger?.debug(`[recordingFileToVideoClip] Generating webhook URLs for fileId=${id}`);
         try {
             const { videoUrl, thumbnailUrl } = await getVideoClipWebhookUrls({
                 deviceId,
                 fileId: id,
                 plugin,
+                logger,
             });
             videoHref = videoUrl;
             thumbnailHref = thumbnailUrl;
+            logger?.debug(`[recordingFileToVideoClip] Webhook URLs generated successfully: videoHref="${videoHref}", thumbnailHref="${thumbnailHref}"`);
         } catch (e) {
-            logger?.error('recordingFileToVideoClip: failed to generate webhook URLs', e);
+            logger?.error(`[recordingFileToVideoClip] Failed to generate webhook URLs for fileId=${id}:`, e);
         }
     } else if (!videoHref && api) {
         // Fallback to direct RTMP URL if webhook is not used
+        logger?.debug(`[recordingFileToVideoClip] Fetching RTMP playback URL for fileName=${rec.fileName}`);
         try {
             const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
                 fileName: rec.fileName,
             });
             videoHref = rtmpVodUrl;
+            logger?.debug(`[recordingFileToVideoClip] RTMP URL fetched successfully: videoHref="${videoHref}"`);
         } catch (e) {
-            logger?.debug('recordingFileToVideoClip: failed to build playback URL for recording', rec.fileName, e);
+            logger?.debug(`[recordingFileToVideoClip] Failed to build playback URL for recording fileName=${rec.fileName}:`, e);
         }
+    } else {
+        logger?.debug(`[recordingFileToVideoClip] No URL generation: useWebhook=${useWebhook}, hasPlugin=${!!plugin}, deviceId=${deviceId}, providedVideoHref=${providedVideoHref || 'none'}, hasApi=${!!api}`);
     }
 
     const description = ('name' in rec && typeof rec.name === 'string' && rec.name) ? rec.name : (rec.fileName ?? rec.id ?? '');
 
     // Build detectionClasses from flags or recordType
-    const detectionClasses: string[] = ['Motion'];
+    const detectionClasses: string[] = [];
 
-    // Check for EnrichedRecordingFile flags
+    // Check for EnrichedRecordingFile flags first (most accurate)
+    let hasAnyDetection = false;
     if ('hasPerson' in rec && rec.hasPerson) {
         detectionClasses.push('Person');
+        hasAnyDetection = true;
     }
     if ('hasVehicle' in rec && rec.hasVehicle) {
         detectionClasses.push('Vehicle');
+        hasAnyDetection = true;
     }
     if ('hasAnimal' in rec && rec.hasAnimal) {
         detectionClasses.push('Animal');
+        hasAnyDetection = true;
     }
     if ('hasFace' in rec && rec.hasFace) {
         detectionClasses.push('Face');
+        hasAnyDetection = true;
+    }
+    if ('hasMotion' in rec && rec.hasMotion) {
+        detectionClasses.push('Motion');
+        hasAnyDetection = true;
     }
     if ('hasDoorbell' in rec && rec.hasDoorbell) {
         detectionClasses.push('Doorbell');
+        hasAnyDetection = true;
     }
     if ('hasPackage' in rec && rec.hasPackage) {
         detectionClasses.push('Package');
+        hasAnyDetection = true;
+    }
+
+    // Log detection flags for debugging
+    if (logger) {
+        const flags = {
+            hasPerson: 'hasPerson' in rec ? rec.hasPerson : undefined,
+            hasVehicle: 'hasVehicle' in rec ? rec.hasVehicle : undefined,
+            hasAnimal: 'hasAnimal' in rec ? rec.hasAnimal : undefined,
+            hasFace: 'hasFace' in rec ? rec.hasFace : undefined,
+            hasMotion: 'hasMotion' in rec ? rec.hasMotion : undefined,
+            hasDoorbell: 'hasDoorbell' in rec ? rec.hasDoorbell : undefined,
+            hasPackage: 'hasPackage' in rec ? rec.hasPackage : undefined,
+            recordType: rec.recordType || 'none',
+        };
     }
 
     // Fallback: parse recordType string if flags are not available
-    if (detectionClasses.length === 0 && rec.recordType) {
+    if (!hasAnyDetection && rec.recordType) {
         const recordTypeLower = rec.recordType.toLowerCase();
         if (recordTypeLower.includes('people') || recordTypeLower.includes('person')) {
             detectionClasses.push('Person');
@@ -249,6 +305,19 @@ export async function recordingFileToVideoClip(
         }
     }
 
+    // Always include Motion if no other detections found
+    if (detectionClasses.length === 0) {
+        detectionClasses.push('Motion');
+    }
+
+    const resources = videoHref || thumbnailHref
+        ? {
+            ...(videoHref ? { video: { href: videoHref } } : {}),
+            ...(thumbnailHref ? { thumbnail: { href: thumbnailHref } } : {}),
+        }
+        : undefined;
+
+
     return {
         id,
         startTime: recStartMs,
@@ -256,12 +325,7 @@ export async function recordingFileToVideoClip(
         event: rec.recordType,
         description,
         detectionClasses: detectionClasses.length > 0 ? detectionClasses : undefined,
-        resources: videoHref || thumbnailHref
-            ? {
-                ...(videoHref ? { video: { href: videoHref } } : {}),
-                ...(thumbnailHref ? { thumbnail: { href: thumbnailHref } } : {}),
-            }
-            : undefined,
+        resources,
     };
 }
 
@@ -272,17 +336,26 @@ export async function getVideoClipWebhookUrls(props: {
     deviceId: string;
     fileId: string;
     plugin: ScryptedDeviceBase;
+    logger?: Console;
 }): Promise<{ videoUrl: string; thumbnailUrl: string }> {
-    const { deviceId, fileId, plugin } = props;
+    const { deviceId, fileId, plugin, logger } = props;
+    const log = logger || plugin.console;
+
+    // log.debug?.(`[getVideoClipWebhookUrls] Starting URL generation: deviceId=${deviceId}, fileId=${fileId}`);
 
     try {
         let endpoint: string;
+        let endpointSource: 'cloud' | 'local';
         try {
             endpoint = await sdk.endpointManager.getCloudEndpoint(undefined, { public: true });
+            endpointSource = 'cloud';
+            // log.debug?.(`[getVideoClipWebhookUrls] Using cloud endpoint: ${endpoint}`);
         } catch (e) {
             // Fallback to local endpoint if cloud is not available (e.g., not logged in)
-            // plugin.console.debug('Cloud endpoint not available, using local endpoint', e);
+            log.debug?.(`[getVideoClipWebhookUrls] Cloud endpoint not available, using local endpoint: ${e instanceof Error ? e.message : String(e)}`);
             endpoint = await sdk.endpointManager.getLocalEndpoint(undefined, { public: true });
+            endpointSource = 'local';
+            // log.debug?.(`[getVideoClipWebhookUrls] Using local endpoint: ${endpoint}`);
         }
 
         const encodedDeviceId = encodeURIComponent(deviceId);
@@ -296,7 +369,7 @@ export async function getVideoClipWebhookUrls(props: {
         const queryParams = endpointUrl.search;
         // Remove query parameters from the base endpoint URL
         endpointUrl.search = '';
-        
+
         // Ensure endpoint has trailing slash
         const normalizedEndpoint = endpointUrl.toString().endsWith('/') ? endpointUrl.toString() : `${endpointUrl.toString()}/`;
 
@@ -306,7 +379,10 @@ export async function getVideoClipWebhookUrls(props: {
 
         return { videoUrl, thumbnailUrl };
     } catch (e) {
-        plugin.console.error('Failed to generate webhook URLs', e);
+        log.error?.(
+            `[getVideoClipWebhookUrls] Failed to generate webhook URLs: deviceId=${deviceId}, fileId=${fileId}`,
+            e
+        );
         throw e;
     }
 }
@@ -319,10 +395,13 @@ export async function extractThumbnailFromVideo(props: {
     filePath?: string;
     fileId: string;
     deviceId: string;
-    logger: Console;
+    logger?: Console;
+    device?: CommonCameraMixin;
 }): Promise<MediaObject> {
-    const { rtmpUrl, filePath, fileId, deviceId, logger } = props;
-    
+    const { rtmpUrl, filePath, fileId, deviceId, device } = props;
+    // Use device logger if available, otherwise fallback to provided logger
+    const logger = device?.getBaichuanLogger?.() || props.logger || console;
+
     // Use file path if available, otherwise use RTMP URL
     const inputSource = filePath || rtmpUrl;
     if (!inputSource) {
@@ -330,89 +409,17 @@ export async function extractThumbnailFromVideo(props: {
     }
 
     try {
-        // Get ffmpeg path
-        const ffmpegPath = await sdk.mediaManager.getFFmpegPath();
-
-        // Build ffmpeg args to extract a frame at 2 seconds
-        const ffmpegArgs = [
-            '-ss', '2', // Seek to 2 seconds
-            '-i', inputSource,
-            '-vframes', '1', // Extract only 1 frame
-            '-q:v', '2', // High quality JPEG
-            '-f', 'image2', // Output format
-            'pipe:1', // Output to stdout
-        ];
-
-        return new Promise<MediaObject>((resolve, reject) => {
-            const ffmpeg = spawn(ffmpegPath, ffmpegArgs, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-
-            const chunks: Buffer[] = [];
-            let errorOutput = '';
-
-            ffmpeg.stdout.on('data', (chunk: Buffer) => {
-                chunks.push(chunk);
-            });
-
-            ffmpeg.stderr.on('data', (chunk: Buffer) => {
-                errorOutput += chunk.toString();
-            });
-
-            let resolved = false;
-
-            ffmpeg.on('close', async (code) => {
-                if (resolved) return;
-                resolved = true;
-
-                if (code !== 0) {
-                    logger.error(`[Thumbnail] Error: fileId=${fileId}`, new Error(`ffmpeg failed with code ${code}: ${errorOutput}`));
-                    reject(new Error(`ffmpeg failed with code ${code}: ${errorOutput}`));
-                    return;
-                }
-
-                try {
-                    const imageBuffer = Buffer.concat(chunks);
-                    if (imageBuffer.length === 0) {
-                        logger.error(`[Thumbnail] Error: fileId=${fileId}`, new Error('No image data received from ffmpeg'));
-                        reject(new Error('No image data received from ffmpeg'));
-                        return;
-                    }
-
-                    const mo = await sdk.mediaManager.createMediaObject(imageBuffer, 'image/jpeg');
-                    logger.log(`[Thumbnail] Completed: fileId=${fileId}, size=${imageBuffer.length} bytes`);
-                    resolve(mo);
-                } catch (e) {
-                    logger.error(`[Thumbnail] Error: fileId=${fileId}`, e);
-                    reject(e);
-                }
-            });
-
-            ffmpeg.on('error', (error) => {
-                if (resolved) return;
-                resolved = true;
-                logger.error(`[Thumbnail] Error: fileId=${fileId}`, error);
-                reject(error);
-            });
-
-            // Timeout after 30 seconds
-            const timeout = setTimeout(() => {
-                if (resolved) return;
-                resolved = true;
-                try {
-                    ffmpeg.kill('SIGKILL');
-                } catch (e) {
-                    // Ignore
-                }
-                reject(new Error('Thumbnail extraction timeout'));
-            }, 30000);
-
-            ffmpeg.on('close', () => {
-                clearTimeout(timeout);
-            });
+        // Use createFFmpegMediaObject which handles codec detection better
+        // For Download URLs from NVR, they might return only a short segment, so use 1 second instead of 5
+        const mo = await sdk.mediaManager.createFFmpegMediaObject({
+            inputArguments: [
+                '-ss', '00:00:01', // Seek to 1 second (safer for short segments from NVR Download URLs)
+                '-i', inputSource,
+            ],
         });
+        return mo;
     } catch (e) {
-        logger.error(`[Thumbnail] Error: fileId=${fileId}`, e);
+        // Error already logged in main.ts
         throw e;
     }
 }
@@ -426,7 +433,7 @@ function getVideoClipCachePath(deviceId: string, fileId: string): string {
     const hash = crypto.createHash('md5').update(fileId).digest('hex');
     // Keep original extension if present, otherwise use .mp4
     const ext = fileId.includes('.') ? path.extname(fileId) : '.mp4';
-    const cacheDir = path.join(pluginVolume, 'snapshots', deviceId);
+    const cacheDir = path.join(pluginVolume, 'videoclips', deviceId);
     return path.join(cacheDir, `${hash}${ext}`);
 }
 
@@ -440,12 +447,14 @@ export async function handleVideoClipRequest(props: {
     fileId: string;
     request: HttpRequest;
     response: HttpResponse;
-    logger: Console;
+    logger?: Console;
 }): Promise<void> {
-    const { device, deviceId, fileId, request, response, logger } = props;
+    const { device, deviceId, fileId, request, response } = props;
+    const logger = device.getBaichuanLogger?.() || props.logger || console;
 
     // Check if file is cached
     const cachePath = getVideoClipCachePath(deviceId, fileId);
+    const MIN_VIDEO_CACHE_BYTES = 16 * 1024; // 16KB, evita file quasi vuoti/corrotti
 
     try {
         // Check if cached file exists
@@ -453,6 +462,17 @@ export async function handleVideoClipRequest(props: {
         const fileSize = stat.size;
         const range = request.headers.range;
 
+        if (fileSize < MIN_VIDEO_CACHE_BYTES) {
+            logger.warn(`Cached video clip too small, deleting and reloading: fileId=${fileId}, size=${fileSize} bytes`);
+            try {
+                await fs.promises.unlink(cachePath);
+            } catch (unlinkErr) {
+                logger.warn(`Failed to delete small cached video clip: fileId=${fileId}`, unlinkErr);
+            }
+            // Force cache miss path below
+            throw new Error('Cached video too small, deleted');
+        }
+
         logger.log(`Serving cached video clip: fileId=${fileId}, size=${fileSize}, range=${range}`);
 
         if (range) {
@@ -493,32 +513,231 @@ export async function handleVideoClipRequest(props: {
         }
     } catch (e) {
         // File not cached, need to proxy RTMP stream
-        logger.log(`Cache miss, proxying RTMP stream: fileId=${fileId}`);
+        logger.log(`[VideoClip] Stream start: fileId=${fileId}`);
 
-        // Get RTMP URL directly from API using fileId
-        // Cast device to CommonCameraMixin to access API
+        // Get RTMP URL using the appropriate API (NVR or Baichuan)
         let rtmpVodUrl: string | undefined;
         try {
-            const api = await device.ensureClient();
-            const result = await api.getRecordingPlaybackUrls({
-                fileName: fileId,
-            });
-            rtmpVodUrl = result.rtmpVodUrl;
+            rtmpVodUrl = await device.getVideoClipRtmpUrl(fileId);
         } catch (e2) {
-            logger.error(`Failed to get RTMP URL from API: fileId=${fileId}`, e2);
+            logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e2);
             response.send('Failed to get RTMP playback URL', { code: 500 });
             return;
         }
 
         if (!rtmpVodUrl) {
-            logger.error(`No RTMP URL found for video: fileId=${fileId}`);
+            logger.error(`[VideoClip] Stream error: fileId=${fileId} - No URL found`);
             response.send('No RTMP playback URL found for video', { code: 404 });
             return;
         }
 
-        // logger.log(`Got RTMP URL for proxy: fileId=${fileId}`);
+        // Check if URL is HTTP (Playback/Download) or RTMP
+        const isHttpUrl = rtmpVodUrl.startsWith('http://') || rtmpVodUrl.startsWith('https://');
+
+        if (isHttpUrl) {
+            // For HTTP URLs (Playback/Download from NVR), do direct HTTP proxy with ranged headers support
+            logger.debug(`Proxying HTTP URL directly: fileId=${fileId}, url=${rtmpVodUrl}`);
+
+            const sendVideo = async () => {
+                // Pre-fetch ffmpeg path in case we need it for FLV conversion
+                const ffmpegPathPromise = sdk.mediaManager.getFFmpegPath();
+
+                return new Promise<void>(async (resolve, reject) => {
+                    const urlObj = new URL(rtmpVodUrl);
+                    const httpModule = urlObj.protocol === 'https:' ? https : http;
+
+                    // Filter and prepare headers (remove host, connection, etc. that shouldn't be forwarded)
+                    const requestHeaders: Record<string, string> = {};
+                    if (request.headers.range) {
+                        requestHeaders['Range'] = request.headers.range;
+                    }
+                    // Add other headers that might be needed
+                    if (request.headers['user-agent']) {
+                        requestHeaders['User-Agent'] = request.headers['user-agent'];
+                    }
+
+                    const options = {
+                        hostname: urlObj.hostname,
+                        port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+                        path: urlObj.pathname + urlObj.search,
+                        method: 'GET',
+                        headers: requestHeaders,
+                    };
+
+                    logger.debug(`Starting HTTP request: ${rtmpVodUrl}, headers: ${JSON.stringify(requestHeaders)}`);
+
+                    httpModule.get(options, async (httpResponse) => {
+                        if (httpResponse.statusCode && httpResponse.statusCode >= 400) {
+                            logger.error(`HTTP error: status=${httpResponse.statusCode}, message=${httpResponse.statusMessage}`);
+                            reject(new Error(`Error loading the video: ${httpResponse.statusCode} - ${httpResponse.statusMessage}`));
+                            return;
+                        }
+
+                        let contentType = httpResponse.headers['content-type'] || 'video/mp4';
+                        const contentLength = httpResponse.headers['content-length'];
+                        const contentRange = httpResponse.headers['content-range'];
+                        const acceptRanges = httpResponse.headers['accept-ranges'] || 'bytes';
+
+                        // Check if we need to convert FLV to MP4
+                        const isFlv = typeof contentType === 'string' && (contentType === 'video/x-flv' || contentType === 'video/flv');
+
+                        if (isFlv) {
+                            logger.debug(`Content-Type is FLV (${contentType}), will convert to MP4 using ffmpeg`);
+                        }
+
+                        const responseHeaders: Record<string, string> = {
+                            'Content-Type': typeof contentType === 'string' ? contentType : 'video/mp4',
+                            'Accept-Ranges': typeof acceptRanges === 'string' ? acceptRanges : 'bytes',
+                            'Cache-Control': 'no-cache',
+                        };
+
+                        if (contentLength) {
+                            responseHeaders['Content-Length'] = typeof contentLength === 'string' ? contentLength : String(contentLength);
+                        }
+
+                        if (contentRange) {
+                            responseHeaders['Content-Range'] = typeof contentRange === 'string' ? contentRange : String(contentRange);
+                        }
+
+                        const statusCode = httpResponse.statusCode || 200;
+
+                        logger.debug(`HTTP response received: status=${statusCode}, contentType=${contentType}, contentLength=${contentLength || 'unknown'}`);
+
+                        try {
+                            if (isFlv) {
+                                // Convert FLV to MP4 using ffmpeg
+                                const ffmpegPath = await ffmpegPathPromise;
+                                // Re-encode instead of copy because FLV codec might not be supported
+                                const ffmpegArgs: string[] = [
+                                    '-i', 'pipe:0', // Read from stdin (httpResponse)
+                                    '-c:v', 'libx264', // Re-encode video to H.264
+                                    '-preset', 'ultrafast', // Fast encoding for streaming
+                                    '-tune', 'zerolatency', // Low latency
+                                    '-c:a', 'aac', // Re-encode audio to AAC
+                                    '-f', 'mp4',
+                                    '-movflags', 'frag_keyframe+empty_moov', // Enable streaming
+                                    'pipe:1', // Output to stdout
+                                ];
+
+                                const ffmpeg = spawn(ffmpegPath, ffmpegArgs, {
+                                    stdio: ['pipe', 'pipe', 'pipe'],
+                                });
+
+                                let ffmpegError = '';
+                                ffmpeg.stderr.on('data', (chunk: Buffer) => {
+                                    ffmpegError += chunk.toString();
+                                });
+
+                                // Pipe httpResponse to ffmpeg stdin
+                                httpResponse.pipe(ffmpeg.stdin);
+
+                                ffmpeg.stdin.on('error', (err) => {
+                                    // Ignore EPIPE errors when ffmpeg closes
+                                    if ((err as any).code !== 'EPIPE') {
+                                        logger.error(`FFmpeg stdin error: fileId=${fileId}`, err);
+                                    }
+                                });
+
+                                httpResponse.on('error', (err) => {
+                                    logger.error(`HTTP response error before ffmpeg: fileId=${fileId}`, err);
+                                    try {
+                                        ffmpeg.kill('SIGKILL');
+                                    } catch (e) {
+                                        // Ignore
+                                    }
+                                });
+
+                                let streamStarted = false;
+
+                                // Stream ffmpeg output
+                                response.sendStream((async function* () {
+                                    try {
+                                        for await (const chunk of ffmpeg.stdout) {
+                                            if (!streamStarted) {
+                                                streamStarted = true;
+                                            }
+                                            yield chunk;
+                                        }
+                                    } catch (e) {
+                                        logger.error(`Error streaming ffmpeg output: fileId=${fileId}`, e);
+                                        throw e;
+                                    } finally {
+                                        // Clean up ffmpeg process
+                                        try {
+                                            ffmpeg.kill('SIGKILL');
+                                        } catch (e) {
+                                            // Ignore
+                                        }
+                                    }
+                                })(), {
+                                    code: 200,
+                                    headers: {
+                                        'Content-Type': 'video/mp4',
+                                        'Accept-Ranges': 'bytes',
+                                        'Cache-Control': 'no-cache',
+                                    },
+                                });
+
+                                // Handle ffmpeg errors
+                                ffmpeg.on('close', (code) => {
+                                    if (code !== 0 && code !== null && !streamStarted) {
+                                        const sanitized = sanitizeFfmpegOutput(ffmpegError);
+                                        logger.error(`FFmpeg conversion failed: fileId=${fileId}, code=${code}, error=${sanitized}`);
+                                        reject(new Error(`FFmpeg conversion failed: ${code}`));
+                                    } else {
+                                        logger.debug(`FFmpeg conversion completed: fileId=${fileId}, code=${code}`);
+                                        resolve();
+                                    }
+                                });
+
+                                ffmpeg.on('error', (error) => {
+                                    logger.error(`FFmpeg spawn error: fileId=${fileId}`, error);
+                                    reject(error);
+                                });
+
+                                logger.debug(`FFmpeg conversion started: fileId=${fileId}`);
+                            } else {
+                                // Direct proxy for non-FLV content (should be MP4 already)
+                                // Stream directly without buffering - yield chunks as they arrive
+                                response.sendStream((async function* () {
+                                    try {
+                                        for await (const chunk of Readable.from(httpResponse)) {
+                                            yield chunk;
+                                        }
+                                        logger.log(`[VideoClip] Stream end: fileId=${fileId}`);
+                                    } catch (streamErr) {
+                                        logger.error(`[VideoClip] Stream error: fileId=${fileId}`, streamErr);
+                                        throw streamErr;
+                                    }
+                                })(), {
+                                    code: statusCode,
+                                    headers: responseHeaders,
+                                });
+
+                                resolve();
+                            }
+                        } catch (err) {
+                            logger.error(`Error sending stream: fileId=${fileId}`, err);
+                            reject(err);
+                        }
+                    }).on('error', (e) => {
+                        logger.error(`Error fetching videoclip: fileId=${fileId}`, e);
+                        reject(e);
+                    });
+                });
+            };
+
+            try {
+                await sendVideo();
+                return;
+            } catch (e) {
+                logger.error(`HTTP proxy error: fileId=${fileId}`, e);
+                response.send('Failed to proxy HTTP stream', { code: 500 });
+                return;
+            }
+        }
 
-        // Use ffmpeg to proxy the RTMP stream
+        // For RTMP URLs (camera standalone), use ffmpeg
         const ffmpegPath = await sdk.mediaManager.getFFmpegPath();
         const ffmpegArgs: string[] = [
             '-i', rtmpVodUrl,
@@ -548,8 +767,9 @@ export async function handleVideoClipRequest(props: {
                     }
                     yield chunk;
                 }
+                logger.log(`[VideoClip] Stream end: fileId=${fileId}`);
             } catch (e) {
-                logger.error(`Error streaming video: fileId=${fileId}`, e);
+                logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e);
                 throw e;
             } finally {
                 // Clean up ffmpeg process
@@ -571,7 +791,8 @@ export async function handleVideoClipRequest(props: {
         // Handle ffmpeg errors
         ffmpeg.on('close', (code) => {
             if (code !== 0 && code !== null && !streamStarted) {
-                logger.error(`FFmpeg proxy failed for video: fileId=${fileId}, code=${code}, error=${ffmpegError}`);
+                const sanitized = sanitizeFfmpegOutput(ffmpegError);
+                logger.error(`FFmpeg proxy failed for video: fileId=${fileId}, code=${code}, error=${sanitized}`);
             }
         });
 
@@ -581,4 +802,218 @@ export async function handleVideoClipRequest(props: {
 
         return;
     }
+}
+
+/**
+ * Parse recordType string to extract detection classes
+ * Based on the same logic as ReolinkCgiApi.parseRecordTypeFlags
+ */
+function parseRecordTypeToDetectionClasses(recordType?: string): string[] {
+    const detectionClasses: string[] = [];
+
+    if (!recordType) {
+        return ['Motion']; // Default to Motion if no type specified
+    }
+
+    // Split by comma or whitespace and process each type
+    const types = recordType.toLowerCase().split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+
+    let hasMotion = false;
+
+    for (const t of types) {
+        if (t === "people" || t === "person") {
+            detectionClasses.push('Person');
+        } else if (t === "vehicle" || t === "car") {
+            detectionClasses.push('Vehicle');
+        } else if (t === "dog_cat" || t === "animal" || t === "pet") {
+            detectionClasses.push('Animal');
+        } else if (t === "face") {
+            detectionClasses.push('Face');
+        } else if (t === "md" || t === "motion") {
+            hasMotion = true;
+        } else if (t === "visitor" || t === "doorbell") {
+            detectionClasses.push('Doorbell');
+        } else if (t === "package") {
+            detectionClasses.push('Package');
+        }
+    }
+
+    // Always include Motion as base (if not already added or if no other detections)
+    if (hasMotion || detectionClasses.length === 0) {
+        detectionClasses.unshift('Motion');
+    }
+
+    return detectionClasses;
+}
+
+/**
+ * Extract detection classes from parsed filename flags (hex decoding)
+ */
+function parseFilenameFlagsToDetectionClasses(parsed?: ParsedRecordingFileName): string[] {
+    const detectionClasses: string[] = [];
+    const flags = parsed?.flags;
+
+    if (!flags) {
+        return [];
+    }
+
+    // Extract detection types from hex flags (same logic as enrichVodFile)
+    if (flags.aiPerson) {
+        detectionClasses.push('Person');
+    }
+    if (flags.aiVehicle) {
+        detectionClasses.push('Vehicle');
+    }
+    if (flags.aiAnimal) {
+        detectionClasses.push('Animal');
+    }
+    if (flags.aiFace) {
+        detectionClasses.push('Face');
+    }
+    if (flags.motion) {
+        detectionClasses.push('Motion');
+    }
+    if (flags.doorbell) {
+        detectionClasses.push('Doorbell');
+    }
+    if (flags.package) {
+        detectionClasses.push('Package');
+    }
+
+    return detectionClasses;
+}
+
+/**
+ * Convert Reolink time format to Date
+ * Uses UTC to match the API's dateToReolinkTime conversion
+ */
+function reolinkTimeToDate(time: { year: number; mon: number; day: number; hour: number; min: number; sec: number }): Date {
+    return new Date(Date.UTC(
+        time.year,
+        time.mon - 1,
+        time.day,
+        time.hour,
+        time.min,
+        time.sec
+    ));
+}
+
+/**
+ * Convert VOD search results to VideoClip array
+ */
+export async function vodSearchResultsToVideoClips(
+    vodResults: Array<VodSearchResponse>,
+    options: {
+        deviceId: string;
+        plugin: ScryptedDeviceBase;
+        logger?: Console;
+    }
+): Promise<VideoClip[]> {
+    const { deviceId, plugin, logger } = options;
+    const clips: VideoClip[] = [];
+
+    // Import parseRecordingFileName once (it's exported from the package)
+    const reolinkModule = await import("@apocaliss92/reolink-baichuan-js");
+    const parseRecordingFileName = reolinkModule.parseRecordingFileName;
+
+    // Process VOD search results
+    for (const result of vodResults) {
+        if (result.code !== 0) {
+            logger?.debug(`VOD search result code: ${result.code}`, result.error);
+            continue;
+        }
+
+        const searchResult = result.value?.SearchResult;
+        if (!searchResult?.File || !Array.isArray(searchResult.File)) {
+            continue;
+        }
+
+        // Convert each VOD file to VideoClip
+        for (const file of searchResult.File) {
+            try {
+                // Parse filename to extract flags (like enrichVodFile does)
+                const parsed = parseRecordingFileName(file.name);
+
+                // Get times from parsed filename or from StartTime/EndTime
+                // Camera times in StartTime/EndTime are in local timezone (not UTC)
+                // Use local time constructor to preserve the timezone
+                const fileStart = parsed?.start ?? new Date(
+                    file.StartTime.year,
+                    file.StartTime.mon - 1,
+                    file.StartTime.day,
+                    file.StartTime.hour,
+                    file.StartTime.min,
+                    file.StartTime.sec
+                );
+                const fileEnd = parsed?.end ?? new Date(
+                    file.EndTime.year,
+                    file.EndTime.mon - 1,
+                    file.EndTime.day,
+                    file.EndTime.hour,
+                    file.EndTime.min,
+                    file.EndTime.sec
+                );
+
+                const duration = fileEnd.getTime() - fileStart.getTime();
+                const fileName = file.name || '';
+
+                // Extract detection classes from both filename flags (hex) and file.type
+                const filenameFlags = parseFilenameFlagsToDetectionClasses(parsed);
+                const typeFlags = parseRecordTypeToDetectionClasses(file.type);
+
+                // Debug: log file.type to see what we're parsing
+                if (logger && file.type) {
+                    logger.debug(`[VOD] Parsing file.type="${file.type}" for file=${fileName}, filenameFlags=${filenameFlags.join(',')}, typeFlags=${typeFlags.join(',')}`);
+                }
+
+                // Merge both sources (OR them together, like enrichVodFile does)
+                // Remove duplicates and ensure Motion is included if any detection is found
+                const allDetections = [...filenameFlags, ...typeFlags];
+                const detectionClasses = [...new Set(allDetections)];
+
+                // If we have detections from filename flags, use those (they're more accurate)
+                // Otherwise use type flags, or default to Motion
+                if (detectionClasses.length === 0) {
+                    detectionClasses.push('Motion');
+                } else if (!detectionClasses.includes('Motion') && (filenameFlags.length > 0 || typeFlags.some(t => t.toLowerCase().includes('motion') || t.toLowerCase().includes('md')))) {
+                    // Add Motion if we have other detections but Motion is not explicitly included
+                    detectionClasses.push('Motion');
+                }
+
+                // Generate webhook URLs
+                let videoHref: string | undefined;
+                let thumbnailHref: string | undefined;
+                try {
+                    const { videoUrl, thumbnailUrl } = await getVideoClipWebhookUrls({
+                        deviceId,
+                        fileId: fileName,
+                        plugin,
+                        logger,
+                    });
+                    videoHref = videoUrl;
+                    thumbnailHref = thumbnailUrl;
+                } catch (e) {
+                    logger?.debug('Failed to generate webhook URLs for VOD file', fileName, e);
+                }
+
+                const clip: VideoClip = {
+                    id: fileName,
+                    description: fileName,
+                    startTime: fileStart.getTime(),
+                    duration,
+                    resources: {
+                        video: videoHref ? { href: videoHref } : undefined,
+                        thumbnail: thumbnailHref ? { href: thumbnailHref } : undefined,
+                    },
+                    detectionClasses,
+                };
+
+                clips.push(clip);
+            } catch (e) {
+                logger?.warn(`Failed to convert VOD file to clip: ${file.name}`, e);
+            }
+        }
+    }
+
+    return clips;
 }