homebridge-ring-secure-video 1.0.0-beta.3 → 1.0.0-beta.4

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # homebridge-ring-secure-video
 
+## 1.0.0-beta.4 (2026-11-13)
+
+More fixes from the full independent review of 1.0.0-beta.2.
+
+**Changes in behaviour to check after updating:**
+
+- `enableHksv` now means on when it isn't set, as the settings form shows. Configs without it
+  (written by hand, or copied from homebridge-ring) now offer HKSV recording: live view allows
+  one viewer at a time, and recording starts once turned on for the camera in the Home app. Set
+  `"enableHksv": false` to keep the old behaviour.
+- `disableHksvOnBattery` now means on when it isn't set, and looks at whether a camera actually
+  runs on battery: battery models that are wired (power mode wired in the Ring app), like many
+  doorbells, keep HKSV; battery-only cameras don't get it. Configs without the setting therefore
+  lose HKSV on battery-only cameras; set `"disableHksvOnBattery": false` to keep it. Configs
+  saved by the old settings form have it set to true, so their wired battery doorbells now get
+  HKSV.
+- Values the old settings form saved stay until removed: a saved `"media": { "profile":
+  "adaptive" }` still overrides `"hksvPerformanceMode": "rpi"`, and a saved
+  `"hksvVideoBitrateKbps": 3000` still overrides the profile's bitrate. Remove them if you didn't
+  choose them.
+
+**Fixes:**
+
+- One device or location that fails to set up no longer stops the others, the alarm included.
+  A failed device keeps its HomeKit accessory (rooms and automations stay) but shows "No
+  Response"; a location whose devices can't be loaded is logged, and its accessories are kept and
+  show "No Response". If
+  Ring can't be reached when Homebridge starts (an outage, a server error, a sign-in server
+  outage), connecting is retried after 30 s, 1 min, 2 min, ... up to every 10 minutes, with the
+  newest sign-in token and without forcing a new Ring registration.
+- The motion fallback no longer asks Ring for each camera's event history every 20 s all day
+  (about 4,300 requests a day). Once motion events turn out to arrive by push too, it checks every
+  5 minutes as a safety net; a motion event no push reported switches back to frequent checks. A
+  history event counts as pushed if a motion push had its id or came within 90 s of it. If push
+  stops working, it is noticed at the next 5-minute check; a visit found then is only reported if
+  it is at most 3 minutes old, so it can be missed. Remembered events are forgotten an hour after
+  they leave Ring's history.
+- ffmpeg errors no longer end the whole bridge (alarm included): further errors on a process and
+  errors on its output are logged, and a talk-back ffmpeg that fails to start is logged and the
+  live view is reported to HomeKit as not started.
+- A snapshot that can't be refreshed is shown for at most Ring's snapshot lifetime plus 2
+  minutes, as in homebridge-ring, rather than indefinitely.
+- The settings form no longer fills in a bitrate or media profile that overrode the media
+  profile and the older HKSV performance mode.
+- README and settings text: the Raspberry Pi section shows the settings verified on a Pi 4
+  (`lowPower`, `libx264`, with a Ring Video Doorbell 3 Plus); `copy` and `h264_v4l2m2m` are
+  described as not yet verified. Upstream links point to dgreif/ring, and the install commands
+  no longer use `--unsafe-perm`.
+- Development: GitHub Actions and the publishing npm are pinned to exact versions, the GitHub
+  token is kept out of dependency installs, Dependabot is set up, and locked dependencies include
+  the available security fixes.
+
 ## 1.0.0-beta.3 (2026-11-13)
 
 Fixes from a full independent review of 1.0.0-beta.2.

package/README.md

@@ -13,22 +13,22 @@ It is meant to replace `homebridge-ring` on its own: one plugin, one Ring sign-i
 
 ## Origin and Attribution
 
-This project is based on Dustin Greif's original Ring Homebridge ecosystem:
+This project is based on Dusty Greif's original Ring Homebridge ecosystem:
 
-- Upstream plugin: [dgreif/homebridge-ring](https://github.com/dgreif/homebridge-ring)
-- Upstream API library: [dgreif/ring-client-api](https://github.com/dgreif/ring-client-api)
+- Upstream plugin and API library: [dgreif/ring](https://github.com/dgreif/ring)
+  (`homebridge-ring` and `ring-client-api`)
 
 - HKSV fork: [trinityhades/homebridge-ring-hksv](https://github.com/trinityhades/homebridge-ring-hksv), whose history this repository continues
 
-Big thanks to Dustin, trinityhades and all upstream contributors. This plugin reuses and extends that foundation.
+Big thanks to Dusty, trinityhades and all upstream contributors. This plugin reuses and extends that foundation.
 
 ## Important Plugin Options
 
 | Option | Purpose |
 | --- | --- |
-| `enableHksv` | Enables experimental HKSV support for eligible cameras |
-| `enableCameraMotionHistory` | Allows camera motion to fall back to recent Ring event history if live notifications are stale; disable to only trust push-triggered motion |
-| `disableHksvOnBattery` | Disables HKSV on battery cameras to reduce battery/network usage |
+| `enableHksv` | Enables experimental HKSV support for eligible cameras; on by default, set `false` to turn it off |
+| `enableCameraMotionHistory` | Allows camera motion to fall back to recent Ring event history if push notifications don't arrive. The history is checked every `cameraStatusPollingSeconds` until motion events turn out to come by push too, then every 5 minutes as a safety net (and frequently again once a push is missed, so motion can go unreported for up to 5 minutes after push stops working); disable to only trust push-triggered motion |
+| `disableHksvOnBattery` | Disables HKSV on cameras running on battery to reduce battery/network usage; wired battery models keep it. On by default |
 | `hksvPrebufferLengthMs` | HKSV prebuffer duration (minimum 4000ms) |
 | `hksvFragmentLengthMs` | HKSV fragment duration target |
 | `hksvMaxRecordingSeconds` | Optional safety cap for a recording session (default 180 s; 0 disables) |
@@ -61,13 +61,13 @@ normally ends a recording itself when motion stops), or to `0` to disable it.
 If Homebridge is installed globally:
 
 ```bash
-npm i -g --unsafe-perm homebridge-ring-secure-video
+npm i -g homebridge-ring-secure-video
 ```
 
 To try a beta, install the `beta` tag instead:
 
 ```bash
-npm i -g --unsafe-perm homebridge-ring-secure-video@beta
+npm i -g homebridge-ring-secure-video@beta
 ```
 
 If running from source:
@@ -115,7 +115,8 @@ Changing `homeKitAccessoryTag` updates both the exposed accessory name and the g
 
 HKSV support is experimental and actively evolving. Behavior may vary by camera model, wired vs battery power, Ring API changes, and FFmpeg environment.
 
-I currently am able to run 3 cameras with HKSV enabled on a Homebridge instance ran on a M4 Mac Mini 32GB of RAM.
+Verified so far: complete HomeKit clips from a Ring Video Doorbell 3 Plus on a Raspberry Pi 4
+(Node 22, Homebridge 2) with the settings below. The HKSV fork this continues reported 3 cameras on an M4 Mac mini.
 Please report your experience and setup details to help improve support.
 
 Recordings follow the frame rate and audio format HomeKit asks for, and include audio only when
@@ -133,24 +134,23 @@ For fast-motion pixelation or stuttering in HKSV recordings, try increasing
 `cameraVideoCodec: "h264_videotoolbox"` can reduce CPU load by using hardware
 encoding.
 
-For Raspberry Pi 4/5 and other small computers, start with:
+For Raspberry Pi 4/5 and other small computers, start with what has been verified on a Pi 4:
 
 ```json
 {
   "enableHksv": true,
-  "hksvPerformanceMode": "rpi",
-  "cameraVideoCodec": "auto",
-  "hksvMaxConcurrentRecordings": 1
+  "media": {
+    "profile": "lowPower",
+    "recording": { "codec": "libx264", "bitrateKbps": 800 }
+  }
 }
 ```
 
-The `rpi` profile favors remuxing Ring's H.264 video into HomeKit Secure Video
-fragmented MP4 instead of re-encoding it. This is much lighter than libx264, but
-it depends on Ring's current stream being compatible with HomeKit's H.264
-recording requirements. If recording fails in this mode, try
-`cameraVideoCodec: "h264_v4l2m2m"` when your FFmpeg build exposes that encoder,
-or fall back to `cameraVideoCodec: "libx264"` with `hksvVideoPreset:
-"ultrafast"`.
+The `lowPower` profile (also chosen by `"hksvPerformanceMode": "rpi"`) records one clip at a
+time with conservative settings. Lighter codecs exist but complete HomeKit clips with them are
+not verified yet: `copy` (the `lowPower` default for `auto`) remuxes Ring's H.264 without
+re-encoding, which only works when Ring's stream meets HomeKit's recording requirements, and
+`h264_v4l2m2m` uses the Pi's hardware encoder when FFmpeg has it.
 
 ### Minimum specifications for HKSV: 
 [TBD - will be added as more users test and report their setups]

package/config.schema.json

@@ -36,7 +36,7 @@
           "profile": {
             "title": "Media profile",
             "type": "string",
-            "default": "adaptive",
+            "description": "Defaults to the HKSV Performance Mode (rpi gives lowPower, quality gives quality), otherwise adaptive.",
             "oneOf": [
               { "title": "adaptive", "enum": ["adaptive"] },
               { "title": "lowPower", "enum": ["lowPower"] },
@@ -155,13 +155,13 @@
       "enableCameraMotionHistory": {
         "title": "Enable Camera Motion History Fallback",
         "type": "boolean",
-        "description": "If enabled, cameras can synthesize motion from recent Ring event history when live push notifications are missing or stale. Disable this if you only want motion triggered by Ring notifications.",
+        "description": "If enabled, cameras can synthesize motion from recent Ring event history when push notifications don't arrive. The history is checked frequently until push is seen to work, then every 5 minutes as a safety net. Disable this if you only want motion triggered by Ring notifications.",
         "default": true
       },
       "disableHksvOnBattery": {
         "title": "Disable HKSV On Battery Cameras",
         "type": "boolean",
-        "description": "If enabled, HKSV is disabled on battery-powered cameras to reduce battery and network impact.",
+        "description": "If enabled, HKSV is disabled on cameras running on battery, to reduce battery and network impact. Battery models that are wired (power mode wired in the Ring app) keep HKSV.",
         "default": true
       },
       "hksvPrebufferLengthMs": {
@@ -189,7 +189,7 @@
       "hksvPerformanceMode": {
         "title": "HKSV Performance Mode",
         "type": "string",
-        "description": "High-level HKSV tuning profile. Use rpi for Raspberry Pi and other small computers; it favors remuxing, lower advertised recording tiers, and conservative concurrency.",
+        "description": "High-level HKSV tuning profile. Use rpi for Raspberry Pi and other small computers: lower advertised recording tiers, one recording at a time, and remuxing (copy) unless a codec other than auto is set. Verified on a Pi 4 with the codec set to libx264.",
         "default": "balanced",
         "oneOf": [
           {
@@ -225,8 +225,7 @@
         "type": "integer",
         "minimum": 256,
         "maximum": 12000,
-        "default": 3000,
-        "description": "Target video bitrate for HKSV recording transcodes. Increase this first if fast motion becomes blocky or pixelated. 4000-6000 is a good starting range for wired cameras."
+        "description": "Target video bitrate for HKSV recording transcodes. Defaults to the media profile's (1000 lowPower, 3000 adaptive, 5000 quality). Increase this first if fast motion becomes blocky or pixelated. 4000-6000 is a good starting range for wired cameras."
       },
       "hksvVideoMaxBitrateKbps": {
         "title": "HKSV Max Video Bitrate (kbps)",
@@ -308,7 +307,7 @@
       "cameraVideoCodec": {
         "title": "Camera Video Codec",
         "type": "string",
-        "description": "Preferred FFmpeg H.264 handling for HKSV recordings. auto chooses the lowest-cost option for the configured performance mode; copy remuxes Ring video without re-encoding.",
+        "description": "Preferred FFmpeg H.264 handling for HKSV recordings. auto chooses the lowest-cost option for the configured performance mode; copy remuxes Ring video without re-encoding. Complete clips are verified with libx264; copy and h264_v4l2m2m are not verified yet.",
         "oneOf": [
           {
             "title": "auto",

package/lib/camera-source.js

@@ -225,46 +225,79 @@ class StreamingSessionWrapper {
                 // deSerialize will sometimes fail, but the errors can be ignored
             }
             return null;
-        }), releaseReturnAudioFfmpeg = hksvRecordingQueue.trackFfmpegProcess(), returnAudioTranscoder = new ReturnAudioTranscoder({
-            prepareStreamRequest: getReturnAudioPrepareStreamRequest(this.prepareStreamRequest),
-            startStreamRequest: request,
-            incomingAudioOptions: {
-                ssrc: this.audioSsrc,
-                rtcpPort: 0, // we don't care about rtcp for incoming audio
-            },
-            outputArgs: [
-                '-acodec',
-                'libopus',
-                '-application',
-                'lowdelay',
-                '-frame_duration',
-                '60',
-                '-flags',
-                '+global_header',
-                '-ar',
-                '48k',
-                '-b:a',
-                '48k',
-                '-bufsize',
-                '192k',
-                '-ac',
-                '2',
-                '-f',
-                'rtp',
-                `rtp://127.0.0.1:${await returnAudioTranscodedSplitter.portPromise}`,
-            ],
-            ffmpegPath: getFfmpegPath(),
-            exitCallback: () => {
-                releaseReturnAudioFfmpeg();
-                this.stop();
-            },
-            logger: {
-                info: logDebug,
-                error: logError,
-            },
-            logLabel: `Return Audio (${this.ringCamera.name})`,
-            returnAudioSplitter: this.audioSplitter,
         });
+        // Port first, so a failure here leaves nothing counted or open.
+        let returnAudioPort;
+        try {
+            returnAudioPort = await returnAudioTranscodedSplitter.portPromise;
+        }
+        catch (e) {
+            returnAudioTranscodedSplitter.close();
+            throw e;
+        }
+        if (this.stopped) {
+            returnAudioTranscodedSplitter.close();
+            throw getLiveStreamAbortError();
+        }
+        const releaseReturnAudioFfmpeg = hksvRecordingQueue.trackFfmpegProcess();
+        let returnAudioTranscoder;
+        try {
+            returnAudioTranscoder = new ReturnAudioTranscoder({
+                prepareStreamRequest: getReturnAudioPrepareStreamRequest(this.prepareStreamRequest),
+                startStreamRequest: request,
+                incomingAudioOptions: {
+                    ssrc: this.audioSsrc,
+                    rtcpPort: 0, // we don't care about rtcp for incoming audio
+                },
+                outputArgs: [
+                    '-acodec',
+                    'libopus',
+                    '-application',
+                    'lowdelay',
+                    '-frame_duration',
+                    '60',
+                    '-flags',
+                    '+global_header',
+                    '-ar',
+                    '48k',
+                    '-b:a',
+                    '48k',
+                    '-bufsize',
+                    '192k',
+                    '-ac',
+                    '2',
+                    '-f',
+                    'rtp',
+                    `rtp://127.0.0.1:${returnAudioPort}`,
+                ],
+                ffmpegPath: getFfmpegPath(),
+                exitCallback: () => {
+                    releaseReturnAudioFfmpeg();
+                    this.stop();
+                },
+                logger: {
+                    info: logDebug,
+                    error: logError,
+                },
+                logLabel: `Return Audio (${this.ringCamera.name})`,
+                returnAudioSplitter: this.audioSplitter,
+            });
+        }
+        catch (e) {
+            releaseReturnAudioFfmpeg();
+            returnAudioTranscodedSplitter.close();
+            throw e;
+        }
+        // @homebridge/camera-utils' ffmpeg has no 'error' listener: a failed start (no ffmpeg, too
+        // many processes) would be an unhandled 'error' event and end the whole bridge, alarm
+        // included. Its spawn errors arrive on the next tick, so listening now is in time.
+        const returnAudioFfmpeg = returnAudioTranscoder.ffmpegProcess?.ff;
+        for (const emitter of [returnAudioFfmpeg, returnAudioFfmpeg?.stdout, returnAudioFfmpeg?.stderr]) {
+            emitter?.on('error', (error) => {
+                logError(`Return Audio (${this.ringCamera.name}): ${error.message}`);
+                this.stop();
+            });
+        }
         this.streamingSession.onCallEnded.pipe(take(1)).subscribe(() => {
             returnAudioTranscoder.stop();
             returnAudioTranscodedSplitter.close();
@@ -277,6 +310,9 @@ class StreamingSessionWrapper {
         });
         this.listenForAudioPackets(request);
         await returnAudioTranscoder.start();
+        // A talk-back ffmpeg that failed to start stopped the stream meanwhile: report it to HomeKit.
+        if (this.stopped)
+            throw getLiveStreamAbortError();
     }
     stop() {
         if (this.stopped) {
@@ -329,10 +365,20 @@ export function getHksvRecordingFormatArguments(configuration, videoArguments, c
 // Raspberry Pi's V4L2 encoder) otherwise leave an empty avcC, and HomeKit can't decode the
 // recording. The first media fragment arrives no later than before.
 export const HKSV_RECORDING_MOVFLAGS = 'frag_keyframe+empty_moov+default_base_moof+delay_moov';
+/**
+ * Whether a camera gets HomeKit Secure Video. Unset settings mean what the settings form shows:
+ * HKSV on, except for cameras running on battery (each recording opens a Ring live call, which
+ * drains it). A battery model that is wired, like many doorbells, counts as wired.
+ */
+export function isHksvEnabled(config, operatingOnBattery) {
+    return (config.enableHksv !== false &&
+        !(config.disableHksvOnBattery !== false && operatingOnBattery));
+}
 export class CameraSource {
     controller;
     sessions = {};
     cachedSnapshot;
+    cachedSnapshotAt = 0;
     ringCamera;
     config;
     mediaIngress;
@@ -345,7 +391,7 @@ export class CameraSource {
         this.ringCamera = ringCamera;
         this.config = config;
         this.mediaIngress = new RingMediaIngress(ringCamera);
-        const enableHksv = config.enableHksv && !(config.disableHksvOnBattery && ringCamera.hasBattery);
+        const enableHksv = isHksvEnabled(config, ringCamera.operatingOnBattery);
         const controllerOptions = {
             cameraStreamCount: enableHksv ? 1 : 10,
             delegate: this,
@@ -512,6 +558,7 @@ export class CameraSource {
         try {
             const previousSnapshot = this.cachedSnapshot, newSnapshot = await this.ringCamera.getSnapshot({ uuid: imageUuid });
             this.cachedSnapshot = newSnapshot;
+            this.cachedSnapshotAt = Date.now();
             logDebug(`Snapshot cached for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''} (${getDurationSeconds(start)}s)`);
         }
         catch (e) {
@@ -535,7 +582,13 @@ export class CameraSource {
         if (!this.ringCamera.hasSnapshotWithinLifetime) {
             this.loadSnapshot().catch(logError);
         }
-        // may or may not have a snapshot cached
+        // May or may not have a snapshot cached. A failed load keeps the last one for a while, but
+        // not past Ring's snapshot lifetime plus 2 minutes (as upstream): an hours-old image would
+        // look current in the Home app.
+        if (this.cachedSnapshot &&
+            Date.now() - this.cachedSnapshotAt > this.ringCamera.snapshotLifeTime + 2 * 60_000) {
+            return undefined;
+        }
         return this.cachedSnapshot;
     }
     async handleSnapshotRequest(request, callback) {

package/lib/camera.js

@@ -1,12 +1,155 @@
 import { hap } from "./hap.js";
 import { PushNotificationAction } from 'ring-client-api';
 import { BaseDataAccessory } from "./base-data-accessory.js";
-import { catchError, exhaustMap, filter, map, mergeMap, share, switchMap, throttleTime, } from 'rxjs/operators';
+import { catchError, exhaustMap, filter, finalize, map, mergeMap, share, switchMap, throttleTime, } from 'rxjs/operators';
 import { CameraSource } from "./camera-source.js";
 import { TargetValueTimer } from "./target-value-timer.js";
 import { delay, logError, logInfo } from 'ring-client-api/util';
-import { defer, EMPTY, firstValueFrom, from, merge, of, timer } from 'rxjs';
+import { defer, EMPTY, firstValueFrom, merge, of, timer } from 'rxjs';
 export const MOTION_WATCHDOG_MS = 30_000;
+/** How often Ring's event history is checked once its push notifications are known to arrive. */
+export const HISTORY_CHECK_WHILE_PUSH_WORKS_MS = 5 * 60_000;
+/** A push motion this close to a history event's time is taken as that event's notification. */
+export const PUSH_MATCH_WINDOW_MS = 90_000;
+/** After a gap in checking, a history event older than this no longer gives motion. */
+export const HISTORY_MOTION_MAX_AGE_MS = 180_000;
+/** A history event first seen less than this ago may still get its push; judged at a later check. */
+const PUSH_GRACE_MS = 30_000;
+/** Checks in a row that found only pushed events (no misses in between) before push is trusted. */
+const MATCHES_TO_TRUST_PUSH = 2;
+/**
+ * Ids no longer in the history are forgotten after this. Ids still in it are kept, however old:
+ * on a quiet camera the 10 newest events can be days old, and must not count as new again.
+ */
+const ID_MEMORY_MS = 60 * 60_000;
+/**
+ * Motion from Ring's event history, for when its push notifications don't arrive.
+ *
+ * Checking every pollSeconds (20 s by default) costs some 4,300 Ring requests a day per camera,
+ * on the same session as everything else. So the history is checked that often only until motion
+ * events in it (two in a row) turn out to have come by push too; from then on push is trusted
+ * and the history is checked every 5 minutes as a safety net. A motion event no push reported
+ * switches back to frequent checks. While checking frequently every new event gives motion; after
+ * a gap (5-minute checks, a failure) only events from the last 3 minutes do, as one found later
+ * would only record an empty doorway.
+ */
+export function getHistoryMotionEvents(device, pollSeconds) {
+    return defer(() => {
+        const startedAt = Date.now() - 5000, historySeen = new Map(), 
+        // Events that already gave motion from here (a young one is judged again later).
+        shownAsMotion = new Map(), 
+        // When an event not judged yet was first seen in the history (by the Pi's clock).
+        firstSeen = new Map(), pushIds = new Map(), pushMotionTimes = [], baseRetryMs = Math.max(pollSeconds * 1000, 30_000), forget = (ids, now) => {
+            for (const [id, at] of ids) {
+                if (now - at > ID_MEMORY_MS)
+                    ids.delete(id);
+            }
+        };
+        let pushWorks = false, matchedInARow = 0, lastCheckAt = 0, lastSuccessAt = 0, failureCount = 0, nextCheckAt = 0;
+        const notifications = device.onNewNotification.subscribe((notification) => {
+            if (notification.android_config?.category !== PushNotificationAction.Motion)
+                return;
+            const id = notification.data?.event?.ding?.id, now = Date.now();
+            if (id !== undefined)
+                pushIds.set(String(id), now);
+            pushMotionTimes.push(now);
+            if (pushMotionTimes.length > 50)
+                pushMotionTimes.shift();
+        });
+        return timer(pollSeconds * 1000, pollSeconds * 1000).pipe(exhaustMap(() => {
+            const now = Date.now();
+            if (now < nextCheckAt)
+                return EMPTY;
+            if (pushWorks && now - lastCheckAt < HISTORY_CHECK_WHILE_PUSH_WORKS_MS) {
+                return EMPTY;
+            }
+            lastCheckAt = now;
+            // Checked recently and frequently: anything new is recent, whatever the clocks say
+            // (a Pi clock ahead of Ring's would otherwise make every event look too old).
+            const checkedJustBefore = !pushWorks && now - lastSuccessAt <= pollSeconds * 1000 + 30_000;
+            return defer(() => device.getEvents({ limit: 10, kind: 'motion' })).pipe(mergeMap(({ events }) => {
+                const checkedAt = Date.now();
+                failureCount = 0;
+                nextCheckAt = 0;
+                lastSuccessAt = checkedAt;
+                // Still in the history: remembered as long as it stays there.
+                for (const event of events) {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    for (const ids of [historySeen, shownAsMotion, firstSeen, pushIds]) {
+                        if (ids.has(id) && ids !== firstSeen)
+                            ids.set(id, checkedAt);
+                    }
+                }
+                forget(historySeen, checkedAt);
+                forget(shownAsMotion, checkedAt);
+                forget(firstSeen, checkedAt);
+                forget(pushIds, checkedAt);
+                const isPushed = (event) => {
+                    const id = event.ding_id_str || String(event.ding_id), at = Date.parse(event.created_at);
+                    return (pushIds.has(id) ||
+                        pushMotionTimes.some((t) => Math.abs(t - at) <= PUSH_MATCH_WINDOW_MS));
+                };
+                const newEvents = events.filter((event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    return (event.kind === 'motion' &&
+                        Date.parse(event.created_at) >= startedAt &&
+                        !historySeen.has(id));
+                });
+                // Too young to know whether its push is still coming: judged at a later check, but
+                // it can still give motion now (once). Young by when it was first seen here, so a
+                // Pi clock behind Ring's doesn't keep it young.
+                const young = (event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    if (!firstSeen.has(id))
+                        firstSeen.set(id, checkedAt);
+                    return !isPushed(event) && checkedAt - (firstSeen.get(id) ?? checkedAt) < PUSH_GRACE_MS;
+                };
+                const judged = newEvents.filter((event) => !young(event)), missed = judged.filter((event) => !isPushed(event));
+                judged.forEach((event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    historySeen.set(id, checkedAt);
+                    firstSeen.delete(id);
+                });
+                if (pushWorks && judged.length < newEvents.length) {
+                    // An event to judge soon: check again shortly rather than in 5 minutes.
+                    lastCheckAt = checkedAt - HISTORY_CHECK_WHILE_PUSH_WORKS_MS + PUSH_GRACE_MS + 10_000;
+                }
+                if (missed.length) {
+                    matchedInARow = 0;
+                    if (pushWorks) {
+                        pushWorks = false;
+                        logInfo(`${device.name}: Ring event history shows motion no push notification reported; checking it every ${pollSeconds} s again`);
+                    }
+                }
+                else if (judged.length) {
+                    // One per check: a single push can match several events.
+                    matchedInARow += 1;
+                    if (!pushWorks && matchedInARow >= MATCHES_TO_TRUST_PUSH) {
+                        pushWorks = true;
+                        logInfo(`${device.name}: Ring push notifications are arriving; checking Ring event history every ${HISTORY_CHECK_WHILE_PUSH_WORKS_MS / 60_000} minutes instead of every ${pollSeconds} s`);
+                    }
+                }
+                const unpushedNow = newEvents.filter((event) => !isPushed(event)), givesMotion = unpushedNow.some((event) => !shownAsMotion.has(event.ding_id_str || String(event.ding_id)) &&
+                    (checkedJustBefore ||
+                        checkedAt - Date.parse(event.created_at) <= HISTORY_MOTION_MAX_AGE_MS));
+                unpushedNow.forEach((event) => shownAsMotion.set(event.ding_id_str || String(event.ding_id), checkedAt));
+                if (!givesMotion)
+                    return EMPTY;
+                logInfo(`${device.name} Detected Motion from Ring event history fallback`);
+                return of(true);
+            }), catchError(() => {
+                failureCount++;
+                const retryDelayMs = Math.min(5 * 60 * 1000, baseRetryMs * 2 ** Math.min(failureCount - 1, 4));
+                nextCheckAt = Date.now() + retryDelayMs;
+                const nextInMs = pushWorks
+                    ? Math.max(retryDelayMs, lastCheckAt + HISTORY_CHECK_WHILE_PUSH_WORKS_MS - Date.now())
+                    : retryDelayMs;
+                logError(`${device.name} failed to poll Ring event history for motion fallback; retrying in ${Math.ceil(nextInMs / 1000)} seconds`);
+                return EMPTY;
+            }));
+        }), finalize(() => notifications.unsubscribe()));
+    });
+}
 /**
  * Motion from Ring's push notifications, as HomeKit needs it: true for every new motion alert.
  *
@@ -217,56 +360,12 @@ export class Camera extends BaseDataAccessory {
         }
     }
     getMotionDetectedObservable() {
-        const pollSeconds = Math.max(this.config.cameraStatusPollingSeconds ?? 20, 10), startedAt = Date.now() - 5000, seenEventIds = new Set(), pushMotionEvents = getPushMotionEvents(this.device), enableMotionHistoryFallback = this.config.enableCameraMotionHistory !== false;
-        let historyFailureCount = 0;
-        let nextHistoryPollAt = 0;
-        const baseHistoryRetryMs = Math.max(pollSeconds * 1000, 30_000), polledNewMotionEvents = timer(pollSeconds * 1000, pollSeconds * 1000).pipe(exhaustMap(() => {
-            if (Date.now() < nextHistoryPollAt) {
-                return EMPTY;
-            }
-            return from(this.device.getEvents({
-                limit: 10,
-                kind: 'motion',
-            })).pipe(mergeMap(({ events }) => {
-                historyFailureCount = 0;
-                nextHistoryPollAt = 0;
-                const newMotionEvents = events
-                    .filter((event) => {
-                    const eventId = event.ding_id_str || String(event.ding_id);
-                    return (event.kind === 'motion' &&
-                        Date.parse(event.created_at) >= startedAt &&
-                        !seenEventIds.has(eventId));
-                })
-                    .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
-                newMotionEvents.forEach((event) => {
-                    seenEventIds.add(event.ding_id_str || String(event.ding_id));
-                });
-                if (!newMotionEvents.length)
-                    return EMPTY;
-                logInfo(`${this.device.name} Detected Motion from Ring event history fallback`);
-                return of(true);
-            }), catchError(() => {
-                historyFailureCount++;
-                const retryDelayMs = Math.min(5 * 60 * 1000, baseHistoryRetryMs * 2 ** Math.min(historyFailureCount - 1, 4));
-                nextHistoryPollAt = Date.now() + retryDelayMs;
-                logError(`${this.device.name} failed to poll Ring event history for motion fallback; retrying in ${Math.ceil(retryDelayMs / 1000)} seconds`);
-                return EMPTY;
-            }));
-        })), 
-        // No separate "motion off" for these: the watchdog below turns motion off 30 s after the
-        // last event, and a 65 s one from here could cut a later push-started visit short.
-        polledMotionEvents = polledNewMotionEvents;
-        if (enableMotionHistoryFallback) {
-            this.device.onNewNotification.subscribe((notification) => {
-                const dingId = notification.data?.event?.ding?.id;
-                if (dingId) {
-                    seenEventIds.add(String(dingId));
-                }
-            });
+        const pushMotionEvents = getPushMotionEvents(this.device);
+        if (this.config.enableCameraMotionHistory === false) {
+            return addMotionWatchdog(pushMotionEvents);
         }
-        return addMotionWatchdog(enableMotionHistoryFallback
-            ? merge(pushMotionEvents, polledMotionEvents)
-            : pushMotionEvents);
+        const pollSeconds = Math.max(this.config.cameraStatusPollingSeconds ?? 20, 10);
+        return addMotionWatchdog(merge(pushMotionEvents, getHistoryMotionEvents(this.device, pollSeconds)));
     }
     async loadSnapshotForEvent(eventDescription, characteristicValue) {
         let imageUuid = this.device.latestNotificationSnapshotUuid;

package/lib/managed-ffmpeg-process.js

@@ -37,6 +37,10 @@ export class ManagedFfmpegProcess {
         if (options.stdoutCallback) {
             this.child.stdout.on('data', options.stdoutCallback);
         }
+        // An unhandled 'error' event would crash the whole bridge (alarm included).
+        for (const stream of [this.child.stdout, this.child.stderr]) {
+            stream.on('error', (error) => options.logger.error(prefix + error.message));
+        }
         this.child.stderr.on('data', (data) => {
             options.logger.info(prefix + data);
         });
@@ -45,11 +49,12 @@ export class ManagedFfmpegProcess {
                 options.logger.error(prefix + error.message);
             }
         });
-        this.child.once('error', (error) => {
-            if (this.didExit)
-                return;
+        this.child.on('error', (error) => {
             options.logger.error(prefix + error.message);
-            this.finish(null, null, false);
+            // Without a pid it never started, and no 'exit' will follow. A running process (say a
+            // failed kill) still exits on its own and must stay tracked until then.
+            if (this.child.pid === undefined)
+                this.finish(null, null, false);
         });
         this.child.once('exit', (code, signal) => {
             this.finish(code, signal, true);

package/lib/ring-platform.js

@@ -182,6 +182,47 @@ export function createRefreshTokenSaver(api, tokenInConfig, clearRefreshFlags) {
         }
     };
 }
+/** An error as a short text; ring-client-api's HTTP errors have no message, only a status. */
+export function describeError(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    const status = error?.response?.status;
+    if (status)
+        return `Ring returned HTTP ${status}`;
+    return error instanceof Error ? error.name : String(error);
+}
+/**
+ * A Ring error that retrying can't fix. Only an outdated Node.js: ring-client-api reports a Ring
+ * sign-in server outage (5xx, 429) as "Refresh token is not valid", the same as a revoked token,
+ * so that is retried (every 10 minutes at most, a single request each time).
+ */
+export function isPermanentRingError(error) {
+    return describeError(error).includes('too old to support');
+}
+/**
+ * Keeps an accessory that couldn't be set up in HomeKit (its room, name and automations stay)
+ * but makes it show "No Response", rather than old values and controls that silently do nothing
+ * (an alarm that seems to arm).
+ */
+function markNotResponding(accessory) {
+    const failure = () => {
+        throw new hap.HapStatusError(-70402 /* hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+    };
+    for (const service of accessory.services) {
+        if (service.UUID === hap.Service.AccessoryInformation.UUID)
+            continue;
+        for (const characteristic of service.characteristics) {
+            characteristic.onGet(failure);
+            if (characteristic.props.perms.includes("pw" /* hap.Perms.PAIRED_WRITE */)) {
+                characteristic.onSet(failure);
+            }
+        }
+    }
+}
+/** 30 s, 1 min, 2 min, ... up to 10 min between attempts to reach Ring at startup. */
+export function getRetryDelayMs(attempt) {
+    return Math.min(30_000 * 2 ** attempt, 600_000);
+}
 export class RingPlatform {
     homebridgeAccessories = {};
     log;
@@ -224,19 +265,52 @@ export class RingPlatform {
             queueTimeoutMs: 30_000,
         });
         logInfo(`Media profile ${media.profile}: recordingConcurrency=${media.recording.maxConcurrentRecordings}, codec=${media.recording.codec}`);
+        this.api.on('shutdown', () => {
+            this.shuttingDown = true;
+            clearTimeout(this.retryTimer);
+        });
         this.api.on('didFinishLaunching', () => {
             this.log.debug('didFinishLaunching');
             if (config.refreshToken) {
-                this.connectToApi().catch((e) => {
-                    this.log.error('Error connecting to API');
-                    this.log.error(e);
-                });
+                void this.connectWithRetry();
             }
             else {
                 this.log.warn('Plugin is not configured. See the README of homebridge-ring-secure-video for setup instructions.');
             }
         });
     }
+    retryTimer;
+    shuttingDown = false;
+    devicesSetUp = false;
+    /**
+     * Connects to Ring, retrying later if Ring can't be reached when Homebridge starts (an outage,
+     * a server error), with a fresh connection each time: until then the alarm and every other
+     * accessory would stay unconnected. Not retried: an outdated Node.js, a failure once devices
+     * were being set up (which would set them up twice), and anything after shutdown.
+     */
+    async connectWithRetry(attempt = 0) {
+        try {
+            await this.connectToApi();
+        }
+        catch (e) {
+            const message = describeError(e);
+            if (this.shuttingDown || this.devicesSetUp || isPermanentRingError(e)) {
+                this.log.error(`Error connecting to Ring: ${message}`);
+                return;
+            }
+            const delay = getRetryDelayMs(attempt);
+            this.log.error(`Could not connect to Ring (${message}). Trying again in ${Math.round(delay / 1000)} s.${message.includes('Refresh token is not valid')
+                ? ' If this keeps happening, sign in again in the plugin settings.'
+                : ''}`);
+            this.retryTimer = setTimeout(() => {
+                void this.connectWithRetry(attempt + 1);
+            }, delay);
+        }
+    }
+    // A separate method so tests can stand in for Ring.
+    createRingApi(options) {
+        return new RingApi(options);
+    }
     configureAccessory(accessory) {
         logInfo(`Configuring cached accessory ${accessory.UUID} ${accessory.displayName}`);
         this.log.debug('%j', accessory);
@@ -260,7 +334,7 @@ export class RingPlatform {
         if (refreshTokenWithoutPushCredentials) {
             logInfo('Forcing Ring push credential refresh because Ring push credentials were removed from the startup token');
         }
-        const ringApi = new RingApi({
+        const ringApi = this.createRingApi({
             controlCenterDisplayName,
             ...config,
             ...(refreshTokenWithoutPushCredentials
@@ -269,13 +343,48 @@ export class RingPlatform {
             systemId,
         });
         ringApi.onRefreshTokenUpdated.subscribe(createRefreshTokenSaver(this.api, config.refreshToken, Boolean(refreshTokenWithoutPushCredentials)));
-        const locations = await ringApi.getLocations(), cachedAccessoryIds = Object.keys(this.homebridgeAccessories), platformAccessories = [], externalAccessories = [], activeAccessoryIds = [];
+        // A retry must sign in with the newest token (Ring may have replaced the old one) and must
+        // not force a new identity or push registration again.
+        ringApi.onRefreshTokenUpdated.subscribe(({ newRefreshToken }) => {
+            config.refreshToken = newRefreshToken;
+            config.forceRefreshRingPushCredentials = false;
+            config.forceRefreshRingApiSession = false;
+        });
+        let locations, loadedDevices;
+        try {
+            locations = await ringApi.getLocations();
+            // Load the devices of every location now: if none can be loaded (a Ring error while
+            // connecting to the alarm, say), a retry with a new connection may do better, and nothing
+            // has been set up yet. A location that fails while others work is reported below.
+            // Loaded once: after a failed connection, ring-client-api's getDevices() waits forever.
+            loadedDevices = await Promise.allSettled(locations.map((location) => location.getDevices()));
+            const firstFailure = loadedDevices.find((result) => result.status === 'rejected');
+            if (firstFailure && loadedDevices.every((result) => result.status === 'rejected')) {
+                throw firstFailure.reason;
+            }
+        }
+        catch (e) {
+            // A retry starts over with a new connection.
+            ringApi.disconnect();
+            throw e;
+        }
+        if (this.shuttingDown) {
+            ringApi.disconnect();
+            return;
+        }
+        this.devicesSetUp = true;
+        const cachedAccessoryIds = Object.keys(this.homebridgeAccessories), platformAccessories = [], externalAccessories = [], activeAccessoryIds = [];
         logInfo('Found the following locations:');
         locations.forEach((location) => {
             logInfo(`  locationId: ${location.id} - ${location.name}`);
         });
-        await Promise.all(locations.map(async (location) => {
-            const devices = await location.getDevices(), { cameras, chimes, intercoms } = location, allDevices = [...devices, ...cameras, ...chimes, ...intercoms], securityPanel = devices.find((x) => x.deviceType === RingDeviceType.SecurityPanel), debugPrefix = debug ? 'TEST ' : '', hapDevices = allDevices.map((device) => {
+        // One location (or device) that fails to set up must not stop the others, the alarm
+        // included; its cached accessories are kept rather than removed as stale.
+        const locationResults = await Promise.allSettled(locations.map(async (location, locationIndex) => {
+            const loaded = loadedDevices[locationIndex];
+            if (loaded.status === 'rejected')
+                throw loaded.reason;
+            const devices = loaded.value, { cameras, chimes, intercoms } = location, allDevices = [...devices, ...cameras, ...chimes, ...intercoms], securityPanel = devices.find((x) => x.deviceType === RingDeviceType.SecurityPanel), debugPrefix = debug ? 'TEST ' : '', hapDevices = allDevices.map((device) => {
                 const isCamera = device instanceof RingCamera, isIntercomVideo = device instanceof RingIntercom &&
                     device.deviceType === 'intercom_handset_video', cameraIdentitySalt = isCamera && config.externalCameraIdSalt
                     ? `-${config.externalCameraIdSalt}`
@@ -320,7 +429,7 @@ export class RingPlatform {
                 });
             }
             if (config.locationModePollingSeconds &&
-                (await location.supportsLocationModeSwitching())) {
+                (await location.supportsLocationModeSwitching().catch(() => false))) {
                 hapDevices.push({
                     deviceType: 'location.mode',
                     device: location,
@@ -334,73 +443,104 @@ export class RingPlatform {
             logInfo(`Configuring ${cameras.length} cameras and ${hapDevices.length} devices for location "${location.name}" - locationId: ${location.id}`);
             hapDevices.forEach(({ deviceType, device, isCamera, isIntercomVideo, id, name, AccessoryClass, }) => {
                 const uuid = hap.uuid.generate(debugPrefix + id), displayName = debugPrefix + name;
-                if (!AccessoryClass ||
-                    (config.hideLightGroups &&
-                        deviceType === RingDeviceType.BeamsLightGroupSwitch) ||
-                    hideDeviceIds.includes(uuid) ||
-                    (onlyDeviceTypes && !onlyDeviceTypes.includes(deviceType))) {
-                    if (!ignoreHiddenDeviceTypes.includes(deviceType)) {
-                        logInfo(`Hidden accessory ${uuid} ${deviceType} ${displayName}`);
+                try {
+                    if (!AccessoryClass ||
+                        (config.hideLightGroups &&
+                            deviceType === RingDeviceType.BeamsLightGroupSwitch) ||
+                        hideDeviceIds.includes(uuid) ||
+                        (onlyDeviceTypes && !onlyDeviceTypes.includes(deviceType))) {
+                        if (!ignoreHiddenDeviceTypes.includes(deviceType)) {
+                            logInfo(`Hidden accessory ${uuid} ${deviceType} ${displayName}`);
+                        }
+                        return;
                     }
-                    return;
-                }
-                if (isCamera && this.homebridgeAccessories[uuid]) {
-                    // Camera was previously bridged.  Remove it from the platform so that it can be added as an external accessory
-                    this.log.warn(`Camera ${displayName} was previously bridged. You will need to manually pair it as a new accessory.`);
-                    this.api.unregisterPlatformAccessories(pluginName, platformName, [
-                        this.homebridgeAccessories[uuid],
-                    ]);
-                    delete this.homebridgeAccessories[uuid];
-                }
-                const createHomebridgeAccessory = () => {
-                    const category = isCamera
-                        ? 17 /* hap.Categories.CAMERA */
-                        : isIntercomVideo
-                            ? 18 /* hap.Categories.VIDEO_DOORBELL */
-                            : 11 /* hap.Categories.SECURITY_SYSTEM */;
-                    const accessory = new api.platformAccessory(displayName, uuid, category);
-                    if (isCamera) {
-                        logInfo(`Configured camera ${uuid} ${deviceType} ${displayName}`);
-                        externalAccessories.push(accessory);
-                    }
-                    else if (isIntercomVideo) {
-                        logInfo(`Configured Ring Intercom Video ${uuid} ${deviceType} ${displayName}`);
-                        externalAccessories.push(accessory);
-                    }
-                    else {
-                        logInfo(`Adding new accessory ${uuid} ${deviceType} ${displayName}`);
-                        platformAccessories.push(accessory);
+                    if (isCamera && this.homebridgeAccessories[uuid]) {
+                        // Camera was previously bridged.  Remove it from the platform so that it can be added as an external accessory
+                        this.log.warn(`Camera ${displayName} was previously bridged. You will need to manually pair it as a new accessory.`);
+                        this.api.unregisterPlatformAccessories(pluginName, platformName, [
+                            this.homebridgeAccessories[uuid],
+                        ]);
+                        delete this.homebridgeAccessories[uuid];
                     }
-                    return accessory;
-                }, homebridgeAccessory = this.homebridgeAccessories[uuid] || createHomebridgeAccessory(), accessory = new AccessoryClass(device, homebridgeAccessory, config);
-                accessory.initBase();
-                this.homebridgeAccessories[uuid] = homebridgeAccessory;
-                activeAccessoryIds.push(uuid);
-                if (config.cameraMotionNotificationSensor &&
-                    accessory instanceof Camera &&
-                    accessory.motionDetected) {
-                    const sensorUuid = getMotionNotificationSensorUuid(debugPrefix + id), sensorName = `${displayName} Motion`;
-                    let sensorAccessory = this.homebridgeAccessories[sensorUuid];
-                    if (!sensorAccessory) {
-                        sensorAccessory = new api.platformAccessory(sensorName, sensorUuid, 10 /* hap.Categories.SENSOR */);
-                        logInfo(`Adding motion notification sensor ${sensorUuid} ${sensorName}`);
-                        platformAccessories.push(sensorAccessory);
+                    let addTo;
+                    const createHomebridgeAccessory = () => {
+                        const category = isCamera
+                            ? 17 /* hap.Categories.CAMERA */
+                            : isIntercomVideo
+                                ? 18 /* hap.Categories.VIDEO_DOORBELL */
+                                : 11 /* hap.Categories.SECURITY_SYSTEM */;
+                        const accessory = new api.platformAccessory(displayName, uuid, category);
+                        if (isCamera) {
+                            logInfo(`Configured camera ${uuid} ${deviceType} ${displayName}`);
+                            addTo = externalAccessories;
+                        }
+                        else if (isIntercomVideo) {
+                            logInfo(`Configured Ring Intercom Video ${uuid} ${deviceType} ${displayName}`);
+                            addTo = externalAccessories;
+                        }
+                        else {
+                            logInfo(`Adding new accessory ${uuid} ${deviceType} ${displayName}`);
+                            addTo = platformAccessories;
+                        }
+                        return accessory;
+                    }, homebridgeAccessory = this.homebridgeAccessories[uuid] || createHomebridgeAccessory(), accessory = new AccessoryClass(device, homebridgeAccessory, config);
+                    accessory.initBase();
+                    // Registered only once set up: a half-built accessory isn't added to HomeKit.
+                    addTo?.push(homebridgeAccessory);
+                    this.homebridgeAccessories[uuid] = homebridgeAccessory;
+                    activeAccessoryIds.push(uuid);
+                    if (config.cameraMotionNotificationSensor &&
+                        accessory instanceof Camera &&
+                        accessory.motionDetected) {
+                        const sensorUuid = getMotionNotificationSensorUuid(debugPrefix + id), sensorName = `${displayName} Motion`;
+                        let sensorAccessory = this.homebridgeAccessories[sensorUuid];
+                        if (!sensorAccessory) {
+                            sensorAccessory = new api.platformAccessory(sensorName, sensorUuid, 10 /* hap.Categories.SENSOR */);
+                            logInfo(`Adding motion notification sensor ${sensorUuid} ${sensorName}`);
+                        }
+                        setUpMotionNotificationSensor(sensorAccessory, sensorName, `${device.id}-motion`, accessory.motionDetected);
+                        if (!this.homebridgeAccessories[sensorUuid]) {
+                            platformAccessories.push(sensorAccessory);
+                        }
+                        this.homebridgeAccessories[sensorUuid] = sensorAccessory;
+                        activeAccessoryIds.push(sensorUuid);
                     }
-                    setUpMotionNotificationSensor(sensorAccessory, sensorName, `${device.id}-motion`, accessory.motionDetected);
-                    this.homebridgeAccessories[sensorUuid] = sensorAccessory;
-                    activeAccessoryIds.push(sensorUuid);
+                }
+                catch (e) {
+                    this.log.error(`Could not set up ${displayName} (${deviceType}): ${describeError(e)}. The other accessories are unaffected; restart Homebridge to try again.`);
+                    const cached = this.homebridgeAccessories[uuid];
+                    if (cached)
+                        markNotResponding(cached);
+                    // Keep it (and a motion sensor it had) in HomeKit rather than removing it as stale.
+                    activeAccessoryIds.push(uuid, getMotionNotificationSensorUuid(debugPrefix + id));
                 }
             });
         }));
+        const failedLocations = locations.filter((_, i) => locationResults[i].status === 'rejected');
+        locationResults.forEach((result, i) => {
+            if (result.status === 'rejected') {
+                const reason = result.reason;
+                this.log.error(`Could not set up the devices of location "${locations[i].name}": ${describeError(reason)}. Restart Homebridge to try again.`);
+            }
+        });
         if (platformAccessories.length) {
             api.registerPlatformAccessories(pluginName, platformName, platformAccessories);
         }
         if (externalAccessories.length) {
             api.publishExternalAccessories(pluginName, externalAccessories);
         }
-        const staleAccessories = cachedAccessoryIds
-            .filter((cachedId) => !activeAccessoryIds.includes(cachedId))
-            .map((id) => this.homebridgeAccessories[id]);
+        // With a location that failed, which cached accessories belong to it is unknown: keep all,
+        // showing "No Response" until a restart sets them up.
+        if (failedLocations.length) {
+            cachedAccessoryIds
+                .filter((cachedId) => !activeAccessoryIds.includes(cachedId))
+                .forEach((id) => markNotResponding(this.homebridgeAccessories[id]));
+        }
+        const staleAccessories = failedLocations.length
+            ? []
+            : cachedAccessoryIds
+                .filter((cachedId) => !activeAccessoryIds.includes(cachedId))
+                .map((id) => this.homebridgeAccessories[id]);
         staleAccessories.forEach((staleAccessory) => {
             logInfo(`Removing stale cached accessory ${staleAccessory.UUID} ${staleAccessory.displayName}`);
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-ring-secure-video",
   "displayName": "Ring Secure Video",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.4",
   "description": "Homebridge plugin for Ring devices with HomeKit Secure Video recording, based on homebridge-ring and homebridge-ring-hksv",
   "type": "module",
   "main": "./lib/index.js",
@@ -85,7 +85,7 @@
     "category-outdoor"
   ],
   "allowScripts": {
-    "ffmpeg-for-homebridge@2.2.1": true,
-    "protobufjs@7.6.4": true
+    "ffmpeg-for-homebridge@2.2.2": true,
+    "protobufjs@7.6.6": true
   }
 }