@apocaliss92/scrypted-reolink-native 0.1.33 → 0.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.33",
+   "version": "0.1.36",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/baichuan-base.ts

@@ -219,9 +219,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             
             // Only reuse if both conditions are true
             if (isConnected && isLoggedIn) {
-                return this.baichuanApi;
-            }
-            
+            return this.baichuanApi;
+        }
+
             // If socket is not connected or not logged in, cleanup the stale client
             // This prevents leaking connections when the socket appears connected but isn't
             const logger = this.getBaichuanLogger();
@@ -358,7 +358,7 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                 // Only cleanup if this is still the current API instance
                 // This prevents cleanup of a new connection that was created
                 // while the old one was closing
-                await this.cleanupBaichuanApi();
+            await this.cleanupBaichuanApi();
             }
 
             // Call custom close handler if provided

package/src/common.ts

@@ -5,6 +5,8 @@ import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
 import { spawn } from 'node:child_process';
+import http from 'http';
+import https from 'https';
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
@@ -22,7 +24,7 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, pirSuffix, recordingFileToVideoClip, sirenSuffix, updateDeviceInfo } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingFileToVideoClip, sanitizeFfmpegOutput, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -550,7 +552,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         },
         enableVideoclips: {
             title: "Enable Video Clips",
-            subgroup: 'Videoclips',
             description: "Enable video clips functionality. If disabled, getVideoClips will return empty and all other videoclip settings are ignored.",
             type: "boolean",
             defaultValue: false,
@@ -559,6 +560,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 this.updateVideoClipsAutoLoad();
             },
         },
+        clipsSource: {
+            title: "Clips Source",
+            subgroup: 'Videoclips',
+            description: "Source for fetching video clips: NVR (fetch from NVR device) or Device (fetch directly from camera).",
+            type: "string",
+            choices: ["NVR", "Device"],
+            immediate: true,
+        },
         loadVideoclips: {
             title: "Auto-load Video Clips",
             subgroup: 'Videoclips',
@@ -591,6 +600,16 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 this.updateVideoClipsAutoLoad();
             },
         },
+        videoclipsDaysToPreload: {
+            title: "Days to Preload",
+            subgroup: 'Videoclips',
+            description: "Number of days to preload video clips and thumbnails (default: 1, only today).",
+            type: "number",
+            defaultValue: 3,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
         diagnosticsRun: {
             subgroup: 'Diagnostics',
             title: 'Run Diagnostics',
@@ -709,36 +728,125 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         const start = new Date(startMs);
         const end = new Date(endMs);
-        start.setHours(0, 0, 0, 0);
+        // Use UTC to match API's dateToReolinkTime conversion
+        start.setUTCHours(0, 0, 0, 0);
 
         try {
-            const api = await this.ensureClient();
-            const recordings = await api.listEnrichedRecordingsByTime({
-                start,
-                end,
-                count,
-                streamType: 'mainStream',
-                httpFallback: false,
-                fetchRtmpUrls: true
-            });
+            const { clipsSource } = this.storageSettings.values;
+            const useNvr = clipsSource === "NVR" && this.nvrDevice;
+
+            if (useNvr) {
+                // Fetch from NVR using listEnrichedVodFiles (library handles parsing correctly)
+                const channel = this.storageSettings.values.rtspChannel ?? 0;
+
+                // Use listEnrichedVodFiles which properly parses filenames and extracts detection info
+                logger.debug(`[NVR VOD] Searching for video clips: channel=${channel}, start=${start.toISOString()}, end=${end.toISOString()}`);
+                // Filter to only include recordings within the requested time window
+                const enrichedRecordings = await this.nvrDevice.listEnrichedVodFiles({
+                    channel,
+                    start,
+                    end,
+                    streamType: "main",
+                    autoSearchByDay: false, // Disable autoSearchByDay to avoid searching past days
+                    bypassCache: false,
+                });
 
-            const clips: VideoClip[] = [];
+                logger.debug(`[NVR VOD] Found ${enrichedRecordings.length} enriched recordings from NVR`);
+
+                // Log sample of enriched recordings to see what the library returned
+                if (enrichedRecordings.length > 0) {
+                    const sampleSize = Math.min(3, enrichedRecordings.length);
+                    for (let i = 0; i < sampleSize; i++) {
+                        const rec = enrichedRecordings[i];
+                        logger.debug(`[NVR VOD] Sample enriched recording ${i + 1}/${enrichedRecordings.length}:`, {
+                            fileName: rec.fileName,
+                            startTimeMs: rec.startTimeMs,
+                            endTimeMs: rec.endTimeMs,
+                            durationMs: rec.durationMs,
+                            hasPerson: rec.hasPerson,
+                            hasVehicle: rec.hasVehicle,
+                            hasAnimal: rec.hasAnimal,
+                            hasFace: rec.hasFace,
+                            hasMotion: rec.hasMotion,
+                            hasDoorbell: rec.hasDoorbell,
+                            hasPackage: rec.hasPackage,
+                            recordType: rec.recordType,
+                            parsedFileName: rec.parsedFileName ? {
+                                start: rec.parsedFileName.start?.toISOString(),
+                                end: rec.parsedFileName.end?.toISOString(),
+                                flags: rec.parsedFileName.flags,
+                            } : null,
+                        });
+                    }
+                }
 
-            for (const rec of recordings) {
-                const clip = await recordingFileToVideoClip(rec, {
-                    fallbackStart: start,
-                    api,
-                    logger,
-                    plugin: this,
-                    deviceId: this.id,
-                    useWebhook: true,
+                // Convert enriched recordings to VideoClip array
+                const clips: VideoClip[] = [];
+
+                for (const rec of enrichedRecordings) {
+                    // Log detection flags before conversion
+                    const flags = {
+                        hasPerson: 'hasPerson' in rec ? rec.hasPerson : false,
+                        hasVehicle: 'hasVehicle' in rec ? rec.hasVehicle : false,
+                        hasAnimal: 'hasAnimal' in rec ? rec.hasAnimal : false,
+                        hasFace: 'hasFace' in rec ? rec.hasFace : false,
+                        hasMotion: 'hasMotion' in rec ? rec.hasMotion : false,
+                        hasDoorbell: 'hasDoorbell' in rec ? rec.hasDoorbell : false,
+                        hasPackage: 'hasPackage' in rec ? rec.hasPackage : false,
+                        recordType: rec.recordType || 'none',
+                    };
+                    logger.debug(`[NVR VOD] Processing recording: fileName=${rec.fileName}, flags=${JSON.stringify(flags)}`);
+
+                    const clip = await recordingFileToVideoClip(rec, {
+                        fallbackStart: start,
+                        logger,
+                        plugin: this,
+                        deviceId: this.id,
+                        useWebhook: true,
+                    });
+
+                    // Log detection classes in the final clip
+                    logger.debug(`[NVR VOD] Generated clip: id=${clip.id}, detectionClasses=${clip.detectionClasses?.join(',') || 'none'}`);
+                    clips.push(clip);
+                }
+
+                // Apply count limit if specified
+                const finalClips = count ? clips.slice(0, count) : clips;
+                logger.debug(`[NVR VOD] Converted ${finalClips.length} video clips (limit: ${count || 'none'})`);
+
+                return finalClips;
+            } else {
+                // Fetch directly from device using Baichuan API
+                const api = await this.ensureClient();
+
+                const recordings = await api.listEnrichedRecordingsByTime({
+                    start,
+                    end,
+                    count,
+                    channel: this.storageSettings.values.rtspChannel,
+                    streamType: 'mainStream',
+                    httpFallback: false,
+                    fetchRtmpUrls: true
                 });
-                clips.push(clip);
-            }
 
-            logger.debug(`Videoclips found: ${JSON.stringify(clips)}`);
+                const clips: VideoClip[] = [];
+
+                for (const rec of recordings) {
+                    const clip = await recordingFileToVideoClip(rec, {
+                        fallbackStart: start,
+                        api,
+                        logger,
+                        plugin: this,
+                        deviceId: this.id,
+                        useWebhook: true,
+                    });
+                    clips.push(clip);
+                }
+
+                logger.debug(`Videoclips found: ${clips.length}`);
 
-            return clips;
+                return clips;
+            }
         } catch (e: any) {
             const message = e instanceof Error ? e.message : String(e);
 
@@ -779,7 +887,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     async getVideoClip(videoId: string): Promise<MediaObject> {
         const logger = this.getBaichuanLogger();
         try {
-            const cacheEnabled = this.storageSettings.values.downloadVideoclipsLocally
+            const cacheEnabled = this.storageSettings.values.downloadVideoclipsLocally;
+            const MIN_VIDEO_CACHE_BYTES = 16 * 1024;
 
             // Always check cache first, even if caching is disabled (in case user enabled it before)
             const cachePath = this.getVideoClipCachePath(videoId);
@@ -789,10 +898,19 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             try {
                 await fs.promises.access(cachePath, fs.constants.F_OK);
                 const stats = await fs.promises.stat(cachePath);
-                logger.debug(`[VideoClip] Using cached file: fileId=${videoId}, size=${stats.size} bytes`);
-                // Return cached file as MediaObject
-                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
-                return mo;
+                if (stats.size < MIN_VIDEO_CACHE_BYTES) {
+                    logger.warn(`[VideoClip] Cached file too small, deleting and re-downloading: fileId=${videoId}, size=${stats.size} bytes`);
+                    try {
+                        await fs.promises.unlink(cachePath);
+                    } catch (unlinkErr) {
+                        logger.warn(`[VideoClip] Failed to delete small cached file: fileId=${videoId}`, unlinkErr);
+                    }
+                } else {
+                    logger.debug(`[VideoClip] Using cached file: fileId=${videoId}, size=${stats.size} bytes`);
+                    // Return cached file as MediaObject
+                    const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                    return mo;
+                }
             } catch (e) {
                 // File doesn't exist or error accessing it
                 logger.debug(`[VideoClip] Cache miss: fileId=${videoId}, error=${e instanceof Error ? e.message : String(e)}`);
@@ -806,25 +924,71 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await fs.promises.mkdir(cacheDir, { recursive: true });
             }
 
-            const api = await this.ensureClient();
+            const { clipsSource } = this.storageSettings.values;
+            const useNvr = clipsSource === "NVR" && this.nvrDevice && videoId.includes('/');
 
-            // videoId is the fileId (fileName or id from the recording)
-            const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
-                fileName: videoId,
-            });
+            // NVR/HUB case: prefer Download endpoint (HTTP) instead of RTMP
+            if (useNvr && this.nvrDevice) {
+                // Reuse centralized logic for NVR VOD URL (Download)
+                const downloadUrl = await this.getVideoClipRtmpUrl(videoId);
+
+                // If caching is enabled, download via HTTP and cache as file
+                if (cacheEnabled) {
+                    const cachePath = this.getVideoClipCachePath(videoId);
+                    logger.log(`Downloading video clip from NVR to cache: fileId=${videoId}, path=${cachePath}`);
+
+                    await new Promise<void>((resolve, reject) => {
+                        const urlObj = new URL(downloadUrl);
+                        const httpModule = urlObj.protocol === 'https:' ? https : http;
+
+                        const fileStream = fs.createWriteStream(cachePath);
 
-            if (!rtmpVodUrl) {
-                throw new Error(`No playback URL found for video ${videoId}`);
+                        const req = httpModule.get(downloadUrl, (res) => {
+                            if (!res.statusCode || res.statusCode >= 400) {
+                                reject(new Error(`NVR download failed: ${res.statusCode} ${res.statusMessage}`));
+                                return;
+                            }
+
+                            res.pipe(fileStream);
+
+                            res.on('error', (err) => {
+                                reject(err);
+                            });
+
+                            fileStream.on('finish', () => {
+                                resolve();
+                            });
+
+                            fileStream.on('error', (err) => {
+                                reject(err);
+                            });
+                        });
+
+                        req.on('error', (err) => {
+                            reject(err);
+                        });
+                    });
+
+                    const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                    return mo;
+                } else {
+                    // Caching disabled: return HTTP Download URL directly
+                    const mo = await sdk.mediaManager.createMediaObjectFromUrl(downloadUrl);
+                    return mo;
+                }
             }
 
-            // If caching is enabled, download and cache the video
+            // Standalone camera (or fallback): reuse getVideoClipRtmpUrl (Baichuan RTMP)
+            const playbackUrl = await this.getVideoClipRtmpUrl(videoId);
+
+            // If caching is enabled, download and cache the video via ffmpeg
             if (cacheEnabled) {
                 const cachePath = this.getVideoClipCachePath(videoId);
 
                 // Download and convert RTMP to MP4 using ffmpeg
                 const ffmpegPath = await sdk.mediaManager.getFFmpegPath();
                 const ffmpegArgs = [
-                    '-i', rtmpVodUrl,
+                    '-i', playbackUrl,
                     '-c', 'copy', // Copy codecs without re-encoding
                     '-f', 'mp4',
                     '-movflags', 'frag_keyframe+empty_moov', // Enable streaming
@@ -846,8 +1010,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
                     ffmpeg.on('close', (code) => {
                         if (code !== 0) {
-                            logger.error(`ffmpeg failed to download video clip: ${errorOutput}`);
-                            reject(new Error(`ffmpeg failed with code ${code}: ${errorOutput}`));
+                            const sanitized = sanitizeFfmpegOutput(errorOutput);
+                            logger.error(`ffmpeg failed to download video clip: ${sanitized}`);
+                            reject(new Error(`ffmpeg failed with code ${code}: ${sanitized}`));
                             return;
                         }
 
@@ -875,8 +1040,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
                 return mo;
             } else {
-                // Caching disabled, return RTMP URL directly
-                const mo = await sdk.mediaManager.createMediaObjectFromUrl(rtmpVodUrl);
+                // Caching disabled, return playback URL directly (RTMP for standalone camera)
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(playbackUrl);
                 return mo;
             }
         } catch (e) {
@@ -910,14 +1075,24 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             // Check cache first
             const cachePath = this.getThumbnailCachePath(thumbnailId);
             const cacheDir = this.getThumbnailCacheDir();
+            const MIN_THUMB_CACHE_BYTES = 512; // 0.5KB, evita file vuoti o quasi
 
             try {
                 await fs.promises.access(cachePath, fs.constants.F_OK);
                 const stats = await fs.promises.stat(cachePath);
-                logger.debug(`[Thumbnail] Using cached: fileId=${thumbnailId}, size=${stats.size} bytes`);
-                // Return cached thumbnail as MediaObject
-                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
-                return mo;
+                if (stats.size < MIN_THUMB_CACHE_BYTES) {
+                    logger.warn(`[Thumbnail] Cached thumbnail too small, deleting and regenerating: fileId=${thumbnailId}, size=${stats.size} bytes`);
+                    try {
+                        await fs.promises.unlink(cachePath);
+                    } catch (unlinkErr) {
+                        logger.warn(`[Thumbnail] Failed to delete small cached thumbnail: fileId=${thumbnailId}`, unlinkErr);
+                    }
+                } else {
+                    logger.debug(`[Thumbnail] Using cached: fileId=${thumbnailId}, size=${stats.size} bytes`);
+                    // Return cached thumbnail as MediaObject
+                    const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                    return mo;
+                }
             } catch {
                 // File doesn't exist, need to generate it
                 logger.debug(`[Thumbnail] Cache miss: fileId=${thumbnailId}`);
@@ -945,36 +1120,19 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                     deviceId: this.id,
                     fileId: thumbnailId,
                     filePath: videoCachePath,
-                    logger: this.getBaichuanLogger(),
+                    device: this,
                 });
             } else {
-                // Ensure client is connected and logged in (reuses existing connection if available)
-                // This ensures no new sessions are created during thumbnail operations
-                const api = await this.ensureClient();
-
-                if (!api.client.isSocketConnected() || !api.client.loggedIn) {
-                    logger.warn(`[Thumbnail] Client not ready, waiting for connection: fileId=${thumbnailId}`);
-                    // ensureClient should have already handled connection, but wait a bit if needed
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                }
-
-                // Get RTMP URL from fileId
-                // Note: getRecordingPlaybackUrls internally calls login(), but it should be idempotent
-                // if ensureClient() already established the connection
-                const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
-                    fileName: thumbnailId,
-                });
-
-                if (!rtmpVodUrl) {
-                    throw new Error(`No playback URL found for video ${thumbnailId}`);
-                }
+                // Get RTMP URL using the appropriate API (NVR or Baichuan)
+                // Use forThumbnail=true to prefer Download over Playback (better for ffmpeg)
+                const rtmpVodUrl = await this.getVideoClipRtmpUrl(thumbnailId, true);
 
                 // Use the plugin's thumbnail generation queue with RTMP URL
                 thumbnail = await this.plugin.generateThumbnail({
                     deviceId: this.id,
                     fileId: thumbnailId,
                     rtmpUrl: rtmpVodUrl,
-                    logger: this.getBaichuanLogger(),
+                    device: this,
                 });
             }
 
@@ -995,6 +1153,50 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
+    /**
+     * Get RTMP URL for a video clip file
+     * Handles both NVR source (full path) and Device source (filename only)
+     * @param fileId - The file ID or full path
+     * @param forThumbnail - If true, prefer Download over Playback (better for ffmpeg thumbnail extraction)
+     */
+    async getVideoClipRtmpUrl(fileId: string, forThumbnail: boolean = false): Promise<string> {
+        const logger = this.getBaichuanLogger();
+        const { clipsSource } = this.storageSettings.values;
+        const useNvr = clipsSource === "NVR" && this.nvrDevice && fileId.includes('/');
+
+        if (useNvr) {
+            logger.debug(`[getVideoClipRtmpUrl] Using NVR API for fileId="${fileId}", forThumbnail=${forThumbnail}`);
+            const nvrApi = await this.nvrDevice.ensureClient();
+            const channel = this.storageSettings.values.rtspChannel ?? 0;
+
+            try {
+                logger.debug(`[getVideoClipRtmpUrl] Trying getVodUrl with Download requestType...`);
+                const url = await nvrApi.getVodUrl(fileId, channel, {
+                    requestType: "Download",
+                    streamType: "main",
+                });
+                logger.debug(`[getVideoClipRtmpUrl] NVR getVodUrl Download URL received: url="${url || 'none'}"`);
+                if (url) return url;
+            } catch (e: any) {
+                logger.error(`[getVideoClipRtmpUrl] getVodUrl Download failed: ${e.message}`);
+            }
+
+            throw new Error(`No streaming URL found from NVR for file ${fileId} after trying Playback and Download methods`);
+        } else {
+            // Camera standalone: DEVE usare RTMP da Baichuan API
+            logger.debug(`[getVideoClipRtmpUrl] Getting RTMP URL from Baichuan API for fileId="${fileId}" (camera standalone)`);
+            const api = await this.ensureClient();
+            const result = await api.getRecordingPlaybackUrls({
+                fileName: fileId,
+            });
+            logger.debug(`[getVideoClipRtmpUrl] Baichuan RTMP URL received: rtmpVodUrl="${result.rtmpVodUrl || 'none'}"`);
+            if (!result.rtmpVodUrl) {
+                throw new Error(`No RTMP URL found from Baichuan API for file ${fileId}`);
+            }
+            return result.rtmpVodUrl;
+        }
+    }
+
     removeVideoClips(...videoClipIds: string[]): Promise<void> {
         throw new Error("removeVideoClips is not implemented yet.");
     }
@@ -1050,21 +1252,23 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.videoClipsAutoLoadInProgress = true;
 
         try {
-            logger.log('Auto-loading today\'s video clips and thumbnails...');
+            const daysToPreload = this.storageSettings.values.videoclipsDaysToPreload ?? 1;
+            logger.log(`Auto-loading video clips and thumbnails for the last ${daysToPreload} day(s)...`);
 
-            // Get today's date range (start of today to now)
+            // Get date range (start of N days ago to now)
             const now = new Date();
-            const startOfToday = new Date(now);
-            startOfToday.setHours(0, 0, 0, 0);
-            startOfToday.setMinutes(0, 0, 0);
+            const startDate = new Date(now);
+            startDate.setUTCDate(startDate.getUTCDate() - (daysToPreload - 1));
+            startDate.setUTCHours(0, 0, 0, 0);
+            startDate.setUTCMinutes(0, 0, 0);
 
-            // Fetch today's video clips
+            // Fetch video clips for the specified number of days
             const clips = await this.getVideoClips({
-                startTime: startOfToday.getTime(),
+                startTime: startDate.getTime(),
                 endTime: now.getTime(),
             });
 
-            logger.log(`Found ${clips.length} video clips for today`);
+            logger.log(`Found ${clips.length} video clips for the last ${daysToPreload} day(s)`);
 
             const downloadVideoclipsLocally = this.storageSettings.values.downloadVideoclipsLocally ?? false;
 
@@ -2082,11 +2286,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
             let supportedStreams: ReolinkSupportedStream[] = [];
             // Homehub RTMP is not efficient, crashes, offers native streams to not overload the hub
-            if (this.nvrDevice && this.nvrDevice.info.model === 'HOMEHUB') {
-                supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
-            } else {
-                supportedStreams = [...rtspStreams, ...rtmpStreams, ...nativeStreams];
-            }
+            // if (this.nvrDevice && this.nvrDevice.info.model === 'HOMEHUB') {
+            supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
+            // } else {
+            //     supportedStreams = [...rtspStreams, ...rtmpStreams, ...nativeStreams];
+            // }
 
             for (const supportedStream of supportedStreams) {
                 const { id, metadata, url, name, container } = supportedStream;
@@ -2293,7 +2497,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 logger.warn('Failed to connect/refresh during init', e);
             }
         }
-
+        this.storageSettings.settings.clipsSource.hide = !this.nvrDevice;
+        this.storageSettings.settings.clipsSource.defaultValue = this.nvrDevice ? "NVR" : "Device";
 
         this.storageSettings.settings.videoclipsRegularChecks.defaultValue = this.isBattery ? 120 : 30;
 

package/src/main.ts

@@ -12,7 +12,8 @@ interface ThumbnailRequest {
     fileId: string;
     rtmpUrl?: string;
     filePath?: string;
-    logger: Console;
+    logger?: Console;
+    device?: CommonCameraMixin;
     resolve: (mo: MediaObject) => void;
     reject: (error: Error) => void;
 }
@@ -22,7 +23,8 @@ interface ThumbnailRequestInput {
     fileId: string;
     rtmpUrl?: string;
     filePath?: string;
-    logger: Console;
+    logger?: Console;
+    device?: CommonCameraMixin;
 }
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
@@ -347,8 +349,9 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
      */
     async generateThumbnail(request: ThumbnailRequestInput): Promise<MediaObject> {
         const queueLength = this.thumbnailQueue.length;
-        const isProcessing = this.thumbnailProcessing;
-        request.logger.log(`[Thumbnail] Adding to queue: fileId=${request.fileId}, queueLength=${queueLength}, processing=${isProcessing}`);
+        // Use device logger if available, otherwise fallback to provided logger
+        const logger = request.device?.getBaichuanLogger?.() || request.logger || console;
+        logger.log(`[Thumbnail] Download start: fileId=${request.fileId}, queuePosition=${queueLength + 1}`);
 
         return new Promise((resolve, reject) => {
             this.thumbnailQueue.push({
@@ -372,10 +375,11 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         while (this.thumbnailQueue.length > 0) {
             const request = this.thumbnailQueue.shift()!;
-            const logger = request.logger;
+            const logger = request.device?.getBaichuanLogger?.() || request.logger || console;
 
             try {
                 const thumbnail = await extractThumbnailFromVideo(request);
+                logger.log(`[Thumbnail] Download completed: fileId=${request.fileId}`);
                 request.resolve(thumbnail);
             } catch (error) {
                 logger.error(`[Thumbnail] Error: fileId=${request.fileId}`, error);