iobroker.eusec 1.2.0 → 1.3.0

package/build/main.js

@@ -5,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,43 +18,65 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var main_exports = {};
+__export(main_exports, {
+  euSec: () => euSec
+});
+module.exports = __toCommonJS(main_exports);
 var utils = __toESM(require("@iobroker/adapter-core"));
 var path = __toESM(require("path"));
 var import_eufy_security_client = require("eufy-security-client");
 var import_i18n_iso_countries = require("i18n-iso-countries");
 var import_i18n_iso_languages = require("@cospired/i18n-iso-languages");
-var import_fs_extra = __toESM(require("fs-extra"));
 var import_util = __toESM(require("util"));
 var import_child_process = __toESM(require("child_process"));
 var import_go2rtc_static = __toESM(require("go2rtc-static"));
-var import_os = __toESM(require("os"));
+var import_ffmpeg_for_homebridge = __toESM(require("ffmpeg-for-homebridge"));
 var import_types = require("./lib/types");
 var import_utils = require("./lib/utils");
 var import_log = require("./lib/log");
 var import_video = require("./lib/video");
 class euSec extends utils.Adapter {
+  eufy;
+  /*private downloadEvent: {
+      [index: string]: NodeJS.Timeout;
+  } = {};*/
+  persistentFile = "adapter.json";
+  persistentDriverFile = "driver.json";
+  logger;
+  persistentData = {
+    version: ""
+  };
+  captchaId = null;
+  verify_code = false;
+  skipInit = false;
   constructor(options = {}) {
     super({
       ...options,
       name: "eusec"
     });
-    this.persistentData = {
-      version: ""
-    };
-    this.captchaId = null;
-    this.verify_code = false;
-    const data_dir = utils.getAbsoluteInstanceDataDir(this);
-    this.persistentFile = path.join(data_dir, "adapter.json");
-    if (!import_fs_extra.default.existsSync(data_dir))
-      import_fs_extra.default.mkdirSync(data_dir);
     this.on("ready", this.onReady.bind(this));
     this.on("stateChange", this.onStateChange.bind(this));
+    this.on("message", this.onMessage.bind(this));
     this.on("unload", this.onUnload.bind(this));
   }
+  restartAdapter() {
+    this.skipInit = true;
+    this.restart();
+  }
+  /**
+   * Is called when databases are connected and adapter received configuration.
+   */
   async onReady() {
+    var _a;
     this.logger = new import_log.ioBrokerLogger(this.log);
     await this.setObjectNotExistsAsync("verify_code", {
       type: "state",
@@ -157,132 +183,209 @@ class euSec extends utils.Adapter {
       this.logger.error("Reset sensor states - Error", error);
     }
     try {
-      if (import_fs_extra.default.statSync(this.persistentFile).isFile()) {
-        const fileContent = import_fs_extra.default.readFileSync(this.persistentFile, "utf8");
-        this.persistentData = JSON.parse(fileContent);
+      if (await this.fileExistsAsync(this.namespace, this.persistentFile)) {
+        const fileContent = await this.readFileAsync(this.namespace, this.persistentFile);
+        this.persistentData = JSON.parse(fileContent.file.toString("utf8"));
       }
     } catch (error) {
-      this.logger.debug("No stored data from last exit found.", error);
-    }
-    this.subscribeStates("verify_code");
-    this.subscribeStates("captcha");
-    const systemConfig = await this.getForeignObjectAsync("system.config");
-    let countryCode = void 0;
-    let languageCode = void 0;
-    if (systemConfig) {
-      countryCode = (0, import_i18n_iso_countries.getAlpha2Code)(systemConfig.common.country, "en");
-      if ((0, import_i18n_iso_languages.isValid)(systemConfig.common.language))
-        languageCode = systemConfig.common.language;
-    }
-    if (this.config.hostname === "") {
-      this.config.hostname = import_os.default.hostname();
+      this.logger.debug("No adapter stored data from last exit found.", error);
     }
+    let persistentDriverData = "{}";
     try {
-      if (this.persistentData.version !== this.version) {
-        const currentVersion = Number.parseFloat((0, import_utils.removeLastChar)(this.version, "."));
-        const previousVersion = this.persistentData.version !== "" && this.persistentData.version !== void 0 ? Number.parseFloat((0, import_utils.removeLastChar)(this.persistentData.version, ".")) : 0;
-        this.logger.debug(`Handling of adapter update - currentVersion: ${currentVersion} previousVersion: ${previousVersion}`);
-        if (previousVersion < currentVersion) {
-          await (0, import_utils.handleUpdate)(this, this.logger, previousVersion);
-          this.persistentData.version = this.version;
-          this.writePersistentData();
-        }
+      if (await this.fileExistsAsync(this.namespace, this.persistentDriverFile)) {
+        const fileContent = await this.readFileAsync(this.namespace, this.persistentDriverFile);
+        persistentDriverData = fileContent.file.toString("utf8");
       }
     } catch (error) {
-      this.logger.error(`Handling of adapter update - Error:`, error);
+      this.logger.debug("No driver stored data from last exit found.", error);
     }
-    let connectionType = import_eufy_security_client.P2PConnectionType.QUICKEST;
-    if (this.config.p2pConnectionType === "only_local") {
-      connectionType = import_eufy_security_client.P2PConnectionType.ONLY_LOCAL;
+    this.subscribeStates("verify_code");
+    this.subscribeStates("captcha");
+    const hosts = await this.getForeignObjectsAsync("system.host.*", "host");
+    if (hosts !== void 0 && hosts !== null && Object.values(hosts).length !== 0) {
+      if (this.config.hostname === "") {
+        this.config.hostname = Object.values(hosts)[0].native.os.hostname;
+      }
+      const nodeVersion = Object.values(hosts)[0].native.process.versions.node;
+      const nodeMajorVersion = nodeVersion.split(".")[0];
+      let fixNeeded;
+      switch (parseInt(nodeMajorVersion)) {
+        case 18:
+          fixNeeded = nodeVersion.localeCompare("18.19.1", void 0, { numeric: true, sensitivity: "base" });
+          break;
+        case 20:
+          fixNeeded = nodeVersion.localeCompare("20.11.1", void 0, { numeric: true, sensitivity: "base" });
+          break;
+        default:
+          fixNeeded = nodeVersion.localeCompare("21.6.2", void 0, { numeric: true, sensitivity: "base" });
+          break;
+      }
+      if (fixNeeded >= 0) {
+        const adapter = await this.getForeignObjectAsync(`system.adapter.${this.namespace}`);
+        if (adapter !== void 0 && adapter !== null) {
+          if (!((_a = adapter.common.nodeProcessParams) == null ? void 0 : _a.includes("--security-revert=CVE-2023-46809"))) {
+            adapter.common.nodeProcessParams = ["--security-revert=CVE-2023-46809"];
+            await this.setForeignObjectAsync(`system.adapter.${this.namespace}`, adapter);
+            this.log.warn("Required fix to use livestreaming with this version of Node.js (CVE-2023-46809) applied. Restart of the adapter initiated to activate the fix.");
+            this.restartAdapter();
+          }
+        }
+      }
     }
-    const config = {
-      username: this.config.username,
-      password: this.config.password,
-      country: countryCode,
-      language: languageCode,
-      persistentDir: utils.getAbsoluteInstanceDataDir(this),
-      eventDurationSeconds: this.config.eventDuration,
-      p2pConnectionSetup: connectionType,
-      pollingIntervalMinutes: this.config.pollingInterval,
-      acceptInvitations: this.config.acceptInvitations
-    };
-    this.eufy = await import_eufy_security_client.EufySecurity.initialize(config, this.logger);
-    this.eufy.on("station added", (station) => this.onStationAdded(station));
-    this.eufy.on("device added", (device) => this.onDeviceAdded(device));
-    this.eufy.on("station removed", (station) => this.onStationRemoved(station));
-    this.eufy.on("device removed", (device) => this.onDeviceRemoved(device));
-    this.eufy.on("push message", (messages) => this.handlePushNotification(messages));
-    this.eufy.on("push connect", () => this.onPushConnect());
-    this.eufy.on("push close", () => this.onPushClose());
-    this.eufy.on("mqtt connect", () => this.onMQTTConnect());
-    this.eufy.on("mqtt close", () => this.onMQTTClose());
-    this.eufy.on("connect", () => this.onConnect());
-    this.eufy.on("close", () => this.onClose());
-    this.eufy.on("device property changed", (device, name, value) => this.onDevicePropertyChanged(device, name, value));
-    this.eufy.on("station command result", (station, result) => this.onStationCommandResult(station, result));
-    this.eufy.on("station livestream start", (station, device, metadata, videostream, audiostream) => this.onStationLivestreamStart(station, device, metadata, videostream, audiostream));
-    this.eufy.on("station livestream stop", (station, device) => this.onStationLivestreamStop(station, device));
-    this.eufy.on("station rtsp url", (station, device, value) => this.onStationRTSPUrl(station, device, value));
-    this.eufy.on("station property changed", (station, name, value) => this.onStationPropertyChanged(station, name, value));
-    this.eufy.on("station connect", (station) => this.onStationConnect(station));
-    this.eufy.on("station close", (station) => this.onStationClose(station));
-    this.eufy.on("tfa request", () => this.onTFARequest());
-    this.eufy.on("captcha request", (captchaId, captcha) => this.onCaptchaRequest(captchaId, captcha));
-    this.eufy.setCameraMaxLivestreamDuration(this.config.maxLivestreamDuration);
-    await this.eufy.connect();
-    if (import_go2rtc_static.default) {
-      const go2rtcConfig = {
-        "api": {
-          "listen": `:${this.config.go2rtc_api_port}`
-        },
-        "rtsp": {
-          "listen": `:${this.config.go2rtc_rtsp_port}`
-        },
-        "srtp": {
-          "listen": `:${this.config.go2rtc_srtp_port}`
-        },
-        "webrtc": {
-          "listen": `:${this.config.go2rtc_webrtc_port}`
-        },
-        "streams": {}
-      };
-      if (this.config.go2rtc_rtsp_username !== "" && this.config.go2rtc_rtsp_password !== "") {
-        go2rtcConfig.rtsp.username = this.config.go2rtc_rtsp_username;
-        go2rtcConfig.rtsp.password = this.config.go2rtc_rtsp_password;
+    if (!this.skipInit) {
+      const systemConfig = await this.getForeignObjectAsync("system.config");
+      let countryCode = void 0;
+      let languageCode = void 0;
+      if (systemConfig) {
+        countryCode = (0, import_i18n_iso_countries.getAlpha2Code)(systemConfig.common.country, "en");
+        if ((0, import_i18n_iso_languages.isValid)(systemConfig.common.language))
+          languageCode = systemConfig.common.language;
       }
-      for (const device of await this.eufy.getDevices()) {
-        go2rtcConfig.streams[device.getSerial()] = null;
+      if (this.config.country !== "iobroker") {
+        countryCode = this.config.country;
+      }
+      try {
+        if (this.persistentData.version !== this.version) {
+          const currentVersion = Number.parseFloat((0, import_utils.removeLastChar)(this.version, "."));
+          const previousVersion = this.persistentData.version !== "" && this.persistentData.version !== void 0 ? Number.parseFloat((0, import_utils.removeLastChar)(this.persistentData.version, ".")) : 0;
+          this.logger.debug(`Handling of adapter update - currentVersion: ${currentVersion} previousVersion: ${previousVersion}`);
+          if (previousVersion < currentVersion) {
+            await (0, import_utils.handleUpdate)(this, this.logger, previousVersion, currentVersion);
+            this.persistentData.version = this.version;
+            await this.writePersistentData();
+          }
+        }
+      } catch (error) {
+        this.logger.error(`Handling of adapter update - Error:`, error);
+      }
+      let connectionType = import_eufy_security_client.P2PConnectionType.QUICKEST;
+      if (this.config.p2pConnectionType === "only_local") {
+        connectionType = import_eufy_security_client.P2PConnectionType.ONLY_LOCAL;
+      }
+      if (this.config.username !== "" && this.config.password !== "") {
+        const config = {
+          username: this.config.username,
+          password: this.config.password,
+          country: countryCode,
+          language: languageCode,
+          persistentData: persistentDriverData,
+          eventDurationSeconds: this.config.eventDuration,
+          p2pConnectionSetup: connectionType,
+          pollingIntervalMinutes: this.config.pollingInterval,
+          acceptInvitations: this.config.acceptInvitations,
+          logging: {
+            level: this.log.level === "silly" ? import_eufy_security_client.LogLevel.Trace : this.log.level === "debug" ? import_eufy_security_client.LogLevel.Debug : this.log.level === "info" ? import_eufy_security_client.LogLevel.Info : this.log.level === "warn" ? import_eufy_security_client.LogLevel.Warn : this.log.level === "error" ? import_eufy_security_client.LogLevel.Error : import_eufy_security_client.LogLevel.Info
+          }
+        };
+        this.eufy = await import_eufy_security_client.EufySecurity.initialize(config, this.logger);
+        this.eufy.on("persistent data", (data) => this.onPersistentData(data));
+        this.eufy.on("station added", (station) => this.onStationAdded(station));
+        this.eufy.on("device added", (device) => this.onDeviceAdded(device));
+        this.eufy.on("station removed", (station) => this.onStationRemoved(station));
+        this.eufy.on("device removed", (device) => this.onDeviceRemoved(device));
+        this.eufy.on("push message", (messages) => this.handlePushNotification(messages));
+        this.eufy.on("push connect", () => this.onPushConnect());
+        this.eufy.on("push close", () => this.onPushClose());
+        this.eufy.on("mqtt connect", () => this.onMQTTConnect());
+        this.eufy.on("mqtt close", () => this.onMQTTClose());
+        this.eufy.on("connect", () => this.onConnect());
+        this.eufy.on("close", () => this.onClose());
+        this.eufy.on("device property changed", (device, name, value) => this.onDevicePropertyChanged(device, name, value));
+        this.eufy.on("station command result", (station, result) => this.onStationCommandResult(station, result));
+        this.eufy.on("station livestream start", (station, device, metadata, videostream, audiostream) => this.onStationLivestreamStart(station, device, metadata, videostream, audiostream));
+        this.eufy.on("station livestream stop", (station, device) => this.onStationLivestreamStop(station, device));
+        this.eufy.on("station rtsp url", (station, device, value) => this.onStationRTSPUrl(station, device, value));
+        this.eufy.on("station property changed", (station, name, value) => this.onStationPropertyChanged(station, name, value));
+        this.eufy.on("station connect", (station) => this.onStationConnect(station));
+        this.eufy.on("station close", (station) => this.onStationClose(station));
+        this.eufy.on("tfa request", () => this.onTFARequest());
+        this.eufy.on("captcha request", (captchaId, captcha) => this.onCaptchaRequest(captchaId, captcha));
+        this.eufy.setCameraMaxLivestreamDuration(this.config.maxLivestreamDuration);
+        await this.eufy.connect();
+        if (import_go2rtc_static.default) {
+          const go2rtcConfig = {
+            "api": {
+              "listen": `:${this.config.go2rtc_api_port}`
+            },
+            "rtsp": {
+              "listen": `:${this.config.go2rtc_rtsp_port}`
+            },
+            "srtp": {
+              "listen": `:${this.config.go2rtc_srtp_port}`
+            },
+            "webrtc": {
+              "listen": `:${this.config.go2rtc_webrtc_port}`
+            },
+            "ffmpeg": {
+              "bin": import_ffmpeg_for_homebridge.default !== "" && import_ffmpeg_for_homebridge.default !== void 0 ? import_ffmpeg_for_homebridge.default : "ffmpeg"
+            },
+            "streams": {}
+            /*"log": {
+                "level": "debug",  // default level
+                "api": "debug",
+                "exec": "debug",
+                "ngrok": "debug",
+                "rtsp": "debug",
+                "streams": "debug",
+                "webrtc": "debug",
+            }*/
+          };
+          if (this.config.go2rtc_rtsp_username !== "" && this.config.go2rtc_rtsp_password !== "") {
+            go2rtcConfig.rtsp.username = this.config.go2rtc_rtsp_username;
+            go2rtcConfig.rtsp.password = this.config.go2rtc_rtsp_password;
+          }
+          for (const device of await this.eufy.getDevices()) {
+            go2rtcConfig.streams[device.getSerial()] = null;
+          }
+          const go2rtc = import_child_process.default.spawn(import_go2rtc_static.default, ["-config", JSON.stringify(go2rtcConfig)], { shell: false, detached: false, windowsHide: true });
+          go2rtc.on("error", (error) => {
+            this.log.error(`go2rtc error: ${error}`);
+          });
+          go2rtc.stdout.setEncoding("utf8");
+          go2rtc.stdout.on("data", (data) => {
+            this.log.info(`go2rtc started: ${data}`);
+          });
+          go2rtc.stderr.setEncoding("utf8");
+          go2rtc.stderr.on("data", (data) => {
+            this.log.error(`go2rtc error: ${data}`);
+          });
+          go2rtc.on("close", (exitcode) => {
+            this.log.info(`go2rtc terminated with exitcode ${exitcode}`);
+          });
+          process.on("exit", () => {
+            go2rtc.kill();
+          });
+        }
+      }
+      const channels = await this.getChannelsAsync();
+      for (const channel of channels) {
+        if (channel.common.name === "unknown") {
+          const states = await this.getStatesAsync(`${channel._id}.*`);
+          if (Object.keys(states).length === 0) {
+            await this.delObjectAsync(channel._id);
+          }
+        }
       }
-      const go2rtc = import_child_process.default.spawn(import_go2rtc_static.default, ["-config", JSON.stringify(go2rtcConfig)], { shell: false, detached: false, windowsHide: true });
-      go2rtc.on("error", (error) => {
-        this.log.error(`go2rtc error: ${error}`);
-      });
-      go2rtc.stdout.setEncoding("utf8");
-      go2rtc.stdout.on("data", (data) => {
-        this.log.info(`go2rtc started: ${data}`);
-      });
-      go2rtc.stderr.setEncoding("utf8");
-      go2rtc.stderr.on("data", (data) => {
-        this.log.error(`go2rtc error: ${data}`);
-      });
-      go2rtc.on("close", (exitcode) => {
-        this.log.info(`go2rtc terminated with exitcode ${exitcode}`);
-      });
-      process.on("exit", () => {
-        go2rtc.kill();
-      });
     }
   }
-  writePersistentData() {
+  async writePersistentData() {
     try {
-      import_fs_extra.default.writeFileSync(this.persistentFile, JSON.stringify(this.persistentData));
+      await this.writeFileAsync(this.namespace, this.persistentFile, JSON.stringify(this.persistentData));
     } catch (error) {
       this.logger.error(`writePersistentData() - Error: ${error}`);
     }
   }
+  onPersistentData(data) {
+    this.writeFileAsync(this.namespace, this.persistentDriverFile, data).catch((error) => {
+      this.logger.error(`writePersistentDriverData() - Error: ${error}`);
+    });
+  }
+  /**
+   * Is called when adapter shuts down - callback has to be called under any circumstances!
+   */
   async onUnload(callback) {
     try {
-      this.writePersistentData();
+      await this.writePersistentData();
       if (this.eufy) {
         if (this.eufy.isConnected())
           await this.setStateAsync("info.connection", { val: false, ack: true }).catch();
@@ -294,6 +397,23 @@ class euSec extends utils.Adapter {
       callback();
     }
   }
+  // If you need to react to object changes, uncomment the following block and the corresponding line in the constructor.
+  // You also need to subscribe to the objects with `this.subscribeObjects`, similar to `this.subscribeStates`.
+  // /**
+  //  * Is called if a subscribed object changes
+  //  */
+  // private onObjectChange(id: string, obj: ioBroker.Object | null | undefined): void {
+  //     if (obj) {
+  //         // The object was changed
+  //         this.log.info(`object ${id} changed: ${JSON.stringify(obj)}`);
+  //     } else {
+  //         // The object was deleted
+  //         this.log.info(`object ${id} deleted`);
+  //     }
+  // }
+  /**
+   * Is called if a subscribed state changes
+   */
   async onStateChange(id, state) {
     if (state) {
       if (!id || state.ack) {
@@ -412,6 +532,9 @@ class euSec extends utils.Adapter {
             case import_types.DeviceStateID.SET_PRIVACY_ANGLE:
               await station.setPrivacyAngle(device);
               break;
+            case import_types.DeviceStateID.OPEN_BOX:
+              await station.open(device);
+              break;
           }
         } catch (error) {
           this.logger.error(`cameras - Error:`, error);
@@ -421,6 +544,183 @@ class euSec extends utils.Adapter {
       this.logger.debug(`state ${id} deleted`);
     }
   }
+  /**
+   * Some message was sent to this instance over message box. Used by email, pushover, text2speech, ...
+   * Using this method requires "common.message" property to be set to true in io-package.json
+   */
+  async onMessage(obj) {
+    if (typeof obj === "object" && obj.message) {
+      try {
+        if (obj.command === "quickResponse") {
+          this.log.debug(`quickResponse command - message: ${JSON.stringify(obj.message)}`);
+          if (typeof obj.message === "object" && typeof obj.message.station_sn === "string" && obj.message.station_sn !== "" && typeof obj.message.device_sn === "string" && obj.message.device_sn !== "" && typeof obj.message.voice_id === "number") {
+            try {
+              const station = await this.eufy.getStation(obj.message.station_sn);
+              const device = await this.eufy.getDevice(obj.message.device_sn);
+              if (device.hasCommand(import_eufy_security_client.CommandName.DeviceQuickResponse)) {
+                await station.quickResponse(device, obj.message.voice_id);
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: true,
+                    result: "quickResponse command sended"
+                  }, obj.callback);
+              } else {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "quickResponse command not supported by specified device"
+                  }, obj.callback);
+              }
+            } catch (error) {
+              if (error instanceof import_eufy_security_client.StationNotFoundError) {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "quickResponse command not sended because specified station doesn't exists"
+                  }, obj.callback);
+              } else if (error instanceof import_eufy_security_client.DeviceNotFoundError) {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "quickResponse command not sended because specified device doesn't exists"
+                  }, obj.callback);
+              } else {
+                throw error;
+              }
+            }
+          } else {
+            if (obj.callback)
+              this.sendTo(obj.from, obj.command, {
+                sended: false,
+                result: "quickResponse command not sended because some required parameters are missing"
+              }, obj.callback);
+          }
+        } else if (obj.command === "getQuickResponseVoices") {
+          this.log.debug(`getQuickResponseVoices command - message: ${JSON.stringify(obj.message)}`);
+          if (typeof obj.message === "object" && typeof obj.message.device_sn === "string" && obj.message.device_sn !== "") {
+            const voices = await this.eufy.getApi().getVoices(obj.message.device_sn);
+            if (obj.callback)
+              this.sendTo(obj.from, obj.command, {
+                sended: true,
+                result: voices
+              }, obj.callback);
+          } else {
+            if (obj.callback)
+              this.sendTo(obj.from, obj.command, {
+                sended: false,
+                result: "getQuickResponseVoices command not sended because some required parameters are missing"
+              }, obj.callback);
+          }
+        } else if (obj.command === "snooze") {
+          this.log.debug(`snooze command - message: ${JSON.stringify(obj.message)}`);
+          if (typeof obj.message === "object" && typeof obj.message.station_sn === "string" && obj.message.station_sn !== "" && typeof obj.message.device_sn === "string" && obj.message.device_sn !== "" && typeof obj.message.snooze_time === "number" && (obj.message.snooze_chime === void 0 || typeof obj.message.snooze_chime === "boolean") && (obj.message.snooze_homebase === void 0 || typeof obj.message.snooze_homebase === "boolean") && (obj.message.snooze_motion === void 0 || typeof obj.message.snooze_motion === "boolean")) {
+            try {
+              const station = await this.eufy.getStation(obj.message.station_sn);
+              const device = await this.eufy.getDevice(obj.message.device_sn);
+              if (device.hasCommand(import_eufy_security_client.CommandName.DeviceSnooze)) {
+                await station.snooze(device, {
+                  snooze_time: obj.message.snooze_time,
+                  snooze_chime: obj.message.snooze_chime,
+                  snooze_homebase: obj.message.snooze_homebase,
+                  snooze_motion: obj.message.snooze_motion
+                });
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: true,
+                    result: "snooze command sended"
+                  }, obj.callback);
+              } else {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "snooze command not supported by specified device"
+                  }, obj.callback);
+              }
+            } catch (error) {
+              if (error instanceof import_eufy_security_client.StationNotFoundError) {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "snooze command not sended because specified station doesn't exists"
+                  }, obj.callback);
+              } else if (error instanceof import_eufy_security_client.DeviceNotFoundError) {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "snooze command not sended because specified device doesn't exists"
+                  }, obj.callback);
+              } else {
+                throw error;
+              }
+            }
+          } else {
+            if (obj.callback)
+              this.sendTo(obj.from, obj.command, {
+                sended: false,
+                result: "snooze command not sended because some required parameters are missing"
+              }, obj.callback);
+          }
+        } else if (obj.command === "chime") {
+          this.log.debug(`snooze command - message: ${JSON.stringify(obj.message)}`);
+          if (typeof obj.message === "object" && typeof obj.message.station_sn === "string" && obj.message.station_sn !== "" && (obj.message.ringtone === void 0 || typeof obj.message.ringtone === "number")) {
+            try {
+              const station = await this.eufy.getStation(obj.message.station_sn);
+              if (station.hasCommand(import_eufy_security_client.CommandName.StationChime)) {
+                await station.chimeHomebase(obj.message.ringtone !== void 0 && typeof obj.message.ringtone === "number" ? obj.message.ringtone : 0);
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: true,
+                    result: "chime command sended"
+                  }, obj.callback);
+              } else {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "chime command not supported by specified station"
+                  }, obj.callback);
+              }
+              if (obj.callback)
+                this.sendTo(obj.from, obj.command, "chime command sended", obj.callback);
+            } catch (error) {
+              if (error instanceof import_eufy_security_client.StationNotFoundError) {
+                if (obj.callback)
+                  this.sendTo(obj.from, obj.command, {
+                    sended: false,
+                    result: "snooze command not sended because specified station doesn't exists"
+                  }, obj.callback);
+              } else {
+                throw error;
+              }
+            }
+          }
+        } else if (obj.command === "pollRefresh") {
+          this.log.debug(`pollRefresh command`);
+          await this.eufy.refreshCloudData();
+          if (obj.callback)
+            this.sendTo(obj.from, obj.command, {
+              sended: true,
+              result: "pollRefresh command sended"
+            }, obj.callback);
+        } else {
+          const errorMessage = `Received unknown message: ${JSON.stringify(obj.message)}`;
+          this.log.warn(errorMessage);
+          if (obj.callback)
+            this.sendTo(obj.from, obj.command, {
+              sended: false,
+              result: errorMessage
+            }, obj.callback);
+        }
+      } catch (error) {
+        const errorMessage = `Error during processing of received message: ${error instanceof Error ? `${error.name} - ${error.message}` : error}`;
+        this.log.error(errorMessage);
+        if (obj.callback)
+          this.sendTo(obj.from, obj.command, {
+            sended: false,
+            result: errorMessage
+          }, obj.callback);
+      }
+    }
+  }
   getStateCommon(property) {
     const state = {
       name: property.label,
@@ -428,7 +728,7 @@ class euSec extends utils.Adapter {
       role: "state",
       read: property.readable,
       write: property.writeable,
-      def: property.default
+      def: property.type === "object" && typeof property.default === "object" ? JSON.stringify(property.default) : property.default
     };
     switch (property.type) {
       case "number": {
@@ -689,6 +989,19 @@ class euSec extends utils.Adapter {
         native: {}
       });
     }
+    if (device.hasCommand(import_eufy_security_client.CommandName.DeviceOpen)) {
+      await this.setObjectNotExistsAsync(device.getStateID(import_types.DeviceStateID.OPEN_BOX), {
+        type: "state",
+        common: {
+          name: "Open Box",
+          type: "boolean",
+          role: "button.start",
+          read: false,
+          write: true
+        },
+        native: {}
+      });
+    }
     if (device.hasCommand(import_eufy_security_client.CommandName.DeviceStartLivestream)) {
       await this.setObjectNotExistsAsync(device.getStateID(import_types.DeviceStateID.START_STREAM), {
         type: "state",
@@ -831,10 +1144,38 @@ class euSec extends utils.Adapter {
     this.delObjectAsync(station.getStateID("", 0), { recursive: true }).catch((error) => {
       this.logger.error(`Error deleting states of removed station`, error);
     });
-    import_fs_extra.default.remove(path.join(utils.getAbsoluteInstanceDataDir(this), station.getSerial())).catch((error) => {
+    this.delFileAsync(this.namespace, station.getSerial()).catch((error) => {
       this.logger.error(`Error deleting fs contents of removed station`, error);
     });
   }
+  /*private async downloadEventVideo(device: Device, event_time: number, full_path: string | undefined, cipher_id: number | undefined): Promise<void> {
+          this.logger.debug(`Device: ${device.getSerial()} full_path: ${full_path} cipher_id: ${cipher_id}`);
+          try {
+              if (!isEmpty(full_path) && cipher_id !== undefined) {
+                  const station = await this.eufy.getStation(device.getStationSerial());
+  
+                  if (station !== undefined) {
+                      if (this.downloadEvent[device.getSerial()])
+                          clearTimeout(this.downloadEvent[device.getSerial()]);
+  
+                      let videoLength = getVideoClipLength(device);
+                      const time_passed = (new Date().getTime() - new Date(event_time).getTime()) / 1000;
+  
+                      if (time_passed >= videoLength)
+                          videoLength = 1;
+                      else
+                          videoLength = videoLength - time_passed;
+  
+                      this.logger.info(`Downloading video event for device ${device.getSerial()} in ${videoLength} seconds...`);
+                      this.downloadEvent[device.getSerial()] = setTimeout(async () => {
+                          station.startDownload(device, full_path!, cipher_id);
+                      }, videoLength * 1000);
+                  }
+              }
+          } catch (error) {
+              this.logger.error(`Device: ${device.getSerial()} - Error`, error);
+          }
+      }*/
   async handlePushNotification(message) {
     try {
       if (message.device_sn !== void 0) {
@@ -895,8 +1236,10 @@ class euSec extends utils.Adapter {
       const reg = new RegExp(`^${this.namespace}.[0-9A-Z]+.[a-z]+.[0-9A-Z]+$`);
       for (const id of allDevices) {
         if (id._id.match(reg)) {
-          const serial = id._id.split(".")[4];
-          if (!deviceSerials.includes(serial)) {
+          const values = id._id.split(".");
+          const stateChannel = values[3];
+          const serial = values[4];
+          if (!deviceSerials.includes(serial) || deviceSerials.includes(serial) && devices[deviceSerials.indexOf(serial)].getStateChannel() !== "unknown" && stateChannel === "unknown") {
             await this.delObjectAsync(id._id, { recursive: true });
           }
         }
@@ -947,41 +1290,29 @@ class euSec extends utils.Adapter {
     } catch (error) {
       this.log.error(`Delete obsolete properties ERROR - ${JSON.stringify(error)}`);
     }
-    new Promise(async (resolve, reject) => {
-      try {
-        const dir_path = path.join(utils.getAbsoluteInstanceDataDir(this));
-        if (import_fs_extra.default.existsSync(dir_path)) {
-          for (const content of import_fs_extra.default.readdirSync(dir_path).filter((fn) => fn.match("^T[0-9A-Z]+$") !== null)) {
-            if (!stationSerials.includes(content)) {
-              import_fs_extra.default.removeSync(path.join(dir_path, content));
-            } else {
-              for (const dir of import_fs_extra.default.readdirSync(path.join(dir_path, content))) {
-                if (dir === import_types.DataLocation.LIVESTREAM || dir === import_types.DataLocation.LAST_LIVESTREAM || dir === import_types.DataLocation.TEMP) {
-                  import_fs_extra.default.removeSync(path.join(dir_path, content, dir));
-                } else {
-                  const files = import_fs_extra.default.readdirSync(path.join(dir_path, content, dir));
-                  let deletedFiles = 0;
-                  for (const file of files) {
-                    if (!deviceSerials.includes(file.substring(0, 16))) {
-                      import_fs_extra.default.removeSync(path.join(dir_path, content, dir, file));
-                      deletedFiles++;
-                    }
-                  }
-                  if (deletedFiles === files.length) {
-                    import_fs_extra.default.removeSync(path.join(dir_path, content, dir));
-                  }
-                }
-              }
+    try {
+      const contents = await this.readDirAsync(this.namespace, "");
+      for (const content of contents.filter((fn) => fn.file.match("^T[0-9A-Z]+$") !== null && fn.isDir)) {
+        if (!stationSerials.includes(content.file)) {
+          await this.delFileAsync(this.namespace, content.file);
+        } else {
+          const dirContents = await this.readDirAsync(this.namespace, content.file);
+          for (const dir of dirContents.filter((fn) => Object.values(import_types.DataLocation).includes(fn.file) && fn.isDir)) {
+            const files = await this.readDirAsync(this.namespace, path.join(content.file, dir.file));
+            let deletedFiles = 0;
+            for (const file of files.filter((fn) => !deviceSerials.includes(fn.file.substring(0, 16)) && !fn.isDir)) {
+              await this.delFileAsync(this.namespace, path.join(content.file, dir.file, file.file));
+              deletedFiles++;
+            }
+            if (deletedFiles === files.length) {
+              await this.delFileAsync(this.namespace, path.join(content.file, dir.file));
             }
           }
         }
-        resolve();
-      } catch (error) {
-        reject(error);
       }
-    }).catch((error) => {
-      this.log.error(`Delete obsolete directories/files ERROR - ${JSON.stringify(error)}`);
-    });
+    } catch (error) {
+      this.log.error(`Delete obsolete directories/files ERROR - ${error}`);
+    }
   }
   async onClose() {
     await this.setStateAsync("info.connection", { val: false, ack: true }).catch();
@@ -1074,16 +1405,7 @@ class euSec extends utils.Adapter {
     await this.setStateAsync("info.mqtt_connection", { val: false, ack: true });
   }
   async onStationCommandResult(station, result) {
-    if (result.return_code !== 0 && result.command_type === import_eufy_security_client.CommandType.CMD_START_REALTIME_MEDIA) {
-      this.logger.debug(`Station: ${station.getSerial()} command ${import_eufy_security_client.CommandType[result.command_type]} failed with error: ${import_eufy_security_client.ErrorCode[result.return_code]} (${result.return_code}) fallback to RTMP livestream...`);
-      try {
-        const device = await this.eufy.getStationDevice(station.getSerial(), result.channel);
-        if (device.isCamera())
-          this.eufy.startCloudLivestream(device.getSerial());
-      } catch (error) {
-        this.logger.error(`Station: ${station.getSerial()} command ${import_eufy_security_client.CommandType[result.command_type]} RTMP fallback failed - Error ${error}`);
-      }
-    } else if (result.return_code !== 0 && result.command_type !== import_eufy_security_client.CommandType.P2P_QUERY_STATUS_IN_LOCK) {
+    if (result.return_code !== 0 && result.command_type !== import_eufy_security_client.CommandType.P2P_QUERY_STATUS_IN_LOCK) {
       this.logger.error(`Station: ${station.getSerial()} command ${import_eufy_security_client.CommandType[result.command_type]} failed with error: ${import_eufy_security_client.ErrorCode[result.return_code]} (${result.return_code})`);
     }
   }
@@ -1122,12 +1444,12 @@ class euSec extends utils.Adapter {
       try {
         const picture = value;
         const fileName = `${device.getSerial()}.${picture.type.ext}`;
-        const filePath = path.join(utils.getAbsoluteInstanceDataDir(this), device.getStationSerial(), import_types.DataLocation.LAST_EVENT);
-        if (!import_fs_extra.default.existsSync(filePath)) {
-          import_fs_extra.default.mkdirSync(filePath, { mode: 509, recursive: true });
+        const filePath = path.join(device.getStationSerial(), import_types.DataLocation.LAST_EVENT);
+        if (!await this.fileExistsAsync(this.namespace, filePath)) {
+          await this.mkdirAsync(this.namespace, filePath);
         }
-        await import_fs_extra.default.writeFile(path.join(filePath, fileName), picture.data);
-        await (0, import_utils.setStateChangedAsync)(this, device.getStateID(import_types.DeviceStateID.PICTURE_URL), `/${this.namespace}/${device.getStationSerial()}/${import_types.DataLocation.LAST_EVENT}/${device.getSerial()}.${picture.type.ext}`);
+        await this.writeFileAsync(this.namespace, path.join(filePath, fileName), picture.data);
+        await this.setStateAsync(device.getStateID(import_types.DeviceStateID.PICTURE_URL), `/files/${this.namespace}/${device.getStationSerial()}/${import_types.DataLocation.LAST_EVENT}/${device.getSerial()}.${picture.type.ext}`, true);
         await (0, import_utils.setStateChangedAsync)(this, device.getStateID(import_types.DeviceStateID.PICTURE_HTML), (0, import_utils.getImageAsHTML)(picture.data, picture.type.mime));
       } catch (err) {
         const error = (0, import_eufy_security_client.ensureError)(err);
@@ -1174,7 +1496,9 @@ class euSec extends utils.Adapter {
     try {
       this.setStateAsync(device.getStateID(import_types.DeviceStateID.LIVESTREAM), { val: `${this.config.https ? "https" : "http"}://${this.config.hostname}:${this.config.go2rtc_api_port}/stream.html?src=${device.getSerial()}`, ack: true });
       this.setStateAsync(device.getStateID(import_types.DeviceStateID.LIVESTREAM_RTSP), { val: `rtsp://${this.config.hostname}:${this.config.go2rtc_rtsp_port}/${device.getSerial()}`, ack: true });
-      await (0, import_video.ffmpegStreamToGo2rtc)(this.config, this.namespace, device.getSerial(), metadata, videostream, audiostream, this.logger);
+      await (0, import_video.streamToGo2rtc)(device.getSerial(), videostream, audiostream, this.logger, this.config, this.namespace, metadata).catch((error) => {
+        this.logger.debug(`Station: ${station.getSerial()} Device: ${device.getSerial()} - Stopping livestream...`, error);
+      });
     } catch (error) {
       this.logger.error(`Station: ${station.getSerial()} Device: ${device.getSerial()} - Error - Stopping livestream...`, error);
       this.eufy.stopStationLivestream(device.getSerial()).catch(async (error2) => {
@@ -1186,6 +1510,59 @@ class euSec extends utils.Adapter {
     this.delStateAsync(device.getStateID(import_types.DeviceStateID.LIVESTREAM));
     this.delStateAsync(device.getStateID(import_types.DeviceStateID.LIVESTREAM_RTSP));
   }
+  /*private async onStationDownloadFinish(_station: Station, _device: Device): Promise<void> {
+      //this.logger.trace(`Station: ${station.getSerial()} channel: ${channel}`);
+  }*/
+  /*private async onStationDownloadStart(station: Station, device: Device, metadata: StreamMetadata, videostream: Readable, audiostream: Readable): Promise<void> {
+          try {
+              //TODO: Deactivated because the decryption of the download has changed.
+              await removeFiles(this, station.getSerial(), DataLocation.TEMP, device.getSerial()).catch();
+              const file_path = getDataFilePath(this, station.getSerial(), DataLocation.TEMP, `${device.getSerial()}${STREAM_FILE_NAME_EXT}`);
+  
+              await ffmpegStreamToHls(this.config, this.namespace, metadata, videostream, audiostream, file_path, this.logger)
+                  .then(async () => {
+                      if (fse.pathExistsSync(file_path)) {
+                          await removeFiles(this, station.getSerial(), DataLocation.LAST_EVENT, device.getSerial());
+                          return true;
+                      }
+                      return false;
+                  })
+                  .then(async (result) => {
+                      if (result)
+                          await moveFiles(this, station.getSerial(), device.getSerial(), DataLocation.TEMP, DataLocation.LAST_EVENT);
+                      return result;
+                  })
+                  .then(async (result) => {
+                      if (result) {
+                          const filename_without_ext = getDataFilePath(this, station.getSerial(), DataLocation.LAST_EVENT, device.getSerial());
+                          setStateAsync(this, device.getStateID(DeviceStateID.LAST_EVENT_VIDEO_URL), "Last captured video URL", `/${this.namespace}/${station.getSerial()}/${DataLocation.LAST_EVENT}/${device.getSerial()}${STREAM_FILE_NAME_EXT}`, "url");
+                          if (fse.pathExistsSync(`${filename_without_ext}${STREAM_FILE_NAME_EXT}`))
+                              await ffmpegPreviewImage(this.config, `${filename_without_ext}${STREAM_FILE_NAME_EXT}`, `${filename_without_ext}${IMAGE_FILE_JPEG_EXT}`, this.logger)
+                                  .then(() => {
+                                      setStateAsync(this, device.getStateID(DeviceStateID.LAST_EVENT_PIC_URL), "Last event picture URL", `/${this.namespace}/${station.getSerial()}/${DataLocation.LAST_EVENT}/${device.getSerial()}${IMAGE_FILE_JPEG_EXT}`, "url");
+                                      try {
+                                          if (fse.existsSync(`${filename_without_ext}${IMAGE_FILE_JPEG_EXT}`)) {
+                                              const image_data = getImageAsHTML(fse.readFileSync(`${filename_without_ext}${IMAGE_FILE_JPEG_EXT}`));
+                                              setStateAsync(this, device.getStateID(DeviceStateID.LAST_EVENT_PIC_HTML), "Last event picture HTML image", image_data, "html");
+                                          }
+                                      } catch (error) {
+                                          this.logger.error(`Station: ${station.getSerial()} device: ${device.getSerial()} - Error`, error);
+                                      }
+                                  })
+                                  .catch((error) => {
+                                      this.logger.error(`ffmpegPreviewImage - station: ${station.getSerial()} device: ${device.getSerial()} - Error`, error);
+                                  });
+                      }
+                  })
+                  .catch(async (error) => {
+                      this.logger.error(`Station: ${station.getSerial()} Device: ${device.getSerial()} - Error - Cancelling download...`, error);
+                      await this.eufy.cancelStationDownload(device.getSerial());
+                  });
+          } catch(error) {
+              this.logger.error(`Station: ${station.getSerial()} Device: ${device.getSerial()} - Error - Cancelling download...`, error);
+              await this.eufy.cancelStationDownload(device.getSerial());
+          }
+      }*/
   onStationRTSPUrl(station, device, value) {
     (0, import_utils.setStateChangedAsync)(this, device.getStateID(import_types.DeviceStateID.RTSP_STREAM_URL), value);
   }
@@ -1233,4 +1610,8 @@ if (require.main !== module) {
 } else {
   (() => new euSec())();
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  euSec
+});
 //# sourceMappingURL=main.js.map