Init

build/mqtt/interface.d.ts

@@ -0,0 +1,6 @@
+import { DeviceSmartLockMessage } from "./model";
+export interface MQTTServiceEvents {
+    "connect": () => void;
+    "close": () => void;
+    "lock message": (message: DeviceSmartLockMessage) => void;
+}

build/mqtt/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

build/mqtt/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../src/mqtt/interface.ts"],"names":[],"mappings":""}

build/mqtt/model.d.ts

@@ -0,0 +1,24 @@
+export interface DeviceSmartLockNotifyData {
+    stationSn: string;
+    deviceSn: string;
+    eventType: number;
+    eventTime: number;
+    shortUserId: string;
+    unknown1: string;
+    nickName: string;
+    userId: string;
+    unknown2: string;
+    deviceName: string;
+    unknown3: string;
+    lockState: string;
+}
+export interface DeviceSmartLockNotify {
+    timestamp: number;
+    uuid: string;
+    data: DeviceSmartLockNotifyData;
+}
+export interface DeviceSmartLockMessage {
+    eventType: number;
+    userId: string;
+    data: DeviceSmartLockNotify;
+}

build/mqtt/model.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model.js.map

build/mqtt/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/mqtt/model.ts"],"names":[],"mappings":""}

build/mqtt/mqtt-eufy.crt

@@ -0,0 +1,79 @@
+-----BEGIN CERTIFICATE-----
+MIIE0DCCA7igAwIBAgIBBzANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
+EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
+ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTExMDUwMzA3MDAwMFoXDTMxMDUwMzA3
+MDAwMFowgbQxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
+EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjEtMCsGA1UE
+CxMkaHR0cDovL2NlcnRzLmdvZGFkZHkuY29tL3JlcG9zaXRvcnkvMTMwMQYDVQQD
+EypHbyBEYWRkeSBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IC0gRzIwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC54MsQ1K92vdSTYuswZLiBCGzD
+BNliF44v/z5lz4/OYuY8UhzaFkVLVat4a2ODYpDOD2lsmcgaFItMzEUz6ojcnqOv
+K/6AYZ15V8TPLvQ/MDxdR/yaFrzDN5ZBUY4RS1T4KL7QjL7wMDge87Am+GZHY23e
+cSZHjzhHU9FGHbTj3ADqRay9vHHZqm8A29vNMDp5T19MR/gd71vCxJ1gO7GyQ5HY
+pDNO6rPWJ0+tJYqlxvTV0KaudAVkV4i1RFXULSo6Pvi4vekyCgKUZMQWOlDxSq7n
+eTOvDCAHf+jfBDnCaQJsY1L6d8EbyHSHyLmTGFBUNUtpTrw700kuH9zB0lL7AgMB
+AAGjggEaMIIBFjAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV
+HQ4EFgQUQMK9J47MNIMwojPX+2yz8LQsgM4wHwYDVR0jBBgwFoAUOpqFBxBnKLbv
+9r0FQW4gwZTaD94wNAYIKwYBBQUHAQEEKDAmMCQGCCsGAQUFBzABhhhodHRwOi8v
+b2NzcC5nb2RhZGR5LmNvbS8wNQYDVR0fBC4wLDAqoCigJoYkaHR0cDovL2NybC5n
+b2RhZGR5LmNvbS9nZHJvb3QtZzIuY3JsMEYGA1UdIAQ/MD0wOwYEVR0gADAzMDEG
+CCsGAQUFBwIBFiVodHRwczovL2NlcnRzLmdvZGFkZHkuY29tL3JlcG9zaXRvcnkv
+MA0GCSqGSIb3DQEBCwUAA4IBAQAIfmyTEMg4uJapkEv/oV9PBO9sPpyIBslQj6Zz
+91cxG7685C/b+LrTW+C05+Z5Yg4MotdqY3MxtfWoSKQ7CC2iXZDXtHwlTxFWMMS2
+RJ17LJ3lXubvDGGqv+QqG+6EnriDfcFDzkSnE3ANkR/0yBOtg2DZ2HKocyQetawi
+DsoXiWJYRBuriSUBAA/NxBti21G00w9RKpv0vHP8ds42pM3Z2Czqrpv1KrKQ0U11
+GIo/ikGQI31bS/6kA1ibRrLDYGCD+H1QQc7CoZDDu+8CL9IVVO5EFdkKrqeKM+2x
+LXY2JtwE65/3YR8V3Idv7kaWKK2hJn0KCacuBKONvPi8BDAB
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEfTCCA2WgAwIBAgIDG+cVMA0GCSqGSIb3DQEBCwUAMGMxCzAJBgNVBAYTAlVT
+MSEwHwYDVQQKExhUaGUgR28gRGFkZHkgR3JvdXAsIEluYy4xMTAvBgNVBAsTKEdv
+IERhZGR5IENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTQwMTAx
+MDcwMDAwWhcNMzEwNTMwMDcwMDAwWjCBgzELMAkGA1UEBhMCVVMxEDAOBgNVBAgT
+B0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoTEUdvRGFkZHku
+Y29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRpZmljYXRlIEF1
+dGhvcml0eSAtIEcyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv3Fi
+CPH6WTT3G8kYo/eASVjpIoMTpsUgQwE7hPHmhUmfJ+r2hBtOoLTbcJjHMgGxBT4H
+Tu70+k8vWTAi56sZVmvigAf88xZ1gDlRe+X5NbZ0TqmNghPktj+pA4P6or6KFWp/
+3gvDthkUBcrqw6gElDtGfDIN8wBmIsiNaW02jBEYt9OyHGC0OPoCjM7T3UYH3go+
+6118yHz7sCtTpJJiaVElBWEaRIGMLKlDliPfrDqBmg4pxRyp6V0etp6eMAo5zvGI
+gPtLXcwy7IViQyU0AlYnAZG0O3AqP26x6JyIAX2f1PnbU21gnb8s51iruF9G/M7E
+GwM8CetJMVxpRrPgRwIDAQABo4IBFzCCARMwDwYDVR0TAQH/BAUwAwEB/zAOBgNV
+HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFDqahQcQZyi27/a9BUFuIMGU2g/eMB8GA1Ud
+IwQYMBaAFNLEsNKR1EwRcbNhyz2h/t2oatTjMDQGCCsGAQUFBwEBBCgwJjAkBggr
+BgEFBQcwAYYYaHR0cDovL29jc3AuZ29kYWRkeS5jb20vMDIGA1UdHwQrMCkwJ6Al
+oCOGIWh0dHA6Ly9jcmwuZ29kYWRkeS5jb20vZ2Ryb290LmNybDBGBgNVHSAEPzA9
+MDsGBFUdIAAwMzAxBggrBgEFBQcCARYlaHR0cHM6Ly9jZXJ0cy5nb2RhZGR5LmNv
+bS9yZXBvc2l0b3J5LzANBgkqhkiG9w0BAQsFAAOCAQEAWQtTvZKGEacke+1bMc8d
+H2xwxbhuvk679r6XUOEwf7ooXGKUwuN+M/f7QnaF25UcjCJYdQkMiGVnOQoWCcWg
+OJekxSOTP7QYpgEGRJHjp2kntFolfzq3Ms3dhP8qOCkzpN1nsoX+oYggHFCJyNwq
+9kIDN0zmiN/VryTyscPfzLXs4Jlet0lUIDyUGAzHHFIYSaRt4bNYC8nY7NmuHDKO
+KHAN4v6mF56ED71XcLNa6R+ghlO773z/aQvgSMO3kwvIClTErF0UZzdsyqUvMQg3
+qm5vjLyb4lddJIGvl5echK1srDdMZvNhkREg5L4wn3qkKQmw4TRfZHcYQFHfjDCm
+rw==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----

build/mqtt/proto/lock.proto

@@ -0,0 +1,33 @@
+// Copyright: (c) 2022-2024, Patrick Broetto <patrick.broetto@gmail.com>
+// MIT License
+
+syntax = "proto3";
+
+package eufy_security_client.lock;
+
+message DeviceSmartLockMessage {
+    optional uint32 event_type = 1;
+    optional string user_id = 2;
+    optional DeviceSmartLockNotify data = 3;
+}
+
+message DeviceSmartLockNotify {
+    optional uint64 timestamp = 1;
+    optional string uuid = 2;
+    optional DeviceSmartLockNotifyData data = 3;
+}
+
+message DeviceSmartLockNotifyData {
+    optional string station_sn = 1;
+    optional string device_sn = 2;
+    optional uint32 event_type = 3;
+    optional uint64 event_time = 4;
+    optional string short_user_id = 5;
+    optional string unknown1 = 6;
+    optional string nick_name = 7;
+    optional string user_id = 8;
+    optional string unknown2 = 9;
+    optional string device_name = 10;
+    optional string unknown3 = 11;
+    optional string lock_state = 12;
+}

build/mqtt/service.d.ts

@@ -0,0 +1,28 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import { MQTTServiceEvents } from "./interface";
+export declare class MQTTService extends TypedEmitter<MQTTServiceEvents> {
+    private readonly CLIENT_ID_FORMAT;
+    private readonly USERNAME_FORMAT;
+    private readonly SUBSCRIBE_NOTICE_FORMAT;
+    private readonly SUBSCRIBE_LOCK_FORMAT;
+    private readonly SUBSCRIBE_DOORBELL_FORMAT;
+    private static proto;
+    private connected;
+    private client;
+    private connecting;
+    private clientID?;
+    private androidID?;
+    private apiBase?;
+    private email?;
+    private subscribeLocks;
+    private deviceSmartLockMessageModel;
+    private constructor();
+    static init(): Promise<MQTTService>;
+    private parseSmartLockMessage;
+    private getMQTTBrokerUrl;
+    connect(clientID: string, androidID: string, apiBase: string, email: string): void;
+    private _subscribeLock;
+    subscribeLock(deviceSN: string): void;
+    isConnected(): boolean;
+    close(): void;
+}

build/mqtt/service.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTTService = void 0;
+const mqtt = __importStar(require("mqtt"));
+const tiny_typed_emitter_1 = require("tiny-typed-emitter");
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const protobufjs_1 = require("protobufjs");
+const utils_1 = require("../utils");
+const logging_1 = require("../logging");
+const error_1 = require("../error");
+class MQTTService extends tiny_typed_emitter_1.TypedEmitter {
+    CLIENT_ID_FORMAT = "android_EufySecurity_<user_id>_<android_id>";
+    USERNAME_FORMAT = "eufy_<user_id>";
+    SUBSCRIBE_NOTICE_FORMAT = "/phone/<user_id>/notice";
+    SUBSCRIBE_LOCK_FORMAT = "/phone/smart_lock/<device_sn>/push_message";
+    SUBSCRIBE_DOORBELL_FORMAT = "/phone/doorbell/<device_sn>/push_message";
+    static proto = null;
+    connected = false;
+    client = null;
+    connecting = false;
+    clientID;
+    androidID;
+    apiBase;
+    email;
+    subscribeLocks = [];
+    deviceSmartLockMessageModel;
+    constructor() {
+        super();
+        this.deviceSmartLockMessageModel = MQTTService.proto.lookupType("DeviceSmartLockMessage");
+    }
+    static async init() {
+        try {
+            this.proto = await (0, protobufjs_1.load)(path.join(__dirname, "./proto/lock.proto"));
+        }
+        catch (error) {
+            logging_1.rootMainLogger.error("Error loading MQTT proto lock file", { error: (0, error_1.ensureError)(error) });
+        }
+        return new MQTTService();
+    }
+    parseSmartLockMessage(data) {
+        const message = this.deviceSmartLockMessageModel.decode(data);
+        const object = this.deviceSmartLockMessageModel.toObject(message, {
+            longs: String,
+            enums: String,
+            bytes: String,
+        });
+        return object;
+    }
+    getMQTTBrokerUrl(apiBase) {
+        switch (apiBase) {
+            case "https://security-app.eufylife.com":
+                return "mqtts://security-mqtt.eufylife.com";
+            case "https://security-app-ci.eufylife.com":
+                return "mqtts://security-mqtt-ci.eufylife.com";
+            case "https://security-app-qa.eufylife.com":
+            case "https://security-app-cn-qa.anker-in.com":
+                return "mqtts://security-mqtt-qa.eufylife.com";
+            case "https://security-app-eu.eufylife.com":
+                return "mqtts://security-mqtt-eu.eufylife.com";
+            case "https://security-app-short-qa.eufylife.com":
+                return "mqtts://security-mqtt-short-qa.eufylife.com";
+            default:
+                return "mqtts://security-mqtt.eufylife.com";
+        }
+    }
+    connect(clientID, androidID, apiBase, email) {
+        this.clientID = clientID;
+        this.androidID = androidID;
+        this.apiBase = apiBase;
+        this.email = email;
+        if (!this.connected && !this.connecting && this.clientID && this.androidID && this.apiBase && this.email && this.subscribeLocks.length > 0) {
+            this.connecting = true;
+            this.client = mqtt.connect(this.getMQTTBrokerUrl(apiBase), {
+                keepalive: 60,
+                clean: true,
+                reschedulePings: true,
+                resubscribe: true,
+                port: 8789,
+                username: this.USERNAME_FORMAT.replace("<user_id>", clientID),
+                password: email,
+                ca: fse.readFileSync(path.join(__dirname, "./mqtt-eufy.crt")),
+                clientId: this.CLIENT_ID_FORMAT.replace("<user_id>", clientID).replace("<android_id>", androidID),
+                rejectUnauthorized: false // Some eufy mqtt servers have an expired certificate :(
+            });
+            this.client.on("connect", (_connack) => {
+                this.connected = true;
+                this.connecting = false;
+                this.emit("connect");
+                this.client.subscribe(this.SUBSCRIBE_NOTICE_FORMAT.replace("<user_id>", clientID), { qos: 1 });
+                if (this.subscribeLocks.length > 0) {
+                    let lock;
+                    while ((lock = this.subscribeLocks.shift()) !== undefined) {
+                        this._subscribeLock(lock);
+                    }
+                }
+            });
+            this.client.on("close", () => {
+                this.connected = false;
+                this.emit("close");
+            });
+            this.client.on("error", (error) => {
+                this.connecting = false;
+                logging_1.rootMQTTLogger.error("MQTT Error", { error: (0, utils_1.getError)(error) });
+                if (error.code === 1 || error.code === 2 || error.code === 4 || error.code === 5)
+                    this.client?.end();
+            });
+            this.client.on("message", (topic, message, _packet) => {
+                if (topic.includes("smart_lock")) {
+                    const parsedMessage = this.parseSmartLockMessage(message);
+                    logging_1.rootMQTTLogger.debug("Received a smart lock message over MQTT", { message: parsedMessage });
+                    this.emit("lock message", parsedMessage);
+                }
+                else {
+                    logging_1.rootMQTTLogger.debug("MQTT message received", { topic: topic, message: message.toString("hex") });
+                }
+            });
+        }
+    }
+    _subscribeLock(deviceSN) {
+        this.client?.subscribe(this.SUBSCRIBE_LOCK_FORMAT.replace("<device_sn>", deviceSN), { qos: 1 }, (error, granted) => {
+            if (error) {
+                logging_1.rootMQTTLogger.error(`Subscribe error for lock ${deviceSN}`, { error: (0, utils_1.getError)(error), deviceSN: deviceSN });
+            }
+            if (granted) {
+                logging_1.rootMQTTLogger.info(`Successfully registered to MQTT notifications for lock ${deviceSN}`);
+            }
+        });
+    }
+    subscribeLock(deviceSN) {
+        if (this.connected) {
+            this._subscribeLock(deviceSN);
+        }
+        else {
+            if (!this.subscribeLocks.includes(deviceSN)) {
+                this.subscribeLocks.push(deviceSN);
+            }
+            if (this.clientID && this.androidID && this.apiBase && this.email)
+                this.connect(this.clientID, this.androidID, this.apiBase, this.email);
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    close() {
+        if (this.connected) {
+            this.client?.end(true);
+            this.connected = false;
+            this.connecting = false;
+        }
+    }
+}
+exports.MQTTService = MQTTService;
+//# sourceMappingURL=service.js.map