node-red-contrib-homekit-bridged 2.0.0-dev.4 → 2.0.0-dev.5

package/build/lib/api.js

@@ -94,7 +94,7 @@ module.exports = (RED) => {
                 }
             }
             catch (e) {
-                console.error(e);
+                log.error(e);
             }
         }
         else if (releaseVersionFound) {
@@ -108,7 +108,7 @@ module.exports = (RED) => {
                 }
             }
             catch (e) {
-                console.error(e);
+                log.error(e);
             }
         }
         else {

package/build/lib/camera/CameraControl.d.ts

@@ -0,0 +1,3 @@
+import { type Accessory } from '@homebridge/hap-nodejs';
+import type CameraConfigType from '../types/CameraConfigType';
+export declare const configureCamera: (accessory: Accessory, config?: CameraConfigType) => void;

package/build/lib/camera/CameraControl.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCamera = void 0;
+const hap_nodejs_1 = require("@homebridge/hap-nodejs");
+const CameraDelegate_1 = require("./CameraDelegate");
+const configureCamera = (accessory, config) => {
+    const streamDelegate = new CameraDelegate_1.CameraDelegate(accessory, config);
+    const cameraController = new hap_nodejs_1.CameraController({
+        cameraStreamCount: Math.max(1, (config === null || config === void 0 ? void 0 : config.cameraConfigMaxStreams) || 2),
+        delegate: streamDelegate,
+        streamingOptions: {
+            supportedCryptoSuites: [
+                2,
+                0
+            ],
+            video: {
+                codec: {
+                    profiles: [0, 1, 2],
+                    levels: [0, 1, 2]
+                },
+                resolutions: (() => {
+                    const maxW = config === null || config === void 0 ? void 0 : config.cameraConfigMaxWidth;
+                    const maxH = config === null || config === void 0 ? void 0 : config.cameraConfigMaxHeight;
+                    const maxFps = config === null || config === void 0 ? void 0 : config.cameraConfigMaxFPS;
+                    const defaults = [
+                        [1920, 1080, 30],
+                        [1280, 960, 30],
+                        [1280, 720, 30],
+                        [1024, 768, 30],
+                        [640, 480, 30],
+                        [640, 360, 30],
+                        [480, 360, 30],
+                        [480, 270, 30],
+                        [320, 240, 30],
+                        [320, 240, 15],
+                        [320, 180, 30]
+                    ];
+                    return defaults
+                        .filter(([w, h]) => (!maxW || w <= maxW) && (!maxH || h <= maxH))
+                        .map(([w, h, f]) => [w, h, Math.min(f, maxFps || f)]);
+                })()
+            }
+        },
+        recording: {
+            options: {
+                prebufferLength: 4000,
+                mediaContainerConfiguration: {
+                    type: 0,
+                    fragmentLength: 4000
+                },
+                video: {
+                    type: 0,
+                    parameters: {
+                        profiles: [2],
+                        levels: [2]
+                    },
+                    resolutions: [
+                        [320, 180, 30],
+                        [320, 240, 15],
+                        [320, 240, 30],
+                        [480, 270, 30],
+                        [480, 360, 30],
+                        [640, 360, 30],
+                        [640, 480, 30],
+                        [1280, 720, 30],
+                        [1280, 960, 30],
+                        [1920, 1080, 30],
+                        [1600, 1200, 30]
+                    ]
+                },
+                audio: {
+                    codecs: {
+                        type: 1,
+                        audioChannels: 1,
+                        samplerate: 5,
+                        bitrateMode: 0
+                    }
+                }
+            },
+            delegate: streamDelegate
+        },
+        sensors: {
+            motion: true,
+            occupancy: true
+        }
+    });
+    streamDelegate.controller = cameraController;
+    accessory.configureController(cameraController);
+};
+exports.configureCamera = configureCamera;

package/build/lib/camera/CameraDelegate.d.ts

@@ -0,0 +1,38 @@
+import { type ChildProcess } from 'node:child_process';
+import { type Accessory, CameraController, type CameraRecordingConfiguration, type CameraRecordingDelegate, type CameraStreamingDelegate, type HDSProtocolSpecificErrorReason, type PrepareStreamCallback, type PrepareStreamRequest, type RecordingPacket, type SnapshotRequest, type SnapshotRequestCallback, SRTPCryptoSuites, type StreamingRequest, type StreamRequestCallback } from '@homebridge/hap-nodejs';
+import type CameraConfigType from '../types/CameraConfigType';
+import { MP4StreamingServer } from './MP4StreamingServer';
+type SessionInfo = {
+    address: string;
+    videoPort: number;
+    localVideoPort: number;
+    videoCryptoSuite: SRTPCryptoSuites;
+    videoSRTP: Buffer;
+    videoSSRC: number;
+};
+type OngoingSession = {
+    localVideoPort: number;
+    process: ChildProcess;
+};
+export declare class CameraDelegate implements CameraStreamingDelegate, CameraRecordingDelegate {
+    private accessory;
+    private config?;
+    private ffmpegDebugOutput;
+    private log;
+    controller?: CameraController;
+    pendingSessions: Record<string, SessionInfo>;
+    ongoingSessions: Record<string, OngoingSession>;
+    configuration?: CameraRecordingConfiguration;
+    handlingStreamingRequest: boolean;
+    server?: MP4StreamingServer;
+    constructor(accessory: Accessory, config?: CameraConfigType | undefined);
+    handleSnapshotRequest(request: SnapshotRequest, callback: SnapshotRequestCallback): void;
+    prepareStream(request: PrepareStreamRequest, callback: PrepareStreamCallback): void;
+    handleStreamRequest(request: StreamingRequest, callback: StreamRequestCallback): void;
+    updateRecordingActive(active: boolean): void;
+    updateRecordingConfiguration(configuration: CameraRecordingConfiguration | undefined): void;
+    handleRecordingStreamRequest(_streamId: number): AsyncGenerator<RecordingPacket>;
+    closeRecordingStream(streamId: number, reason?: HDSProtocolSpecificErrorReason): void;
+    acknowledgeStream(streamId: number): void;
+}
+export {};

package/build/lib/camera/CameraDelegate.js

@@ -0,0 +1,430 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraDelegate = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_child_process_1 = require("node:child_process");
+const hap_nodejs_1 = require("@homebridge/hap-nodejs");
+const logger_1 = require("@nrchkb/logger");
+const MP4StreamingServer_1 = require("./MP4StreamingServer");
+const FFMPEGH264ProfileNames = ['baseline', 'main', 'high'];
+const FFMPEGH264LevelNames = ['3.1', '3.2', '4.0'];
+const ports = new Set();
+function getPort() {
+    for (let i = 5011;; i++) {
+        if (!ports.has(i)) {
+            ports.add(i);
+            return i;
+        }
+    }
+}
+class CameraDelegate {
+    constructor(accessory, config) {
+        this.accessory = accessory;
+        this.config = config;
+        this.ffmpegDebugOutput = false;
+        this.log = (0, logger_1.logger)('NRCHKB', 'CameraDelegate');
+        this.pendingSessions = {};
+        this.ongoingSessions = {};
+        this.handlingStreamingRequest = false;
+        try {
+            const name = (accessory === null || accessory === void 0 ? void 0 : accessory.displayName) || (accessory === null || accessory === void 0 ? void 0 : accessory.UUID) || 'UnknownAccessory';
+            this.log = (0, logger_1.logger)('NRCHKB', 'CameraDelegate', name);
+        }
+        catch (_) {
+        }
+    }
+    handleSnapshotRequest(request, callback) {
+        var _a, _b, _c, _d, _e;
+        const ffmpegPath = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.cameraConfigVideoProcessor) || 'ffmpeg';
+        const stillSource = (_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.cameraConfigStillImageSource) === null || _c === void 0 ? void 0 : _c.trim();
+        const mainSource = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.cameraConfigSource) === null || _e === void 0 ? void 0 : _e.trim();
+        let imageSource;
+        if (stillSource) {
+            imageSource = stillSource;
+        }
+        else if (mainSource) {
+            imageSource = mainSource;
+        }
+        else {
+            imageSource = `-f lavfi -i testsrc=s=${request.width}x${request.height}`;
+        }
+        const ffmpegCommand = `${imageSource} -t 1 -s ${request.width}x${request.height} -f image2 -`;
+        const ffmpeg = (0, node_child_process_1.spawn)(ffmpegPath, ffmpegCommand.split(' '), {
+            env: process.env
+        });
+        const snapshotBuffers = [];
+        ffmpeg.stdout.on('data', (data) => snapshotBuffers.push(data));
+        ffmpeg.stderr.on('data', (data) => {
+            var _a;
+            if (this.ffmpegDebugOutput || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.cameraConfigDebug)) {
+                this.log.debug(`SNAPSHOT: ${String(data)}`);
+            }
+        });
+        ffmpeg.on('exit', (code, signal) => {
+            if (signal) {
+                this.log.error(`Snapshot process was killed with signal: ${signal}`);
+                callback(new Error(`killed with signal ${signal}`));
+            }
+            else if (code === 0) {
+                this.log.debug(`Successfully captured snapshot at ${request.width}x${request.height}`);
+                callback(undefined, Buffer.concat(snapshotBuffers));
+            }
+            else {
+                this.log.error(`Snapshot process exited with code ${code}`);
+                callback(new Error(`Snapshot process exited with code ${code}`));
+            }
+        });
+    }
+    prepareStream(request, callback) {
+        const sessionId = request.sessionID;
+        const targetAddress = request.targetAddress;
+        const video = request.video;
+        const videoCryptoSuite = video.srtpCryptoSuite;
+        const videoSrtpKey = video.srtp_key;
+        const videoSrtpSalt = video.srtp_salt;
+        const videoSSRC = hap_nodejs_1.CameraController.generateSynchronisationSource();
+        const localPort = getPort();
+        const sessionInfo = {
+            address: targetAddress,
+            videoPort: video.port,
+            localVideoPort: localPort,
+            videoCryptoSuite: videoCryptoSuite,
+            videoSRTP: Buffer.concat([videoSrtpKey, videoSrtpSalt]),
+            videoSSRC: videoSSRC
+        };
+        const response = {
+            video: {
+                port: localPort,
+                ssrc: videoSSRC,
+                srtp_key: videoSrtpKey,
+                srtp_salt: videoSrtpSalt
+            }
+        };
+        this.pendingSessions[sessionId] = sessionInfo;
+        callback(undefined, response);
+    }
+    handleStreamRequest(request, callback) {
+        var _a, _b, _c, _d;
+        const sessionId = request.sessionID;
+        switch (request.type) {
+            case "start": {
+                const sessionInfo = this.pendingSessions[sessionId];
+                const video = request.video;
+                const profile = FFMPEGH264ProfileNames[video.profile];
+                const level = FFMPEGH264LevelNames[video.level];
+                const width = video.width;
+                const height = video.height;
+                let fps = video.fps;
+                const payloadType = video.pt;
+                let maxBitrate = video.max_bit_rate;
+                const mtu = video.mtu;
+                const address = sessionInfo.address;
+                const videoPort = sessionInfo.videoPort;
+                const localVideoPort = sessionInfo.localVideoPort;
+                const ssrc = sessionInfo.videoSSRC;
+                const cryptoSuite = sessionInfo.videoCryptoSuite;
+                const videoSRTP = sessionInfo.videoSRTP.toString('base64');
+                const cfg = this.config;
+                const ffmpegPath = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigVideoProcessor) || 'ffmpeg';
+                const source = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigSource) ||
+                    `-f lavfi -i testsrc=s=${width}x${height}:r=${fps}`;
+                const vcodec = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigVideoCodec) || 'libx264';
+                const additional = (_a = cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigAdditionalCommandLine) === null || _a === void 0 ? void 0 : _a.trim();
+                const mapvideo = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigMapVideo) || '0:0';
+                const mapaudio = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigMapAudio) || '0:1';
+                const maxConfigBitrate = cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigMaxBitrate;
+                if (maxConfigBitrate &&
+                    maxConfigBitrate > 0 &&
+                    maxConfigBitrate < maxBitrate) {
+                    maxBitrate = maxConfigBitrate;
+                }
+                const maxConfigFps = cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigMaxFPS;
+                if (maxConfigFps && maxConfigFps > 0 && maxConfigFps < fps) {
+                    fps = maxConfigFps;
+                }
+                const vf = [];
+                if ((cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigVideoFilter) !== null &&
+                    (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigVideoFilter) !== undefined &&
+                    (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigVideoFilter) !== '') {
+                    vf.push(cfg.cameraConfigVideoFilter);
+                    if (cfg.cameraConfigHorizontalFlip)
+                        vf.push('hflip');
+                    if (cfg.cameraConfigVerticalFlip)
+                        vf.push('vflip');
+                }
+                this.log.debug(`Starting video stream (${width}x${height}, ${fps} fps, ${maxBitrate} kbps, ${mtu} mtu)...`);
+                let videoffmpegCommand = `${source} -map ${mapvideo} -vcodec ${vcodec} -pix_fmt yuv420p -r ${fps} -f rawvideo ` +
+                    `${additional ? `${additional} ` : ''}` +
+                    `${vf.length > 0 ? `-vf ${vf.join(',')} ` : ''}` +
+                    `-b:v ${maxBitrate}k -bufsize ${maxBitrate}k -maxrate ${maxBitrate}k ` +
+                    `-profile:v ${profile} -level:v ${level} ` +
+                    `-payload_type ${payloadType} -ssrc ${ssrc} -f rtp `;
+                if (cryptoSuite !== 2) {
+                    let suite;
+                    switch (cryptoSuite) {
+                        case 0:
+                            suite = 'AES_CM_128_HMAC_SHA1_80';
+                            break;
+                        case 1:
+                            suite = 'AES_CM_256_HMAC_SHA1_80';
+                            break;
+                    }
+                    videoffmpegCommand += `-srtp_out_suite ${suite} -srtp_out_params ${videoSRTP} s`;
+                }
+                videoffmpegCommand += `rtp://${address}:${videoPort}?rtcpport=${videoPort}&localrtcpport=${localVideoPort}&pkt_size=${(cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigPacketSize) || mtu}`;
+                const audioEnabled = ((_b = this.config) === null || _b === void 0 ? void 0 : _b.cameraConfigAudio) === true ||
+                    ((_c = this.config) === null || _c === void 0 ? void 0 : _c.cameraConfigAudio) === 'true';
+                let audioffmpegCommand = '';
+                if (audioEnabled) {
+                    const acodec = (cfg === null || cfg === void 0 ? void 0 : cfg.cameraConfigAudioCodec) || 'libfdk_aac';
+                    const abitrate = 32;
+                    const asamplerate = 16;
+                    const apayloadType = 110;
+                    audioffmpegCommand =
+                        ` -map ${mapaudio} -acodec ${acodec} -profile:a aac_eld -flags +global_header -f null -ar ${asamplerate}k -b:a ${abitrate}k -bufsize ${abitrate}k -ac 1 ` +
+                            `-payload_type ${apayloadType} `;
+                }
+                if (this.ffmpegDebugOutput || ((_d = this.config) === null || _d === void 0 ? void 0 : _d.cameraConfigDebug)) {
+                    this.log.debug(`FFMPEG command: ${ffmpegPath} ${videoffmpegCommand}${audioffmpegCommand}`);
+                }
+                const ffmpegVideo = (0, node_child_process_1.spawn)(ffmpegPath, (videoffmpegCommand + audioffmpegCommand).split(' '), {
+                    env: process.env
+                });
+                let started = false;
+                ffmpegVideo.stderr.on('data', (data) => {
+                    var _a;
+                    this.log.debug(data.toString('utf8'));
+                    if (!started) {
+                        started = true;
+                        this.log.debug('FFMPEG: received first frame');
+                        callback();
+                    }
+                    if (this.ffmpegDebugOutput || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.cameraConfigDebug)) {
+                        this.log.debug(`VIDEO: ${String(data)}`);
+                    }
+                });
+                ffmpegVideo.on('error', (error) => {
+                    this.log.error(`[Video] Failed to start video stream: ${error.message}`);
+                    callback(new Error('ffmpeg process creation failed!'));
+                });
+                ffmpegVideo.on('exit', (code, signal) => {
+                    var _a;
+                    const message = '[Video] ffmpeg exited with code: ' +
+                        code +
+                        ' and signal: ' +
+                        signal;
+                    if (code == null || code === 255) {
+                        this.log.debug(`${message} (Video stream stopped!)`);
+                    }
+                    else {
+                        this.log.error(`${message} (error)`);
+                        if (!started) {
+                            callback(new Error(message));
+                        }
+                        else {
+                            (_a = this.controller) === null || _a === void 0 ? void 0 : _a.forceStopStreamingSession(sessionId);
+                        }
+                    }
+                });
+                this.ongoingSessions[sessionId] = {
+                    localVideoPort: localVideoPort,
+                    process: ffmpegVideo
+                };
+                delete this.pendingSessions[sessionId];
+                break;
+            }
+            case "reconfigure":
+                this.log.debug('Received (unsupported) request to reconfigure to: ' +
+                    JSON.stringify(request.video));
+                callback();
+                break;
+            case "stop": {
+                const ongoingSession = this.ongoingSessions[sessionId];
+                if (!ongoingSession) {
+                    callback();
+                    break;
+                }
+                ports.delete(ongoingSession.localVideoPort);
+                try {
+                    ongoingSession.process.kill('SIGKILL');
+                }
+                catch (e) {
+                    this.log.error('Error occurred terminating the video process!');
+                    this.log.error(String(e));
+                }
+                delete this.ongoingSessions[sessionId];
+                this.log.debug('Stopped streaming session!');
+                callback();
+                break;
+            }
+        }
+    }
+    updateRecordingActive(active) {
+        this.log.debug(`Recording active set to ${active}`);
+    }
+    updateRecordingConfiguration(configuration) {
+        this.configuration = configuration;
+        this.log.debug(JSON.stringify(configuration));
+    }
+    handleRecordingStreamRequest(_streamId) {
+        return __asyncGenerator(this, arguments, function* handleRecordingStreamRequest_1() {
+            var _a, e_1, _b, _c;
+            var _d, _e, _f;
+            (0, node_assert_1.default)(!!this.configuration);
+            const STOP_AFTER_MOTION_STOP = false;
+            this.handlingStreamingRequest = true;
+            (0, node_assert_1.default)(this.configuration.videoCodec.type === 0);
+            const profile = this.configuration.videoCodec.parameters.profile === 2
+                ? 'high'
+                : this.configuration.videoCodec.parameters.profile === 1
+                    ? 'main'
+                    : 'baseline';
+            const level = this.configuration.videoCodec.parameters.level === 2
+                ? '4.0'
+                : this.configuration.videoCodec.parameters.level === 1
+                    ? '3.2'
+                    : '3.1';
+            const videoArgs = [
+                '-an',
+                '-sn',
+                '-dn',
+                '-codec:v',
+                'libx264',
+                '-pix_fmt',
+                'yuv420p',
+                '-profile:v',
+                profile,
+                '-level:v',
+                level,
+                '-b:v',
+                `${this.configuration.videoCodec.parameters.bitRate}k`,
+                '-force_key_frames',
+                `expr:eq(t,n_forced*${this.configuration.videoCodec.parameters.iFrameInterval / 1000})`,
+                '-r',
+                this.configuration.videoCodec.resolution[2].toString()
+            ];
+            let samplerate;
+            switch (this.configuration.audioCodec.samplerate) {
+                case 0:
+                    samplerate = '8';
+                    break;
+                case 1:
+                    samplerate = '16';
+                    break;
+                case 2:
+                    samplerate = '24';
+                    break;
+                case 3:
+                    samplerate = '32';
+                    break;
+                case 4:
+                    samplerate = '44.1';
+                    break;
+                case 5:
+                    samplerate = '48';
+                    break;
+                default:
+                    throw new Error('Unsupported audio samplerate: ' +
+                        this.configuration.audioCodec.samplerate);
+            }
+            const audioArgs = ((_e = (_d = this.controller) === null || _d === void 0 ? void 0 : _d.recordingManagement) === null || _e === void 0 ? void 0 : _e.recordingManagementService.getCharacteristic(hap_nodejs_1.Characteristic.RecordingAudioActive))
+                ? [
+                    '-acodec',
+                    'libfdk_aac',
+                    ...(this.configuration.audioCodec.type ===
+                        0
+                        ? ['-profile:a', 'aac_low']
+                        : ['-profile:a', 'aac_eld']),
+                    '-ar',
+                    `${samplerate}k`,
+                    '-b:a',
+                    `${this.configuration.audioCodec.bitrate}k`,
+                    '-ac',
+                    `${this.configuration.audioCodec.audioChannels}`
+                ]
+                : [];
+            this.server = new MP4StreamingServer_1.MP4StreamingServer('ffmpeg', `-f lavfi -i \
+      testsrc=s=${this.configuration.videoCodec.resolution[0]}x${this.configuration.videoCodec.resolution[1]}:r=${this.configuration.videoCodec.resolution[2]}`.split(/ /g), audioArgs, videoArgs);
+            yield __await(this.server.start());
+            if (!this.server || this.server.destroyed) {
+                return yield __await(void 0);
+            }
+            const pending = [];
+            try {
+                try {
+                    for (var _g = true, _h = __asyncValues(this.server.generator()), _j; _j = yield __await(_h.next()), _a = _j.done, !_a; _g = true) {
+                        _c = _j.value;
+                        _g = false;
+                        const box = _c;
+                        pending.push(box.header, box.data);
+                        const motionDetected = (_f = this.accessory
+                            .getService(hap_nodejs_1.Service.MotionSensor)) === null || _f === void 0 ? void 0 : _f.getCharacteristic(hap_nodejs_1.Characteristic.MotionDetected).value;
+                        this.log.debug(`mp4 box type ${box.type} and length ${box.length}`);
+                        if (box.type === 'moov' || box.type === 'mdat') {
+                            const fragment = Buffer.concat(pending);
+                            pending.splice(0, pending.length);
+                            const isLast = STOP_AFTER_MOTION_STOP && !motionDetected;
+                            yield yield __await({
+                                data: fragment,
+                                isLast: isLast
+                            });
+                            if (isLast) {
+                                this.log.debug('Ending session due to motion stopped!');
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_g && !_a && (_b = _h.return)) yield __await(_b.call(_h));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                if (!error.message.startsWith('FFMPEG')) {
+                    this.log.error(`Encountered unexpected error on generator ${error.stack}`);
+                }
+            }
+        });
+    }
+    closeRecordingStream(streamId, reason) {
+        if (reason) {
+            this.log.error(`Closing stream ${streamId} due to error: ${reason}`);
+        }
+        if (this.server) {
+            this.server.destroy();
+            this.server = undefined;
+        }
+        this.handlingStreamingRequest = false;
+    }
+    acknowledgeStream(streamId) {
+        this.closeRecordingStream(streamId);
+    }
+}
+exports.CameraDelegate = CameraDelegate;

package/build/lib/camera/MP4StreamingServer.d.ts

@@ -0,0 +1,26 @@
+import { type ChildProcess } from 'node:child_process';
+import { type Server, type Socket } from 'node:net';
+interface MP4Atom {
+    header: Buffer;
+    length: number;
+    type: string;
+    data: Buffer;
+}
+export declare class MP4StreamingServer {
+    readonly server: Server;
+    readonly debugMode: boolean;
+    readonly ffmpegPath: string;
+    readonly args: string[];
+    socket?: Socket;
+    childProcess?: ChildProcess;
+    destroyed: boolean;
+    connectPromise: Promise<void>;
+    connectResolve?: () => void;
+    constructor(ffmpegPath: string, ffmpegInput: Array<string>, audioOutputArgs: Array<string>, videoOutputArgs: Array<string>);
+    start(): Promise<void>;
+    destroy(): void;
+    handleConnection(socket: Socket): void;
+    generator(): AsyncGenerator<MP4Atom>;
+    read(length: number): Promise<Buffer>;
+}
+export {};

package/build/lib/camera/MP4StreamingServer.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MP4StreamingServer = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_events_1 = require("node:events");
+const node_net_1 = require("node:net");
+const logger_1 = require("@nrchkb/logger");
+const log = (0, logger_1.logger)('NRCHKB', 'MP4StreamingServer');
+class MP4StreamingServer {
+    constructor(ffmpegPath, ffmpegInput, audioOutputArgs, videoOutputArgs) {
+        this.debugMode = false;
+        this.destroyed = false;
+        this.connectPromise = new Promise((resolve) => {
+            this.connectResolve = resolve;
+        });
+        this.server = (0, node_net_1.createServer)(this.handleConnection.bind(this));
+        this.ffmpegPath = ffmpegPath;
+        this.args = [];
+        this.args.push(...ffmpegInput);
+        this.args.push(...audioOutputArgs);
+        this.args.push('-f', 'mp4');
+        this.args.push(...videoOutputArgs);
+        this.args.push('-fflags', '+genpts', '-reset_timestamps', '1');
+        this.args.push('-movflags', 'frag_keyframe+empty_moov+default_base_moof');
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const promise = (0, node_events_1.once)(this.server, 'listening');
+            this.server.listen();
+            yield promise;
+            if (this.destroyed) {
+                return;
+            }
+            const port = this.server.address().port;
+            this.args.push(`tcp://127.0.0.1:${port}`);
+            log.debug(`${this.ffmpegPath} ${this.args.join(' ')}`);
+            this.childProcess = (0, node_child_process_1.spawn)(this.ffmpegPath, this.args, {
+                env: process.env,
+                stdio: this.debugMode ? 'pipe' : 'ignore'
+            });
+            if (!this.childProcess) {
+                log.error('ChildProcess is undefined directly after the init!');
+            }
+            if (this.debugMode) {
+                (_a = this.childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => log.debug(data.toString()));
+                (_b = this.childProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => log.debug(data.toString()));
+            }
+        });
+    }
+    destroy() {
+        var _a, _b;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.childProcess) === null || _b === void 0 ? void 0 : _b.kill();
+        this.socket = undefined;
+        this.childProcess = undefined;
+        this.destroyed = true;
+    }
+    handleConnection(socket) {
+        var _a;
+        this.server.close();
+        this.socket = socket;
+        (_a = this.connectResolve) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    generator() {
+        return __asyncGenerator(this, arguments, function* generator_1() {
+            yield __await(this.connectPromise);
+            if (!this.socket || !this.childProcess) {
+                log.error('Socket undefined ' +
+                    !!this.socket +
+                    ' childProcess undefined ' +
+                    !!this.childProcess);
+                throw new Error('Unexpected state!');
+            }
+            while (true) {
+                const header = yield __await(this.read(8));
+                const length = header.readInt32BE(0) - 8;
+                const type = header.subarray(4).toString();
+                const data = yield __await(this.read(length));
+                yield yield __await({
+                    header: header,
+                    length: length,
+                    type: type,
+                    data: data
+                });
+            }
+        });
+    }
+    read(length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.socket) {
+                throw Error('FFMPEG tried reading from closed socket!');
+            }
+            if (!length) {
+                return Buffer.alloc(0);
+            }
+            const value = this.socket.read(length);
+            if (value) {
+                return value;
+            }
+            return new Promise((resolve, reject) => {
+                const readHandler = () => {
+                    var _a;
+                    const value = (_a = this.socket) === null || _a === void 0 ? void 0 : _a.read(length);
+                    if (value) {
+                        cleanup();
+                        resolve(value);
+                    }
+                };
+                const endHandler = () => {
+                    cleanup();
+                    reject(new Error(`FFMPEG socket closed during read for ${length} bytes!`));
+                };
+                const cleanup = () => {
+                    var _a, _b;
+                    (_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeListener('readable', readHandler);
+                    (_b = this.socket) === null || _b === void 0 ? void 0 : _b.removeListener('close', endHandler);
+                };
+                if (!this.socket) {
+                    throw new Error('FFMPEG socket is closed now!');
+                }
+                this.socket.on('readable', readHandler);
+                this.socket.on('close', endHandler);
+            });
+        });
+    }
+}
+exports.MP4StreamingServer = MP4StreamingServer;

package/build/lib/utils/ServiceUtils.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const util = __importStar(require("node:util"));
 const hap_nodejs_1 = require("@homebridge/hap-nodejs");
 const logger_1 = require("@nrchkb/logger");
+const CameraControl_1 = require("../camera/CameraControl");
 const NRCHKBError_1 = __importDefault(require("../NRCHKBError"));
 module.exports = (node) => {
     const log = (0, logger_1.logger)('NRCHKB', 'ServiceUtils', node.config.name, node);
@@ -267,13 +268,14 @@ module.exports = (node) => {
         }
         return service;
     };
-    const configureCameraSource = (_accessory, _service, config) => {
+    const configureCameraSource = (accessory, _service, config) => {
         if (config.cameraConfigSource) {
             log.debug('Configuring Camera Source');
             if (!config.cameraConfigVideoProcessor) {
                 log.error('Missing configuration for CameraControl: videoProcessor cannot be empty!');
             }
             else {
+                (0, CameraControl_1.configureCamera)(accessory, config);
             }
         }
         else {

package/build/lib/utils/ServiceUtils2.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const hap_nodejs_1 = require("@homebridge/hap-nodejs");
 const logger_1 = require("@nrchkb/logger");
+const CameraControl_1 = require("../camera/CameraControl");
 const NRCHKBError_1 = __importDefault(require("../NRCHKBError"));
 const Storage_1 = require("../Storage");
 module.exports = (node) => {
@@ -254,13 +255,14 @@ module.exports = (node) => {
         }
         return service;
     };
-    const configureCameraSource = (_accessory, _service, config) => {
+    const configureCameraSource = (accessory, _service, config) => {
         if (config.cameraConfigSource) {
             log.debug('Configuring Camera Source');
             if (!config.cameraConfigVideoProcessor) {
                 log.error('Missing configuration for CameraControl: videoProcessor cannot be empty!');
             }
             else {
+                (0, CameraControl_1.configureCamera)(accessory, config);
             }
         }
         else {

package/build/nodes/nrchkb.js

@@ -83,11 +83,11 @@ module.exports = (RED) => {
             log.error('node-red restart highly recommended');
             log.trace(error);
         }
-        if (process.env.NRCHKB_EXPERIMENTAL === 'true') {
-            log.debug('Registering nrchkb type');
-            RED.nodes.registerType('nrchkb', function (config) {
-                RED.nodes.createNode(this, config);
-            });
-        }
     });
+    if (process.env.NRCHKB_EXPERIMENTAL === 'true') {
+        log.debug('Registering nrchkb type');
+        RED.nodes.registerType('nrchkb', function (config) {
+            RED.nodes.createNode(this, config);
+        });
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-homekit-bridged",
-  "version": "2.0.0-dev.4",
+  "version": "2.0.0-dev.5",
   "description": "Node-RED nodes to simulate Apple HomeKit devices.",
   "main": "build/nodes/nrchkb.js",
   "scripts": {
@@ -11,7 +11,7 @@
     "test:watch": "vitest",
     "format": "npx @biomejs/biome check --write",
     "lint": "npx @biomejs/biome check",
-    "prepare": "husky install"
+    "prepare": "husky || true"
   },
   "repository": {
     "type": "git",