@apocaliss92/scrypted-reolink-native 0.1.8 → 0.1.10

package/src/common.ts

@@ -2,6 +2,7 @@ import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, Reo
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
+import { BaseBaichuanClass, type BaichuanConnectionConfig, type BaichuanConnectionCallbacks } from "./baichuan-base";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
 import { convertDebugLogsToApiOptions, DebugLogDisplayNames, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
@@ -32,27 +33,27 @@ class ReolinkCameraSiren extends ScryptedDeviceBase implements OnOff {
     }
 
     async turnOff(): Promise<void> {
-        this.camera.getLogger().log(`Siren toggle: turnOff (device=${this.nativeId})`);
+        this.camera.getBaichuanLogger().log(`Siren toggle: turnOff (device=${this.nativeId})`);
         this.on = false;
         try {
             await this.camera.setSirenEnabled(false);
-            this.camera.getLogger().log(`Siren toggle: turnOff ok (device=${this.nativeId})`);
+            this.camera.getBaichuanLogger().log(`Siren toggle: turnOff ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getLogger().warn(`Siren toggle: turnOff failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOff failed (device=${this.nativeId})`, e);
             throw e;
         }
     }
 
     async turnOn(): Promise<void> {
-        this.camera.getLogger().log(`Siren toggle: turnOn (device=${this.nativeId})`);
+        this.camera.getBaichuanLogger().log(`Siren toggle: turnOn (device=${this.nativeId})`);
         this.on = true;
         try {
             await this.camera.setSirenEnabled(true);
-            this.camera.getLogger().log(`Siren toggle: turnOn ok (device=${this.nativeId})`);
+            this.camera.getBaichuanLogger().log(`Siren toggle: turnOn ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getLogger().warn(`Siren toggle: turnOn failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOn failed (device=${this.nativeId})`, e);
             throw e;
         }
     }
@@ -64,40 +65,40 @@ class ReolinkCameraFloodlight extends ScryptedDeviceBase implements OnOff, Brigh
     }
 
     async setBrightness(brightness: number): Promise<void> {
-        this.camera.getLogger().log(`Floodlight toggle: setBrightness (device=${this.nativeId} brightness=${brightness})`);
+        this.camera.getBaichuanLogger().log(`Floodlight toggle: setBrightness (device=${this.nativeId} brightness=${brightness})`);
         this.brightness = brightness;
         try {
             await this.camera.setFloodlightState(undefined, brightness);
-            this.camera.getLogger().log(`Floodlight toggle: setBrightness ok (device=${this.nativeId} brightness=${brightness})`);
+            this.camera.getBaichuanLogger().log(`Floodlight toggle: setBrightness ok (device=${this.nativeId} brightness=${brightness})`);
         }
         catch (e) {
-            this.camera.getLogger().warn(`Floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`, e);
             throw e;
         }
     }
 
     async turnOff(): Promise<void> {
-        this.camera.getLogger().log(`Floodlight toggle: turnOff (device=${this.nativeId})`);
+        this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOff (device=${this.nativeId})`);
         this.on = false;
         try {
             await this.camera.setFloodlightState(false);
-            this.camera.getLogger().log(`Floodlight toggle: turnOff ok (device=${this.nativeId})`);
+            this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOff ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getLogger().warn(`Floodlight toggle: turnOff failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOff failed (device=${this.nativeId})`, e);
             throw e;
         }
     }
 
     async turnOn(): Promise<void> {
-        this.camera.getLogger().log(`Floodlight toggle: turnOn (device=${this.nativeId})`);
+        this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOn (device=${this.nativeId})`);
         this.on = true;
         try {
             await this.camera.setFloodlightState(true);
-            this.camera.getLogger().log(`Floodlight toggle: turnOn ok (device=${this.nativeId})`);
+            this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOn ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getLogger().warn(`Floodlight toggle: turnOn failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOn failed (device=${this.nativeId})`, e);
             throw e;
         }
     }
@@ -185,7 +186,7 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
     }
 }
 
-export abstract class CommonCameraMixin extends ScryptedDeviceBase implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom {
+export abstract class CommonCameraMixin extends BaseBaichuanClass implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom {
     storageSettings = new StorageSettings(this, {
         // Basic connection settings
         ipAddress: {
@@ -302,7 +303,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                             // Trigger reconnection
                             await this.ensureClient();
                         } catch (e) {
-                            this.getLogger().warn('Failed to reset client after debug logs change', e);
+                            this.getBaichuanLogger().warn('Failed to reset client after debug logs change', e);
                         }
                     }, 2000);
                 }
@@ -386,7 +387,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     return;
                 }
 
-                const logger = this.getLogger();
+                const logger = this.getBaichuanLogger();
                 logger.log(`PTZ presets: create preset requested (name=${name})`);
 
                 const preset = await this.withBaichuanRetry(async () => {
@@ -427,7 +428,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     throw new Error('No preset selected');
                 }
 
-                const logger = this.getLogger();
+                const logger = this.getBaichuanLogger();
                 logger.log(`PTZ presets: update position requested (presetId=${presetId})`);
 
                 await this.withBaichuanRetry(async () => {
@@ -450,7 +451,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     throw new Error('No preset selected');
                 }
 
-                const logger = this.getLogger();
+                const logger = this.getBaichuanLogger();
                 logger.log(`PTZ presets: delete requested (presetId=${presetId})`);
 
                 await this.withBaichuanRetry(async () => {
@@ -482,13 +483,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     protected lastNetPortCacheAttempt: number = 0;
     protected netPortCacheBackoffMs: number = 5000; // 5 seconds backoff on failure
 
-    // Client management
-    protected baichuanApi: ReolinkBaichuanApi | undefined;
-    protected ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
-    protected connectionTime: number | undefined;
-    private closeListener?: () => void;
-    private lastDisconnectTime: number = 0;
-    private readonly reconnectBackoffMs: number = 2000; // 2 seconds minimum between reconnects
+    // Client management (inherited from BaseBaichuanClass)
     protected readonly protocol: BaichuanTransport;
     private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
@@ -516,6 +511,60 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             await this.parentInit();
         }, 2000);
     }
+
+    // BaseBaichuanClass abstract methods implementation
+    protected getConnectionConfig(): BaichuanConnectionConfig {
+        const { ipAddress, username, password, uid } = this.storageSettings.values;
+        const debugOptions = this.getBaichuanDebugOptions();
+        const normalizedUid = this.protocol === 'udp' ? normalizeUid(uid) : undefined;
+
+        if (this.protocol === 'udp' && !normalizedUid) {
+            throw new Error('UID is required for battery cameras (BCUDP)');
+        }
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            uid: normalizedUid,
+            transport: this.protocol,
+            logger: this.console,
+            debugOptions,
+        };
+    }
+
+    protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
+        return {
+            onError: undefined, // Use default error handling
+            onClose: async () => {
+                // Reset client state on close
+                // The base class already handles cleanup
+            },
+            onSimpleEvent: this.onSimpleEvent,
+            getEventSubscriptionEnabled: () => this.isEventDispatchEnabled?.() ?? false,
+        };
+    }
+
+
+    protected isDebugEnabled(): boolean {
+        return this.isEventLogsEnabled();
+    }
+
+    protected getDeviceName(): string {
+        return this.name || 'Camera';
+    }
+
+    protected async onBeforeCleanup(): Promise<void> {
+        // Unsubscribe from events if needed
+        if (this.onSimpleEvent && this.baichuanApi) {
+            try {
+                this.baichuanApi.offSimpleEvent(this.onSimpleEvent);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
     createStreamClient(): Promise<ReolinkBaichuanApi> {
         throw new Error("Method not implemented.");
     }
@@ -524,10 +573,6 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         return this.storageSettings.values.capabilities;
     }
 
-    getLogger(): Console {
-        return this.console;
-    }
-
     getBaichuanDebugOptions(): any | undefined {
         const debugLogs = this.storageSettings.values.debugLogs || [];
         return convertDebugLogsToApiOptions(debugLogs);
@@ -557,14 +602,10 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
     // Event subscription methods
     unsubscribedToEvents(): void {
-        const api = (this as any).baichuanApi;
-        if (!api) return;
-        try {
-            api.offSimpleEvent(this.onSimpleEvent);
-        }
-        catch {
+        // Use base class unsubscribe
+        this.unsubscribeFromEvents().catch(() => {
             // ignore
-        }
+        });
 
         if (this.motionDetected) {
             this.motionDetected = false;
@@ -573,24 +614,18 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
     onSimpleEvent = (ev: ReolinkSimpleEvent) => {
         try {
-            const logger = this.getLogger();
+            const logger = this.getBaichuanLogger();
 
-            if (this.isEventLogsEnabled()) {
-                logger.log(`Baichuan event: ${JSON.stringify(ev)}`);
-            }
+            logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
 
             if (!this.isEventDispatchEnabled()) {
-                if (this.isEventLogsEnabled()) {
-                    logger.debug('Event dispatch is disabled, ignoring event');
-                }
+                logger.debug('Event dispatch is disabled, ignoring event');
                 return;
             }
 
             const channel = this.storageSettings.values.rtspChannel;
             if (ev?.channel !== undefined && ev.channel !== channel) {
-                if (this.isEventLogsEnabled()) {
-                    logger.debug(`Event channel ${ev.channel} does not match camera channel ${channel}, ignoring`);
-                }
+                logger.error(`Event channel ${ev.channel} does not match camera channel ${channel}, ignoring`);
                 return;
             }
 
@@ -600,9 +635,6 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             switch (ev?.type) {
                 case 'motion':
                     motion = true;
-                    if (this.isEventLogsEnabled()) {
-                        logger.log(`Motion event received (may be PIR or MD)`);
-                    }
                     break;
                 case 'doorbell':
                     this.handleDoorbellEvent();
@@ -618,9 +650,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     motion = true;
                     break;
                 default:
-                    if (this.isEventLogsEnabled()) {
-                        logger.debug(`Unknown event type: ${ev?.type}`);
-                    }
+                    logger.error(`Unknown event type: ${ev?.type}`);
                     return;
             }
 
@@ -629,7 +659,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             });
         }
         catch (e) {
-            this.getLogger().warn('Error in onSimpleEvent handler', e);
+            this.getBaichuanLogger().warn('Error in onSimpleEvent handler', e);
         }
     }
 
@@ -638,7 +668,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             return;
         }
 
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
         const selection = Array.from(this.getDispatchEventsSelection?.() ?? new Set()).sort();
         const enabled = selection.length > 0;
 
@@ -736,13 +766,13 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         if (preset !== undefined && preset !== null) {
             const presetId = Number(preset);
             if (!Number.isFinite(presetId)) {
-                this.getLogger().warn(`Invalid PTZ preset id: ${preset}`);
+                this.getBaichuanLogger().warn(`Invalid PTZ preset id: ${preset}`);
                 return;
             }
             if (this.ptzPresets) {
                 await this.ptzPresets.moveToPreset(presetId);
             } else {
-                this.getLogger().warn('PTZ presets not available');
+                this.getBaichuanLogger().warn('PTZ presets not available');
             }
             return;
         }
@@ -777,14 +807,14 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
             const step = Number(this.storageSettings.values.ptzZoomStep);
             if (!Number.isFinite(step) || step <= 0) {
-                this.getLogger().warn('Invalid PTZ zoom step, using default 0.1');
+                this.getBaichuanLogger().warn('Invalid PTZ zoom step, using default 0.1');
                 return;
             }
 
             // Get current zoom factor and apply step
             const info = await client.getZoomFocus(channel);
             if (!info?.zoom) {
-                this.getLogger().warn('Zoom command requested but camera did not report zoom support.');
+                this.getBaichuanLogger().warn('Zoom command requested but camera did not report zoom support.');
                 return;
             }
 
@@ -1003,7 +1033,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                 deviceData,
             });
         } catch (e) {
-            this.getLogger().warn('Failed to fetch device info', e);
+            this.getBaichuanLogger().warn('Failed to fetch device info', e);
         }
     }
 
@@ -1092,7 +1122,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     const sirenState = await api.getSiren(channel);
                     this.siren.on = sirenState.enabled;
                 } catch (e) {
-                    this.getLogger().debug('Failed to align siren state', e);
+                    this.getBaichuanLogger().debug('Failed to align siren state', e);
                 }
             }
 
@@ -1105,7 +1135,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                         this.floodlight.brightness = wl.brightness;
                     }
                 } catch (e) {
-                    this.getLogger().debug('Failed to align floodlight state', e);
+                    this.getBaichuanLogger().debug('Failed to align floodlight state', e);
                 }
             }
 
@@ -1129,11 +1159,11 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                         }
                     }
                 } catch (e) {
-                    this.getLogger().debug('Failed to align PIR state', e);
+                    this.getBaichuanLogger().debug('Failed to align PIR state', e);
                 }
             }
         } catch (e) {
-            this.getLogger().debug('Failed to align auxiliary devices state', e);
+            this.getBaichuanLogger().debug('Failed to align auxiliary devices state', e);
         }
     }
 
@@ -1163,7 +1193,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             return url.toString();
         } catch (e) {
             // If URL parsing fails, return original URL
-            this.getLogger().warn('Failed to parse URL for credentials', e);
+            this.getBaichuanLogger().warn('Failed to parse URL for credentials', e);
             return rtspUrl;
         }
     }
@@ -1204,7 +1234,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         } catch (e) {
             // Only log if it's not a recoverable error to avoid spam
             if (!this.isRecoverableBaichuanError?.(e)) {
-                this.getLogger().warn('Failed to get net port, using defaults', e);
+                this.getBaichuanLogger().warn('Failed to get net port, using defaults', e);
             }
             // Use defaults if we can't get the ports
             this.cachedNetPort = {
@@ -1215,7 +1245,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async getVideoStreamOptions(): Promise<UrlMediaStreamOptions[]> {
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
 
         if (this.cachedVideoStreamOptions?.length) {
             return this.cachedVideoStreamOptions;
@@ -1260,7 +1290,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
 
         if (streams.length) {
-            logger.log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
+            this.getBaichuanLogger().log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
             this.cachedVideoStreamOptions = streams;
             return streams;
         }
@@ -1333,165 +1363,11 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     async ensureClient(): Promise<ReolinkBaichuanApi> {
         // If camera is connected to NVR, use NVR's shared Baichuan connection
         if (this.nvrDevice) {
-            const logger = this.getLogger();
             return await this.nvrDevice.ensureBaichuanClient();
         }
 
-        // Reuse existing client if socket is still connected and logged in
-        if (this.baichuanApi && this.baichuanApi.client.isSocketConnected() && this.baichuanApi.client.loggedIn) {
-            return this.baichuanApi;
-        }
-
-        // Prevent concurrent login storms
-        if (this.ensureClientPromise) return await this.ensureClientPromise;
-
-        // Apply backoff to avoid aggressive reconnection after disconnection
-        if (this.lastDisconnectTime > 0) {
-            const timeSinceDisconnect = Date.now() - this.lastDisconnectTime;
-            if (timeSinceDisconnect < this.reconnectBackoffMs) {
-                const waitTime = this.reconnectBackoffMs - timeSinceDisconnect;
-                const logger = this.getLogger();
-                logger.log(`[BaichuanClient] Waiting ${waitTime}ms before reconnection (backoff)`);
-                await new Promise(resolve => setTimeout(resolve, waitTime));
-            }
-        }
-
-        this.ensureClientPromise = (async () => {
-            const { ipAddress, username, password, uid } = this.storageSettings.values;
-
-            // Only tear down previous session if it exists and is not connected
-            if (this.baichuanApi) {
-                // Remove close listener from old client
-                if (this.closeListener) {
-                    try {
-                        this.baichuanApi.client.off("close", this.closeListener);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    this.closeListener = undefined;
-                }
-
-                const isConnected = this.baichuanApi.client.isSocketConnected();
-                if (!isConnected) {
-                    try {
-                        this.baichuanApi.offSimpleEvent(this.onSimpleEvent);
-                    }
-                    catch {
-                        // ignore
-                    }
-
-                    try {
-                        await this.baichuanApi.close();
-                    }
-                    catch {
-                        // ignore
-                    }
-                } else {
-                    // Socket is still connected, just re-attach event handler if needed
-                    if (this.isEventDispatchEnabled?.() && this.onSimpleEvent) {
-                        try {
-                            this.baichuanApi.offSimpleEvent(this.onSimpleEvent);
-                            this.baichuanApi.onSimpleEvent(this.onSimpleEvent);
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                    // Reuse existing client
-                    this.connectionTime = Date.now();
-                    return this.baichuanApi;
-                }
-            }
-
-            // Create new client
-            const debugOptions = this.getBaichuanDebugOptions();
-            const normalizedUid = this.protocol === 'udp' ? normalizeUid(uid) : undefined;
-
-            if (this.protocol === 'udp' && !normalizedUid) {
-                throw new Error('UID is required for battery cameras (BCUDP)');
-            }
-
-            const api = await createBaichuanApi(
-                {
-                    inputs: {
-                        host: ipAddress,
-                        username: username,
-                        password: password,
-                        uid: normalizedUid,
-                        logger: this.console,
-                        debugOptions,
-                    },
-                    transport: this.protocol,
-                    logger: this.console,
-                }
-            );
-            await api.login();
-
-            // Verify socket is connected before returning
-            if (!api.client.isSocketConnected()) {
-                throw new Error('Socket not connected after login');
-            }
-
-            this.baichuanApi = api;
-            this.connectionTime = Date.now();
-
-            // Listen for socket disconnection to reset client state
-            // This ensures ensureClient() will create a new connection on next call
-            this.closeListener = () => {
-                const logger = this.getLogger();
-                if (this.baichuanApi === api) {
-                    const now = Date.now();
-                    const timeSinceLastDisconnect = now - this.lastDisconnectTime;
-                    this.lastDisconnectTime = now;
-
-                    logger.log(`[BaichuanClient] Socket closed, resetting client state for reconnection (last disconnect ${timeSinceLastDisconnect}ms ago)`);
-
-                    // Reset client state
-                    this.baichuanApi = undefined;
-                    this.ensureClientPromise = undefined;
-                    this.closeListener = undefined;
-
-                    // Remove event handler to prevent operations during reconnection
-                    try {
-                        if (this.onSimpleEvent) {
-                            api.offSimpleEvent(this.onSimpleEvent);
-                        }
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-            };
-            api.client.on("close", this.closeListener);
-
-            // Re-attach event handler if enabled
-            // Note: We don't reattach here immediately to avoid operations being called
-            // during reconnection. subscribeToEvents() will be called when needed.
-            // However, if events were already subscribed, we need to reattach them.
-            // We'll let subscribeToEvents() handle this, but we can also try here if needed.
-            if (this.isEventDispatchEnabled?.() && this.onSimpleEvent) {
-                try {
-                    // Verify connection is fully ready before subscribing
-                    if (api.client.isSocketConnected() && api.client.loggedIn) {
-                        api.onSimpleEvent(this.onSimpleEvent);
-                    }
-                }
-                catch (e) {
-                    const logger = this.getLogger();
-                    logger.warn(`[BaichuanClient] Failed to reattach event handler after reconnection, will retry via subscribeToEvents()`, e);
-                }
-            }
-            return api;
-        })();
-
-        try {
-            return await this.ensureClientPromise;
-        }
-        finally {
-            // Allow future reconnects and avoid pinning rejected promises
-            this.ensureClientPromise = undefined;
-        }
+        // Use base class implementation
+        return await this.ensureBaichuanClient();
     }
 
     async credentialsChanged(): Promise<void> {
@@ -1515,7 +1391,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
         this.refreshingState = true;
 
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
         const channel = this.storageSettings.values.rtspChannel;
 
         try {
@@ -1543,14 +1419,14 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     info: this.info,
                 };
 
-                logger.log(`Updating device interfaces: ${JSON.stringify(device)}`);
+                this.getBaichuanLogger().log(`Updating device interfaces: ${JSON.stringify(device)}`);
 
                 await sdk.deviceManager.onDeviceDiscovered(device);
             } catch (e) {
-                logger.error('Failed to update device interfaces', e);
+                this.getBaichuanLogger().error('Failed to update device interfaces', e);
             }
 
-            this.console.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
+            this.getBaichuanLogger().log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
         }
         catch (e) {
             logger.error('Failed to refresh abilities', e);
@@ -1560,7 +1436,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async parentInit(): Promise<void> {
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
 
         try {
             await this.ensureClient();
@@ -1612,7 +1488,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
         this.streamManager = new StreamManager({
             createStreamClient: () => this.createStreamClient(),
-            getLogger: () => this.getLogger(),
+            getLogger: () => this.getBaichuanLogger() as Console,
             credentials: {
                 username,
                 password

package/src/connect.ts

@@ -51,7 +51,7 @@ export async function createBaichuanApi(props: {
         host: inputs.host,
         username: inputs.username,
         password: inputs.password,
-        logger: inputs.logger,
+        logger: logger, // Use the logger passed to createBaichuanApi, not inputs.logger
         debugOptions: inputs.debugOptions ?? {}
     };
 
@@ -60,7 +60,6 @@ export async function createBaichuanApi(props: {
         // uncaught exception. Ensure we always have a listener.
         try {
             api.client.on("error", (err: unknown) => {
-                const logger = inputs.logger;
                 if (!logger) return;
                 const msg = (err as any)?.message || (err as any)?.toString?.() || String(err);
                 // Only log if it's not a recoverable error to avoid spam

package/src/debug-options.ts

@@ -60,7 +60,7 @@ export function convertDebugLogsToApiOptions(debugLogs: string[]): DebugOptions
         }
     }
 
-    console.log(debugLogs, apiOptions);
+    // Removed debug log that was causing "[] {}" output
     return Object.keys(apiOptions).length > 0 ? apiOptions : undefined;
 }
 

package/src/intercom.ts

@@ -31,7 +31,7 @@ export class ReolinkBaichuanIntercom {
     }
 
     async start(media: MediaObject): Promise<void> {
-        const logger = this.camera.getLogger();
+        const logger = this.camera.getBaichuanLogger();
 
         const ffmpegInput = await sdk.mediaManager.convertMediaObjectToJSON<FFmpegInput>(
             media,
@@ -177,7 +177,7 @@ export class ReolinkBaichuanIntercom {
         if (this.stopping) return this.stopping;
 
         this.stopping = (async () => {
-            const logger = this.camera.getLogger();
+            const logger = this.camera.getBaichuanLogger();
 
             const ffmpeg = this.ffmpeg;
             this.ffmpeg = undefined;
@@ -243,7 +243,7 @@ export class ReolinkBaichuanIntercom {
         bytesNeeded: number,
         blockSize: number,
     ): void {
-        const logger = this.camera.getLogger();
+        const logger = this.camera.getBaichuanLogger();
 
         this.sendChain = this.sendChain
             .then(async () => {