@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.0

package/src/stream-utils.ts

@@ -1,9 +1,9 @@
 import type {
     CompositeStreamPipOptions,
+    NativeVideoStreamVariant,
     ReolinkBaichuanApi,
     Rfc4571TcpServer,
     StreamProfile,
-    VideoType,
 } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 
 import sdk, {
@@ -17,10 +17,11 @@ export interface StreamManagerOptions {
     /**
      * Creates a dedicated Baichuan session for streaming.
      * Required to support concurrent main+ext streams on firmwares where streamType overlaps.
-     * @param profile The stream profile (main, sub, ext) - used to determine if a new client is needed.
+     * @param streamKey The unique stream key (e.g., "composite_default_main", "channel_0_main", etc.)
+     *                  Contains all necessary information (profile, variantType, channel) for stream identification.
      */
-    createStreamClient: (profile?: StreamProfile) => Promise<ReolinkBaichuanApi>;
-    getLogger: () => Console;
+    createStreamClient: (streamKey: string) => Promise<ReolinkBaichuanApi>;
+    logger: Console;
     /**
      * Credentials to include in the TCP stream (username, password).
      * Uses the same credentials as the main connection.
@@ -39,19 +40,38 @@ export function parseStreamProfileFromId(id: string | undefined): StreamProfile
     if (!id)
         return;
 
-    // Handle native stream IDs: native_main, native_sub, native_ext
+    // Handle plain profiles (used by composite parsing: 'main'/'sub'/'ext')
+    if (id === 'main' || id === 'sub' || id === 'ext') {
+        return id as StreamProfile;
+    }
+
+    // Handle native stream IDs: native_main, native_sub, native_ext, native_autotrack_main, native_autotrack_sub, etc.
     if (id.startsWith('native_')) {
-        const profile = id.replace('native_', '');
-        return profile as StreamProfile;
+        const withoutPrefix = id.replace('native_', '');
+        // Extract profile from formats like "main", "sub", "ext", "autotrack_main", "telephoto_sub", etc.
+        // The profile is always the last part after underscore or the whole string if no underscore
+        const parts = withoutPrefix.split('_');
+        const profile = parts[parts.length - 1]; // Take the last part as profile
+        if (profile === 'main' || profile === 'sub' || profile === 'ext') {
+            return profile as StreamProfile;
+        }
+        // If no valid profile found, try to match the whole string
+        if (withoutPrefix === 'main' || withoutPrefix === 'sub' || withoutPrefix === 'ext') {
+            return withoutPrefix as StreamProfile;
+        }
+        return undefined;
     }
 
     // Handle RTMP IDs: main.bcs, sub.bcs, ext.bcs
     if (id.endsWith('.bcs')) {
         const profile = id.replace('.bcs', '');
-        return profile as StreamProfile;
+        if (profile === 'main' || profile === 'sub' || profile === 'ext') {
+            return profile as StreamProfile;
+        }
+        return undefined;
     }
 
-    // Handle RTSP IDs: h264Preview_XX_main, h264Preview_XX_sub
+    // Handle RTSP IDs: h264Preview_XX_main, h264Preview_XX_sub, Preview_03_autotrack, etc.
     if (id.startsWith('h264Preview_')) {
         if (id.endsWith('_main'))
             return 'main';
@@ -59,9 +79,78 @@ export function parseStreamProfileFromId(id: string | undefined): StreamProfile
             return 'sub';
     }
 
+    // Handle RTSP IDs like Preview_03_autotrack, Preview_03_autotrack_sub
+    // These should map to main or sub based on the suffix
+    if (id.includes('Preview_')) {
+        if (id.endsWith('_autotrack_sub') || id.endsWith('_sub')) {
+            return 'sub';
+        }
+        if (id.endsWith('_autotrack') || id.endsWith('_main') || id.match(/Preview_\d+_?[a-z]*$/)) {
+            return 'main';
+        }
+    }
+
     return;
 }
 
+/**
+ * Extract and normalize variant type from stream ID or URL (e.g., "autotrack" from "native_autotrack_main" or "?variant=autotrack")
+ * Returns undefined if no variant is present, or "autotrack"/"telephoto" if present
+ * Note: on Hub/NVR multifocal firmwares, the tele lens is often requested via "telephoto".
+ */
+export function extractVariantFromStreamId(id: string | undefined, url?: string | undefined): 'autotrack' | 'telephoto' | undefined {
+    let variant: string | undefined;
+
+    // First try to extract from ID
+    if (id) {
+        // Handle native stream IDs: native_autotrack_main, native_telephoto_sub, etc.
+        if (id.startsWith('native_')) {
+            const withoutPrefix = id.replace('native_', '');
+            const parts = withoutPrefix.split('_');
+            // If there are more than 1 parts, the first part(s) before the profile is the variant
+            // e.g., "autotrack_main" -> variant: "autotrack", profile: "main"
+            if (parts.length > 1) {
+                const profile = parts[parts.length - 1];
+                // Only return variant if profile is valid (main/sub/ext)
+                if (profile === 'main' || profile === 'sub' || profile === 'ext') {
+                    // Join all parts except the last one as variant (handles multi-part variants)
+                    variant = parts.slice(0, -1).join('_');
+                }
+            }
+        }
+
+        // Handle RTSP IDs like Preview_03_autotrack, Preview_03_autotrack_sub
+        if (!variant && id.includes('Preview_')) {
+            if (id.includes('_autotrack')) {
+                variant = 'autotrack';
+            } else if (id.includes('_telephoto')) {
+                variant = 'telephoto';
+            }
+        }
+    }
+
+    // Fallback: try to extract from URL query parameter
+    if (!variant && url) {
+        try {
+            const urlObj = new URL(url);
+            const variantParam = urlObj.searchParams.get('variant');
+            if (variantParam) {
+                variant = variantParam;
+            }
+        } catch {
+            // Invalid URL, ignore
+        }
+    }
+
+    // Normalize variant: accept "autotrack", "telephoto", or map "default" to undefined
+    if (variant === 'autotrack' || variant === 'telephoto') {
+        // Preserve explicit variants; firmware-specific behavior is handled by the library.
+        return variant as 'autotrack' | 'telephoto';
+    }
+
+    return undefined;
+}
+
 export function selectStreamOption(
     vsos: UrlMediaStreamOptions[] | undefined,
     request: RequestMediaStreamOptions,
@@ -72,39 +161,18 @@ export function selectStreamOption(
     return selected;
 }
 
-export function expectedVideoTypeFromUrlMediaStreamOptions(selected: UrlMediaStreamOptions): 'H264' | 'H265' | undefined {
-    const codec = selected?.video?.codec;
-    if (typeof codec !== 'string') return undefined;
-    if (codec.includes('265')) return 'H265';
-    if (codec.includes('264')) return 'H264';
-    return undefined;
-}
-
 export async function createRfc4571MediaObjectFromStreamManager(params: {
     streamManager: StreamManager;
     channel: number;
     profile: StreamProfile;
     streamKey: string;
-    expectedVideoType?: 'H264' | 'H265';
+    variant?: NativeVideoStreamVariant;
     selected: UrlMediaStreamOptions;
     sourceId: string;
-    onDetectedCodec?: (detectedCodec: 'h264' | 'h265') => void;
 }): Promise<MediaObject> {
-    const { streamManager, channel, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
-
-    const { host, port, sdp, audio, username, password } = await streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
+    const { streamManager, channel, profile, streamKey, variant, selected, sourceId } = params;
 
-    // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
-    try {
-        const detected = /a=rtpmap:\d+\s+(H26[45])\//.exec(sdp)?.[1];
-        if (detected) {
-            const dc = detected === 'H265' ? 'h265' : 'h264';
-            onDetectedCodec?.(dc);
-        }
-    }
-    catch {
-        // ignore
-    }
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcStream(channel, profile, streamKey, variant);
 
     const { url: _ignoredUrl, ...mso }: any = selected;
     mso.container = 'rtp';
@@ -139,26 +207,26 @@ export async function createRfc4571CompositeMediaObjectFromStreamManager(params:
     streamManager: StreamManager;
     profile: StreamProfile;
     streamKey: string;
-    expectedVideoType?: 'H264' | 'H265';
     selected: UrlMediaStreamOptions;
     sourceId: string;
-    onDetectedCodec?: (detectedCodec: 'h264' | 'h265') => void;
+    variantType?: NativeVideoStreamVariant;
 }): Promise<MediaObject> {
-    const { streamManager, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
-
-    const { host, port, sdp, audio, username, password } = await streamManager.getRfcCompositeStream(profile, streamKey, expectedVideoType);
-
-    // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
-    try {
-        const detected = /a=rtpmap:\d+\s+(H26[45])\//.exec(sdp)?.[1];
-        if (detected) {
-            const dc = detected === 'H265' ? 'h265' : 'h264';
-            onDetectedCodec?.(dc);
+    const { streamManager, profile, streamKey, selected, sourceId, variantType } = params;
+
+    // Extract variantType from streamKey if not provided (format: composite_${variantType}_${profile})
+    let extractedVariantType = variantType;
+    if (!extractedVariantType && streamKey.startsWith('composite_')) {
+        const parts = streamKey.split('_');
+        if (parts.length >= 3) {
+            // Format: composite_${variantType}_${profile}
+            const variantPart = parts[1];
+            if (variantPart === 'default' || variantPart === 'autotrack' || variantPart === 'telephoto') {
+                extractedVariantType = variantPart as NativeVideoStreamVariant;
+            }
         }
     }
-    catch {
-        // ignore
-    }
+
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcCompositeStream(profile, streamKey, extractedVariantType);
 
     const { url: _ignoredUrl, ...mso }: any = selected;
     mso.container = 'rtp';
@@ -170,12 +238,18 @@ export async function createRfc4571CompositeMediaObjectFromStreamManager(params:
     }
 
     // Build URL with credentials: tcp://username:password@host:port
-    const encodedUsername = encodeURIComponent(username || '');
-    const encodedPassword = encodeURIComponent(password || '');
-    const url = `tcp://${encodedUsername}:${encodedPassword}@${host}:${port}`;
+    // Keep this consistent with non-composite path (URL object -> JSON string via toJSON()).
+    const urlObj = new URL(`tcp://${host}`);
+    urlObj.port = port.toString();
+    if (username) {
+        urlObj.username = username;
+    }
+    if (password) {
+        urlObj.password = password;
+    }
 
     const rfc = {
-        url,
+        url: urlObj,
         sdp,
         mediaStreamOptions: mso as ResponseMediaStreamOptions,
     };
@@ -199,18 +273,22 @@ export class StreamManager {
     private nativeRfcServerCreatePromises = new Map<string, Promise<RfcServerInfo>>();
 
     constructor(private opts: StreamManagerOptions) {
+        // Ensure logger is always valid
+        if (!this.opts.logger) {
+            this.opts.logger = console;
+        }
     }
 
-    private getLogger() {
-        return this.opts.getLogger();
+    private getLogger(): Console {
+        return this.opts.logger || console;
     }
 
     private async ensureRfcServer(
         streamKey: string,
         profile: StreamProfile,
-        expectedVideoType: 'H264' | 'H265' | undefined,
         options: {
             channel?: number;
+            variant?: NativeVideoStreamVariant;
             compositeOptions?: CompositeStreamPipOptions;
         },
     ): Promise<RfcServerInfo> {
@@ -223,37 +301,28 @@ export class StreamManager {
         // Double-check: if server already exists and is listening, return it immediately
         const existingServer = this.nativeRfcServers.get(streamKey);
         if (existingServer?.server?.listening) {
-            if (!expectedVideoType || existingServer.videoType === expectedVideoType) {
-                return {
-                    host: existingServer.host,
-                    port: existingServer.port,
-                    sdp: existingServer.sdp,
-                    audio: existingServer.audio,
-                    username: existingServer.username || this.opts.credentials.username,
-                    password: existingServer.password || this.opts.credentials.password,
-                };
-            }
+            this.getLogger().log(`Reusing existing RFC4571 server for streamKey=${streamKey} (port=${existingServer.port})`);
+            return {
+                host: existingServer.host,
+                port: existingServer.port,
+                sdp: existingServer.sdp,
+                audio: existingServer.audio,
+                username: existingServer.username || this.opts.credentials.username,
+                password: existingServer.password || this.opts.credentials.password,
+            };
         }
 
         const createPromise = (async () => {
             const cached = this.nativeRfcServers.get(streamKey);
             if (cached?.server?.listening) {
-                if (expectedVideoType && cached.videoType !== expectedVideoType) {
-                    const kind = options.channel === undefined ? 'composite' : 'native';
-                    this.getLogger().warn(
-                        `Native RFC ${kind} cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
-                    );
-                }
-                else {
-                    return {
-                        host: cached.host,
-                        port: cached.port,
-                        sdp: cached.sdp,
-                        audio: cached.audio,
-                        username: cached.username || this.opts.credentials.username,
-                        password: cached.password || this.opts.credentials.password,
-                    };
-                }
+                return {
+                    host: cached.host,
+                    port: cached.port,
+                    sdp: cached.sdp,
+                    audio: cached.audio,
+                    username: cached.username || this.opts.credentials.username,
+                    password: cached.password || this.opts.credentials.password,
+                };
             }
 
             if (cached) {
@@ -266,26 +335,71 @@ export class StreamManager {
                 this.nativeRfcServers.delete(streamKey);
             }
 
-            const api = await this.opts.createStreamClient(profile);
+            const isComposite = options.channel === undefined;
+
+            // For composite streams, MUST use two distinct Baichuan sessions (widerApi and teleApi).
+            // Otherwise cmd_id=3 frames can mix when streamType overlaps (wide/tele alternation/corruption).
+            // Each stream needs its own dedicated socket to avoid frame mixing.
+            // Create separate streamKeys for wider and tele to ensure distinct sockets:
+            // Format: composite_${variantType}_${profile}_wider and composite_${variantType}_${profile}_tele
+            const compositeApis = isComposite
+                ? {
+                    widerApi: await this.opts.createStreamClient(`${streamKey}_wider`),
+                    teleApi: await this.opts.createStreamClient(`${streamKey}_tele`),
+                }
+                : undefined;
+
+            // For non-composite streams, create a single API client
+            // For composite streams, api is still required as baseApi but widerApi and teleApi are used instead
+            // Pass streamKey to createStreamClient - it contains all necessary information (profile, variantType, channel)
+            // For composite streams, streamKey format: composite_${variantType}_${profile}
+            // For regular streams, streamKey format: channel_${channel}_${profile}_${variantType} or similar
+            const api = isComposite
+                ? compositeApis.widerApi // For composite, use widerApi as baseApi (it will be overridden by compositeApis)
+                : await this.opts.createStreamClient(streamKey);
+
             const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
 
-            // Use the same credentials as the main connection
             const { username, password } = this.opts.credentials;
 
             // If connection is shared, don't close it when stream teardown happens
-            const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
-
-            const created = await createRfc4571TcpServer({
-                api,
-                channel: options.channel,
-                profile,
-                logger: this.getLogger(),
-                expectedVideoType: expectedVideoType as VideoType | undefined,
-                closeApiOnTeardown,
-                username,
-                password,
-                ...(options.compositeOptions ? { compositeOptions: options.compositeOptions } : {}),
-            });
+            // For composite, we create dedicated APIs even if the device uses a shared main connection.
+            // Ensure they are closed on teardown.
+            const closeApiOnTeardown = isComposite ? true : !(this.opts.sharedConnection ?? false);
+
+            let created: any;
+            try {
+                const compositeOptions = isComposite
+                    ? {
+                        ...(options.compositeOptions ?? {}),
+                        forceH264: true,
+                    }
+                    : undefined;
+
+                created = await createRfc4571TcpServer({
+                    api,
+                    channel: options.channel,
+                    profile,
+                    variant: options.variant,
+                    logger: this.getLogger(),
+                    closeApiOnTeardown,
+                    username,
+                    password,
+                    // Composite can take a bit longer (ffmpeg warmup + first IDR).
+                    ...(isComposite ? { keyframeTimeoutMs: 20_000, idleTeardownMs: 20_000 } : {}),
+                    ...(compositeOptions ? { compositeOptions } : {}),
+                    ...(compositeApis ? { compositeApis } : {}),
+                });
+            }
+            catch (e) {
+                if (isComposite && closeApiOnTeardown && compositeApis) {
+                    await Promise.allSettled([
+                        compositeApis.widerApi?.close?.(),
+                        compositeApis.teleApi?.close?.(),
+                    ]);
+                }
+                throw e;
+            }
 
             this.nativeRfcServers.set(streamKey, created);
             created.server.once('close', () => {
@@ -316,20 +430,37 @@ export class StreamManager {
         channel: number,
         profile: StreamProfile,
         streamKey: string,
-        expectedVideoType?: 'H264' | 'H265',
+        variant?: NativeVideoStreamVariant,
     ): Promise<RfcServerInfo> {
-        return await this.ensureRfcServer(streamKey, profile, expectedVideoType, {
+        return await this.ensureRfcServer(streamKey, profile, {
             channel,
+            variant,
         });
     }
 
     async getRfcCompositeStream(
         profile: StreamProfile,
         streamKey: string,
-        expectedVideoType?: 'H264' | 'H265',
+        variantType?: NativeVideoStreamVariant,
     ): Promise<RfcServerInfo> {
-        return await this.ensureRfcServer(streamKey, profile, expectedVideoType, {
+        // Extract variantType from streamKey if not provided (format: composite_${variantType}_${profile})
+        let extractedVariantType = variantType;
+        if (!extractedVariantType && streamKey.startsWith('composite_')) {
+            const parts = streamKey.split('_');
+            if (parts.length >= 3) {
+                // Format: composite_${variantType}_${profile}
+                const variantPart = parts[1];
+                if (variantPart === 'default' || variantPart === 'autotrack' || variantPart === 'telephoto') {
+                    extractedVariantType = variantPart as NativeVideoStreamVariant;
+                }
+            }
+        }
+        
+        // Pass variantType to ensureRfcServer so it can be used when creating the stream client
+        // This ensures each variantType gets its own socket
+        return await this.ensureRfcServer(streamKey, profile, {
             channel: undefined, // Undefined channel indicates composite stream
+            variant: extractedVariantType,
             compositeOptions: this.opts.compositeOptions,
         });
     }
@@ -347,7 +478,7 @@ export class StreamManager {
                 try {
                     await server.close(reason || 'connection reset');
                 } catch (e) {
-                    this.getLogger().debug('Error closing stream server', e);
+                    this.getLogger().debug('Error closing stream server', e?.message || String(e));
                 }
             })
         );

package/src/utils.ts

@@ -101,7 +101,7 @@ export const getDeviceInterfaces = (props: {
             interfaces.push(ScryptedInterface.BinarySensor);
         }
     } catch (e) {
-        logger.error('Error getting device interfaces', e);
+        logger.error('Error getting device interfaces', e?.message || String(e));
     }
 
     return { interfaces, type: capabilities.isDoorbell ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera };
@@ -211,7 +211,7 @@ export async function recordingFileToVideoClip(
             thumbnailHref = thumbnailUrl;
             logger?.debug(`[recordingFileToVideoClip] Webhook URLs generated successfully: videoHref="${videoHref}", thumbnailHref="${thumbnailHref}"`);
         } catch (e) {
-            logger?.error(`[recordingFileToVideoClip] Failed to generate webhook URLs for fileId=${id}:`, e);
+            logger?.error(`[recordingFileToVideoClip] Failed to generate webhook URLs for fileId=${id}:`, e?.message || String(e));
         }
     } else if (!videoHref && api) {
         // Fallback to direct RTMP URL if webhook is not used
@@ -223,7 +223,7 @@ export async function recordingFileToVideoClip(
             videoHref = rtmpVodUrl;
             logger?.debug(`[recordingFileToVideoClip] RTMP URL fetched successfully: videoHref="${videoHref}"`);
         } catch (e) {
-            logger?.debug(`[recordingFileToVideoClip] Failed to build playback URL for recording fileName=${rec.fileName}:`, e);
+            logger?.debug(`[recordingFileToVideoClip] Failed to build playback URL for recording fileName=${rec.fileName}:`, e?.message || String(e));
         }
     } else {
         logger?.debug(`[recordingFileToVideoClip] No URL generation: useWebhook=${useWebhook}, hasPlugin=${!!plugin}, deviceId=${deviceId}, providedVideoHref=${providedVideoHref || 'none'}, hasApi=${!!api}`);
@@ -368,7 +368,7 @@ export async function recordingsToVideoClips(
             });
             clips.push(clip);
         } catch (e) {
-            logger?.warn(`Failed to convert recording to video clip: fileName=${rec.fileName}`, e);
+            logger?.warn(`Failed to convert recording to video clip: fileName=${rec.fileName}`, e?.message || String(e));
         }
     }
 
@@ -399,7 +399,7 @@ export async function getVideoClipWebhookUrls(props: {
             // log.debug?.(`[getVideoClipWebhookUrls] Using cloud endpoint: ${endpoint}`);
         } catch (e) {
             // Fallback to local endpoint if cloud is not available (e.g., not logged in)
-            log.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?.message || String(e)}`);
             endpoint = await sdk.endpointManager.getLocalEndpoint(undefined, { public: true });
             endpointSource = 'local';
             // log.debug?.(`[getVideoClipWebhookUrls] Using local endpoint: ${endpoint}`);
@@ -428,7 +428,7 @@ export async function getVideoClipWebhookUrls(props: {
     } catch (e) {
         log.error?.(
             `[getVideoClipWebhookUrls] Failed to generate webhook URLs: deviceId=${deviceId}, fileId=${fileId}`,
-            e
+            e?.message || String(e)
         );
         throw e;
     }
@@ -467,7 +467,7 @@ export async function extractThumbnailFromVideo(props: {
         return mo;
     } catch (e) {
         // Error already logged in main.ts
-        throw e;
+        throw e?.message || String(e);
     }
 }
 
@@ -514,7 +514,7 @@ export async function handleVideoClipRequest(props: {
             try {
                 await fs.promises.unlink(cachePath);
             } catch (unlinkErr) {
-                logger.warn(`Failed to delete small cached video clip: fileId=${fileId}`, unlinkErr);
+                logger.warn(`Failed to delete small cached video clip: fileId=${fileId}`, unlinkErr?.message || String(unlinkErr));
             }
             // Force cache miss path below
             throw new Error('Cached video too small, deleted');
@@ -567,7 +567,7 @@ export async function handleVideoClipRequest(props: {
         try {
             rtmpVodUrl = await device.getVideoClipRtmpUrl(fileId);
         } catch (e2) {
-            logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e2);
+            logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e2?.message || String(e2));
             response.send('Failed to get RTMP playback URL', { code: 500 });
             return;
         }
@@ -681,12 +681,12 @@ export async function handleVideoClipRequest(props: {
                                 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);
+                                        logger.error(`FFmpeg stdin error: fileId=${fileId}`, err?.message || String(err));
                                     }
                                 });
 
                                 httpResponse.on('error', (err) => {
-                                    logger.error(`HTTP response error before ffmpeg: fileId=${fileId}`, err);
+                                    logger.error(`HTTP response error before ffmpeg: fileId=${fileId}`, err?.message || String(err));
                                     try {
                                         ffmpeg.kill('SIGKILL');
                                     } catch (e) {
@@ -706,7 +706,7 @@ export async function handleVideoClipRequest(props: {
                                             yield chunk;
                                         }
                                     } catch (e) {
-                                        logger.error(`Error streaming ffmpeg output: fileId=${fileId}`, e);
+                                        logger.error(`Error streaming ffmpeg output: fileId=${fileId}`, e?.message || String(e));
                                         throw e;
                                     } finally {
                                         // Clean up ffmpeg process
@@ -738,7 +738,7 @@ export async function handleVideoClipRequest(props: {
                                 });
 
                                 ffmpeg.on('error', (error) => {
-                                    logger.error(`FFmpeg spawn error: fileId=${fileId}`, error);
+                                    logger.error(`FFmpeg spawn error: fileId=${fileId}`, error?.message || String(error));
                                     reject(error);
                                 });
 
@@ -753,7 +753,7 @@ export async function handleVideoClipRequest(props: {
                                         }
                                         logger.log(`[VideoClip] Stream end: fileId=${fileId}`);
                                     } catch (streamErr) {
-                                        logger.error(`[VideoClip] Stream error: fileId=${fileId}`, streamErr);
+                                        logger.error(`[VideoClip] Stream error: fileId=${fileId}`, streamErr?.message || String(streamErr));
                                         throw streamErr;
                                     }
                                 })(), {
@@ -764,11 +764,11 @@ export async function handleVideoClipRequest(props: {
                                 resolve();
                             }
                         } catch (err) {
-                            logger.error(`Error sending stream: fileId=${fileId}`, err);
+                            logger.error(`Error sending stream: fileId=${fileId}`, err?.message || String(err));
                             reject(err);
                         }
                     }).on('error', (e) => {
-                        logger.error(`Error fetching videoclip: fileId=${fileId}`, e);
+                        logger.error(`Error fetching videoclip: fileId=${fileId}`, e?.message || String(e));
                         reject(e);
                     });
                 });
@@ -778,7 +778,7 @@ export async function handleVideoClipRequest(props: {
                 await sendVideo();
                 return;
             } catch (e) {
-                logger.error(`HTTP proxy error: fileId=${fileId}`, e);
+                logger.error(`HTTP proxy error: fileId=${fileId}`, e?.message || String(e));
                 response.send('Failed to proxy HTTP stream', { code: 500 });
                 return;
             }
@@ -816,7 +816,7 @@ export async function handleVideoClipRequest(props: {
                 }
                 logger.log(`[VideoClip] Stream end: fileId=${fileId}`);
             } catch (e) {
-                logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e);
+                logger.error(`[VideoClip] Stream error: fileId=${fileId}`, e?.message || String(e));
                 throw e;
             } finally {
                 // Clean up ffmpeg process
@@ -844,7 +844,7 @@ export async function handleVideoClipRequest(props: {
         });
 
         ffmpeg.on('error', (error) => {
-            logger.error(`FFmpeg spawn error for video proxy: fileId=${fileId}`, error);
+            logger.error(`FFmpeg spawn error for video proxy: fileId=${fileId}`, error?.message || String(error));
         });
 
         return;