ring-client-api 9.25.0-beta.0 → 9.25.0-beta.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [9.25.0-beta.1](https://github.com/dgreif/ring/compare/v9.25.0-beta.0...v9.25.0-beta.1) (2022-02-14)
+
+
+### Features
+
+* use new WebRTC endpoint for live calls ([6e7779f](https://github.com/dgreif/ring/commit/6e7779feef9789583921fc44bab32c099f3026d2))
+
 ## [9.25.0-beta.0](https://github.com/dgreif/ring/compare/v9.24.0...v9.25.0-beta.0) (2022-01-29)
 
 

package/lib/api/live-call.d.ts

@@ -0,0 +1,41 @@
+import { ReplaySubject } from 'rxjs';
+import { RingCamera } from './ring-camera';
+import { Subscribed } from './subscribed';
+import { RtpPacket } from '@koush/werift';
+declare type SpawnInput = string | number;
+export interface FfmpegOptions {
+    input?: SpawnInput[];
+    video?: SpawnInput[] | false;
+    audio?: SpawnInput[];
+    output: SpawnInput[];
+}
+export declare class LiveCall extends Subscribed {
+    private sessionId;
+    private camera;
+    private readonly ws;
+    private readonly onWsOpen;
+    private readonly onMessage;
+    private readonly pc;
+    readonly onCallAnswered: ReplaySubject<void>;
+    readonly onCallEnded: ReplaySubject<void>;
+    private readonly audioSplitter;
+    private readonly videoSplitter;
+    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
+    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
+    constructor(sessionId: string, camera: RingCamera);
+    private handleMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    prepareTranscoder(transcodeVideoStream: boolean, ffmpegInputOptions: SpawnInput[] | undefined, audioPort: number, videoPort: number, sdpInput: string): {
+        ffmpegInputArguments: SpawnInput[];
+        inputSdpLines: string[];
+    };
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    activated: boolean;
+    activate(): Promise<void>;
+    activateCameraSpeaker(): Promise<void>;
+    private sendMessage;
+    private callEnded;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+}
+export {};

package/lib/api/live-call.js

@@ -0,0 +1,201 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveCall = void 0;
+const rtp_utils_1 = require("./rtp-utils");
+const ws_1 = require("ws");
+const rxjs_1 = require("rxjs");
+const peer_connection_1 = require("./peer-connection");
+const util_1 = require("./util");
+const operators_1 = require("rxjs/operators");
+const subscribed_1 = require("./subscribed");
+const camera_utils_1 = require("@homebridge/camera-utils");
+const ffmpeg_1 = require("./ffmpeg");
+class LiveCall extends subscribed_1.Subscribed {
+    constructor(sessionId, camera) {
+        super();
+        this.sessionId = sessionId;
+        this.camera = camera;
+        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.audioSplitter = new camera_utils_1.RtpSplitter();
+        this.videoSplitter = new camera_utils_1.RtpSplitter();
+        this.activated = false;
+        const liveCallSession = (0, rtp_utils_1.parseLiveCallSession)(sessionId);
+        this.pc = new peer_connection_1.PeerConnection();
+        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
+            headers: {
+                API_VERSION: '3.1',
+                API_TOKEN: sessionId,
+                CLIENT_INFO: 'Ring/3.48.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+            },
+        });
+        this.onAudioRtp = this.pc.onAudioRtp;
+        this.onVideoRtp = this.pc.onVideoRtp;
+        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
+        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
+        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
+        this.addSubscriptions(this.onMessage
+            .pipe((0, operators_1.concatMap)((message) => {
+            return this.handleMessage(JSON.parse(message.data));
+        }))
+            .subscribe(), this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
+        }), onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), onClose.subscribe(() => {
+            this.callEnded();
+        }));
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.method) {
+                case 'sdp':
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
+                    this.onCallAnswered.next();
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
+                    });
+                    return;
+            }
+        });
+    }
+    reservePort(bufferPorts = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ports = yield (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
+            return ports[0];
+        });
+    }
+    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, audioPort, videoPort, sdpInput) {
+        const ffmpegInputArguments = [
+            '-hide_banner',
+            '-protocol_whitelist',
+            'pipe,udp,rtp,file,crypto',
+            '-acodec',
+            'libopus',
+            '-f',
+            'sdp',
+            ...(ffmpegInputOptions || []),
+            '-i',
+            sdpInput,
+        ], inputSdpLines = [
+            'v=0',
+            'o=105202070 3747 461 IN IP4 127.0.0.1',
+            's=Talk',
+            'c=IN IP4 127.0.0.1',
+            'b=AS:380',
+            't=0 0',
+            'a=rtcp-xr:rcvr-rtt=all:10000 stat-summary=loss,dup,jitt,TTL voip-metrics',
+            `m=audio ${audioPort} RTP/SAVP 101`,
+            'a=rtpmap:101 OPUS/48000/2',
+            'a=rtcp-fb:101 nack pli',
+            'a=fmtp:101 useinbandfec=1;sprop-stereo=0',
+            'a=rtcp-mux',
+        ];
+        if (transcodeVideoStream) {
+            inputSdpLines.push(`m=video ${videoPort} RTP/SAVP 96`, 'a=rtpmap:96 H264/90000', 'a=rtcp-fb:96 nack', 'a=rtcp-fb:96 nack pli', 'a=fmtp:96 packetization-mode=1;profile-level-id=640029;level-asymmetry-allowed=1', 'a=rtcp-mux');
+            this.addSubscriptions(this.onVideoRtp
+                .pipe((0, operators_1.concatMap)((rtp) => {
+                return this.videoSplitter.send(rtp.serialize(), {
+                    port: videoPort,
+                });
+            }))
+                .subscribe());
+        }
+        this.addSubscriptions(this.onAudioRtp
+            .pipe((0, operators_1.concatMap)((rtp) => {
+            return this.audioSplitter.send(rtp.serialize(), {
+                port: audioPort,
+            });
+        }))
+            .subscribe());
+        return {
+            ffmpegInputArguments,
+            inputSdpLines,
+        };
+    }
+    startTranscoding(ffmpegOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, { ffmpegInputArguments, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, audioPort, videoPort, 'pipe:'), ff = new camera_utils_1.FfmpegProcess({
+                ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
+                    ? ffmpegOptions.video || ['-vcodec', 'copy']
+                    : []), ...(ffmpegOptions.output || [])),
+                ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+                exitCallback: () => this.callEnded(),
+                logLabel: `From Ring (${this.camera.name})`,
+                logger: {
+                    error: util_1.logError,
+                    info: util_1.logDebug,
+                },
+            });
+            this.onCallEnded.subscribe(() => ff.stop());
+            ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
+            // Activate the stream now that ffmpeg is ready to receive
+            yield this.activate();
+        });
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendMessage({ method: 'activate_session' });
+            this.sendMessage({
+                video_enabled: true,
+                audio_enabled: true,
+                method: 'stream_options',
+            });
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendMessage({
+                stealth_mode: false,
+                method: 'camera_options',
+            });
+        });
+    }
+    sendMessage(message) {
+        this.ws.send(JSON.stringify(message));
+    }
+    callEnded() {
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            this.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+        this.audioSplitter.close();
+        this.videoSplitter.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+    sendAudioPacket(rtp) {
+        this.pc.returnAudioTrack.writeRtp(rtp);
+    }
+}
+exports.LiveCall = LiveCall;

package/lib/api/peer-connection.d.ts

@@ -0,0 +1,17 @@
+import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
+import { Subject } from 'rxjs';
+export declare class PeerConnection {
+    pc: RTCPeerConnection;
+    onAudioRtp: Subject<RtpPacket>;
+    onAudioRtcp: Subject<RtcpPacket>;
+    onVideoRtp: Subject<RtpPacket>;
+    onVideoRtcp: Subject<RtcpPacket>;
+    returnAudioTrack: MediaStreamTrack;
+    constructor();
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    close(): void;
+}

package/lib/api/peer-connection.js

@@ -0,0 +1,96 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerConnection = void 0;
+const werift_1 = require("@koush/werift");
+const rxjs_1 = require("rxjs");
+const util_1 = require("./util");
+const debug = false;
+class PeerConnection {
+    constructor() {
+        this.onAudioRtp = new rxjs_1.Subject();
+        this.onAudioRtcp = new rxjs_1.Subject();
+        this.onVideoRtp = new rxjs_1.Subject();
+        this.onVideoRtcp = new rxjs_1.Subject();
+        this.returnAudioTrack = new werift_1.MediaStreamTrack({ kind: 'audio' });
+        const pc = (this.pc = new werift_1.RTCPeerConnection({
+            codecs: {
+                audio: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'audio/opus',
+                        clockRate: 48000,
+                        channels: 2,
+                    }),
+                ],
+                video: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'video/H264',
+                        clockRate: 90000,
+                        rtcpFeedback: [
+                            { type: 'transport-cc' },
+                            { type: 'ccm', parameter: 'fir' },
+                            { type: 'nack' },
+                            { type: 'nack', parameter: 'pli' },
+                            { type: 'goog-remb' },
+                        ],
+                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                    }),
+                ],
+            },
+        })), audioTransceiver = pc.addTransceiver(this.returnAudioTrack, {
+            direction: 'sendrecv',
+        }), videoTransceiver = pc.addTransceiver('video', {
+            direction: 'recvonly',
+        });
+        audioTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onAudioRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onAudioRtcp.next(rtcp);
+            });
+            if (debug) {
+                track.onReceiveRtp.once(() => {
+                    (0, util_1.logInfo)('received first audio packet');
+                });
+            }
+        });
+        videoTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onVideoRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onVideoRtcp.next(rtcp);
+            });
+            track.onReceiveRtp.once(() => {
+                if (debug) {
+                    (0, util_1.logInfo)('received first video packet');
+                }
+                setInterval(() => videoTransceiver.receiver.sendRtcpPLI(track.ssrc), 2000);
+            });
+        });
+    }
+    createAnswer(offer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pc.setRemoteDescription(offer);
+            const answer = yield this.pc.createAnswer();
+            yield this.pc.setLocalDescription(answer);
+            return answer;
+        });
+    }
+    addIceCandidate(candidate) {
+        return this.pc.addIceCandidate(candidate);
+    }
+    close() {
+        this.pc.close().catch(util_1.logError);
+    }
+}
+exports.PeerConnection = PeerConnection;

package/lib/api/ring-camera.d.ts

@@ -7,6 +7,7 @@ import { DeepPartial } from './util';
 import { FfmpegOptions, SipSession } from './sip-session';
 import { SipOptions } from './sip-call';
 import { Subscribed } from './subscribed';
+import { LiveCall } from './live-call';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
@@ -54,6 +55,7 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
+    startLiveCall(): Promise<LiveCall>;
     startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
     private pollForActiveDing;
     private expiredDingIds;

package/lib/api/ring-camera.js

@@ -18,6 +18,7 @@ const camera_utils_1 = require("@homebridge/camera-utils");
 const util_1 = require("./util");
 const sip_session_1 = require("./sip-session");
 const subscribed_1 = require("./subscribed");
+const live_call_1 = require("./live-call");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -231,6 +232,25 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
+    startLiveCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveCall = yield this.restClient
+                .request({
+                method: 'POST',
+                url: this.doorbotUrl('live_call'),
+            })
+                .catch((e) => {
+                var _a;
+                if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 403) {
+                    const errorMessage = `Camera ${this.name} returned 403 when starting a live stream.  This usually indicates that live streaming is blocked by Modes settings.  Check your Ring app and verify that you are able to stream from this camera with the current Modes settings.`;
+                    (0, util_1.logError)(errorMessage);
+                    throw new Error(errorMessage);
+                }
+                throw e;
+            });
+            return new live_call_1.LiveCall(liveCall.data.session_id, this);
+        });
+    }
     startVideoOnDemand() {
         return this.restClient
             .request({
@@ -439,10 +459,11 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     recordToFile(outputPath, duration = 30) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sipSession = yield this.streamVideo({
+            const liveCall = yield this.startLiveCall();
+            yield liveCall.startTranscoding({
                 output: ['-t', duration.toString(), outputPath],
             });
-            yield (0, rxjs_1.firstValueFrom)(sipSession.onCallEnded);
+            yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
         });
     }
     streamVideo(ffmpegOptions) {

package/lib/api/ring-types.d.ts

@@ -688,6 +688,21 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
+export interface LiveCallResponse {
+    ding_id: string;
+    ding_kind: DingKind;
+    device_id: number;
+    device_kind: RingCameraKind;
+    device_description: string;
+    state: DingState;
+    protocol: 'ring_media_server' | unknown;
+    now: number;
+    video_jitter_buffer_ms: number;
+    audio_jitter_buffer_ms: number;
+    data: {
+        session_id: string;
+    };
+}
 export interface AuthTokenResponse {
     access_token: string;
     expires_in: number;

package/lib/api/rtp-utils.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { RtpSplitter, SrtpOptions } from '@homebridge/camera-utils';
+import { DingKind } from './ring-types';
 export interface RtpStreamOptions extends SrtpOptions {
     port: number;
     rtcpPort: number;
@@ -27,3 +28,28 @@ export declare function sendStunBindingRequest({ rtpDescription, rtpSplitter, rt
     type: 'video' | 'audio';
 }): void;
 export declare function createStunResponder(rtpSplitter: RtpSplitter): void;
+export interface LiveCallSession {
+    alexa_port: 18443;
+    app_session_token: string;
+    availability_zone: 'availability-zone';
+    custom_timer: {
+        max_sec: number;
+    };
+    ding_id: string;
+    ding_kind: DingKind;
+    doorbot_id: number;
+    exp: number;
+    ip: string;
+    port: number;
+    private_ip: string;
+    rms_fqdn: string;
+    rms_version: string;
+    rsp_port: number;
+    rtsp_port: number;
+    session_id: string;
+    sip_port: number;
+    webrtc_port: number;
+    webrtc_url: string;
+    wwr_port: number;
+}
+export declare function parseLiveCallSession(sessionId: string): LiveCallSession;

package/lib/api/rtp-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
+exports.parseLiveCallSession = exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
 const util_1 = require("./util");
 const stun = require('stun');
 const stunMagicCookie = 0x2112a442; // https://tools.ietf.org/html/rfc5389#section-6
@@ -54,3 +54,8 @@ function createStunResponder(rtpSplitter) {
     });
 }
 exports.createStunResponder = createStunResponder;
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = new Buffer(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
+exports.parseLiveCallSession = parseLiveCallSession;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "9.25.0-beta.0",
+  "version": "9.25.0-beta.1",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/api/index.js",
   "bin": {
@@ -14,14 +14,16 @@
     "watch:tests": "jest --watch",
     "lint": "eslint '**/*.ts' --fix",
     "build": "rm -rf lib && tsc --declaration",
-    "example": "npm run build && node ./lib/examples/example.js",
-    "api-example": "npm run build && node ./lib/examples/api-example.js",
-    "record-example": "npm run build && node ./lib/examples/record-example.js",
-    "stream-example": "npm run build && node ./lib/examples/stream-example.js",
-    "browser-example": "npm run build && node ./lib/examples/browser-example.js",
-    "auth-cli": "npm run build && ./ring-auth-cli.js",
-    "device-data-cli": "npm run build && ./ring-device-data-cli.js",
-    "hb": "npm run build && ./build/package-homebridge.sh && homebridge -P ./release-homebridge -U ./.homebridge",
+    "build-quick": "rm -rf lib && esbuild ./{api,examples,homebridge}/*.ts ./api/*.js --target=es2017 --format=cjs --outdir=lib",
+    "example": "npm run build-quick && node ./lib/examples/example.js",
+    "api-example": "npm run build-quick && node ./lib/examples/api-example.js",
+    "record-example": "npm run build-quick && node ./lib/examples/record-example.js",
+    "return-audio-example": "npm run build-quick && node ./lib/examples/return-audio-example.js",
+    "stream-example": "npm run build-quick && node ./lib/examples/stream-example.js",
+    "browser-example": "npm run build-quick && node ./lib/examples/browser-example.js",
+    "auth-cli": "npm run build-quick && ./ring-auth-cli.js",
+    "device-data-cli": "npm run build-quick && ./ring-device-data-cli.js",
+    "hb": "npm run build-quick && ./build/package-homebridge.sh && homebridge -P ./release-homebridge -U ./.homebridge",
     "prepare-npm-packages": "./build/package-api.sh && ./build/package-homebridge.sh",
     "push-with-tags": "git push --follow-tags && node ./build/github-releaser.js",
     "deploy": "git pull -r && standard-version && npm publish ./release-api && npm publish ./release-homebridge && npm run push-with-tags",
@@ -53,8 +55,9 @@
   "author": "dgreif",
   "license": "MIT",
   "dependencies": {
-    "@homebridge/camera-utils": "2.0.4",
+    "@homebridge/camera-utils": "2.1.0",
     "@homebridge/plugin-ui-utils": "0.0.19",
+    "@koush/werift": "0.14.5-beta5",
     "@types/socket.io-client": "1.4.36",
     "colors": "1.4.0",
     "debug": "4.3.3",
@@ -64,18 +67,21 @@
     "socket.io-client": "2.4.0",
     "stun": "2.1.0",
     "systeminformation": "5.10.7",
-    "uuid": "8.3.2"
+    "uuid": "8.3.2",
+    "ws": "8.4.2"
   },
   "devDependencies": {
     "@types/debug": "4.1.7",
     "@types/jest": "27.4.0",
     "@types/node": "17.0.10",
     "@types/uuid": "8.3.4",
+    "@types/ws": "^8.2.2",
     "@typescript-eslint/eslint-plugin": "5.10.0",
     "@typescript-eslint/parser": "5.10.0",
     "concurrently": "^7.0.0",
     "conventional-github-releaser": "3.1.5",
     "dotenv": "14.2.0",
+    "esbuild": "^0.14.19",
     "eslint": "8.7.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-jest": "25.7.0",