@homebridge-plugins/homebridge-eufy-security 4.6.0-beta.3 → 4.6.0-beta.30

package/.claude/skills/new-device-support/map-properties.mjs

@@ -6,13 +6,18 @@
  * to the corresponding property constants in eufy-security-client.
  *
  * Usage:
- *   node map-properties.mjs <raw-properties.json>
- *   cat raw.json | node map-properties.mjs
+ *   node map-properties.mjs <raw-properties.json> [--closest]
+ *   cat raw.json | node map-properties.mjs [--closest]
  *
  * The input JSON should be the rawProperties object from a device dump,
  * e.g. { "1101": { "value": 100 }, "1013": { "value": 1 }, ... }
  * or an array of { "param_type": 1101, "param_value": "..." } objects.
  *
+ * Options:
+ *   --closest   Find the closest existing devices by Jaccard similarity
+ *               on resolved PropertyName overlap. Useful to identify which
+ *               existing device to base the DeviceProperties block on.
+ *
  * Output: a table mapping each param_type to its CommandType/ParamType enum name
  * and all property constants that use that key.
  */
@@ -122,14 +127,17 @@ function parsePropertyConstants(source) {
     props.push({ constName, key, keyRaw, propertyName, spreadFrom });
   }
 
-  // Resolve spreads: if a property has no key but spreads from another, inherit
+  // Resolve spreads: inherit missing fields from parent property
   const byName = new Map(props.map((p) => [p.constName, p]));
   for (const prop of props) {
-    if (prop.key === null && prop.spreadFrom) {
+    if (prop.spreadFrom) {
       const parent = byName.get(prop.spreadFrom);
       if (parent) {
-        prop.key = parent.key;
-        if (!prop.keyRaw) prop.keyRaw = `(spread from ${prop.spreadFrom}) ${parent.keyRaw}`;
+        if (prop.key === null) {
+          prop.key = parent.key;
+          if (!prop.keyRaw) prop.keyRaw = `(spread from ${prop.spreadFrom}) ${parent.keyRaw}`;
+        }
+        // Always inherit propertyName from parent when missing, even if key is overridden
         if (!prop.propertyName) prop.propertyName = parent.propertyName;
       }
     }
@@ -182,7 +190,7 @@ const propUsage = parseDevicePropertiesUsage(httpSource);
 // ── Step 4: Read and parse input JSON ──────────────────────────────────────
 
 let inputData;
-const inputFile = process.argv[2];
+const inputFile = process.argv.slice(2).find((a) => !a.startsWith("-"));
 if (inputFile) {
   inputData = readFileSync(inputFile, "utf-8");
 } else {
@@ -298,19 +306,145 @@ if (unmatched.length > 0) {
   }
 }
 
+// ── Step 6: Companion custom properties ─────────────────────────────────────
+// Some param_type-based properties require a companion custom (runtime) property
+// that never appears in raw device data. Define those pairings here so the
+// suggested block always includes both.
+
+const COMPANION_PROPERTIES = new Map([
+  // DeviceRTSPStream (CMD_NAS_SWITCH) → DeviceRTSPStreamUrl (custom_rtspStreamUrl)
+  ["PropertyName.DeviceRTSPStream", {
+    propertyName: "PropertyName.DeviceRTSPStreamUrl",
+    constName: "DeviceRTSPStreamUrlProperty",
+    reason: "RTSP URL is set at runtime by the station — must accompany DeviceRTSPStream",
+  }],
+  // DeviceWifiRSSI → DeviceWifiSignalLevel (custom_wifiSignalLevel)
+  ["PropertyName.DeviceWifiRSSI", {
+    propertyName: "PropertyName.DeviceWifiSignalLevel",
+    constName: "DeviceWifiSignalLevelProperty",
+    reason: "WiFi signal level is derived at runtime from RSSI",
+  }],
+  // DeviceCellularRSSI → DeviceCellularSignalLevel (custom_cellularSignalLevel)
+  ["PropertyName.DeviceCellularRSSI", {
+    propertyName: "PropertyName.DeviceCellularSignalLevel",
+    constName: "DeviceCellularSignalLevelProperty",
+    reason: "Cellular signal level is derived at runtime from RSSI",
+  }],
+]);
+
 // Output a suggested PropertyName list for use in DeviceProperties block
 console.log();
 console.log("=".repeat(80));
 console.log("SUGGESTED DeviceProperties block entries:");
 console.log("=".repeat(80));
 const seen = new Set();
+const companionsAdded = [];
 for (const m of matched) {
-  for (let i = 0; i < m.constNames.length; i++) {
-    const pn = m.propertyNames[0]; // Use first PropertyName
-    const cn = m.constNames[i];
+  // Use original props lookup to get correct constName → propertyName mapping
+  // (the deduplicated m.propertyNames array loses the index association with m.constNames)
+  const propsForKey = keyToProps.get(m.paramType) || [];
+  for (const prop of propsForKey) {
+    const pn = prop.propertyName;
+    const cn = prop.constName;
     if (pn && !seen.has(pn)) {
       seen.add(pn);
       console.log(`  [${pn}]: ${cn},`);
+
+      // Check if this property has a required companion
+      const companion = COMPANION_PROPERTIES.get(pn);
+      if (companion && !seen.has(companion.propertyName)) {
+        seen.add(companion.propertyName);
+        console.log(`  [${companion.propertyName}]: ${companion.constName},  // ⚠ companion (custom/runtime)`);
+        companionsAdded.push(companion);
+      }
+    }
+  }
+}
+
+if (companionsAdded.length > 0) {
+  console.log();
+  console.log("=".repeat(80));
+  console.log("⚠  COMPANION PROPERTIES (custom/runtime — not in raw device data):");
+  console.log("=".repeat(80));
+  for (const c of companionsAdded) {
+    console.log(`  ${c.constName}: ${c.reason}`);
+  }
+}
+
+// ── Step 7: Closest device detection (--closest flag) ───────────────────────
+
+if (process.argv.includes("--closest")) {
+  // Collect the set of PropertyName values from the matched raw properties
+  const targetPropNames = new Set();
+  for (const m of matched) {
+    for (const pn of m.propertyNames) {
+      if (pn) targetPropNames.add(pn);
+    }
+  }
+
+  if (targetPropNames.size === 0) {
+    console.log("\nCannot compute closest device — no PropertyName matches found.");
+  } else {
+    // Parse DeviceProperties blocks to get property sets per device type
+    const dpStart = httpSource.indexOf("export const DeviceProperties");
+    const dpEnd = httpSource.indexOf("export const StationProperties");
+    if (dpStart !== -1) {
+      const dpSection = httpSource.slice(dpStart, dpEnd === -1 ? undefined : dpEnd);
+
+      const devicePropSets = new Map(); // DeviceType name → Set of PropertyName references
+      const blockRegex = /\[DeviceType\.(\w+)\]\s*:\s*\{([\s\S]*?)\}/g;
+      let bm;
+      while ((bm = blockRegex.exec(dpSection)) !== null) {
+        const dt = bm[1];
+        const body = bm[2];
+        const props = new Set();
+        // Extract property constants used, then resolve to PropertyName
+        const refRegex = /:\s*(\w+Property)/g;
+        let rm;
+        while ((rm = refRegex.exec(body)) !== null) {
+          const constName = rm[1];
+          const prop = allProps.find((p) => p.constName === constName);
+          if (prop && prop.propertyName) props.add(prop.propertyName);
+        }
+        devicePropSets.set(dt, props);
+      }
+
+      // Jaccard similarity
+      const similarities = [];
+      for (const [dt, props] of devicePropSets) {
+        const intersection = new Set([...targetPropNames].filter((p) => props.has(p)));
+        const union = new Set([...targetPropNames, ...props]);
+        const jaccard = union.size > 0 ? intersection.size / union.size : 0;
+        if (jaccard > 0.2) {
+          similarities.push({
+            device: dt,
+            jaccard: Math.round(jaccard * 100),
+            shared: intersection.size,
+            targetOnly: [...targetPropNames].filter((p) => !props.has(p)).length,
+            otherOnly: [...props].filter((p) => !targetPropNames.has(p)).length,
+          });
+        }
+      }
+
+      similarities.sort((a, b) => b.jaccard - a.jaccard);
+      const top = similarities.slice(0, 8);
+
+      console.log();
+      console.log("=".repeat(80));
+      console.log("CLOSEST EXISTING DEVICES (by property overlap with raw data)");
+      console.log("=".repeat(80));
+      if (top.length === 0) {
+        console.log("  No devices with >20% property overlap found.");
+      } else {
+        console.log("  " + "Device".padEnd(38) + "Similarity  Shared  Target-only  Other-only");
+        for (const d of top) {
+          console.log(
+            `  ${d.device.padEnd(38)} ${String(d.jaccard + "%").padEnd(11)} ${String(d.shared).padEnd(7)} ${String(d.targetOnly).padEnd(12)} ${d.otherOnly}`
+          );
+        }
+        console.log();
+        console.log(`  Recommended base: ${top[0].device} (${top[0].jaccard}% overlap)`);
+      }
     }
   }
 }

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)