eufy-security-client 4.0.0-dev.33 → 4.0.0-dev.35

package/README.md

@@ -1,5 +1,37 @@
 # eufy-security-client
 
+> [!CAUTION]
+> # 🚨🚨🚨 LIBRARY DEPRECATION NOTICE 🚨🚨🚨
+>
+> ### ⚠️ Eufy is shutting down the legacy APIs this library is built on. ⚠️
+>
+> Eufy is in the middle of a large migration of their ecosystem. The newer **Eufy Mega**
+> platform (the "5-in-1" app, covering Security / Clean / Lights / Care) is gradually
+> becoming the only supported backend, and Eufy has **already started removing access to
+> the legacy APIs** this library was originally built on. Until recently both worked in
+> parallel — that is no longer guaranteed.
+>
+> **🔔 What this means for you:**
+>
+> - 🟢 A recent PR restores **push notifications** against the new v6 ("eufy_mega")
+>   backend, so push works again **for now**. This is a short-term stopgap.
+> - 🟡 Other functionality that still depends on legacy endpoints may stop working
+>   **without warning** as Eufy continues the rollout. The current Eufy app no longer
+>   uses the legacy API at all.
+> - 🔴 Once the legacy API is fully shut down, **this library will stop functioning** —
+>   no amount of patching here will change that.
+>
+> **🚧 What's next:**
+>
+> A new integration built around **Eufy Mega** is in active development (auto-discovery,
+> less battery drain for P2P), designed from the ground up rather than bolted onto the
+> Security-only structure, and coordinated across the Home Assistant, Homebridge and
+> Homey communities so the new library works for everyone.
+>
+> ### 👉 Treat this release as a **temporary stopgap.** 👈
+>
+> *This notice will be updated as the migration progresses.*
+
 ![Logo](docs/_media/eufy-security-client.png)
 
 [![node](https://img.shields.io/node/v/eufy-security-client.svg)](https://www.npmjs.com/package/eufy-security-client)

package/build/eufysecurity.d.ts

@@ -12,6 +12,8 @@ import { LogLevel } from "typescript-logging";
 export declare class EufySecurity extends TypedEmitter<EufySecurityEvents> {
     private config;
     private api;
+    /** All v6 ("eufy_mega") behaviour — transport, login, push, connect sequencing — is isolated here. */
+    private megaTransition;
     private houses;
     private stations;
     private devices;
@@ -70,7 +72,20 @@ export declare class EufySecurity extends TypedEmitter<EufySecurityEvents> {
     setCameraMaxLivestreamDuration(seconds: number): void;
     getCameraMaxLivestreamDuration(): number;
     registerPushNotifications(credentials?: Credentials, persistentIds?: string[]): Promise<void>;
+    /**
+     * Entry point for the consumer. The whole login sequence (v6-first, legacy best-effort, single
+     * app-ready signal at the end, serialisation, 2FA/captcha routing) lives in {@link MegaTransition};
+     * here we just delegate. Removing the transition layer makes this equivalent to {@link legacyConnect}.
+     */
     connect(options?: LoginOptions): Promise<void>;
+    /**
+     * The original (upstream) login: authenticate the legacy backend and trust the device on first
+     * 2FA. Kept verbatim and driven by {@link MegaTransition} as the best-effort second step; it no
+     * longer signals the app directly (that is now done once, at the end of the sequence).
+     */
+    private legacyConnect;
+    /** The narrow surface the v6 transition layer uses to talk back to us, as a closure object. */
+    private megaTransitionHost;
     getPushPersistentIds(): string[];
     private updateDeviceProperties;
     private onAPIClose;

package/build/eufysecurity.js

@@ -42,7 +42,7 @@ const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const util = __importStar(require("util"));
 const events_1 = __importDefault(require("events"));
-const api_1 = require("./http/api");
+const megaTransition_1 = require("./http/megaTransition");
 const station_1 = require("./http/station");
 const types_1 = require("./http/types");
 const service_1 = require("./push/service");
@@ -61,6 +61,8 @@ const utils_3 = require("./p2p/utils");
 class EufySecurity extends tiny_typed_emitter_1.TypedEmitter {
     config;
     api;
+    /** All v6 ("eufy_mega") behaviour — transport, login, push, connect sequencing — is isolated here. */
+    megaTransition;
     houses = {};
     stations = {};
     devices = {};
@@ -236,17 +238,31 @@ class EufySecurity extends tiny_typed_emitter_1.TypedEmitter {
             this.persistentData.cloud_token_expiration = 0;
             this.persistentData.httpApi = undefined;
         }
-        this.api = await api_1.HTTPApi.initialize(this.config.country, this.config.username, this.config.password, this.persistentData.httpApi);
+        // All v6 ("eufy_mega") behaviour is isolated in MegaTransition (login, push, connect
+        // sequencing). It talks back to us only through this narrow host surface and builds the live
+        // transport (the legacy HTTPApi today). Removing the transition layer reverts everything to the
+        // upstream legacy behaviour.
+        this.megaTransition = new megaTransition_1.MegaTransition(this.megaTransitionHost());
+        this.api = await this.megaTransition.createTransport(this.persistentData.httpApi);
         this.api.setLanguage(this.config.language);
         this.api.setPhoneModel(this.config.trustedDeviceName);
         this.api.on("houses", (houses) => this.handleHouses(houses));
         this.api.on("hubs", (hubs) => this.handleHubs(hubs));
         this.api.on("devices", (devices) => this.handleDevices(devices));
         this.api.on("close", () => this.onAPIClose());
-        this.api.on("connect", () => this.onAPIConnect());
-        this.api.on("captcha request", (id, captcha) => this.onCaptchaRequest(id, captcha));
+        // NOTE: the legacy login emitting "connect" no longer drives the app-ready signal directly —
+        // connect() sequences mega + legacy and calls onAPIConnect() once at the very end (see below).
+        this.api.on("connect", () => logging_1.rootMainLogger.debug("Legacy API connected"));
+        // The legacy login records itself as the pending challenge so the next code/captcha is routed to it.
+        this.api.on("captcha request", (id, captcha) => {
+            this.megaTransition.recordLegacyChallenge();
+            this.onCaptchaRequest(id, captcha);
+        });
         this.api.on("auth token invalidated", () => this.onAuthTokenInvalidated());
-        this.api.on("tfa request", () => this.onTfaRequest());
+        this.api.on("tfa request", () => {
+            this.megaTransition.recordLegacyChallenge();
+            this.onTfaRequest();
+        });
         this.api.on("connection error", (error) => this.onAPIConnectionError(error));
         if (this.persistentData.cloud_token &&
             this.persistentData.cloud_token != "" &&
@@ -273,8 +289,11 @@ class EufySecurity extends tiny_typed_emitter_1.TypedEmitter {
         this.pushService.on("connect", async (token) => {
             this.pushCloudRegistered = await this.api.registerPushToken(token);
             this.pushCloudChecked = await this.api.checkPushToken();
+            const megaRegistered = await this.megaTransition.registerMegaPushToken(token);
             //TODO: Retry if failed with max retry to not lock account
-            if (this.pushCloudRegistered && this.pushCloudChecked) {
+            // Push is "connected" if registration succeeded on EITHER backend: on a migrated account the
+            // legacy registration fails (no legacy session) but the v6 one carries the events.
+            if ((this.pushCloudRegistered && this.pushCloudChecked) || megaRegistered) {
                 logging_1.rootMainLogger.info("Push notification connection successfully established");
                 this.emit("push connect");
             }
@@ -870,7 +889,20 @@ class EufySecurity extends tiny_typed_emitter_1.TypedEmitter {
             this.pushService.setPersistentIds(persistentIds);
         this.pushService.open();
     }
+    /**
+     * Entry point for the consumer. The whole login sequence (v6-first, legacy best-effort, single
+     * app-ready signal at the end, serialisation, 2FA/captcha routing) lives in {@link MegaTransition};
+     * here we just delegate. Removing the transition layer makes this equivalent to {@link legacyConnect}.
+     */
     async connect(options) {
+        return this.megaTransition.connect(options);
+    }
+    /**
+     * The original (upstream) login: authenticate the legacy backend and trust the device on first
+     * 2FA. Kept verbatim and driven by {@link MegaTransition} as the best-effort second step; it no
+     * longer signals the app directly (that is now done once, at the end of the sequence).
+     */
+    async legacyConnect(options) {
         await this.api
             .login(options)
             .then(async () => {
@@ -891,6 +923,25 @@ class EufySecurity extends tiny_typed_emitter_1.TypedEmitter {
             logging_1.rootMainLogger.error("Connect Error", { error: (0, utils_1.getError)(error), options: options });
         });
     }
+    /** The narrow surface the v6 transition layer uses to talk back to us, as a closure object. */
+    megaTransitionHost() {
+        // `api` is a getter so the transition layer always sees the live transport, which we assign
+        // right after building the host (and could swap later); the other members are stable.
+        const eufy = this;
+        return {
+            config: this.config,
+            persistentData: this.persistentData,
+            get api() {
+                return eufy.api;
+            },
+            writePersistentData: () => this.writePersistentData(),
+            emitTfaRequest: () => this.onTfaRequest(),
+            emitCaptchaRequest: (id, captcha) => this.onCaptchaRequest(id, captcha),
+            legacyConnect: (options) => this.legacyConnect(options),
+            onAPIConnect: () => this.onAPIConnect(),
+            onConnectionError: (error) => this.onAPIConnectionError(error),
+        };
+    }
     getPushPersistentIds() {
         return this.pushService.getPersistentIds();
     }