@homebridge-plugins/homebridge-eufy-security 5.0.0-beta.2 → 5.0.0-beta.21

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') {
@@ -204,21 +257,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 +321,7 @@
     } else if (result.state === 'authentication-required') {
       elements.setup.hidden = false;
     }
+    return attention(result, { title, summary }, messages);
   }
 
   function bindPreferences(elements, getConfig, saveConfig, getMessages, openDevice) {
@@ -260,7 +352,11 @@
       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 +378,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;
             });
@@ -295,6 +398,30 @@
     });
   }
 
+  /**
+   * 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;
+    }
+  }
+
   /**
    * Fills the settings page for one device, which is where its controls live rather than on the tile itself.
    *
@@ -312,7 +439,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/homebridge-ui/public/js/profile-wizard.js

@@ -1,52 +1,22 @@
 (function attachDiagnosticsWizard(global) {
-  const questions = [
-    { profile: 'dashboard-ui', message: 'diagnosticsQuestionDashboard' },
-    { profile: 'startup-authentication', message: 'diagnosticsQuestionStartup' },
-    { profile: 'device-representation', message: 'diagnosticsQuestionDevices' },
-    { profile: 'control-state', message: 'diagnosticsQuestionControl' },
-    { profile: 'live-media', message: 'diagnosticsQuestionLiveMedia' },
-    { profile: 'hksv-recording', message: 'diagnosticsQuestionRecording' },
+  const profiles = [
+    'startup-authentication',
+    'device-representation',
+    'control-state',
+    'live-media',
+    'hksv-recording',
+    'dashboard-ui',
+    'other',
   ];
 
-  function start() {
-    return { mode: 'questions', questionIndex: 0, profile: undefined, source: 'questions' };
-  }
-
-  function answer(state, matches) {
-    if (matches) {
-      return { ...state, mode: 'frequency', profile: questions[state.questionIndex].profile };
-    }
-    if (state.questionIndex === questions.length - 1) {
-      return { ...state, mode: 'frequency', profile: 'other' };
-    }
-    return { ...state, questionIndex: state.questionIndex + 1 };
-  }
-
-  function direct() {
-    return { mode: 'direct', questionIndex: 0, profile: undefined, source: 'direct' };
-  }
-
-  function selectDirect(state, profile) {
-    return { ...state, mode: 'frequency', profile, source: 'direct' };
-  }
-
-  function reject(state) {
-    return state.source === 'direct' ? direct() : start();
-  }
-
-  function chooseReproductionMode(state, reproductionMode) {
-    return { ...state, mode: 'match', reproductionMode };
-  }
-
-  function backFromFrequency(state) {
-    return state.source === 'direct' ? direct() : 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';
+  /**
+   * Which screen a session puts on the panel: its file while one can be downloaded, its capture while one runs, and
+   * otherwise the question, since picking an area replaces the session with a capture of that area.
+   */
+  function screen(session) {
+    if (session.partialExportAvailable) return 'review';
+    if (session.status === 'reproducing') return 'reproduce';
+    return 'choose';
   }
 
   function backgroundActive(session) {
@@ -54,15 +24,8 @@
   }
 
   global.HomebridgeEufyDiagnosticsWizard = {
-    answer,
-    backFromFrequency,
     backgroundActive,
-    chooseReproductionMode,
-    direct,
-    questions,
-    reject,
+    profiles,
     screen,
-    selectDirect,
-    start,
   };
 })(window);

package/i18n/runtime/en.json

@@ -4,22 +4,26 @@
   "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.retryLock": "Retry the lock control manually",
   "log.action.retryTalkback": "Close and reopen the camera, then try speaking again",
   "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",
@@ -85,7 +89,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.2",
+  "version": "5.0.0-beta.21",
   "description": "Control Eufy Security from homebridge.",
   "type": "module",
   "license": "Apache-2.0",
@@ -47,17 +47,17 @@
   ],
   "dependencies": {
     "@homebridge/plugin-ui-utils": "^2.2.6",
-    "@mega-yfue/eufy-sdk": "0.1.0",
+    "@mega-yfue/eufy-sdk": "0.4.0-beta.18",
     "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.3",
     "homebridge": "^2.4.0",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.9",
     "rimraf": "^6.1.3",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.3"
   },
   "homepage": "https://homebridge-plugins.github.io/homebridge-eufy/",
   "author": "homebridge-eufy",