@homebridge-plugins/homebridge-eufy-security 4.6.0-beta.4 → 4.6.0-beta.41

package/.claude/skills/new-device-support/verify-device.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * verify-device.mjs
+ *
+ * Post-implementation verification script. Checks that a device type is fully
+ * wired into all required registration points after implementation.
+ *
+ * Usage:
+ *   node verify-device.mjs <ENUM_NAME>
+ *
+ * Example:
+ *   node verify-device.mjs CAMERA_4G_S330
+ *   node verify-device.mjs INDOOR_PT_CAMERA_E30
+ *
+ * Output: PASS/FAIL per check, with a final summary.
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const CLIENT_ROOT = join(__dirname, "..", "..", "..", "..", "eufy-security-client");
+const HB_ROOT = join(__dirname, "..", "..", "..");
+const TYPES_HTTP = join(CLIENT_ROOT, "src", "http", "types.ts");
+const DEVICE_TS = join(CLIENT_ROOT, "src", "http", "device.ts");
+const DEVICE_IMAGES = join(HB_ROOT, "homebridge-ui", "public", "utils", "device-images.js");
+const SUPPORTED_DEVICES = join(CLIENT_ROOT, "docs", "supported_devices.md");
+
+const enumName = process.argv[2];
+if (!enumName || enumName.startsWith("-")) {
+  console.error("Usage: verify-device.mjs <ENUM_NAME>");
+  console.error("Example: verify-device.mjs CAMERA_4G_S330");
+  process.exit(1);
+}
+
+const httpSource = readFileSync(TYPES_HTTP, "utf-8");
+const deviceSource = readFileSync(DEVICE_TS, "utf-8");
+
+// ── Extract type number from enum ───────────────────────────────────────────
+
+function getTypeNumber(source, enumN) {
+  const re = new RegExp(`^\\s*${enumN}\\s*=\\s*(\\d+)`, "m");
+  const match = source.match(re);
+  return match ? parseInt(match[1]) : null;
+}
+
+const typeNumber = getTypeNumber(httpSource, enumName);
+
+// ── Check functions ─────────────────────────────────────────────────────────
+
+function checkEnumExists(source, enumN) {
+  const re = new RegExp(`^\\s*${enumN}\\s*=\\s*\\d+`, "m");
+  return re.test(source);
+}
+
+function checkGenericTypePropertyStates(source, typeNum) {
+  if (!typeNum) return { pass: false, detail: "no type number" };
+  const gtpMatch = source.match(/export\s+const\s+GenericTypeProperty[\s\S]*?states:\s*\{([\s\S]*?)\}/);
+  if (!gtpMatch) return { pass: false, detail: "GenericTypeProperty not found" };
+  const re = new RegExp(`${typeNum}:\\s*"`);
+  const found = re.test(gtpMatch[1]);
+  return { pass: found, detail: found ? "label present" : "missing label entry" };
+}
+
+function checkLookupMap(source, mapName, enumN) {
+  const dpStart = source.indexOf(`export const ${mapName}`);
+  if (dpStart === -1) return { pass: false, detail: `${mapName} not found` };
+  const nextExport = source.indexOf("export const ", dpStart + 20);
+  const section = source.slice(dpStart, nextExport === -1 ? undefined : nextExport);
+  const found = section.includes(`[DeviceType.${enumN}]`);
+  return { pass: found, detail: found ? "entry present" : "missing entry" };
+}
+
+function checkTypeGuard(source, enumN) {
+  // Look for a static method that returns DeviceType.ENUM == type
+  const re = new RegExp(`static\\s+(is\\w+)\\s*\\(\\s*type:\\s*number\\s*\\)[^}]*DeviceType\\.${enumN}`, "g");
+  const methods = [];
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    methods.push(m[1]);
+  }
+  return {
+    pass: methods.length > 0,
+    detail: methods.length > 0 ? `found: ${methods.join(", ")}()` : "no type guard method references this enum",
+  };
+}
+
+function checkInstanceMethod(source, enumN) {
+  // Find methods from the type guard check, then look for matching instance methods
+  const staticRe = new RegExp(`static\\s+(is\\w+)\\s*\\(\\s*type:\\s*number\\s*\\)[^}]*DeviceType\\.${enumN}`, "g");
+  const staticMethods = [];
+  let m;
+  while ((m = staticRe.exec(source)) !== null) {
+    staticMethods.push(m[1]);
+  }
+
+  const instanceMethods = [];
+  for (const methodName of staticMethods) {
+    const instanceRe = new RegExp(`public\\s+${methodName}\\s*\\(\\s*\\)\\s*:\\s*boolean`);
+    if (instanceRe.test(source)) {
+      instanceMethods.push(methodName);
+    }
+  }
+
+  return {
+    pass: instanceMethods.length > 0,
+    detail: instanceMethods.length > 0
+      ? `found: ${instanceMethods.join(", ")}()`
+      : staticMethods.length > 0
+        ? `static ${staticMethods.join(", ")}() found but missing instance method(s)`
+        : "no type guard found",
+  };
+}
+
+function checkClassificationMethods(source, enumN) {
+  // Check broad classification methods (isCamera, isLock, isSensor, etc.)
+  const broadMethods = [
+    "isCamera", "isLock", "isSensor", "isKeyPad", "isSmartDrop",
+    "isSmartSafe", "isSmartTrack", "hasBattery", "isFloodLight",
+    "isIndoorCamera", "isDoorbell", "isPanAndTiltCamera",
+    "isSoloCameras", "isLockWifi", "isLockBle", "isEntrySensor",
+    "isMotionSensor",
+  ];
+  const included = [];
+  for (const method of broadMethods) {
+    const re = new RegExp(`static\\s+${method}\\s*\\(\\s*type:\\s*number\\s*\\)[\\s\\S]*?\\n\\s*\\}`, "g");
+    const match = source.match(re);
+    if (match && match[0].includes(`DeviceType.${enumN}`)) {
+      included.push(method);
+    }
+  }
+  return {
+    pass: included.length > 0,
+    detail: included.length > 0
+      ? `in ${included.length} method(s): ${included.join(", ")}`
+      : "not in any broad classification method",
+  };
+}
+
+function checkDeviceImages(typeNum) {
+  if (!typeNum) return { pass: false, detail: "no type number" };
+  if (!existsSync(DEVICE_IMAGES)) return { pass: false, detail: "device-images.js not found" };
+  const source = readFileSync(DEVICE_IMAGES, "utf-8");
+  const re = new RegExp(`case\\s+${typeNum}:`);
+  const found = re.test(source);
+  return { pass: found, detail: found ? "case present" : "missing case" };
+}
+
+function checkSupportedDevicesDocs(enumN) {
+  if (!existsSync(SUPPORTED_DEVICES)) return { pass: false, detail: "supported_devices.md not found" };
+  const source = readFileSync(SUPPORTED_DEVICES, "utf-8");
+  // Check for the enum name or the display name pattern
+  const found = source.includes(enumN) || (typeNumber && new RegExp(`type\\s+${typeNumber}|${typeNumber}\\)`).test(source));
+  // Also check for model number pattern from enum comment (e.g. "CAMERA_4G_S330 = 111, //T86P2")
+  const enumLine = httpSource.match(new RegExp(`${enumN}\\s*=\\s*\\d+.*?//\\s*(\\S+)`));
+  const model = enumLine ? enumLine[1] : null;
+  const modelFound = model && source.includes(model);
+  if (modelFound) return { pass: true, detail: `model ${model} found in docs` };
+  if (found) return { pass: true, detail: "entry found in docs" };
+  return { pass: false, detail: model ? `model ${model} not found` : "not found in docs" };
+}
+
+function checkBySn(source, enumN) {
+  // Check if this device is referenced in any *BySn method
+  // First get the model prefix from the enum comment
+  const enumLine = httpSource.match(new RegExp(`${enumN}\\s*=\\s*\\d+.*?//\\s*(\\S+)`));
+  const model = enumLine ? enumLine[1] : null;
+  if (!model) return { pass: false, detail: "cannot determine model prefix from enum comment" };
+
+  const bySnMethods = ["isIntegratedDeviceBySn", "isSoloCameraBySn", "isSmartDropBySn", "isGarageCameraBySn", "isFloodlightBySn"];
+  const found = [];
+  for (const method of bySnMethods) {
+    const re = new RegExp(`static\\s+${method}\\s*\\([^)]*\\)[\\s\\S]*?\\n\\s*\\}`, "g");
+    const match = source.match(re);
+    if (match && match[0].includes(`"${model}"`)) {
+      found.push(method);
+    }
+  }
+  return {
+    pass: found.length > 0,
+    detail: found.length > 0
+      ? `in ${found.join(", ")}()`
+      : `model ${model} not in any *BySn method (may not be needed)`,
+  };
+}
+
+// ── Run all checks ──────────────────────────────────────────────────────────
+
+const W = 80;
+console.log("=".repeat(W));
+console.log(`Post-Implementation Verification: ${enumName}${typeNumber ? ` (type ${typeNumber})` : ""}`);
+console.log("=".repeat(W));
+console.log();
+
+if (!typeNumber) {
+  console.log(`FATAL: ${enumName} not found in DeviceType enum. Cannot proceed.`);
+  process.exit(1);
+}
+
+const results = [];
+
+function run(label, check, required = true) {
+  const icon = check.pass ? "+" : required ? "-" : "~";
+  const status = check.pass ? "PASS" : required ? "FAIL" : "WARN";
+  results.push({ label, ...check, required, status });
+  console.log(`  [${icon}] ${label.padEnd(35)} ${status.padEnd(6)} ${check.detail}`);
+}
+
+console.log("EUFY-SECURITY-CLIENT (src/http/types.ts)");
+console.log("-".repeat(W));
+run("DeviceType enum", { pass: checkEnumExists(httpSource, enumName), detail: `${enumName} = ${typeNumber}` });
+run("GenericTypeProperty states", checkGenericTypePropertyStates(httpSource, typeNumber));
+run("DeviceProperties map", checkLookupMap(httpSource, "DeviceProperties", enumName));
+run("DeviceCommands map", checkLookupMap(httpSource, "DeviceCommands", enumName));
+run("StationProperties map", checkLookupMap(httpSource, "StationProperties", enumName), false);
+run("StationCommands map", checkLookupMap(httpSource, "StationCommands", enumName), false);
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (src/http/device.ts)");
+console.log("-".repeat(W));
+run("Dedicated type guard (static)", checkTypeGuard(deviceSource, enumName));
+run("Instance method", checkInstanceMethod(deviceSource, enumName));
+run("Classification methods", checkClassificationMethods(deviceSource, enumName));
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (docs)");
+console.log("-".repeat(W));
+run("docs/supported_devices.md", checkSupportedDevicesDocs(enumName), false);
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (serial number methods)");
+console.log("-".repeat(W));
+run("*BySn serial number methods", checkBySn(deviceSource, enumName), false);
+console.log();
+
+console.log("HOMEBRIDGE-EUFY-SECURITY");
+console.log("-".repeat(W));
+run("device-images.js", checkDeviceImages(typeNumber));
+console.log();
+
+// ── Summary ─────────────────────────────────────────────────────────────────
+
+const failed = results.filter((r) => r.status === "FAIL");
+const warned = results.filter((r) => r.status === "WARN");
+const passed = results.filter((r) => r.status === "PASS");
+
+console.log("=".repeat(W));
+if (failed.length === 0) {
+  console.log(`ALL REQUIRED CHECKS PASSED (${passed.length} pass, ${warned.length} warn)`);
+  if (warned.length > 0) {
+    console.log("Warnings (optional):");
+    for (const w of warned) {
+      console.log(`  - ${w.label}: ${w.detail}`);
+    }
+  }
+} else {
+  console.log(`${failed.length} REQUIRED CHECK(S) FAILED:`);
+  for (const f of failed) {
+    console.log(`  - ${f.label}: ${f.detail}`);
+  }
+  if (warned.length > 0) {
+    console.log(`\n${warned.length} warning(s):`);
+    for (const w of warned) {
+      console.log(`  - ${w.label}: ${w.detail}`);
+    }
+  }
+}
+console.log("=".repeat(W));
+
+process.exit(failed.length > 0 ? 1 : 0);

package/.claude/skills/planner/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: planner
+description: Build a precise, step-by-step action plan before making any code changes. Use this skill whenever the user describes a feature, bug fix, refactor, or any multi-file change. Also use when the user says "plan", "think through", "what would it take", or describes a problem without jumping to code. TRIGGER BEFORE writing any code for non-trivial changes. Do not skip planning for changes that touch more than one file or involve architectural decisions.
+---
+
+# Planner
+
+You are a planning agent for homebridge-eufy-security. Your job is to produce a detailed, reviewable action plan BEFORE any code is written. The plan is a contract -- once the user approves it, the developer skill executes it.
+
+Follow all project conventions from CLAUDE.md (architecture, ESM imports, lint, build, git workflow). Use the Architecture section to trace impact across files.
+
+## When to plan
+
+Always plan when:
+- The change touches more than one file
+- A new device type, accessory, or service is being added
+- The change involves the streaming pipeline or recording delegates
+- Configuration schema changes are needed
+- The change crosses the plugin/eufy-security-client boundary
+
+Skip planning (just do it) when:
+- Single-line typo or constant fix
+- The user explicitly says "just do it" or "quick fix"
+
+## Planning process
+
+### Step 1 -- Understand the goal
+
+Read the relevant source files before planning. Never plan based on assumptions about code you haven't read. Identify:
+
+- What is the user trying to achieve?
+- Is this a bug fix, feature, refactor, or chore?
+- Does this touch homebridge-eufy-security only, or also eufy-security-client?
+
+### Step 2 -- Identify affected files
+
+List every file that needs to change. For each file, note:
+- What section/function changes
+- Why it changes
+- Dependencies on other changes in the plan
+
+### Step 3 -- Define guardrails
+
+For every plan, explicitly state:
+- **Lint**: Will this pass `npm run lint` (zero warnings)?
+- **Build**: Will `npm run build` succeed?
+- **ESM**: Do new imports use `.js` extensions?
+- **Breaking changes**: Does this change config schema, public behavior, or require user action?
+- **Boundary**: Is any part of this change in the wrong layer? (plugin vs eufy-security-client)
+
+### Step 4 -- Sequence the work
+
+Order the changes so each step is independently buildable where possible. Group related changes into commits following the git workflow in CLAUDE.md.
+
+### Step 5 -- Present the plan
+
+Output the plan in this format:
+
+```
+## Plan: <title>
+
+### Goal
+<one sentence>
+
+### Changes
+
+1. **<file path>** -- <what and why>
+   - <specific function/section>
+   - <detail>
+
+2. **<file path>** -- <what and why>
+   ...
+
+### Guardrails
+- [ ] Lint passes
+- [ ] Build passes
+- [ ] ESM imports correct
+- [ ] No breaking config changes (or: breaking change documented)
+- [ ] Correct architectural layer
+
+### Commits
+1. `feat: <message>` -- files: <list>
+2. `fix: <message>` -- files: <list>
+
+### Risks / Open questions
+- <anything uncertain that needs user input>
+```
+
+Wait for the user to approve, modify, or reject before proceeding.
+
+## Chaining
+
+When the user approves the plan (says "go", "looks good", "approved", "do it", etc.), immediately invoke the **developer** skill to execute it. Pass the approved plan as context -- do not ask the user to repeat it.
+
+## What NOT to do
+
+- Never start editing files during planning
+- Never assume device properties without reading raw data or existing code
+- Never plan changes to `src/version.ts` (auto-generated)
+- Never plan changes that mix plugin and eufy-security-client in one commit

package/.claude/skills/qa/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: qa
+description: Verify that code changes are correct, safe, and ready to ship. Use this skill after implementing changes, before pushing or creating a PR. Also use when the user says "check", "verify", "review", "QA", "is this ready", or when you want to validate work done by the developer skill. Runs build, lint, and structural checks.
+---
+
+# QA / Verification
+
+You are a quality assurance agent for homebridge-eufy-security. Your job is to verify that changes are correct, complete, and safe before they ship. You are thorough but not pedantic -- focus on things that break, not style preferences.
+
+Refer to CLAUDE.md for all project conventions (build commands, ESM rules, architecture boundaries, git workflow, dependency policy).
+
+## Verification checklist
+
+Run through these checks in order. Stop at the first failure and report it.
+
+### 1. Build verification
+
+Run `npm run lint` and `npm run build`. Both must pass with zero errors and zero warnings.
+
+### 2. Import verification
+
+Check all new or modified imports for `.js` extensions (NodeNext), resolution to real files, and circular imports.
+
+### 3. Architectural boundary check
+
+For each changed file, verify:
+- Plugin code uses the eufy-security-client public API (events, commands, property accessors), not internal methods
+- `homebridge-ui/server.js` and `src/utils/accessoriesStore.ts` are in sync if device/station record shapes changed
+- No HomeKit service logic leaked into base classes that shouldn't have it
+
+### 4. Configuration safety
+
+If config schema changed (`src/utils/configTypes.ts`): defaults set for new options, existing configs still work, `config.schema.json` updated if applicable.
+
+### 5. Streaming pipeline check
+
+If streaming code changed (`src/controller/`): valid FFmpeg arguments, correct SRTP handling, clean stream lifecycle, concurrent stream limits respected.
+
+### 6. Git hygiene
+
+Per CLAUDE.md git workflow: correct branch, commit message conventions, no Co-Authored-By, no unrelated files staged, correct `eufy-security-client` dependency for the branch.
+
+### 7. Diff review
+
+Read the full diff and check for: accidental debug logging, hardcoded values that should be in `src/settings.ts`, missing `override` keyword, new eslint-disable comments.
+
+## Output format
+
+```
+## QA Report
+
+### Status: PASS / FAIL
+
+### Checks
+- [x] Build passes
+- [x] Lint passes (0 warnings)
+- [x] ESM imports correct
+- [x] Architecture boundaries respected
+- [ ] Config schema -- ISSUE: <description>
+- [x] Git hygiene
+
+### Issues found
+1. **<severity>**: <description> -- <file>:<line>
+
+### Ready to push: YES / NO
+```
+
+## Chaining
+
+- **If QA passes**: Ask the user if they want to push and/or create a PR.
+- **If QA fails**: Fix issues that are safe to fix silently (typos, missing `.js` extensions). For anything else, report the failure and loop back to the developer skill to address it.
+
+## When to flag vs fix
+
+- **Typos in your own changes**: Fix silently
+- **Missing `.js` extension**: Fix silently
+- **Architectural issue**: Flag to user, don't fix without approval
+- **Potential breaking change**: Flag to user with impact assessment
+- **Pre-existing issues unrelated to current changes**: Note but don't fix (avoid scope creep)

package/.claude/skills/support/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: support
+description: Triage a GitHub issue using diagnostics archives and logs. Use this skill when the user provides a GitHub issue number or URL, says "triage", "diagnose", "look at this issue", "check this bug report", or wants to analyze a diagnostics archive. Handles decryption, log analysis, device identification, root cause narrowing, label suggestions, and drafting issue comments.
+---
+
+# Support / Issue Triage
+
+You are a support triage agent for homebridge-eufy-security. Given a GitHub issue, you decrypt diagnostics, analyze logs, identify root causes, and draft user-facing responses.
+
+Refer to CLAUDE.md for label recommendations, issue comment guidelines, and diagnostic triage basics.
+
+## Input
+
+The user provides `$ARGUMENTS` as either:
+- A GitHub issue number (e.g. `423`)
+- A GitHub issue URL (e.g. `https://github.com/homebridge-plugins/homebridge-eufy-security/issues/423`)
+
+## Step 1 -- Fetch the issue
+
+```bash
+gh issue view <number> --repo homebridge-plugins/homebridge-eufy-security
+```
+
+Extract:
+- What the user reports (symptoms, expected vs actual behavior)
+- Device model/type if mentioned
+- Plugin version if mentioned
+- Whether a diagnostics archive is attached
+
+If no diagnostics attached, draft a comment asking the user to export diagnostics with debug mode enabled and stop.
+
+## Step 2 -- Download and decrypt diagnostics
+
+Download the `.tar.gz.enc` attachment, then:
+
+```bash
+node scripts/decrypt-diagnostics.mjs <file>.tar.gz.enc
+```
+
+The script prints the archive creation date. Note if the archive is older than 90 days -- data may be stale.
+
+## Step 3 -- Validate archive completeness
+
+List the extracted files and check what's present:
+
+| File | Required for |
+|---|---|
+| `accessories.json` | All issues |
+| `eufy-security.log` | Runtime issues |
+| `eufy-lib.log` | Runtime issues |
+| `configui-server.log` | UI issues |
+| `configui-lib.log` | UI issues |
+| `ffmpeg.log` | Streaming/snapshot issues |
+| `ffmpeg-<serial>.log` | Per-camera streaming issues |
+| `ffmpeg-snapshots.log` | Snapshot issues |
+| `unsupported.json` | Device support requests |
+
+**Stop conditions:**
+- Runtime logs missing (`eufy-security.log`, `eufy-lib.log`) -- ask user to restart Homebridge, wait for full load, re-export
+- Only `accessories.json` present -- archive incomplete, can only confirm device presence
+
+## Step 4 -- Check debug mode
+
+In `eufy-security.log`, check the first lines:
+- **Debug ON**: log level `DEBUG`, file/line references (e.g. `platform.ts:311`), logger name includes version (e.g. `[EufySecurity-4.4.2-beta.41]`)
+- **Debug OFF**: log level starts at `INFO`, no file/line refs, logger name is just `[EufySecurity]`
+
+Also check config dump for `"enableDetailedLogging":true`.
+
+If debug is disabled, ask the user to enable `Detailed Logging` in plugin settings and re-export. Label `debug log missing`.
+
+## Step 5 -- Extract environment
+
+From the first lines of `eufy-security.log`:
+- Plugin version
+- eufy-security-client version
+- Node.js version
+- OS and architecture
+
+**HOOBS check**: If the environment indicates HOOBS (storage path, OS, or user mentions it), label `hoobs` + `wontfix`, comment, and close per CLAUDE.md guidelines.
+
+**Node.js check**: Plugin requires Node.js 20, 22, or 24. If on an unsupported version, note it.
+
+**PKCS1 check**: Node.js 24.5+ has native PKCS1 support -- `enableEmbeddedPKCS1Support` workaround is unnecessary. For Node.js 20/22, the embedded fallback is still needed.
+
+## Step 6 -- Check config for excluded devices
+
+From the config dump in `eufy-security.log`:
+- `ignoreDevices` -- serial numbers excluded
+- `ignoreStations` -- station serials excluded
+- `cleanCache` -- stale accessory pruning
+
+In `accessories.json`:
+- `disabled: true` on a station -- its devices won't load
+- `ignored: true` on a device -- excluded
+- `unsupported: true` -- device type not supported
+
+## Step 7 -- Confirm device presence
+
+Search `accessories.json` for the reported device by type, model, serial, or name. Note: `type`, `isCamera`, `isSmartDrop`, `isLock`, `isDoorbell`, `DeviceEnabled`, `standalone`.
+
+## Step 8 -- Analyze logs
+
+### Runtime issues (`eufy-security.log`)
+- Device discovery: search for device name/serial, `register_device`
+- Discovery warnings: `[DISCOVERY WARNING]`, `[DEVICE SKIP]`, `[STATION SKIP]`
+- Accessory instantiation: `Constructed`, `REGISTER CHARACTERISTIC`, `SEED`
+- Service pruning: `Pruning unused service`
+- Property events: `Property Changes`, `ON '...`
+- Errors: `Error`, stack traces
+
+### Library issues (`eufy-lib.log`)
+- Device serial presence -- did the library load it?
+- `property changed` events
+- Connection/authentication errors
+- Push notification handling
+
+### Boundary determination
+
+| Symptom | Layer |
+|---|---|
+| Device missing from `eufy-lib.log` or API errors | `eufy-security-client` |
+| Device loads in library but fails in accessory registration | `homebridge-eufy-security` |
+| P2P/push/MQTT failures | `eufy-security-client` |
+| HomeKit service wrong or missing | `homebridge-eufy-security` |
+| Config not applied | `homebridge-eufy-security` |
+
+### Streaming issues
+
+Check per-camera FFmpeg log (`ffmpeg-<serial>.log`) first -- it isolates that camera's stderr. Look for codec errors, resolution mismatches, connection failures.
+
+If logs are insufficient for livestream issues, consider requesting temporary device sharing:
+
+```
+To validate a fix and avoid back-and-forth log exchanges, I'd need to test against an actual <device model> device. Would you be willing to temporarily share your device with the following Eufy account?
+
+homebridge.eufy.sec@gmail.com
+
+Please also let me know which country your account is registered in.
+
+This is entirely optional -- no obligation. I understand sharing device access requires trust. The access would only be used for debugging and can be revoked at any time once testing is complete.
+```
+
+## Step 9 -- Cross-reference with code
+
+If needed, read the relevant source to confirm behavior. Use the Architecture section in CLAUDE.md to locate the right files.
+
+## Step 10 -- Produce triage report
+
+Output:
+
+```
+## Triage: #<issue-number> -- <title>
+
+### Environment
+- Plugin: <version>
+- eufy-security-client: <version>
+- Node.js: <version>
+- OS: <os>
+
+### Root cause
+<concise explanation with file:line references if applicable>
+
+### Layer
+homebridge-eufy-security / eufy-security-client / configuration issue / inconclusive
+
+### Suggested labels
+<comma-separated labels from CLAUDE.md label table>
+
+### Suggested action
+<what to do next: fix, upstream issue, request more info, close>
+
+### Draft comment
+<user-facing comment ready to post -- formal, concise, first person, simple language, no jargon>
+```