@mega-yfue/eufy-sdk 0.5.0-beta.7 → 0.5.0-beta.8

package/dist/client/eufy-mega.d.ts

@@ -835,11 +835,14 @@ export declare class EufyMega extends EventEmitter {
      */
     setProperty(sn: string, name: string, value: boolean | number | string): Promise<void>;
     /**
-     * Restart a HomeBase.
-     *
-     * **HomeBases only** — restart is a hub operation, so a non-HomeBase serial (a camera, an NVR)
-     * throws rather than doing nothing. The hub drops its connection and returns after a minute or two,
-     * so everything behind it is briefly offline. Verified on real hardware.
+     * Restart a station: a HomeBase, or a camera-family device that is its own station.
+     *
+     * The restart is `RESTART_HUB` on the station's broadcast channel, so it reaches whatever owns the
+     * P2P session. A standalone camera or doorbell owns its own session and is the station it restarts.
+     * A camera attached to a HomeBase is not — the same frame would restart its HomeBase — so its serial
+     * throws, as does any non-camera serial, rather than doing nothing. The device drops its connection
+     * and returns after a minute or two; a HomeBase takes everything behind it offline meanwhile.
+     * Verified on real hardware against a HomeBase and a standalone indoor camera.
      */
     reboot(sn: string): Promise<void>;
     /**

package/dist/index.js

@@ -16249,6 +16249,21 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.send(this.connectAddress, RequestMessageType.DATA, data);
     return true;
   }
+  /**
+   * The level-1 twin of {@link sendRawLevel2Bytes}: the plaintext `payload` sealed AES-128-ECB under the
+   * level-1 key, signCode 1 — the seal of the level-1 media start. Returns `false` when not connected.
+   */
+  sendRawLevel1Bytes(payload, channel, outerCmd) {
+    if (!this.connectAddress)
+      return false;
+    const data = Buffer.concat([
+      buildCommandHeader(this.seqNumber, outerCmd),
+      buildRawCommandPayload(encryptP2PData(paddingP2PData(payload), this.level1Key), channel, 1)
+    ]);
+    this.seqNumber = this.seqNumber + 1 & 65535;
+    this.send(this.connectAddress, RequestMessageType.DATA, data);
+    return true;
+  }
   /**
    * Stop the realtime media stream (`CMD_STOP_REALTIME_MEDIA`, 1004) on a camera `channel`, in the shape
    * its runtime topology takes, as {@link startLiveMedia} selects its start:
@@ -21197,14 +21212,20 @@ var P2PCommandRouter = class _P2PCommandRouter {
     }
   }
   /**
-   * Restart a HomeBase. `RESTART_HUB` (1034) is a station-scalar on the broadcast channel 255: a
-   * level-2 frame whose body is `[u32 value][account_id padded]` — the same shape as the hub
-   * alarm-volume control. ✅ Wire-confirmed byte-exact from a capture of the app's own Restart
-   * (2026-08-03) and HW-tested: the captured frame carried value `0` and rebooted the hub. Replays
-   * like every other level-2 control, so a single dropped datagram doesn't lose it.
+   * Restart the station that owns `sn`'s P2P session. `RESTART_HUB` (1034) is a station-scalar on the
+   * broadcast channel 255 whose body is `[u32 value][account_id padded]`, value `0`. ✅ Wire-confirmed
+   * byte-exact as a level-2 frame from a capture of the app's own HomeBase Restart (2026-08-03).
+   *
+   * The seal follows the session, as {@link sendBySessionLevel} defines it: a keyed session takes the
+   * level-2 frame, a keyless one — a standalone camera, which never negotiates a key — the same body
+   * sealed level-1. Both are replayed {@link DIRECT_CMD_SENDS}× at 200ms, as every other unacknowledged
+   * control here is.
    */
   async rebootStation(sn) {
-    await this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8));
+    await this.sendBySessionLevel(sn, {
+      l2: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8), resolved),
+      l1: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel1Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB), resolved)
+    });
   }
   /**
    * A {@link MediaProvider} bound to one serial — resolves the session then calls `p2p/media`.
@@ -27310,16 +27331,20 @@ var EufyMega = class extends EventEmitter9 {
     await this.commandSinkFor(sn).dispatch(cmd);
   }
   /**
-   * Restart a HomeBase.
+   * Restart a station: a HomeBase, or a camera-family device that is its own station.
    *
-   * **HomeBases only** — restart is a hub operation, so a non-HomeBase serial (a camera, an NVR)
-   * throws rather than doing nothing. The hub drops its connection and returns after a minute or two,
-   * so everything behind it is briefly offline. Verified on real hardware.
+   * The restart is `RESTART_HUB` on the station's broadcast channel, so it reaches whatever owns the
+   * P2P session. A standalone camera or doorbell owns its own session and is the station it restarts.
+   * A camera attached to a HomeBase is not — the same frame would restart its HomeBase — so its serial
+   * throws, as does any non-camera serial, rather than doing nothing. The device drops its connection
+   * and returns after a minute or two; a HomeBase takes everything behind it offline meanwhile.
+   * Verified on real hardware against a HomeBase and a standalone indoor camera.
    */
   async reboot(sn) {
     const ctx = await this.commandContext(sn);
-    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model })) {
-      throw new Error(`reboot: ${sn} is not a HomeBase (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart is a hub-only operation`);
+    const standaloneCamera = ctx.codec === "camera" && this.p2p.stationKeyOf(sn) === sn;
+    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model }) && !standaloneCamera) {
+      throw new Error(`reboot: ${sn} is neither a HomeBase nor a standalone camera (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart addresses the station that owns the P2P session`);
     }
     await this.p2p.rebootStation(sn);
   }