@apocaliss92/scrypted-reolink-native 0.1.35 → 0.1.37

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 {
@@ -198,6 +200,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.ipAddress = ipAddress;
             device.storageSettings.values.capabilities = capabilities;
             device.storageSettings.values.uid = uid;
+            device.storageSettings.values.discoveryMethod = detection.udpDiscoveryMethod;
 
             return nativeId;
         }
@@ -347,7 +350,9 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
      */
     async generateThumbnail(request: ThumbnailRequestInput): Promise<MediaObject> {
         const queueLength = this.thumbnailQueue.length;
-        request.logger.log(`[Thumbnail] Download start: fileId=${request.fileId}, queuePosition=${queueLength + 1}`);
+        // 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({
@@ -371,11 +376,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] OK: fileId=${request.fileId}`);
+                logger.log(`[Thumbnail] Download completed: fileId=${request.fileId}`);
                 request.resolve(thumbnail);
             } catch (error) {
                 logger.error(`[Thumbnail] Error: fileId=${request.fileId}`, error);

package/src/nvr.ts

@@ -1,9 +1,10 @@
-import type { DeviceInfoResponse, EnrichedRecordingFile, EventsResponse, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { DeviceInfoResponse, EnrichedRecordingFile, EventsResponse, ListNvrRecordingsParams, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { AdoptDevice, Device, DeviceDiscovery, DeviceProvider, DiscoveredDevice, Reboot, ScryptedDeviceType, ScryptedInterface, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
+import { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { normalizeUid } from "./connect";
 import ReolinkNativePlugin from "./main";
 import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
@@ -44,8 +45,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             onPut: async () => await this.reinit()
         },
         diagnosticsRun: {
-            subgroup: 'Diagnostics',
-            title: 'Run NVR Diagnostics',
+            subgroup: 'Advanced',
+            title: 'Run Diagnostics',
             description: 'Collect NVR diagnostics and display results in logs.',
             type: 'button',
             immediate: true,
@@ -53,6 +54,47 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 await this.runNvrDiagnostics();
             },
         },
+        socketApiDebugLogs: {
+            subgroup: 'Advanced',
+            title: 'Socket API Debug Logs',
+            description: 'Enable specific debug logs.',
+            multiple: true,
+            combobox: true,
+            immediate: true,
+            defaultValue: [],
+            choices: getDebugLogChoices(),
+            onPut: async (ov, value) => {
+                const logger = this.getBaichuanLogger();
+                const oldApiOptions = getApiRelevantDebugLogs(ov || []);
+                const newApiOptions = getApiRelevantDebugLogs(value || []);
+
+                const oldSel = new Set(oldApiOptions);
+                const newSel = new Set(newApiOptions);
+
+                const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
+                if (changed) {
+                    // Clear any existing timeout
+                    if (this.debugLogsResetTimeout) {
+                        clearTimeout(this.debugLogsResetTimeout);
+                        this.debugLogsResetTimeout = undefined;
+                    }
+
+                    // Defer reset by 2 seconds to allow settings to settle
+                    this.debugLogsResetTimeout = setTimeout(async () => {
+                        this.debugLogsResetTimeout = undefined;
+                        try {
+                            // Force reconnection with new debug options
+                            this.baichuanApi = undefined;
+                            this.ensureClientPromise = undefined;
+                            // Trigger reconnection
+                            await this.ensureBaichuanClient();
+                        } catch (e) {
+                            logger.warn('Failed to reset client after debug logs change', e);
+                        }
+                    }, 2000);
+                }
+            },
+        },
     });
     plugin: ReolinkNativePlugin;
     nvrApi: ReolinkCgiApi | undefined;
@@ -71,6 +113,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
     private initReinitTimeout: NodeJS.Timeout | undefined;
+    private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
         super(nativeId);
@@ -84,22 +127,28 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         await api.reboot();
     }
 
-    // BaseBaichuanClass abstract methods implementation
     protected getConnectionConfig(): BaichuanConnectionConfig {
         const { ipAddress, username, password } = this.storageSettings.values;
         if (!ipAddress || !username || !password) {
             throw new Error('Missing NVR credentials');
         }
 
+        const debugOptions = this.getBaichuanDebugOptions();
+
         return {
             host: ipAddress,
             username,
             password,
             transport: 'tcp',
-            logger: this.console,
+            debugOptions,
         };
     }
 
+    getBaichuanDebugOptions(): any | undefined {
+        const socketDebugLogs = this.storageSettings.values.socketApiDebugLogs || [];
+        return convertDebugLogsToApiOptions(socketDebugLogs);
+    }
+
     protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
         return {
             onError: undefined, // Use default error handling
@@ -187,29 +236,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         return this.nvrApi;
     }
 
-    /**
-     * List enriched VOD files (with proper parsing and detection info)
-     * This uses the library's enrichVodFile which handles all parsing correctly
-     */
-    async listEnrichedVodFiles(params: {
-        channel: number;
-        start: Date;
-        end: Date;
-        streamType?: "main" | "sub";
-        autoSearchByDay?: boolean;
-        bypassCache?: boolean;
-    }): Promise<Array<EnrichedRecordingFile>> {
-        const api = await this.ensureClient();
-        return await api.listEnrichedVodFiles({
-            channel: params.channel,
-            start: params.start,
-            end: params.end,
-            streamType: params.streamType,
-            autoSearchByDay: params.autoSearchByDay,
-            bypassCache: params.bypassCache,
-        });
-    }
-
     private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
         const logger = this.getBaichuanLogger();
 
@@ -298,15 +324,13 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         logger.log(`Starting NVR diagnostics...`);
 
         try {
-            const cgiApi = await this.ensureClient();
+            const cgiApi = await this.ensureBaichuanClient();
 
             const diagnostics = await cgiApi.collectNvrDiagnostics({
                 logger: this.console,
             });
 
             logger.log(`NVR diagnostics completed successfully.`);
-
-            cgiApi.printNvrDiagnostics(diagnostics, this.console);
         } catch (e) {
             logger.error('Failed to run NVR diagnostics', e);
             throw e;
@@ -427,7 +451,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         const { ipAddress } = this.storageSettings.values;
         try {
-            const api = await this.ensureClient();
+            const api = await this.ensureBaichuanClient();
             const deviceData = await api.getInfo();
 
             await updateDeviceInfo({

package/src/utils.ts

@@ -8,6 +8,25 @@ 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
@@ -186,6 +205,7 @@ export async function recordingFileToVideoClip(
                 deviceId,
                 fileId: id,
                 plugin,
+                logger,
             });
             videoHref = videoUrl;
             thumbnailHref = thumbnailUrl;
@@ -309,6 +329,53 @@ export async function recordingFileToVideoClip(
     };
 }
 
+/**
+ * Convert an array of RecordingFile or EnrichedRecordingFile to VideoClip array
+ * Uses recordingFileToVideoClip for each recording
+ * Handles both NVR (EnrichedRecordingFile) and device standalone (RecordingFile) cases
+ */
+export async function recordingsToVideoClips(
+    recordings: (RecordingFile | EnrichedRecordingFile)[],
+    options: {
+        /** Fallback start date if recording doesn't have one */
+        fallbackStart: Date;
+        /** API instance to get playback URLs (optional, for device standalone recordings) */
+        api?: ReolinkBaichuanApi;
+        /** Logger for debug messages */
+        logger?: Console;
+        /** Plugin instance for generating webhook URLs */
+        plugin?: ScryptedDeviceBase;
+        /** Device ID for webhook URLs */
+        deviceId?: string;
+        /** Use webhook URLs instead of direct RTMP URLs */
+        useWebhook?: boolean;
+        /** Maximum number of clips to return (optional) */
+        count?: number;
+    }
+): Promise<VideoClip[]> {
+    const { fallbackStart, api, logger, plugin, deviceId, useWebhook, count } = options;
+    const clips: VideoClip[] = [];
+
+    for (const rec of recordings) {
+        try {
+            const clip = await recordingFileToVideoClip(rec, {
+                fallbackStart,
+                api,
+                logger,
+                plugin,
+                deviceId,
+                useWebhook,
+            });
+            clips.push(clip);
+        } catch (e) {
+            logger?.warn(`Failed to convert recording to video clip: fileName=${rec.fileName}`, e);
+        }
+    }
+
+    // Apply count limit if specified
+    return count ? clips.slice(0, count) : clips;
+}
+
 /**
  * Generate webhook URLs for video clips
  */
@@ -316,10 +383,12 @@ 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;
 
-    plugin.console.debug(`[getVideoClipWebhookUrls] Starting URL generation: deviceId=${deviceId}, fileId=${fileId}`);
+    // log.debug?.(`[getVideoClipWebhookUrls] Starting URL generation: deviceId=${deviceId}, fileId=${fileId}`);
 
     try {
         let endpoint: string;
@@ -327,13 +396,13 @@ export async function getVideoClipWebhookUrls(props: {
         try {
             endpoint = await sdk.endpointManager.getCloudEndpoint(undefined, { public: true });
             endpointSource = 'cloud';
-            plugin.console.debug(`[getVideoClipWebhookUrls] Using cloud endpoint: ${endpoint}`);
+            // 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(`[getVideoClipWebhookUrls] Cloud endpoint not available, using local endpoint: ${e instanceof Error ? e.message : String(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';
-            plugin.console.debug(`[getVideoClipWebhookUrls] Using local endpoint: ${endpoint}`);
+            // log.debug?.(`[getVideoClipWebhookUrls] Using local endpoint: ${endpoint}`);
         }
 
         const encodedDeviceId = encodeURIComponent(deviceId);
@@ -341,8 +410,6 @@ export async function getVideoClipWebhookUrls(props: {
         const cleanFileId = fileId.startsWith('/') ? fileId.substring(1) : fileId;
         const encodedFileId = encodeURIComponent(cleanFileId);
 
-        plugin.console.debug(`[getVideoClipWebhookUrls] Encoding: deviceId="${deviceId}" -> "${encodedDeviceId}", fileId="${fileId}" -> cleanFileId="${cleanFileId}" -> encodedFileId="${encodedFileId}"`);
-
         // Parse endpoint URL to extract query parameters (for authentication)
         const endpointUrl = new URL(endpoint);
         // Preserve query parameters (e.g., user_token for authentication)
@@ -350,22 +417,19 @@ export async function getVideoClipWebhookUrls(props: {
         // Remove query parameters from the base endpoint URL
         endpointUrl.search = '';
 
-        plugin.console.debug(`[getVideoClipWebhookUrls] Parsed endpoint URL: base="${endpointUrl.toString()}", queryParams="${queryParams}"`);
-
         // Ensure endpoint has trailing slash
         const normalizedEndpoint = endpointUrl.toString().endsWith('/') ? endpointUrl.toString() : `${endpointUrl.toString()}/`;
 
-        plugin.console.debug(`[getVideoClipWebhookUrls] Normalized endpoint: "${normalizedEndpoint}"`);
-
         // Build webhook URLs and append query parameters at the end
         const videoUrl = `${normalizedEndpoint}webhook/video/${encodedDeviceId}/${encodedFileId}${queryParams}`;
         const thumbnailUrl = `${normalizedEndpoint}webhook/thumbnail/${encodedDeviceId}/${encodedFileId}${queryParams}`;
 
-        plugin.console.debug(`[getVideoClipWebhookUrls] Generated URLs: videoUrl="${videoUrl}", thumbnailUrl="${thumbnailUrl}"`);
-
         return { videoUrl, thumbnailUrl };
     } catch (e) {
-        plugin.console.error(`[getVideoClipWebhookUrls] Failed to generate webhook URLs: deviceId=${deviceId}, fileId=${fileId}`, e);
+        log.error?.(
+            `[getVideoClipWebhookUrls] Failed to generate webhook URLs: deviceId=${deviceId}, fileId=${fileId}`,
+            e
+        );
         throw e;
     }
 }
@@ -378,9 +442,12 @@ 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;
@@ -427,12 +494,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
@@ -440,6 +509,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) {
@@ -503,12 +583,12 @@ export async function handleVideoClipRequest(props: {
 
         if (isHttpUrl) {
             // For HTTP URLs (Playback/Download from NVR), do direct HTTP proxy with ranged headers support
-            logger.log(`Proxying HTTP URL directly: fileId=${fileId}, url=${rtmpVodUrl}`);
+            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;
@@ -531,7 +611,7 @@ export async function handleVideoClipRequest(props: {
                         headers: requestHeaders,
                     };
 
-                    logger.log(`Starting HTTP request: ${rtmpVodUrl}, headers: ${JSON.stringify(requestHeaders)}`);
+                    logger.debug(`Starting HTTP request: ${rtmpVodUrl}, headers: ${JSON.stringify(requestHeaders)}`);
 
                     httpModule.get(options, async (httpResponse) => {
                         if (httpResponse.statusCode && httpResponse.statusCode >= 400) {
@@ -547,9 +627,9 @@ export async function handleVideoClipRequest(props: {
 
                         // Check if we need to convert FLV to MP4
                         const isFlv = typeof contentType === 'string' && (contentType === 'video/x-flv' || contentType === 'video/flv');
-                        
+
                         if (isFlv) {
-                            logger.log(`Content-Type is FLV (${contentType}), will convert to MP4 using ffmpeg`);
+                            logger.debug(`Content-Type is FLV (${contentType}), will convert to MP4 using ffmpeg`);
                         }
 
                         const responseHeaders: Record<string, string> = {
@@ -568,11 +648,11 @@ export async function handleVideoClipRequest(props: {
 
                         const statusCode = httpResponse.statusCode || 200;
 
-                        logger.log(`HTTP response received: status=${statusCode}, contentType=${contentType}, contentLength=${contentLength || 'unknown'}`);
+                        logger.debug(`HTTP response received: status=${statusCode}, contentType=${contentType}, contentLength=${contentLength || 'unknown'}`);
 
                         try {
-                        if (isFlv) {
-                            // Convert FLV to MP4 using ffmpeg
+                            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[] = [
@@ -648,10 +728,11 @@ export async function handleVideoClipRequest(props: {
                                 // Handle ffmpeg errors
                                 ffmpeg.on('close', (code) => {
                                     if (code !== 0 && code !== null && !streamStarted) {
-                                        logger.error(`FFmpeg conversion failed: fileId=${fileId}, code=${code}, error=${ffmpegError}`);
+                                        const sanitized = sanitizeFfmpegOutput(ffmpegError);
+                                        logger.error(`FFmpeg conversion failed: fileId=${fileId}, code=${code}, error=${sanitized}`);
                                         reject(new Error(`FFmpeg conversion failed: ${code}`));
                                     } else {
-                                        logger.log(`FFmpeg conversion completed: fileId=${fileId}, code=${code}`);
+                                        logger.debug(`FFmpeg conversion completed: fileId=${fileId}, code=${code}`);
                                         resolve();
                                     }
                                 });
@@ -661,7 +742,7 @@ export async function handleVideoClipRequest(props: {
                                     reject(error);
                                 });
 
-                                logger.log(`FFmpeg conversion started: fileId=${fileId}`);
+                                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
@@ -757,7 +838,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}`);
             }
         });
 
@@ -953,6 +1035,7 @@ export async function vodSearchResultsToVideoClips(
                         deviceId,
                         fileId: fileName,
                         plugin,
+                        logger,
                     });
                     videoHref = videoUrl;
                     thumbnailHref = thumbnailUrl;