@homebridge-plugins/homebridge-eufy-security 5.0.0-beta.4 → 5.0.0-beta.40

package/homebridge-ui/public/js/dashboard.js

@@ -8,12 +8,65 @@
       .replaceAll("'", ''');
   }
 
+  const EUFY_MODES = [
+    { value: 'away', label: 'Away' },
+    { value: 'home', label: 'Home' },
+    { value: 'schedule', label: 'Schedule' },
+    { value: 'custom1', label: 'Custom 1' },
+    { value: 'custom2', label: 'Custom 2' },
+    { value: 'custom3', label: 'Custom 3' },
+    { value: 'off', label: 'Off' },
+    { value: 'geo', label: 'Geofencing' },
+    { value: 'disarmed', label: 'Disarmed' },
+  ];
+  /** What each HomeKit state means where the household assigned nothing, as the adapter resolves it. */
+  const DEFAULT_ARMING_MODES = { home: 'home', away: 'away', off: 'disarmed' };
+  const ARMING_SLOTS = [
+    { slot: 'home', label: 'armingSlotHome' },
+    { slot: 'away', label: 'armingSlotAway' },
+    { slot: 'night', label: 'armingSlotNight' },
+    { slot: 'off', label: 'armingSlotOff' },
+  ];
+
+  /**
+   * The guard-mode map: four states HomeKit names against the nine a station reports, one pairing per row.
+   *
+   * Folded shut, because the four defaults are what nearly every household keeps and the panel has a camera's
+   * worth of settings above it. The summary carries the whole map as text, so the answer is readable without
+   * opening anything, and a household that assigned a state of its own finds it already open.
+   *
+   * A row is the whole control — the state names itself and the select beside it says what it means. An
+   * unassigned state shows a dash, which is what keeps Night out of HomeKit until it is given a mode.
+   *
+   * It is withheld while the security system it maps is turned off, and the stored map is kept for when it is back.
+   */
+  function armingModeControl(device, assigned, messages, securitySystem) {
+    const summary = ARMING_SLOTS.map(
+      ({ slot, label }) => `${messages[label]} → ${EUFY_MODES.find((mode) => mode.value === assigned[slot])?.label ?? '—'}`,
+    ).join(' · ');
+    const rows = ARMING_SLOTS.map(({ slot, label }) => {
+      const value = assigned[slot] ?? '';
+      const id = `arming-${escapeHtml(device.serial)}-${slot}`;
+      const options = EUFY_MODES.map(
+        (mode) =>
+          `<option value="${mode.value}"${value === mode.value ? ' selected' : ''}>${escapeHtml(mode.label)}</option>`,
+      ).join('');
+      return `<tr><th scope="row"><label for="${id}">${escapeHtml(messages[label])}</label></th><td><select id="${id}" data-preference="armingModes" data-slot="${slot}" data-serial="${escapeHtml(device.serial)}" data-original="${escapeHtml(value)}"><option value=""${value === '' ? ' selected' : ''}>—</option>${options}</select></td></tr>`;
+    }).join('');
+    const assignedItself = ARMING_SLOTS.some(({ slot }) => assigned[slot] !== DEFAULT_ARMING_MODES[slot]);
+    return `<details class="arming-setting" data-setting${assignedItself ? ' open' : ''}${device.represented && securitySystem ? '' : ' hidden'} data-requires-representation data-requires-security-system><summary><span class="setting-label">${escapeHtml(messages.preferenceArmingModes)}</span><span class="arming-summary">${escapeHtml(summary)}</span></summary><table class="arming-table"><thead><tr><th scope="col">HomeKit</th><th scope="col">eufy</th></tr></thead><tbody>${rows}</tbody></table><p class="snapshot-help">${escapeHtml(messages.armingModesHelp)}</p></details>`;
+  }
+
   function preferenceControl(device, key, preference, messages) {
     const labels = {
       represented: messages.preferenceRepresented,
       audio: messages.preferenceAudio,
+      securitySystem: messages.preferenceSecuritySystem,
       snapshotMode: messages.preferenceSnapshotMode,
     };
+    if (key === 'armingModes') {
+      return armingModeControl(device, preference.armingModes, messages, preference.securitySystem);
+    }
     const represented = preference.represented;
     const dependent = key === 'represented' ? '' : ` data-requires-representation${represented ? '' : ' hidden'}`;
     if (key === 'snapshotMode') {
@@ -29,7 +82,7 @@
 
   function markPendingPreference(control, key, value) {
     if (!control?.classList || control.dataset.original === undefined) return;
-    const current = key === 'snapshotMode' ? String(value) : String(Boolean(value));
+    const current = key === 'snapshotMode' || key === 'armingModes' ? String(value) : String(Boolean(value));
     const setting = control.closest('[data-setting]');
     const changed = current !== control.dataset.original;
     if (key === 'snapshotMode') {
@@ -43,35 +96,20 @@
     tile?.classList.toggle('device-tile-changed', Boolean(tile.querySelector('.preference-control-changed')));
   }
 
-  /**
-   * The eight battery icons the shipped set draws, from empty to full.
-   *
-   * Ordered, because the level picks one by its position: eight steps of twelve and a half percent each.
-   */
-  const BATTERY_STEPS = [
-    'battery_0',
-    'battery_1',
-    'battery_2',
-    'battery_3',
-    'battery_4',
-    'battery_5',
-    'battery_6',
-    'battery_full',
-  ];
-
   /**
    * The battery badge a device gets, where it reports a level, and nothing where it does not.
    *
    * The icon carries the level and the exact percentage goes to the label: a tile is read at a glance, and a
    * number on every tile would be read deliberately or not at all. A device on mains power reports no level, and
-   * neither does one nothing is observing, so both are left without a badge rather than shown an empty one.
+   * neither does one nothing is observing, so both are left without a badge rather than shown an empty one. The
+   * shipped set draws eight icons, `battery_0` to `battery_6` then `battery_full`, one per twelve and a half percent.
    */
   function batteryBadge(device, messages) {
     if (typeof device.battery !== 'number') {
       return undefined;
     }
-    const step = Math.floor(device.battery / (100 / BATTERY_STEPS.length));
-    const icon = BATTERY_STEPS[Math.min(BATTERY_STEPS.length - 1, Math.max(0, step))];
+    const step = Math.min(7, Math.max(0, Math.floor(device.battery / 12.5)));
+    const icon = step === 7 ? 'battery_full' : `battery_${step}`;
     const label = (messages.deviceBattery ?? '').replace('{level}', String(Math.round(device.battery)));
     return label ? { icon, label, variant: 'battery' } : undefined;
   }
@@ -204,21 +242,59 @@
   }
 
   /*
-   * The states a diagnostic run can shed light on. Sign-in, another process holding the session, and a pending
-   * restart each have their own remedy stated on the page, so sending those to the wizard would be a detour.
+   * The states a diagnostic run can shed light on. Sign-in, another process holding the session, a pending
+   * restart, a plugin that stopped on an error, a page that could not load, and a connection that recovers on its
+   * own each have their own remedy stated on the page, so sending those to the wizard would be a detour.
    */
-  const DIAGNOSABLE = new Set(['degraded', 'incomplete', 'missing', 'stale']);
+  const DIAGNOSABLE = new Set(['incomplete', 'missing', 'stale']);
+
+  /** The diagnostics area a condition's capture belongs to, by its code. A code no entry matches is `other`. */
+  const CONDITION_AREAS = [
+    [/^camera-recording/, 'hksv-recording'],
+    [/^camera-(?:live|media|streaming|snapshot|talkback)/, 'live-media'],
+    [/lock|light|arming|siren|contact|camera-control/, 'control-state'],
+    [/transport-degraded/, 'startup-authentication'],
+  ];
 
+  /**
+   * The problem the diagnostics action points at, or nothing: a state a run explains, then the first active condition
+   * this page has words for, then the first device nothing can reach. Each names the diagnostics area a run on it is
+   * about. A condition is worded under its log keys; the ones left unworded are those the page answers on its own,
+   * such as a sign-in or another owner, and the devices no action makes supported.
+   */
+  function attention(result, state, messages) {
+    if (DIAGNOSABLE.has(result.state)) return { ...state, profile: 'startup-authentication' };
+    const condition = (result.conditions ?? []).find(
+      ({ summaryKey, actionKey }) => messages[summaryKey] && messages[actionKey],
+    );
+    if (condition) {
+      return {
+        title: messages[condition.summaryKey],
+        summary: messages[condition.actionKey],
+        profile: CONDITION_AREAS.find(([code]) => code.test(condition.code))?.[1] ?? 'other',
+      };
+    }
+    const device = result.devices.find((candidate) => candidate.availability === 'unavailable');
+    return (
+      device && {
+        title: (messages.attentionUnreachableTitle ?? '').replace('{device}', device.name),
+        summary: messages.attentionUnreachableSummary ?? '',
+        profile: 'device-representation',
+      }
+    );
+  }
+
+  /** Draws the dashboard, and answers the problem it shows the diagnostics action, if any. */
   function render(result, config, messages, elements) {
     const suffix = result.state
       .split('-')
       .map((part) => part[0].toUpperCase() + part.slice(1))
       .join('');
-    elements.title.textContent = messages[`dashboard${suffix}Title`] ?? messages.dashboardIncompleteTitle;
-    elements.summary.textContent = messages[`dashboard${suffix}Summary`] ?? messages.dashboardIncompleteSummary;
+    const title = messages[`dashboard${suffix}Title`] ?? messages.dashboardIncompleteTitle;
+    const summary = messages[`dashboard${suffix}Summary`] ?? messages.dashboardIncompleteSummary;
+    elements.title.textContent = title;
+    elements.summary.textContent = summary;
     elements.dashboard.dataset.state = result.state;
-    // Offered rather than announced: a run is worth suggesting only where the state is one a run explains.
-    if (elements.diagnose) elements.diagnose.hidden = !DIAGNOSABLE.has(result.state);
     elements.dashboard.hidden = false;
     elements.masthead.hidden = true;
     renderUpdatePending(result, messages, elements);
@@ -230,6 +306,7 @@
     } else if (result.state === 'authentication-required') {
       elements.setup.hidden = false;
     }
+    return attention(result, { title, summary }, messages);
   }
 
   function bindPreferences(elements, getConfig, saveConfig, getMessages, openDevice) {
@@ -254,13 +331,17 @@
       },
       true,
     );
-    (elements.deviceSettingsControls ?? elements.groups).addEventListener('change', async (event) => {
+    const onPreferenceChange = async (event) => {
       const control = event.target;
       const serial = control?.dataset?.serial;
       const key = control?.dataset?.preference;
       const existing = getConfig();
       if (!existing || !serial || !key) return;
-      const defaults = { represented: true, audio: true, snapshotMode: 'Refresh' };
+      const defaults = { represented: true, audio: true, securitySystem: true, snapshotMode: 'Refresh' };
+      if (key === 'armingModes') {
+        await saveArmingMode(control, serial, existing, saveConfig, getMessages, elements);
+        return;
+      }
       const value = key === 'snapshotMode' ? control.value : control.checked;
       markPendingPreference(control, key, value);
       if (key === 'snapshotMode') {
@@ -282,9 +363,16 @@
             (candidate) => candidate.dataset.serial === serial,
           );
           tile?.classList.toggle('device-tile-disabled', !value);
+          const grid = control.closest('.preference-grid');
+          const securityOff = grid?.querySelector('[data-preference="securitySystem"]')?.checked === false;
+          grid?.querySelectorAll('[data-requires-representation]').forEach((setting) => {
+            setting.hidden = !value || (securityOff && setting.hasAttribute('data-requires-security-system'));
+          });
+        }
+        if (key === 'securitySystem') {
           control
             .closest('.preference-grid')
-            ?.querySelectorAll('[data-requires-representation]')
+            ?.querySelectorAll('[data-requires-security-system]')
             .forEach((setting) => {
               setting.hidden = !value;
             });
@@ -292,7 +380,34 @@
       } catch {
         elements.summary.textContent = getMessages().preferenceSaveFailed;
       }
-    });
+    };
+    for (const container of elements.preferenceContainers ?? [elements.deviceSettingsControls ?? elements.groups]) {
+      container.addEventListener('change', onPreferenceChange);
+    }
+  }
+
+  /**
+   * Records one HomeKit state's guard mode, keeping the map sparse: a state set back to the plugin's own choice
+   * is removed rather than pinned, so a later default reaches a household that never overrode it.
+   */
+  async function saveArmingMode(control, serial, existing, saveConfig, getMessages, elements) {
+    const slot = control.dataset.slot;
+    const value = control.value;
+    markPendingPreference(control, 'armingModes', value);
+    const entityPreferences = { ...(existing.entityPreferences ?? {}) };
+    const preference = { ...(entityPreferences[serial] ?? {}) };
+    const armingModes = { ...(preference.armingModes ?? {}) };
+    if (value === '') delete armingModes[slot];
+    else armingModes[slot] = value;
+    if (Object.keys(armingModes).length === 0) delete preference.armingModes;
+    else preference.armingModes = armingModes;
+    if (Object.keys(preference).length === 0) delete entityPreferences[serial];
+    else entityPreferences[serial] = preference;
+    try {
+      await saveConfig({ ...existing, entityPreferences });
+    } catch {
+      elements.summary.textContent = getMessages().preferenceSaveFailed;
+    }
   }
 
   /**
@@ -312,7 +427,9 @@
     const preference = {
       represented: preferences[device.serial]?.represented ?? true,
       audio: preferences[device.serial]?.audio ?? true,
+      securitySystem: preferences[device.serial]?.securitySystem ?? true,
       snapshotMode: preferences[device.serial]?.snapshotMode ?? 'Refresh',
+      armingModes: { ...DEFAULT_ARMING_MODES, ...preferences[device.serial]?.armingModes },
     };
     const controls = device.preferences
       .map((key) => preferenceControl(device, key, preference, messages))

package/i18n/runtime/en.json

@@ -4,22 +4,28 @@
   "log.action.checkPhysicalArmingMode": "Check the physical security-system mode before retrying",
   "log.action.checkPhysicalLight": "Check the physical smart-light state before retrying",
   "log.action.checkPhysicalLock": "Check the physical lock state before retrying",
+  "log.action.controlTimedOut": "The device did not answer in time; use the Eufy app for this control, and attach a diagnostics file to your issue if it keeps happening",
   "log.action.checkCameraSnapshot": "Check that the camera is reachable and can produce an image, then open the camera again",
   "log.action.waitCameraControl": "No action is needed; the control returns when the camera reports it again",
   "log.action.checkCameraControl": "Check the camera in the Eufy app; this control is unavailable until it reports its state",
   "log.action.retryCameraControl": "Try the control again; the camera did not confirm the change",
   "log.action.enableCamera": "Turn the camera on in the Eufy app, then open live view again",
-  "log.action.openDashboard": "Review device representation in the Homebridge Eufy dashboard",
+  "log.action.notSupportedYet": "No action is needed; these devices are not supported in HomeKit yet",
   "log.action.reduceConcurrentMedia": "Open live view again; if it keeps happening, close a camera already open or raise the concurrent camera media limit in the plugin settings",
   "log.action.reauthenticate": "Authenticate again in the Homebridge Eufy dashboard, then restart Homebridge",
   "log.action.retryArming": "Retry the security-system control manually",
   "log.action.retryLight": "Retry the smart-light control manually",
   "log.action.retryLiveView": "Open live view again, and check network access between Homebridge and the camera",
+  "log.action.setFfmpegPath": "Set a custom FFmpeg path in Advanced settings in the Homebridge Eufy dashboard",
+  "log.action.checkFfmpegPath": "FFmpeg could not be started; check the custom FFmpeg path in Advanced settings in the Homebridge Eufy dashboard",
+  "log.action.checkStation": "Check that the station or HomeBase this camera uses is powered and online, and network access between Homebridge and it, then open live view again",
+  "log.action.retryLiveViewNoPicture": "The camera answered but sent no picture in time. Open live view again; if it keeps happening, send a diagnostics file",
   "log.action.retryLock": "Retry the lock control manually",
   "log.action.retryTalkback": "Close and reopen the camera, then try speaking again",
+  "log.action.trySmallVideoPackets": "If the live view never shows in the Home app, turn on Smaller live video packets in Advanced settings in the Homebridge Eufy dashboard",
   "log.action.reviewRuntime": "Review Homebridge Eufy health in the dashboard and restart Homebridge",
   "log.action.stopOtherOwner": "Stop the other Homebridge Eufy owner before restarting Homebridge",
-  "log.action.selectSupportedArmingMode": "Select Stay, Away, or Disarm to leave the unsupported mode",
+  "log.action.mapArmingMode": "Assign this mode to a HomeKit state under HomeKit guard modes in the device's settings in the Homebridge Eufy dashboard",
   "log.action.waitBattery": "Wait for complete battery capability evidence",
   "log.action.waitArming": "Wait for complete arming capability evidence",
   "log.action.waitBatteryObservation": "Wait for a valid battery observation",
@@ -39,6 +45,7 @@
   "log.condition.affectedOne": "1 accessory is affected.",
   "log.condition.recovered": "Recovered: {summary}.",
   "log.diagnosticFileFailed": "Diagnostic file logging failed; check storage permissions.",
+  "log.liveVideoEncoders": "Live video encoders, in order of use: {encoders}.",
   "log.discardedSettings": "Some legacy settings were discarded. Review and acknowledge them in the Homebridge Eufy dashboard.",
   "log.snapshotCacheInvalid": "An invalid retained camera image was removed",
   "log.homekit.batteryCapabilityUnavailable": "Battery information is unavailable",
@@ -85,7 +92,7 @@
   "log.notice.stateSubscriberFailed": "A runtime state consumer failed; review Homebridge Eufy health in the dashboard.",
   "log.notice.statusPublicationFailed": "Runtime status could not be published; dashboard status may be stale.",
   "log.notice.channelServeFailed": "Live runtime status could not be served to the plugin settings page; it will show the last published status instead.",
-  "log.notice.diagnosticsAuthorizationArmed": "Diagnostic evidence collection is now active in the plugin runtime.",
+  "log.notice.diagnosticsAuthorizationArmed": "A diagnostics capture started; finish it from the plugin settings before {finishBy}.",
   "log.notice.standDownNotRearmed": "Homebridge Eufy stood down for an authentication and could not take the account session back; restart Homebridge to bring it back.",
   "log.notice.standDownAccountReplaced": "Homebridge Eufy stood down for an authentication that replaced the account; restart Homebridge to use the new account.",
   "log.runtime.authenticationRequired": "Eufy authentication is required",

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Homebridge Eufy",
   "name": "@homebridge-plugins/homebridge-eufy-security",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.40",
   "description": "Control Eufy Security from homebridge.",
   "type": "module",
   "license": "Apache-2.0",
@@ -26,12 +26,9 @@
   "scripts": {
     "lint": "prettier --check 'src/**/*.ts' 'test/**/*.ts'",
     "lint-fix": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "build": "npm run build-plugin",
-    "build-plugin": "rimraf ./dist && tsc",
+    "build": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\" && tsc",
     "guard:no-ecs": "bash scripts/guard-no-ecs.sh",
     "qualify:release": "node scripts/qualify-release.mjs",
-    "docs:dev": "npm -C docs run dev",
-    "docs:build": "npm -C docs run build",
     "test": "vitest run",
     "verify": "npm run lint && npm run guard:no-ecs && npm run build && npm test",
     "prepublishOnly": "npm run build && npm run qualify:release && npm run verify"
@@ -47,21 +44,23 @@
   ],
   "dependencies": {
     "@homebridge/plugin-ui-utils": "^2.2.6",
-    "@mega-yfue/eufy-sdk": "0.1.0",
+    "@mega-yfue/eufy-sdk": "0.6.0-beta.26",
     "ffmpeg-for-homebridge": "2.2.2"
   },
   "devDependencies": {
-    "@homebridge/hap-nodejs": "2.2.2",
-    "@types/node": "^26.4.1",
+    "@homebridge/hap-nodejs": "2.2.3",
+    "@types/node": "^26.6.5",
     "homebridge": "^2.4.0",
-    "prettier": "^3.9.6",
-    "rimraf": "^6.1.3",
+    "prettier": "^3.9.10",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.5"
   },
   "homepage": "https://homebridge-plugins.github.io/homebridge-eufy/",
   "author": "homebridge-eufy",
   "allowScripts": {
     "ffmpeg-for-homebridge@2.2.2": true
+  },
+  "optionalDependencies": {
+    "node-datachannel": "0.33.5"
   }
 }

package/homebridge-ui/public/js/legacy-settings.js

@@ -1,37 +0,0 @@
-(function legacySettingsModule(global) {
-  const keys = [
-    'CameraMaxLivestreamDuration',
-    'autoSyncStation',
-    'cameras',
-    'cleanCache',
-    'debugLivestream',
-    'enableDetailedLogging',
-    'enableEmbeddedPKCS1Support',
-    'experimentalMode',
-    'hkAway',
-    'hkHome',
-    'hkNight',
-    'hkOff',
-    'ignoreDevices',
-    'ignoreMultipleDevicesWarning',
-    'ignoreStations',
-    'omitLogFiles',
-    'stations',
-    'syncStationModes',
-    'useEmbeddedPKCS1Support',
-  ];
-
-  function effectful(key, value) {
-    const defaults = { CameraMaxLivestreamDuration: 30, hkHome: 1, hkAway: 0, hkNight: 3, hkOff: 63 };
-    if (Object.hasOwn(defaults, key)) return value !== defaults[key];
-    if (Array.isArray(value)) return value.length > 0;
-    if (value && typeof value === 'object') return Object.keys(value).length > 0;
-    return Boolean(value);
-  }
-
-  function names(block) {
-    return keys.filter((key) => Object.hasOwn(block, key) && effectful(key, block[key])).sort();
-  }
-
-  global.HomebridgeEufyLegacySettings = { names };
-})(window);

package/homebridge-ui/public/js/profile-wizard.js

@@ -1,61 +0,0 @@
-(function attachDiagnosticsWizard(global) {
-  const profiles = [
-    'startup-authentication',
-    'device-representation',
-    'control-state',
-    'live-media',
-    'hksv-recording',
-    'dashboard-ui',
-    'other',
-  ];
-
-  const deviceProfiles = ['device-representation', 'control-state', 'live-media', 'hksv-recording'];
-
-  function start() {
-    return { mode: 'tiles', profile: undefined };
-  }
-
-  function select(state, profile) {
-    return { ...state, mode: deviceProfiles.includes(profile) ? 'devices' : 'frequency', profile };
-  }
-
-  function chooseDevices(state, devices) {
-    return { ...state, mode: 'frequency', devices };
-  }
-
-  function reject() {
-    return start();
-  }
-
-  function chooseReproductionMode(state, reproductionMode) {
-    return { ...state, mode: 'match', reproductionMode };
-  }
-
-  function backFromFrequency(state) {
-    return deviceProfiles.includes(state.profile) ? { ...state, mode: 'devices' } : start();
-  }
-
-  function screen(session, startingAnother) {
-    if (session.partialExportAvailable && !startingAnother) return 'review';
-    if (startingAnother || session.status === 'inactive' || session.status === 'expired') return 'choose';
-    if (session.status === 'authorized' || session.status === 'reproducing') return 'reproduce';
-    return 'status';
-  }
-
-  function backgroundActive(session) {
-    return session.status === 'reproducing' && session.profile === 'dashboard-ui';
-  }
-
-  global.HomebridgeEufyDiagnosticsWizard = {
-    backFromFrequency,
-    backgroundActive,
-    chooseDevices,
-    chooseReproductionMode,
-    deviceProfiles,
-    profiles,
-    reject,
-    screen,
-    select,
-    start,
-  };
-})(window);