@homebridge-plugins/homebridge-eufy-security 5.0.0-beta.41 → 5.0.0-beta.43

package/dist/diagnostics.js

@@ -264,6 +264,10 @@ const DIAGNOSTICS_UI_EVENTS = [
     'authentication-commit-failed',
     'authentication-timed-out',
     'authentication-closed',
+    'live-picture-seen',
+    'live-picture-not-seen',
+    'live-preview-seen',
+    'live-preview-not-seen',
 ];
 const SUPPORT_ARCHIVE_KEY = {
     keyId: 'support-2026-08-01',
@@ -349,6 +353,18 @@ const DIAGNOSTICS_PROFILES = {
     'dashboard-ui': ['plugin-log', 'ui-log'],
     other: ['plugin-log', 'sdk-log', 'homekit-log', 'ffmpeg-log'],
 };
+/**
+ * The evidence a session collects: its profile's, and the UI log too for a live-media capture that named cameras,
+ * whose guided encoder attempts record the reporter's picture answers.
+ */
+function selectedEvidence(session) {
+    const evidence = DIAGNOSTICS_PROFILES[session.profile];
+    return session.profile === 'live-media' &&
+        Array.isArray(session.affectedDevices) &&
+        session.affectedDevices.length > 0
+        ? [...evidence, 'ui-log']
+        : evidence;
+}
 /** Narrows external profile input against the diagnostics-owned profile registry. */
 export function isDiagnosticsProfile(value) {
     return typeof value === 'string' && Object.hasOwn(DIAGNOSTICS_PROFILES, value);
@@ -397,6 +413,35 @@ function activeDiagnosticsSession(storageRoot, now) {
     const session = readDiagnosticsSession(storageRoot);
     return session && Date.parse(session.expiresAt) > now ? session : undefined;
 }
+/** How many live starts of each named camera a guided live-media capture codes with an encoder variant. */
+const LIVE_ENCODE_ATTEMPTS = 6;
+/**
+ * Counts each live start of a camera that a reproducing live-media capture named, and returns where it falls: the
+ * camera's position among the named ones, and the start's index while it is below {@link LIVE_ENCODE_ATTEMPTS}.
+ * Counting restarts with each reproduction. Outside one, and for a camera it did not name, it counts nothing.
+ */
+export function liveEncodeAttempts(storageRoot, now = Date.now) {
+    let reproduction;
+    const starts = new Map();
+    return (serial) => {
+        const session = activeDiagnosticsSession(storageRoot, now());
+        const named = session?.affectedDevices;
+        const camera = named === undefined || named === 'all' ? -1 : named.indexOf(serial);
+        if (session?.profile !== 'live-media' ||
+            !session.reproductionStartedAt ||
+            session.reproductionEndedAt ||
+            camera < 0) {
+            return undefined;
+        }
+        if (reproduction !== `${session.supportCaseId}@${session.reproductionStartedAt}`) {
+            reproduction = `${session.supportCaseId}@${session.reproductionStartedAt}`;
+            starts.clear();
+        }
+        const started = starts.get(serial) ?? 0;
+        starts.set(serial, started + 1);
+        return { camera, ...(started < LIVE_ENCODE_ATTEMPTS ? { variant: started } : {}) };
+    };
+}
 /**
  * A session as it stands at `now`: a capture still running when its authorization ends is finished at that end.
  *
@@ -742,7 +787,7 @@ export class GuidedDiagnostics {
         this.pendingUiEvents += 1;
         const write = this.uiEventWrites.then(async () => {
             const session = this.requireAuthorized();
-            if (!DIAGNOSTICS_PROFILES[session.profile].includes('ui-log') ||
+            if (!selectedEvidence(session).includes('ui-log') ||
                 !session.reproductionStartedAt ||
                 session.reproductionEndedAt) {
                 throw new Error('An active dashboard or sign-in reproduction is required');
@@ -796,7 +841,7 @@ export class GuidedDiagnostics {
         }
         const collected = await this.collectSupportEvidence(session);
         const reproductionStartedAt = Date.parse(session.reproductionStartedAt);
-        const selected = DIAGNOSTICS_PROFILES[session.profile];
+        const selected = selectedEvidence(session);
         const createdAt = this.now();
         const manifest = {
             version: 2,
@@ -995,7 +1040,7 @@ export class GuidedDiagnostics {
             });
         }
         const log = await this.readReproductionLog(session.reproductionStartedAt, session.reproductionEndedAt);
-        for (const selected of DIAGNOSTICS_PROFILES[session.profile]) {
+        for (const selected of selectedEvidence(session)) {
             const carried = log.get(selected);
             if (!carried)
                 continue;
@@ -1183,11 +1228,11 @@ export class GuidedDiagnostics {
             return { status: 'inactive', selectedEvidence: [], missingEvidence: [], partialExportAvailable: false };
         }
         const { session, exportable } = settledDiagnosticsSession(persisted, this.now());
-        const selectedEvidence = DIAGNOSTICS_PROFILES[session.profile];
+        const selected = selectedEvidence(session);
         const collected = session.reproductionStartedAt && session.reproductionEndedAt
             ? await this.collectSupportEvidence(session)
             : undefined;
-        const missingEvidence = collected ? missingEvidenceClasses(selectedEvidence, collected) : [];
+        const missingEvidence = collected ? missingEvidenceClasses(selected, collected) : [];
         const expired = Date.parse(session.expiresAt) <= this.now() && !exportable;
         const status = expired
             ? 'expired'
@@ -1201,7 +1246,7 @@ export class GuidedDiagnostics {
             supportCaseId: session.supportCaseId,
             profile: session.profile,
             reproductionMode: session.reproductionMode,
-            selectedEvidence,
+            selectedEvidence: selected,
             missingEvidence,
             authorizedAt: session.authorizedAt,
             expiresAt: session.expiresAt,
@@ -1210,8 +1255,76 @@ export class GuidedDiagnostics {
             partialExportAvailable: exportable,
             ...(session.affectedDevices === undefined ? {} : { affectedDevices: session.affectedDevices }),
             issueUrl: bugReportUrl(session, missingEvidence, readHostEnvironment(this.storageRoot)),
+            ...(status === 'reproducing' && session.profile === 'live-media' && Array.isArray(session.affectedDevices)
+                ? { liveEncode: await this.liveEncode(session) }
+                : {}),
         };
     }
+    /** What {@link liveEncodeAttempts} was followed through so far, for one reproduction of one capture. */
+    liveEncodeScan;
+    /**
+     * Follows the live starts a reproducing live-media capture recorded, reading only what the current plugin log
+     * gained since the last read. The starts are kept across a rotation; a process that restarts after one follows
+     * only what the new file holds.
+     */
+    async liveEncode(session) {
+        const reproduction = `${session.supportCaseId}@${session.reproductionStartedAt}`;
+        if (this.liveEncodeScan?.reproduction !== reproduction) {
+            this.liveEncodeScan = { reproduction, offset: 0, starts: [], byAccessory: new Map() };
+        }
+        const scan = this.liveEncodeScan;
+        const startedAt = Date.parse(session.reproductionStartedAt);
+        try {
+            const file = await open(join(this.storageRoot, LOG_DIRECTORY, LOG_FILE), 'r');
+            try {
+                const size = (await file.stat()).size;
+                if (size < scan.offset)
+                    scan.offset = 0;
+                const buffer = Buffer.alloc(size - scan.offset);
+                await file.read(buffer, 0, buffer.length, scan.offset);
+                const end = buffer.lastIndexOf(0x0a) + 1;
+                scan.offset += end;
+                for (const line of buffer.subarray(0, end).toString('utf8').split('\n')) {
+                    let record;
+                    try {
+                        record = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (record.adapter !== 'camera.streaming' || !(Date.parse(String(record.timestamp)) >= startedAt))
+                        continue;
+                    const known = scan.byAccessory.get(record.accessory);
+                    if (record.event === 'live-video-selected' && record.operation === 'start') {
+                        const start = {
+                            ...(typeof record.camera === 'number' ? { camera: record.camera } : {}),
+                            ...(typeof record.variant === 'number' ? { variant: record.variant } : {}),
+                            state: 'started',
+                        };
+                        scan.starts.push(start);
+                        scan.byAccessory.set(record.accessory, start);
+                    }
+                    else if (record.event === 'live-session-streaming' && known?.state === 'started') {
+                        known.state = 'streaming';
+                    }
+                    else if (record.event === 'live-session-released' && known) {
+                        known.state = 'ended';
+                    }
+                }
+            }
+            finally {
+                await file.close();
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const events = (await this.readUiEvents(session)).match(/"event":"live-(?:picture|preview)-[a-z-]+"/g) ?? [];
+        const answers = events.filter((event) => event.includes('picture')).length;
+        const previews = events.filter((event) => event.includes('preview')).map((event) => !event.includes('not-seen'));
+        return { attempts: LIVE_ENCODE_ATTEMPTS, starts: scan.starts, answers, previews };
+    }
     /**
      * Replaces the persisted session, and drops the `diagnostics/evidence` tree with it.
      *
@@ -1388,7 +1501,7 @@ export function createDiagnosticLogger(target, storageRoot, now = Date.now) {
                 return;
             const session = activeDiagnosticsSession(storageRoot, now());
             const verbose = VERBOSE_SCOPES.has(String(event.scope));
-            if (verbose && (!session || !DIAGNOSTICS_PROFILES[session.profile].includes(evidenceClassOf(event)))) {
+            if (verbose && (!session || !selectedEvidence(session).includes(evidenceClassOf(event)))) {
                 return;
             }
             file.write(event);
@@ -2609,6 +2722,7 @@ function sanitizeAdaptationNotice(value, level) {
     const sourceHeight = nonNegativeInteger(value.sourceHeight);
     const cause = allowlistedLabel(value.cause, ADAPTATION_CAUSES);
     const encoder = allowlistedLabel(value.encoder, LIVE_VIDEO_ENCODERS);
+    const variant = boundedInteger(value.variant, LIVE_ENCODE_ATTEMPTS - 1);
     const source = allowlistedLabel(value.source, LIVE_VIDEO_SOURCES);
     return {
         scope: 'ffmpeg',
@@ -2617,6 +2731,7 @@ function sanitizeAdaptationNotice(value, level) {
         event: value.event,
         ...(cause === undefined ? {} : { cause }),
         ...(encoder === undefined ? {} : { encoder }),
+        ...(variant === undefined ? {} : { variant }),
         ...(source === undefined ? {} : { source }),
         ...(sourceWidth === undefined || sourceHeight === undefined ? {} : { sourceWidth, sourceHeight }),
         ...(code === undefined ? {} : { code }),
@@ -2742,6 +2857,8 @@ function sanitizeLiveVideoSelection(value) {
     const mtu = boundedInteger(value.mtu, MAX_LIVE_VIDEO_MTU, MIN_LIVE_VIDEO_MTU);
     const maxBitRate = boundedInteger(value.maxBitRate, MAX_LIVE_VIDEO_BIT_RATE, 0);
     const addressVersion = allowlistedLabel(value.addressVersion, HOMEKIT_LIVE_ADDRESS_VERSIONS);
+    const camera = boundedInteger(value.camera, MAX_ACCESSORY_ALIASES);
+    const variant = boundedInteger(value.variant, LIVE_ENCODE_ATTEMPTS - 1);
     if (!operation ||
         !profile ||
         !codecLevel ||
@@ -2765,6 +2882,8 @@ function sanitizeLiveVideoSelection(value) {
         mtu,
         ...(maxBitRate === undefined ? {} : { maxBitRate }),
         addressVersion,
+        ...(camera === undefined ? {} : { camera }),
+        ...(variant === undefined ? {} : { variant }),
         ...(alias === undefined ? {} : { accessory: alias }),
     };
 }