iobroker.iot 3.6.0 → 4.0.2

package/{lib → build-backend/lib}/remote.js

@@ -1,3 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const node_zlib_1 = require("node:zlib");
+const adminCommonSocket_1 = __importDefault(require("./adminCommonSocket"));
 const MESSAGE_TYPES = {
     MESSAGE: 0,
     PING: 1,
@@ -12,54 +20,60 @@ const MESSAGE_TYPES = {
     COMBINED_CALLBACK: 10,
     COMBINED_MESSAGE: 11,
 };
-
-let axios;
-let zlib;
-let AdminSocket;
-
 const MAX_IOT_MESSAGE_LENGTH = 127 * 1024;
 const MAX_POST_MESSAGE_LENGTH = 127 * 1024;
 const MAX_FILE_SIZE = 4 * 1024 * 1024;
-
 const COLLECT_OBJS_MS = 400;
 const COLLECT_STATES_MS = 400;
 const COLLECT_LOGS_MS = 800;
-
 const NONE = '___none___';
-
 class RemoteAccess {
+    adapter;
+    device = null;
+    gcInterval = null;
+    name = {};
+    objects = {};
+    packets = {};
+    statesCache = {};
+    listOfLogs = [];
+    listOfStates = { ids: [], states: [] };
+    listOfObjects = { ids: [], objs: [] };
+    clientId;
+    config;
+    collectStatesMs;
+    collectObjectsMs;
+    collectLogsMs;
+    handlers;
+    subscribes = { stateChange: {}, objectChange: {}, log: {} };
+    sockets = {};
+    vendorPrefix = '';
+    localAdmin = null;
+    webObj = null;
+    webUrl = '';
+    adminObj = null;
+    adminUrl = '';
+    lang = 'en';
+    sendObjectsTimeout = null;
+    sendLogsTimeout = null;
+    sendStatesTimeout = null;
+    infoTimeout = null;
+    secret = '';
     constructor(adapter, clientId) {
         this.adapter = adapter;
-        this.device = null;
-        this.gcInterval = null;
-
-        if (!this.adapter.config.remote) {
-            return;
-        }
-
-        axios = require('axios');
-        zlib = require('node:zlib');
-        AdminSocket = require('./adminCommonSocket');
-
-        this.name = {};
-        this.objects = {};
-        this.packets = {};
+        this.config = adapter.config;
         this.clientId = clientId;
-        this.statesCache = {};
-        this.listOfLogs = [];
-        this.listOfStates = { ids: [], states: [] };
-        this.listOfObjects = { ids: [], objs: [] };
         this.collectStatesMs =
-            adapter.config.collectStatesMs === undefined
+            this.config.collectStatesMs === undefined
                 ? COLLECT_STATES_MS
-                : parseInt(adapter.config.collectStatesMs, 10);
+                : parseInt(this.config.collectStatesMs, 10);
         this.collectObjectsMs =
-            adapter.config.collectObjectsMs === undefined
+            this.config.collectObjectsMs === undefined
                 ? COLLECT_OBJS_MS
-                : parseInt(adapter.config.collectObjectsMs, 10);
+                : parseInt(this.config.collectObjectsMs, 10);
         this.collectLogsMs =
-            adapter.config.collectLogsMs === undefined ? COLLECT_LOGS_MS : parseInt(adapter.config.collectLogsMs, 10);
-
+            this.config.collectLogsMs === undefined
+                ? COLLECT_LOGS_MS
+                : parseInt(this.config.collectLogsMs, 10);
         this.handlers = {
             getObject: { f: this.adapter.getForeignObjectAsync.bind(this.adapter), args: 1 },
             setObject: { f: this.adapter.setForeignObjectAsync.bind(this.adapter), args: 2 },
@@ -82,71 +96,57 @@ class RemoteAccess {
             readDir: { f: this.adapter.readDirAsync.bind(this.adapter), args: 2 },
             changePassword: { f: this.adapter.setPasswordAsync.bind(this.adapter), args: 2 },
         };
-
-        this.subscribes = {};
-        this.sockets = {};
-
-        if (this.adapter.config.remoteAdminInstance) {
+        if (!this.config.remote) {
+            return;
+        }
+        if (this.config.remoteAdminInstance) {
             try {
                 this.localAdmin = require
                     .resolve('iobroker.admin')
                     .replace(/\\/g, '/')
                     .replace(/main\.js$/, 'www-react');
-            } catch (error) {
+            }
+            catch {
                 this.localAdmin = null;
                 this.adapter.log.warn('[REMOTE] Cannot read admin files while iobroker.admin was not found');
             }
-            this.adapter
-                .getForeignObjectAsync(`system.adapter.${this.adapter.config.remoteAdminInstance}`)
-                .then(obj => {
-                    this.adminObj = obj;
-                    if (obj && obj.native && !obj.native.auth) {
-                        this.adminUrl = `${obj.native.secure ? 'https:' : 'http:'}//localhost:${obj.native.port}`;
-                    }
-                });
+            void this.adapter.getForeignObjectAsync(`system.adapter.${this.config.remoteAdminInstance}`).then(obj => {
+                this.adminObj = obj || null;
+                if (obj?.native && !obj.native.auth) {
+                    this.adminUrl = `${obj.native.secure ? 'https:' : 'http:'}//localhost:${obj.native.port}`;
+                }
+            });
         }
-        if (this.adapter.config.remoteWebInstance) {
-            this.adapter.getForeignObjectAsync(`system.adapter.${this.adapter.config.remoteWebInstance}`).then(obj => {
-                this.webObj = obj;
-                if (obj && obj.native && !obj.native.auth) {
+        if (this.config.remoteWebInstance) {
+            void this.adapter.getForeignObjectAsync(`system.adapter.${this.config.remoteWebInstance}`).then(obj => {
+                this.webObj = obj || null;
+                if (obj?.native && !obj.native.auth) {
                     this.webUrl = `${obj.native.secure ? 'https:' : 'http:'}//localhost:${obj.native.port}`;
                 }
             });
         }
-
-        this.vendorPrefix = '';
-
-        this.adapter.getForeignObjectAsync('system.meta.uuid').then(obj => {
-            if (obj && obj.native) {
+        void this.adapter.getForeignObjectAsync('system.meta.uuid').then(obj => {
+            if (obj?.native) {
                 this.vendorPrefix = obj.native.uuid.length > 36 ? obj.native.uuid.substring(0, 2) : '';
             }
         });
     }
-
     setLanguage(_lang) {
         this.lang = _lang || 'de';
     }
-
     registerDevice(device) {
         this.device = device;
     }
-
     async _sendCachedStates() {
         const sids = Object.keys(this.sockets);
-
         const listOfStates = this.listOfStates;
         // clear cache
         this.listOfStates = { ids: [], states: [] };
-
         if (sids.length) {
-            this.adapter.log.debug(
-                `Send to ${sids.length} sockets: ${listOfStates.ids.map((id, i) => `${id}: ${listOfStates.states[i].val}`).join(', ')}`,
-            );
-
+            this.adapter.log.debug(`Send to ${sids.length} sockets: ${listOfStates.ids.map((id, i) => `${id}: ${listOfStates.states[i]?.val}`).join(', ')}`);
             // pack the data
             const data = JSON.stringify([listOfStates.ids, listOfStates.states]);
-            const args = zlib.deflateSync(data).toString('base64');
-
+            const args = (0, node_zlib_1.deflateSync)(data).toString('base64');
             for (let s = 0; s < sids.length; s++) {
                 const error = await this._sendEvent({ name: 'stateChange', args, sid: sids[s], multi: true });
                 if (error) {
@@ -155,57 +155,51 @@ class RemoteAccess {
             }
         }
     }
-
     updateState(id, state) {
-        if (!this.adapter.config.remote) {
+        if (!this.config.remote) {
             return;
         }
         const cache = JSON.stringify(state);
-
         if (this.statesCache[id] && this.statesCache[id] !== cache) {
-            this.adapter.config.debug &&
+            if (this.config.debug) {
                 this.adapter.log.debug(`[REMOTE] send stateChange "${id}": ${JSON.stringify(state)}`);
-
+            }
             this.statesCache[id] = cache;
-
             this.listOfStates.ids.push(id);
             this.listOfStates.states.push(JSON.parse(JSON.stringify(state)));
-
             // do not wait if the list will be too long
             if (this.listOfStates.ids.length > 70) {
-                this.sendObjectsTimeout && clearTimeout(this.sendObjectsTimeout);
-                this.sendObjectsTimeout = null;
+                if (this.sendObjectsTimeout) {
+                    clearTimeout(this.sendObjectsTimeout);
+                    this.sendObjectsTimeout = null;
+                }
                 this._sendCachedStates().catch(e => this.adapter.log.error(`[REMOTE] Cannot send cached states: ${e}`));
-            } else {
-                this.sendObjectsTimeout =
-                    this.sendObjectsTimeout ||
-                    setTimeout(() => {
-                        this.sendObjectsTimeout = null;
-                        this._sendCachedStates().catch(e =>
-                            this.adapter.log.error(`[REMOTE] Cannot send cached states: ${e}`),
-                        );
-                    }, this.collectStatesMs);
-            }
-        } else {
+            }
+            else {
+                this.sendObjectsTimeout ||= setTimeout(() => {
+                    this.sendObjectsTimeout = null;
+                    this._sendCachedStates().catch(e => this.adapter.log.error(`[REMOTE] Cannot send cached states: ${e}`));
+                }, this.collectStatesMs);
+            }
+        }
+        else {
             // this.adapter.log.debug(`[REMOTE] ignore stateChange "${id}": ${JSON.stringify(state)}`);
         }
     }
-
     updateObject(id, obj) {
-        if (!this.adapter.config.remote) {
+        if (!this.config.remote) {
             return;
         }
         this.listOfObjects.ids.push(id);
         this.listOfObjects.objs.push(JSON.parse(JSON.stringify(obj)));
-
-        this.sendObjectsTimeout && clearTimeout(this.sendObjectsTimeout);
-
+        if (this.sendObjectsTimeout) {
+            clearTimeout(this.sendObjectsTimeout);
+        }
         this.sendObjectsTimeout = setTimeout(async () => {
             this.sendObjectsTimeout = null;
             const listOfObjects = this.listOfObjects;
             this.listOfObjects = { ids: [], objs: [] };
             const sids = Object.keys(this.sockets);
-
             for (let s = 0; s < sids.length; s++) {
                 const error = await this._sendEvent({
                     name: 'objectChange',
@@ -219,43 +213,53 @@ class RemoteAccess {
             }
         }, COLLECT_OBJS_MS);
     }
-
     onLog(obj) {
-        if (!this.adapter.config.remote) {
+        if (!this.config.remote) {
             return;
         }
         this.listOfLogs.push(obj);
-
-        this.sendLogsTimeout && clearTimeout(this.sendLogsTimeout);
-
+        if (this.sendLogsTimeout) {
+            clearTimeout(this.sendLogsTimeout);
+        }
         this.sendLogsTimeout = setTimeout(async () => {
             this.sendLogsTimeout = null;
             const listOfLogs = this.listOfLogs;
             this.listOfLogs = [];
             const sids = Object.keys(this.sockets);
             for (let s = 0; s < sids.length; s++) {
-                const error = await this._sendEvent({ name: 'log', args: [listOfLogs], sid: sids[s], multi: true });
+                const error = await this._sendEvent({
+                    name: 'log',
+                    args: [listOfLogs],
+                    sid: sids[s],
+                    multi: true,
+                });
                 if (error) {
                     this.adapter.log.error(`[REMOTE] cannot send "log": ${JSON.stringify(error)}`);
                 }
             }
         }, COLLECT_LOGS_MS);
     }
-
     destroy() {
-        this.gcInterval && clearInterval(this.gcInterval);
-        this.gcInterval = null;
-        this.sendLogsTimeout && clearTimeout(this.sendLogsTimeout);
-        this.sendLogsTimeout = null;
-        this.sendObjectsTimeout && clearTimeout(this.sendObjectsTimeout);
-        this.sendObjectsTimeout = null;
-        this.sendStatesTimeout && clearTimeout(this.sendStatesTimeout);
-        this.sendStatesTimeout = null;
-        AdminSocket.stopGB();
+        if (this.gcInterval) {
+            clearInterval(this.gcInterval);
+            this.gcInterval = null;
+        }
+        if (this.sendLogsTimeout) {
+            clearTimeout(this.sendLogsTimeout);
+            this.sendLogsTimeout = null;
+        }
+        if (this.sendObjectsTimeout) {
+            clearTimeout(this.sendObjectsTimeout);
+            this.sendObjectsTimeout = null;
+        }
+        if (this.sendStatesTimeout) {
+            clearTimeout(this.sendStatesTimeout);
+            this.sendStatesTimeout = null;
+        }
+        adminCommonSocket_1.default.stopGB();
         this._unsubscribeAll();
-        this.sockets = null;
+        this.sockets = {};
     }
-
     _clearMemory() {
         const now = Date.now();
         const DAY = 36000000 * 3;
@@ -267,29 +271,24 @@ class RemoteAccess {
                 delete this.sockets[sid];
             }
         });
-
         Object.keys(this.packets).forEach(id => {
             if (now - this.packets[id].ts > 120000) {
                 delete this.packets[id];
             }
         });
     }
-
     _readAllObjects() {
         return this.adapter.getObjectListAsync({ include_docs: true }).then(res => {
             const objects = {};
             this.adapter.log.info('[REMOTE] received all objects');
-            if (res) {
-                res = res.rows;
-
-                for (let i = 0; i < res.length; i++) {
-                    objects[res[i].doc._id] = res[i].doc;
+            if (res?.rows) {
+                for (let i = 0; i < res.rows.length; i++) {
+                    objects[res.rows[i].doc._id] = res.rows[i].doc;
                 }
             }
             return objects;
         });
     }
-
     pattern2RegEx(pattern) {
         if (!pattern || typeof pattern !== 'string') {
             return null;
@@ -310,82 +309,75 @@ class RemoteAccess {
         pattern = pattern.replace(/\)/g, '\\)');
         return pattern;
     }
-
     _subscribe(sid, type, pattern) {
         //console.log((socket._name || socket.id) + ' subscribe ' + pattern);
         const socket = this.sockets[sid];
-
-        this.subscribes[type] = this.subscribes[type] || {};
-
+        this.subscribes[type] ||= {};
         let s;
         if (socket) {
-            s = socket._subscribe[type] = socket._subscribe[type] || [];
+            socket._subscribe[type] ||= [];
+            s = socket._subscribe[type];
             for (let i = 0; i < s.length; i++) {
                 if (s[i].pattern === pattern) {
                     return;
                 }
             }
         }
-
-        let p = this.pattern2RegEx(pattern);
+        const p = this.pattern2RegEx(pattern);
         if (p === null) {
             return this.adapter.log.warn('[REMOTE] Empty or invalid pattern on subscribe!');
         }
-        if (socket) {
-            s.push({ pattern: pattern, regex: new RegExp(p) });
+        if (s) {
+            s.push({ pattern, regex: new RegExp(p) });
         }
-
         if (this.subscribes[type][pattern] === undefined) {
             this.subscribes[type][pattern] = 1;
             if (type === 'stateChange') {
                 this.adapter.log.debug(`[REMOTE] Subscribe STATES: ${pattern}`);
                 this.adapter.subscribeForeignStates(pattern);
-            } else if (type === 'objectChange') {
+            }
+            else if (type === 'objectChange') {
                 this.adapter.log.debug(`[REMOTE] Subscribe OBJECTS: ${pattern}`);
-                return this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
-            } else if (type === 'log') {
+                this.adapter.subscribeForeignObjects?.(pattern);
+            }
+            else if (type === 'log') {
                 this.adapter.log.debug('[REMOTE] Subscribe LOGS');
-                this.adapter.requireLog && this.adapter.requireLog(true);
+                void this.adapter.requireLog?.(true);
             }
-        } else {
+        }
+        else {
             this.subscribes[type][pattern]++;
         }
     }
-
     _showSubscribes(sid, type) {
         const socket = this.sockets[sid];
-
-        if (socket && socket._subscribe) {
+        if (socket?._subscribe) {
             const s = socket._subscribe[type] || [];
             const ids = [];
             for (let i = 0; i < s.length; i++) {
                 ids.push(s[i].pattern);
             }
             this.adapter.log.debug(`[REMOTE] Subscribes: ${ids.join(', ')}`);
-        } else {
+        }
+        else {
             this.adapter.log.debug('[REMOTE] Subscribes: no subscribes');
         }
     }
-
     _updateConnectedInfo() {
         if (this.infoTimeout) {
             clearTimeout(this.infoTimeout);
             this.infoTimeout = null;
         }
-
         // TODO
         // this.adapter.setState('info.connection', text, true);
     }
-
     _unsubscribe(sid, type, pattern) {
         const socket = this.sockets[sid];
-        this.subscribes[type] = this.subscribes[type] || {};
-
+        this.subscribes[type] ||= {};
         if (socket && typeof socket === 'object') {
-            if (!socket._subscribe || !socket._subscribe[type]) {
+            if (!socket._subscribe?.[type]) {
                 return;
             }
-
             for (let i = socket._subscribe[type].length - 1; i >= 0; i--) {
                 if (socket._subscribe[type][i].pattern === pattern) {
                     // Remove pattern from global list
@@ -396,26 +388,27 @@ class RemoteAccess {
                                 this.adapter.log.debug(`[REMOTE] Unsubscribe STATES: ${pattern}`);
                                 //console.log((socket._name || socket.id) + ' unsubscribeForeignStates ' + pattern);
                                 this.adapter.unsubscribeForeignStates(pattern);
-                            } else if (type === 'objectChange') {
+                            }
+                            else if (type === 'objectChange') {
                                 this.adapter.log.debug(`[REMOTE] Unsubscribe OBJECTS: ${pattern}`);
                                 //console.log((socket._name || socket.id) + ' unsubscribeForeignObjects ' + pattern);
                                 this.adapter.unsubscribeForeignObjects &&
                                     this.adapter.unsubscribeForeignObjects(pattern);
-                            } else if (type === 'log') {
+                            }
+                            else if (type === 'log') {
                                 //console.log((socket._name || socket.id) + ' requireLog false');
                                 this.adapter.log.debug('[REMOTE] Unsubscribe LOGS');
-                                this.adapter.requireLog && this.adapter.requireLog(false);
+                                void this.adapter.requireLog?.(false);
                             }
                             delete this.subscribes[type][pattern];
                         }
                     }
-
-                    delete socket._subscribe[type][i];
                     socket._subscribe[type].splice(i, 1);
                     return;
                 }
             }
-        } else {
+        }
+        else if (pattern) {
             // Remove pattern from global list
             if (this.subscribes[type][pattern] !== undefined) {
                 this.subscribes[type][pattern]--;
@@ -423,19 +416,20 @@ class RemoteAccess {
                     if (type === 'stateChange') {
                         this.adapter.log.debug(`[REMOTE] Unsubscribe STATES: ${pattern}`);
                         this.adapter.unsubscribeForeignStates(pattern);
-                    } else if (type === 'objectChange') {
+                    }
+                    else if (type === 'objectChange') {
                         this.adapter.log.debug(`[REMOTE] Unsubscribe OBJECTS: ${pattern}`);
-                        this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
-                    } else if (type === 'log') {
+                        this.adapter.unsubscribeForeignObjects?.(pattern);
+                    }
+                    else if (type === 'log') {
                         this.adapter.log.debug('[REMOTE] Unsubscribe LOGS');
-                        this.adapter.requireLog && this.adapter.requireLog(false);
+                        void this.adapter.requireLog?.(false);
                     }
                     delete this.subscribes[type][pattern];
                 }
             }
         }
     }
-
     _unsubscribeAll() {
         Object.keys(this.sockets).forEach(sid => {
             this._unsubscribe(sid, 'stateChange');
@@ -443,14 +437,11 @@ class RemoteAccess {
             this._unsubscribe(sid, 'log');
         });
     }
-
     _unsubscribeSocket(sid, type) {
         const socket = this.sockets[sid];
-
-        if (!socket || !socket._subscribe || !socket._subscribe[type]) {
+        if (!socket?._subscribe?.[type]) {
             return;
         }
-
         for (let i = 0; i < socket._subscribe[type].length; i++) {
             const pattern = socket._subscribe[type][i].pattern;
             if (this.subscribes[type][pattern] !== undefined) {
@@ -459,26 +450,25 @@ class RemoteAccess {
                     if (type === 'stateChange') {
                         this.adapter.log.debug(`[REMOTE] Unsubscribe STATES: ${pattern}`);
                         this.adapter.unsubscribeForeignStates(pattern);
-                    } else if (type === 'objectChange') {
+                    }
+                    else if (type === 'objectChange') {
                         this.adapter.log.debug(`[REMOTE] Unsubscribe OBJECTS: ${pattern}`);
-                        this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
-                    } else if (type === 'log') {
+                        this.adapter.unsubscribeForeignObjects?.(pattern);
+                    }
+                    else if (type === 'log') {
                         this.adapter.log.debug(`[REMOTE] Unsubscribe LOGS: ${pattern}`);
-                        this.adapter.requireLog && this.adapter.requireLog(false);
+                        void this.adapter.requireLog?.(false);
                     }
                     delete this.subscribes[type][pattern];
                 }
             }
         }
     }
-
     _subscribeSocket(sid, type) {
         const socket = this.sockets[sid];
-
-        if (!socket || !socket._subscribe || !socket._subscribe[type]) {
+        if (!socket?._subscribe?.[type]) {
             return;
         }
-
         for (let i = 0; i < socket._subscribe[type].length; i++) {
             const pattern = socket._subscribe[type][i].pattern;
             if (this.subscribes[type][pattern] === undefined) {
@@ -486,57 +476,50 @@ class RemoteAccess {
                 if (type === 'stateChange') {
                     this.adapter.log.debug(`[REMOTE] Subscribe STATES: ${pattern}`);
                     this.adapter.subscribeForeignStates(pattern);
-                } else if (type === 'objectChange') {
+                }
+                else if (type === 'objectChange') {
                     this.adapter.log.debug(`[REMOTE] Subscribe OBJECTS: ${pattern}`);
-                    this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
-                } else if (type === 'log') {
+                    this.adapter.subscribeForeignObjects?.(pattern);
+                }
+                else if (type === 'log') {
                     this.adapter.log.debug('[REMOTE] Subscribe LOGS');
-                    this.adapter.requireLog && this.adapter.requireLog(true);
+                    void this.adapter.requireLog?.(true);
                 }
-            } else {
+            }
+            else {
                 this.subscribes[type][pattern]++;
             }
         }
     }
-
     _sendEvent(message, _originalMessage) {
-        return axios
+        return axios_1.default
             .post('https://remote-events.iobroker.in/', message, {
-                validateStatus: status => status === 200,
-                timeout: 5000,
-            })
-            .then(response => {
-                // console.log(response.data || response.status);
-                return false;
-            })
+            validateStatus: status => status === 200,
+            timeout: 5000,
+        })
+            .then(() => undefined)
             .catch(error => {
-                let errorMessage;
-                if (error.response) {
-                    errorMessage = error.response.data || error.response.status;
-                } else {
-                    errorMessage = error.message;
-                }
-
-                this.adapter.log.warn(
-                    `[REMOTE] Cannot send status update to ${message.sid} (${JSON.stringify(_originalMessage)}): ${JSON.stringify(errorMessage)}`,
-                );
-
-                if (errorMessage.error === 'invalid connectionId') {
-                    if (this.sockets[message.sid]) {
-                        this.adapter.log.debug(`[REMOTE] delete connection id ${message.sid}`);
-                        delete this.sockets[message.sid];
-                    }
-                    errorMessage = false;
-                } else {
-                    this.adapter.log.warn(
-                        `[REMOTE] Cannot send status update to "${message.sid}" (${JSON.stringify(_originalMessage)}): ${JSON.stringify(errorMessage)}`,
-                    );
+            let errorMessage;
+            if (error.response) {
+                errorMessage = error.response.data || error.response.status;
+            }
+            else {
+                errorMessage = error.message?.toString();
+            }
+            this.adapter.log.warn(`[REMOTE] Cannot send status update to ${message.sid} (${JSON.stringify(_originalMessage)}): ${JSON.stringify(errorMessage)}`);
+            if (errorMessage.error === 'invalid connectionId') {
+                if (this.sockets[message.sid]) {
+                    this.adapter.log.debug(`[REMOTE] delete connection id ${message.sid}`);
+                    delete this.sockets[message.sid];
                 }
-
-                return errorMessage;
-            });
+                errorMessage = false;
+            }
+            else {
+                this.adapter.log.warn(`[REMOTE] Cannot send status update to "${message.sid}" (${JSON.stringify(_originalMessage)}): ${JSON.stringify(errorMessage)}`);
+            }
+            return JSON.stringify(errorMessage);
+        });
     }
-
     async _getStatesManyArgs(args) {
         const response = [];
         for (let a = 0; a < args.length; a++) {
@@ -544,14 +527,16 @@ class RemoteAccess {
             try {
                 const result = await this.adapter.getForeignStatesAsync(id || '*');
                 response[a] = [null, result];
-                result && Object.keys(result).forEach(id => (this.statesCache[id] = result[id]));
-            } catch (error) {
+                if (result) {
+                    Object.keys(result).forEach(id => (this.statesCache[id] = JSON.stringify(result[id])));
+                }
+            }
+            catch (error) {
                 response[a] = [error];
             }
         }
         return response;
     }
-
     async _getStateManyArgs(args) {
         const response = [];
         for (let a = 0; a < args.length; a++) {
@@ -559,14 +544,14 @@ class RemoteAccess {
             try {
                 const result = await this.adapter.getForeignStateAsync(id || '*');
                 response[a] = [null, result];
-                this.statesCache[id] = result;
-            } catch (error) {
+                this.statesCache[id] = JSON.stringify(result);
+            }
+            catch (error) {
                 response[a] = [error];
             }
         }
         return response;
     }
-
     async _getObjectManyArgs(args) {
         const response = [];
         for (let a = 0; a < args.length; a++) {
@@ -574,101 +559,104 @@ class RemoteAccess {
             try {
                 const result = await this.adapter.getForeignObjectAsync(id || '*');
                 response[a] = [null, result];
-                this.statesCache[id] = result;
-            } catch (error) {
+            }
+            catch (error) {
                 response[a] = [error];
             }
         }
         return response;
     }
-
-    async _subscribeManyArgs(sid, args) {
-        const response = [];
+    _subscribeManyArgs(sid, args) {
+        const result = [];
         for (let a = 0; a < args.length; a++) {
             const pattern = args[a][0];
-            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+            if (Array.isArray(pattern)) {
                 for (let p = 0; p < pattern.length; p++) {
                     this._subscribe(sid, 'stateChange', pattern[p]);
                 }
-            } else {
+            }
+            else {
                 this._subscribe(sid, 'stateChange', pattern);
             }
+            result.push([null]);
         }
-        return response;
+        return Promise.resolve(result);
     }
-
     async _unsubscribeManyArgs(sid, args) {
-        const response = [];
+        const result = [];
         for (let a = 0; a < args.length; a++) {
             const pattern = args[a][0];
-            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+            if (Array.isArray(pattern)) {
                 for (let p = 0; p < pattern.length; p++) {
                     this._unsubscribe(sid, 'stateChange', pattern[p]);
                 }
-            } else {
+            }
+            else {
                 this._unsubscribe(sid, 'stateChange', pattern);
             }
+            result.push([null]);
         }
-        return response;
+        return Promise.resolve(result);
     }
-
     uploadToServer(url, data, raw) {
-        return axios
+        return axios_1.default
             .put(url, raw ? data.file : Buffer.from(data.file, 'base64'), {
-                headers: {
-                    'Content-Type': data.mimeType,
-                },
-            })
+            headers: {
+                'Content-Type': data.mimeType,
+            },
+        })
             .then(() => {
-                return true;
-            })
+            return true;
+        })
             .catch(e => {
-                console.log(e);
-                return false;
-            });
+            console.log(e);
+            return false;
+        });
     }
-
     readUrlFile(url, path, sid, type, id) {
-        return url
-            ? axios(url + path, { responseType: 'arraybuffer', validateStatus: status => status === 200, timeout: 500 })
-                  .then(response => {
-                      // replace port
-                      if (path.endsWith('_socket/info.js')) {
-                          response.data = response.data.toString();
-                          // var socketUrl = ":8084"; var socketSession = ""; window.sysLang = "ru"; window.socketForceWebSockets = false;
-                          // replace ":8084"; => "";
-                          response.data = response.data.replace(/":\d+";/, '"";');
-                      }
-
-                      return {
-                          file: Buffer.from(response.data).toString('base64'),
-                          mimeType: response.headers['content-type'],
-                      };
-                  })
-                  .catch(error => {
-                      this.adapter.log.warn(`[REMOTE] File ${url}${path} not found`);
-                      let errorMessage;
-                      if (error.response && error.response.status === 404) {
-                          errorMessage = 'Not exists';
-                      } else if (error.response && error.response.status === 401) {
-                          errorMessage = 'Not authorised';
-                      } else {
-                          if (error.response) {
-                              errorMessage = error.response.data || error.response.status;
-                          } else if (error.request) {
-                              errorMessage = 'No answer';
-                          } else {
-                              errorMessage = error.message;
-                          }
-                      }
-                      return { sid, d: [type, id, '', { error: errorMessage }] };
-                  })
-            : { sid, d: [type, id, '', { error: 'Not exists' }] };
+        return (0, axios_1.default)(url + path, {
+            responseType: 'arraybuffer',
+            validateStatus: status => status === 200,
+            timeout: 500,
+        })
+            .then(response => {
+            // replace port
+            if (path.endsWith('_socket/info.js')) {
+                response.data = response.data.toString();
+                // var socketUrl = ":8084"; var socketSession = ""; window.sysLang = "ru"; window.socketForceWebSockets = false;
+                // replace ":8084"; => "";
+                response.data = response.data.replace(/":\d+";/, '"";');
+            }
+            return {
+                file: Buffer.from(response.data).toString('base64'),
+                mimeType: response.headers['content-type'],
+            };
+        })
+            .catch(error => {
+            this.adapter.log.warn(`[REMOTE] File ${url}${path} not found`);
+            let errorMessage;
+            if (error.response && error.response.status === 404) {
+                errorMessage = 'Not exists';
+            }
+            else if (error.response && error.response.status === 401) {
+                errorMessage = 'Not authorised';
+            }
+            else {
+                if (error.response) {
+                    errorMessage = error.response.data || error.response.status;
+                }
+                else if (error.request) {
+                    errorMessage = 'No answer';
+                }
+                else {
+                    errorMessage = error.message;
+                }
+            }
+            return { sid, d: [type, id, '', { error: errorMessage }] };
+        });
     }
-
     _sendResponse(sid, _type, id, name, args, writeUrl, readUrl) {
-        let packed = zlib.deflateSync(JSON.stringify(args)).toString('base64');
-
+        let packed = (0, node_zlib_1.deflateSync)(JSON.stringify(args)).toString('base64');
         if (packed.length > MAX_IOT_MESSAGE_LENGTH) {
             if (writeUrl) {
                 if (args.length === 3) {
@@ -679,22 +667,16 @@ class RemoteAccess {
                             d: [_type, id, name, done ? readUrl : ['Cannot upload']],
                         }));
                     }
-                } else if (args.length === 2) {
+                }
+                else if (args.length === 2) {
                     const [error, result] = args;
                     if (!error) {
-                        return this.uploadToServer(
-                            writeUrl,
-                            { file: JSON.stringify(result), mimeType: 'application/json' },
-                            true,
-                        ).then(done => ({ sid, d: [_type, id, name, done ? readUrl : ['Cannot upload']] }));
+                        return this.uploadToServer(writeUrl, { file: JSON.stringify(result), mimeType: 'application/json' }, true).then(done => ({ sid, d: [_type, id, name, done ? readUrl : ['Cannot upload']] }));
                     }
-                } else if (args.length === 1) {
+                }
+                else if (args.length === 1) {
                     const [result] = args;
-                    return this.uploadToServer(
-                        writeUrl,
-                        { file: JSON.stringify(result), mimeType: 'application/json' },
-                        true,
-                    ).then(done => ({ sid, d: [_type, id, name, done ? readUrl : ['Cannot upload']] }));
+                    return this.uploadToServer(writeUrl, { file: JSON.stringify(result), mimeType: 'application/json' }, true).then(done => ({ sid, d: [_type, id, name, done ? readUrl : ['Cannot upload']] }));
                 }
             }
             // too big message. Do not use iot for that and send directly to socket
@@ -729,10 +711,9 @@ class RemoteAccess {
                     if (packed.length) {
                         packets.push(packed);
                     }
-
                     for (let i = 0; i < packets.length; i++) {
                         const error = await this._sendEvent({
-                            sid: sid,
+                            sid,
                             d: [_type, id, name, packets[i], packets.length, i],
                         });
                         if (error) {
@@ -740,23 +721,21 @@ class RemoteAccess {
                             break;
                         }
                     }
-                } else {
-                    await this._sendEvent({ sid: sid, d: [_type, id, name, packed] });
+                }
+                else {
+                    await this._sendEvent({ sid, d: [_type, id, name, packed] });
                 }
             });
-
-            return { sid, d: [MESSAGE_TYPES.WAIT, id, name, [packed.length]] };
+            return Promise.resolve({ sid, d: [MESSAGE_TYPES.WAIT, id, name, [packed.length]] });
         }
-        return { sid, d: [_type, id, name, packed] };
+        return Promise.resolve({ sid, d: [_type, id, name, packed] });
     }
-
     onCloudDisconnect() {
         // delete all sockets
         this.adapter.log.debug(`[REMOTE] Cloud disconnected`);
         if (!this.sockets) {
             return;
         }
-
         const sids = Object.keys(this.sockets);
         for (let s = 0; s < sids.length; s++) {
             this._unsubscribeSocket(sids[s], 'stateChange');
@@ -765,205 +744,221 @@ class RemoteAccess {
             delete this.sockets[sids[s]];
         }
     }
-
     process(request, serviceType) {
         let message;
         if (typeof request === 'string') {
             try {
                 message = JSON.parse(request);
-            } catch (err) {
+            }
+            catch {
                 this.adapter.log.error(`[REMOTE] Cannot parse request: ${request}`);
                 message = null;
             }
-        } else {
+        }
+        else {
             message = request;
         }
-
         if (message) {
             const [_type, id, name, args, readUrl] = message.d;
             let promiseOne; // answer will be created automatically (error, result)
             let promiseResult; // answer will be created by promise
-
-            if (this.adapter.config.remote && _type === MESSAGE_TYPES.MISSING) {
+            if (this.config.remote && _type === MESSAGE_TYPES.MISSING) {
                 if (this.packets[id]) {
                     const missing = args[0];
-                    this.adapter.log.warn(`[REMOTE] Request for existing trunks: ${id}, "${name}": ${missing}`);
-
-                    this.device &&
+                    this.adapter.log.warn(`[REMOTE] Request for existing trunks: ${id}, "${name}": ${JSON.stringify(missing)}`);
+                    if (this.device) {
                         setImmediate(async () => {
                             try {
                                 for (let m = 0; m < missing.length; m++) {
-                                    await new Promise((resolve, reject) =>
-                                        this.device.publish(
-                                            `response/${this.clientId}/${serviceType}`,
-                                            JSON.stringify(this.packets[id].trunks[m]),
-                                            { qos: 1 },
-                                            error => {
-                                                if (error) {
-                                                    reject(error);
-                                                } else {
-                                                    resolve();
-                                                }
-                                            },
-                                        ),
-                                    );
+                                    await new Promise((resolve, reject) => this.device.publish(`response/${this.clientId}/${serviceType}`, JSON.stringify(this.packets[id].trunks[m]), { qos: 1 }, error => {
+                                        if (error) {
+                                            reject(error);
+                                        }
+                                        else {
+                                            resolve();
+                                        }
+                                    }));
                                 }
-                            } catch (err) {
+                            }
+                            catch (err) {
                                 this.adapter.log.error(`[REMOTE] Cannot send packet: ${err}`);
                             }
                         });
-                } else {
+                    }
+                }
+                else {
                     this.adapter.log.warn(`[REMOTE] Request for non existing trunks: ${id}, "${name}"`);
                 }
                 promiseResult = Promise.resolve(NONE);
-            } else if (this.adapter.config.remote && _type === MESSAGE_TYPES.SENDING_DONE) {
+            }
+            else if (this.config.remote && _type === MESSAGE_TYPES.SENDING_DONE) {
                 this.adapter.log.debug(`[REMOTE] Packet received: ${id}, "${name}"`);
                 delete this.packets[id];
                 promiseResult = Promise.resolve(NONE);
-            } else if (_type === MESSAGE_TYPES.HTML) {
+            }
+            else if (_type === MESSAGE_TYPES.HTML) {
                 let promiseFile;
-
-                if (!this.adapter.config.remote) {
+                if (!this.config.remote) {
                     return Promise.resolve({ sid: message.sid, d: [_type, id, '', ['Not enabled']] });
-                } else if (name === 'listOfPrograms' || name === '/listOfPrograms') {
-                    promiseFile = AdminSocket.getListOfAllAdapters(this.adapter)
+                }
+                else if (name === 'listOfPrograms' || name === '/listOfPrograms') {
+                    promiseFile = adminCommonSocket_1.default.getListOfAllAdapters(this.adapter)
                         .then(result => {
-                            let packed = zlib.deflateSync(JSON.stringify([null, result])).toString('base64');
-                            return { sid: message.sid, d: [_type, id, '', packed] };
-                        })
-                        .catch(error => ({ sid: message.sid, d: [_type, id, '', [error.toString()]] }));
-                } else if (name === 'vendorPrefix' || name === '/vendorPrefix') {
+                        const packed = (0, node_zlib_1.deflateSync)(JSON.stringify([null, result])).toString('base64');
+                        return { sid: message.sid, d: [_type, id, '', packed] };
+                    })
+                        .catch(error => ({
+                        sid: message.sid,
+                        d: [_type, id, '', [error.toString()]],
+                    }));
+                }
+                else if (name === 'vendorPrefix' || name === '/vendorPrefix') {
                     return Promise.resolve({ sid: message.sid, d: [_type, id, '', [null, this.vendorPrefix]] });
-                } else if (name.startsWith('/adapter')) {
-                    if (this.adapter.config.remoteAdminInstance) {
-                        promiseFile = this.readUrlFile(this.adminUrl, name, message.sid, _type, id);
-                    } else {
+                }
+                else if (name.startsWith('/adapter')) {
+                    if (this.config.remoteAdminInstance) {
+                        if (this.adminUrl) {
+                            promiseFile = this.readUrlFile(this.adminUrl, name, message.sid, _type, id);
+                        }
+                        else {
+                            promiseFile = Promise.resolve({
+                                sid: message.sid,
+                                d: [_type, id, '', { error: 'Not exists' }],
+                            });
+                        }
+                    }
+                    else {
                         promiseFile = Promise.resolve({
                             sid: message.sid,
                             d: [_type, id, '', { error: 'Not exists' }],
                         });
                     }
-                } else {
+                }
+                else {
                     const path = name.split('?')[0];
                     const parts = path.split('/');
                     parts.shift(); // remove leading /
-                    const _adapter = parts.shift();
+                    const _adapter = parts.shift() || '';
                     this.adapter.log.debug(`[REMOTE] HTML: ${path}`);
-
                     // html must be returned only by iot channel, as lambda must process the answer
                     promiseFile = this.adapter
                         .readFileAsync(_adapter, parts.join('/'))
                         .then(data => {
-                            data.file = Buffer.from(data.file).toString('base64');
-                            return data;
-                        })
-                        .catch(err =>
+                        data.file = Buffer.from(data.file).toString('base64');
+                        return data;
+                    })
+                        .catch(() => {
+                        if (this.webUrl) {
                             // try to read from server
-                            this.readUrlFile(this.webUrl, path, message.sid, _type, id),
-                        );
+                            return this.readUrlFile(this.webUrl, path, message.sid, _type, id);
+                        }
+                        return {
+                            sid: message.sid,
+                            d: [_type, id, '', { error: 'Not exists' }],
+                        };
+                    });
                 }
-
-                return promiseFile.then(data => {
+                return promiseFile.then((data) => {
                     // if error
                     if (data.sid) {
-                        return data;
-                    } else {
-                        let packed = zlib.deflateSync(JSON.stringify(data)).toString('base64');
-                        if (
-                            typeof args === 'string' &&
-                            args?.startsWith('https:') &&
-                            packed.length > MAX_IOT_MESSAGE_LENGTH
-                        ) {
-                            // upload file to temp server
-                            return this.uploadToServer(args, data).then(done => ({
-                                sid: message.sid,
-                                d: [_type, id, '', done ? '_$%URL' : 'Cannot upload'],
-                            }));
-                        }
-
-                        if (data.file.length > MAX_FILE_SIZE) {
-                            // file too big
-                            this.adapter.log.warn(
-                                `[REMOTE] Requested file ${name} is too big (${Math.round(data.file.length / 1000)}Kb). Max length is ${MAX_FILE_SIZE / 1024}Kb`,
-                            );
-                            return {
-                                sid: message.sid,
-                                d: [
-                                    _type,
-                                    id,
-                                    '',
-                                    {
-                                        error: `File is too big: ${Math.round(data.file.length / 1000)}Kb, max ${MAX_FILE_SIZE / 1024}Kb`,
-                                    },
-                                ],
-                            };
+                        return Promise.resolve(data);
+                    }
+                    const dataFile = data;
+                    let packed = (0, node_zlib_1.deflateSync)(JSON.stringify(data)).toString('base64');
+                    if (typeof args === 'string' &&
+                        args?.startsWith('https:') &&
+                        packed.length > MAX_IOT_MESSAGE_LENGTH) {
+                        // upload file to temp server
+                        return this.uploadToServer(args, dataFile).then(done => ({
+                            sid: message.sid,
+                            d: [_type, id, '', done ? '_$%URL' : 'Cannot upload'],
+                        }));
+                    }
+                    if (dataFile.file.length > MAX_FILE_SIZE) {
+                        // file too big
+                        this.adapter.log.warn(`[REMOTE] Requested file ${name} is too big (${Math.round(dataFile.file.length / 1000)}Kb). Max length is ${MAX_FILE_SIZE / 1024}Kb`);
+                        return Promise.resolve({
+                            sid: message.sid,
+                            d: [
+                                _type,
+                                id,
+                                '',
+                                {
+                                    error: `File is too big: ${Math.round(dataFile.file.length / 1000)}Kb, max ${MAX_FILE_SIZE / 1024}Kb`,
+                                },
+                            ],
+                        });
+                    }
+                    if (packed.length > MAX_IOT_MESSAGE_LENGTH) {
+                        const packets = [];
+                        while (packed.length > MAX_IOT_MESSAGE_LENGTH) {
+                            const trunk = packed.substring(0, MAX_IOT_MESSAGE_LENGTH);
+                            packed = packed.substring(MAX_IOT_MESSAGE_LENGTH);
+                            packets.push(trunk);
                         }
-
-                        if (packed.length > MAX_IOT_MESSAGE_LENGTH) {
-                            const packets = [];
-                            while (packed.length > MAX_IOT_MESSAGE_LENGTH) {
-                                const trunk = packed.substring(0, MAX_IOT_MESSAGE_LENGTH);
-                                packed = packed.substring(MAX_IOT_MESSAGE_LENGTH);
-                                packets.push(trunk);
-                            }
-                            if (packed.length) {
-                                packets.push(packed);
-                            }
-
-                            const trunks = packets.map((trunk, i) => ({
-                                sid: message.sid,
-                                i,
-                                l: packets.length,
-                                d: [_type, id, '', trunk],
-                            }));
-
-                            this.packets[id] = { ts: Date.now(), trunks };
-
-                            // start garbage collector
-                            this.gcInterval = this.gcInterval || setInterval(() => this._clearMemory(), 60000);
-
-                            return trunks;
-                        } else {
-                            return { sid: message.sid, d: [_type, id, '', packed] };
+                        if (packed.length) {
+                            packets.push(packed);
                         }
+                        const trunks = packets.map((trunk, i) => ({
+                            sid: message.sid,
+                            i,
+                            l: packets.length,
+                            d: [_type, id, '', trunk],
+                        }));
+                        this.packets[id] = { ts: Date.now(), trunks };
+                        // start garbage collector
+                        this.gcInterval = this.gcInterval || setInterval(() => this._clearMemory(), 60000);
+                        return Promise.resolve(trunks);
                     }
+                    return Promise.resolve({ sid: message.sid, d: [_type, id, '', packed] });
                 });
             }
-
-            if (!this.adapter.config.remote) {
-                promiseResult = Promise.resolve(
-                    JSON.stringify({ sid: message.sid, d: [_type, id, name, ['Not enabled']] }),
-                );
+            if (!this.config.remote) {
+                promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, ['Not enabled']] });
             }
             let isNew = false;
             if (this.sockets) {
                 if (!this.sockets[message.sid]) {
                     this.adapter.log.debug(`[REMOTE] +++++ CONNECT ${message.sid}`);
-                    this.sockets[message.sid] = { _subscribe: {}, ts: Date.now() };
+                    this.sockets[message.sid] = {
+                        _subscribe: {
+                            stateChange: [],
+                            objectChange: [],
+                            log: [],
+                        },
+                        ts: Date.now(),
+                    };
                     isNew = true;
-                } else {
+                }
+                else {
                     this.sockets[message.sid].ts = Date.now();
                 }
             }
-
             if (promiseResult) {
                 // this answer will be processed at the very end of the function
-            } else if (_type === MESSAGE_TYPES.COMBINED_CALLBACK || _type === MESSAGE_TYPES.COMBINED_MESSAGE) {
+            }
+            else if (_type === MESSAGE_TYPES.COMBINED_CALLBACK || _type === MESSAGE_TYPES.COMBINED_MESSAGE) {
                 let promiseMany;
                 if (name === 'getStates') {
                     promiseMany = this._getStatesManyArgs(args);
-                } else if (name === 'getState') {
+                }
+                else if (name === 'getState') {
                     promiseMany = this._getStateManyArgs(args);
-                } else if (name === 'getObject') {
+                }
+                else if (name === 'getObject') {
                     promiseMany = this._getObjectManyArgs(args);
-                } else if (name === 'subscribe' || name === 'subscribeStates') {
+                }
+                else if (name === 'subscribe' || name === 'subscribeStates') {
                     promiseMany = this._subscribeManyArgs(message.sid, args);
-                } else if (name === 'unsubscribe' || name === 'unsubscribeStates') {
+                }
+                else if (name === 'unsubscribe' || name === 'unsubscribeStates') {
                     promiseMany = this._unsubscribeManyArgs(message.sid, args);
-                } else if (name === 'ppng') {
+                }
+                else if (name === 'ppng') {
                     // ping
                     promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, [0, isNew ? 0 : 1]] }); // 1 is OK, 0 is not OK
-                } else {
+                }
+                else {
                     // error
                     this.adapter.log.error(`[REMOTE] Received unknown multiple request: ${name}`);
                     promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, ['Unknown command']] });
@@ -1005,80 +1000,81 @@ class RemoteAccess {
                         })*/
                         .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
                 }
-            } else if (this.handlers[name]) {
+            }
+            else if (this.handlers[name]) {
+                const argsArray = args;
                 if (!this.handlers[name].args) {
                     promiseOne = this.handlers[name].f();
-                } else if (this.handlers[name].args === 1) {
-                    promiseOne = this.handlers[name].f(args[0]);
-                } else if (this.handlers[name].args === 2) {
-                    promiseOne = this.handlers[name].f(args[0], args[1]);
-                } else if (this.handlers[name].args === 3) {
-                    promiseOne = this.handlers[name].f(args[0], args[1], args[2]);
-                } else if (this.handlers[name].args === 4) {
-                    promiseOne = this.handlers[name].f(args[0], args[1], args[2], args[3]);
-                } else if (this.handlers[name].args === 5) {
-                    promiseOne = this.handlers[name].f(args[0], args[1], args[2], args[3], args[4]);
-                } else if (this.handlers[name].args === 6) {
-                    promiseOne = this.handlers[name].f(args[0], args[1], args[2], args[3], args[4], args[5]);
-                } else {
+                }
+                else if (this.handlers[name].args === 1) {
+                    promiseOne = this.handlers[name].f(argsArray[0]);
+                }
+                else if (this.handlers[name].args === 2) {
+                    promiseOne = this.handlers[name].f(argsArray[0], argsArray[1]);
+                }
+                else if (this.handlers[name].args === 3) {
+                    promiseOne = this.handlers[name].f(argsArray[0], argsArray[1], argsArray[2]);
+                }
+                else if (this.handlers[name].args === 4) {
+                    promiseOne = this.handlers[name].f(argsArray[0], argsArray[1], argsArray[2], argsArray[3]);
+                }
+                else if (this.handlers[name].args === 5) {
+                    promiseOne = this.handlers[name].f(argsArray[0], argsArray[1], argsArray[2], argsArray[3], argsArray[4]);
+                }
+                else if (this.handlers[name].args === 6) {
+                    promiseOne = this.handlers[name].f(argsArray[0], argsArray[1], argsArray[2], argsArray[3], argsArray[4], argsArray[5]);
+                }
+                else {
                     this.adapter.log.warn('[REMOTE] Unsupported number of arguments');
                 }
-            } else if (name === 'ppng') {
+            }
+            else if (name === 'ppng') {
                 // ping
                 promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null, !isNew]] });
-            } else if (name === 'name') {
+            }
+            else if (name === 'name') {
                 const socket = this.sockets[message.sid];
                 if (socket.name === undefined) {
                     socket.name = name;
                     this.adapter.log.info(`[REMOTE] socket ${message.sid} connected with name "${name}"`);
-                } else if (socket.name !== name) {
-                    this.adapter.log.warn(
-                        `[REMOTE] socket ${message.sid} changed socket name from ${socket.name} to ${name}`,
-                    );
+                }
+                else if (socket.name !== name) {
+                    this.adapter.log.warn(`[REMOTE] socket ${message.sid} changed socket name from ${socket.name} to ${name}`);
                     socket.name = name;
                 }
-
                 // start garbage collector
                 this.gcInterval = this.gcInterval || setInterval(() => this._clearMemory(), 60000);
-
                 promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, []] });
-            } else if (name === 'authenticate') {
+            }
+            else if (name === 'authenticate') {
                 promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, [true, false]] });
-            } else if (name === 'getObjects') {
+            }
+            else if (name === 'getObjects') {
                 promiseOne = this._readAllObjects();
-            } else if (name === 'getHostByIp') {
-                promiseResult = AdminSocket.getHostByIp(this.adapter, args[0]).then(result => ({
+            }
+            else if (name === 'getHostByIp') {
+                promiseResult = adminCommonSocket_1.default.getHostByIp(this.adapter, args[0]).then(result => ({
                     sid: message.sid,
                     d: [_type, id, name, [result.ip, result.obj]],
                 }));
-            } else if (name === 'getStates') {
+            }
+            else if (name === 'getStates') {
                 promiseOne = this.adapter.getForeignStatesAsync(args[0] || '*');
-            } else if (name === 'getBinaryState') {
-                promiseOne = this.adapter.getBinaryStateAsync(args[0]).then(data => {
-                    data = data && Buffer.from(data).toString('base64');
-                    return data;
-                });
-            } else if (name === 'setBinaryState') {
-                let data = null;
-                try {
-                    data = Buffer.from(args[1], 'base64');
-                } catch (e) {
-                    this.adapter.log.warn(`[REMOTE] [setBinaryState] Cannot convert base64 data: ${e}`);
-                }
-
-                promiseOne = this.adapter.setBinaryStateAsync(args[0], data);
-            } else if (name === 'requireLog') {
+            }
+            else if (name === 'requireLog') {
                 const isEnabled = args[0];
                 if (isEnabled) {
-                    this._subscribe(this, 'log', 'dummy');
-                } else {
-                    this._unsubscribe(this, 'log', 'dummy');
+                    this._subscribe(message.sid, 'log', 'dummy');
+                }
+                else {
+                    this._unsubscribe(message.sid, 'log', 'dummy');
+                }
+                if (this.adapter.log.level === 'debug') {
+                    this._showSubscribes(message.sid, 'log');
                 }
-
-                this.adapter.log.level === 'debug' && this._showSubscribes(message.sid, 'log');
-
                 promiseOne = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null]] });
-            } else if (name === 'DCT') {
+            }
+            else if (name === 'DCT') {
                 // disconnect
                 const socket = this.sockets[message.sid];
                 this.adapter.log.debug(`[REMOTE] ---- DISCONNECT ${message.sid}`);
@@ -1088,276 +1084,259 @@ class RemoteAccess {
                     this._unsubscribeSocket(message.sid, 'log');
                     delete this.sockets[message.sid];
                 }
-            } else if (name === 'getVersion') {
+            }
+            else if (name === 'getVersion') {
                 promiseResult = Promise.resolve({
                     sid: message.sid,
-                    d: [_type, id, name, [null, this.adminObj.common.version, 'admin']],
+                    d: [_type, id, name, [null, this.adminObj?.common.version, 'admin']],
                 });
-            } else if (name === 'subscribe' || name === 'subscribeStates') {
+            }
+            else if (name === 'subscribe' || name === 'subscribeStates') {
                 const pattern = args[0];
-                if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                if (Array.isArray(pattern)) {
                     for (let p = 0; p < pattern.length; p++) {
                         this._subscribe(message.sid, 'stateChange', pattern[p]);
                     }
-                } else {
+                }
+                else {
                     this._subscribe(message.sid, 'stateChange', pattern);
                 }
-
                 this.adapter.log.level === 'debug' && this._showSubscribes(message.sid, 'stateChange');
                 promiseOne = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null]] });
-            } else if (name === 'unsubscribe' || name === 'unsubscribeStates') {
+            }
+            else if (name === 'unsubscribe' || name === 'unsubscribeStates') {
                 const pattern = args[0];
-                if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                if (Array.isArray(pattern)) {
                     for (let p = 0; p < pattern.length; p++) {
                         this._unsubscribe(message.sid, 'stateChange', pattern[p]);
                     }
-                } else {
+                }
+                else {
                     this._unsubscribe(message.sid, 'stateChange', pattern);
                 }
-
                 this.adapter.log.level === 'debug' && this._showSubscribes(message.sid, 'stateChange');
                 promiseOne = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null]] });
-            } else if (name === 'subscribeObjects') {
-                const pattern = args && args[0] ? args[0] : '*';
-                if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+            }
+            else if (name === 'subscribeObjects') {
+                const pattern = args?.[0] || '*';
+                if (Array.isArray(pattern)) {
                     for (let p = 0; p < pattern.length; p++) {
                         this._subscribe(message.sid, 'objectChange', pattern[p]);
                     }
-                } else {
+                }
+                else {
                     this._subscribe(message.sid, 'objectChange', pattern);
                 }
-
                 this.adapter.log.level === 'debug' && this._showSubscribes(message.sid, 'objectChange');
                 promiseOne = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null]] });
-            } else if (name === 'unsubscribeObjects') {
+            }
+            else if (name === 'unsubscribeObjects') {
                 const pattern = args[0];
-                if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                if (Array.isArray(pattern)) {
                     for (let p = 0; p < pattern.length; p++) {
                         this._unsubscribe(message.sid, 'objectChange', pattern[p]);
                     }
-                } else {
+                }
+                else {
                     this._unsubscribe(message.sid, 'objectChange', pattern);
                 }
-
                 this.adapter.log.level === 'debug' && this._showSubscribes(message.sid, 'objectChange');
                 promiseOne = Promise.resolve({ sid: message.sid, d: [_type, id, name, [null]] });
-            } else if (name === 'authEnabled') {
+            }
+            else if (name === 'authEnabled') {
                 promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, [false, 'admin']] });
-            } else if (name === 'readFile') {
+            }
+            else if (name === 'readFile') {
                 const adapter = args[0];
                 const fileName = args[1];
                 promiseResult = this.adapter
                     .readFileAsync(adapter, fileName)
-                    .then(data =>
-                        this._sendResponse(
-                            message.sid,
-                            _type,
-                            id,
-                            name,
-                            [null, data.file, data.mimeType],
-                            message.wu,
-                            message.ru,
-                        ),
-                    )
+                    .then(data => this._sendResponse(message.sid, _type, id, name, [null, data.file, data.mimeType], message.wu, message.ru))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'readFile64') {
+            }
+            else if (name === 'readFile64') {
                 const adapter = args[0];
                 const fileName = args[1];
                 promiseResult = this.adapter
                     .readFileAsync(adapter, fileName)
                     .then(data => {
-                        let data64;
-                        if (data.mimeType) {
-                            try {
-                                if (
-                                    data.mimeType === 'application/json' ||
-                                    data.mimeType === 'application/json5' ||
-                                    fileName.toLowerCase().endsWith('.json5')
-                                ) {
-                                    data64 = Buffer.from(encodeURIComponent(data.mimeType)).toString('base64');
-                                } else {
-                                    if (typeof data.mimeType === 'string') {
-                                        data64 = Buffer.from(data.mimeType).toString('base64');
-                                    } else {
-                                        data64 = data.mimeType.toString('base64');
-                                    }
-                                }
-                            } catch (error) {
-                                this.adapter.log.error(`[readFile64] Cannot convert data: ${error.toString()}`);
+                    let data64;
+                    if (data.mimeType) {
+                        try {
+                            if (data.mimeType === 'application/json' ||
+                                data.mimeType === 'application/json5' ||
+                                fileName.toLowerCase().endsWith('.json5')) {
+                                data64 = Buffer.from(encodeURIComponent(data.mimeType)).toString('base64');
+                            }
+                            else if (data.mimeType) {
+                                data64 = Buffer.from(data.mimeType).toString('base64');
                             }
                         }
-
-                        return this._sendResponse(
-                            message.sid,
-                            _type,
-                            id,
-                            name,
-                            [null, data64, data.mimeType],
-                            message.wu,
-                            message.ru,
-                        );
-                    })
+                        catch (error) {
+                            this.adapter.log.error(`[readFile64] Cannot convert data: ${error.toString()}`);
+                        }
+                    }
+                    return this._sendResponse(message.sid, _type, id, name, [null, data64, data.mimeType], message.wu, message.ru);
+                })
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'writeFile' || name === 'writeFile64') {
+            }
+            else if (name === 'writeFile' || name === 'writeFile64') {
                 const [adr, fileName, data64, options] = args;
                 if (readUrl) {
-                    promiseOne = axios(readUrl, {
+                    promiseOne = (0, axios_1.default)(readUrl, {
                         responseType: 'arraybuffer',
                         validateStatus: status => status === 200,
                         timeout: 15000,
-                    }).then(response =>
-                        this.adapter.writeFileAsync(adr, fileName, Buffer.from(response.data), options),
-                    );
-                } else if (name === 'wirteFile') {
+                    }).then(response => this.adapter.writeFileAsync(adr, fileName, Buffer.from(response.data), options));
+                }
+                else if (name === 'writeFile') {
                     this.adapter.log.debug('writeFile deprecated. Please use writeFile64');
                     promiseOne = this.adapter.writeFileAsync(adr, fileName, data64, options);
-                } else if (name === 'wirteFile64') {
+                }
+                else if (name === 'writeFile64') {
                     const buffer = Buffer.from(data64, 'base64');
                     promiseOne = this.adapter.writeFileAsync(adr, fileName, buffer, options);
                 }
-            } else if (name === 'getHistory') {
+            }
+            else if (name === 'getHistory') {
                 const _id = args[0];
                 const options = args[1];
                 promiseResult = this.adapter
                     .getHistoryAsync(_id, options)
-                    .then(data =>
-                        this._sendResponse(
-                            message.sid,
-                            _type,
-                            id,
-                            name,
-                            [null, data.result, data.step, data.sessionId],
-                            message.wu,
-                            message.ru,
-                        ),
-                    )
+                    .then(data => this._sendResponse(message.sid, _type, id, name, [null, data.result, data.step, data.sessionId], message.wu, message.ru))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'writeFile64' || name === 'writeFile') {
-                const [_adapter, fileName, data64, options] = args;
-                // Convert base 64 to buffer
-                const buffer = Buffer.from(data64, 'base64');
-                promiseOne = this.adapter.writeFileAsync(_adapter, fileName, buffer, options);
-            } else if (name === 'getEasyMode') {
-                promiseOne = AdminSocket.getEasyMode(this.adapter, this.adminObj);
-            } else if (name === 'getAdapterInstances') {
-                promiseOne = AdminSocket.getAdapterInstances(this.adapter, args[0]);
-            } else if (name === 'getCurrentInstance') {
-                promiseOne = Promise.resolve(this.adapter.config.remoteAdminInstance);
-            } else if (name === 'checkFeatureSupported') {
-                promiseOne = Promise.resolve(this.adapter.supportsFeature && this.adapter.supportsFeature(args[0]));
-            } else if (name === 'getAdapterName') {
+            }
+            else if (name === 'getEasyMode') {
+                promiseOne = adminCommonSocket_1.default.getEasyMode(this.adapter, this.adminObj);
+            }
+            else if (name === 'getAdapterInstances') {
+                promiseOne = adminCommonSocket_1.default.getAdapterInstances(this.adapter, args[0]);
+            }
+            else if (name === 'getCurrentInstance') {
+                promiseOne = Promise.resolve(this.config.remoteAdminInstance);
+            }
+            else if (name === 'checkFeatureSupported') {
+                promiseOne = Promise.resolve(this.adapter.supportsFeature?.(args[0]));
+            }
+            else if (name === 'getAdapterName') {
                 promiseOne = Promise.resolve('admin');
-            } else if (name === 'decrypt') {
+            }
+            else if (name === 'decrypt') {
                 if (this.secret) {
-                    promiseOne = Promise.resolve(this.adapter.tools.decrypt(this.secret, args[0]));
-                } else {
+                    promiseOne = Promise.resolve(this.adapter.decrypt(this.secret, args[0]));
+                }
+                else {
                     promiseOne = this.adapter.getForeignObjectAsync('system.config', (err, obj) => {
-                        if (obj && obj.native && obj.native.secret) {
+                        if (obj?.native?.secret) {
                             this.secret = obj.native.secret;
-                            return this.adapter.tools.decrypt(this.secret, args[0]);
-                        } else {
-                            this.adapter.log.error(`No system.config found: ${err}`);
-                            throw new Error('No system.config found');
+                            return this.adapter.decrypt(this.secret, args[0]);
                         }
+                        this.adapter.log.error(`No system.config found: ${err}`);
+                        throw new Error('No system.config found');
                     });
                 }
-            } else if (name === 'encrypt') {
+            }
+            else if (name === 'encrypt') {
                 if (this.secret) {
-                    promiseOne = Promise.resolve(this.adapter.tools.encrypt(this.secret, args[0]));
-                } else {
+                    promiseOne = Promise.resolve(this.adapter.encrypt(this.secret, args[0]));
+                }
+                else {
                     promiseOne = this.adapter.getForeignObjectAsync('system.config', (err, obj) => {
-                        if (obj && obj.native && obj.native.secret) {
+                        if (obj?.native?.secret) {
                             this.secret = obj.native.secret;
-                            return this.adapter.tools.encrypt(this.secret, args[0]);
-                        } else {
-                            this.adapter.log.error(`No system.config found: ${err}`);
-                            throw new Error('No system.config found');
+                            return this.adapter.encrypt(this.secret, args[0]);
                         }
+                        this.adapter.log.error(`No system.config found: ${err}`);
+                        throw new Error('No system.config found');
                     });
                 }
-            } else if (name === 'getIsEasyModeStrict') {
-                promiseOne = AdminSocket.getIsEasyModeStrict(this.adapter, this.adminObj);
-            } else if (name === 'getAdapters') {
-                promiseOne = AdminSocket.getAdapters(this.adapter, args[0]);
-            } else if (name === 'updateLicenses') {
-                promiseOne = AdminSocket.updateLicenses(this.adapter, args[0], args[1], this.adminObj);
-            } else if (name === 'getCompactInstances') {
-                promiseOne = AdminSocket.getCompactInstances(this.adapter);
-            } else if (name === 'getCompactSystemRepositories') {
-                promiseOne = AdminSocket.getCompactSystemRepositories(this.adapter);
-            } else if (name === 'getCompactAdapters') {
-                promiseOne = AdminSocket.getCompactAdapters(this.adapter);
-            } else if (name === 'getCompactInstalled') {
-                promiseResult = AdminSocket.getCompactInstalled(
-                    this.adapter,
-                    args[0] || this.adminObj.common.host,
-                ).then(data => ({ sid: message.sid, d: [_type, id, name, [data]] }));
-            } else if (name === 'getCompactSystemConfig') {
-                promiseOne = AdminSocket.getCompactSystemConfig(this.adapter);
-            } else if (name === 'getCompactRepository') {
-                promiseResult = AdminSocket.getCompactRepository(
-                    this.adapter,
-                    args[0] || this.adminObj.common.host,
-                ).then(data => ({ sid: message.sid, d: [_type, id, name, [data]] }));
-            } else if (name === 'getCompactHosts') {
-                promiseOne = AdminSocket.getCompactHosts(this.adapter);
-            } else if (name === 'readLogs') {
-                promiseOne = AdminSocket.readLogs(this.adapter, args[0] || this.adminObj.common.host);
-            } else if (name === 'eventsThreshold') {
+            }
+            else if (name === 'getIsEasyModeStrict') {
+                promiseOne = adminCommonSocket_1.default.getIsEasyModeStrict(this.adapter, this.adminObj);
+            }
+            else if (name === 'getAdapters') {
+                promiseOne = adminCommonSocket_1.default.getAdapters(this.adapter, args[0]);
+            }
+            else if (name === 'updateLicenses') {
+                promiseOne = adminCommonSocket_1.default.updateLicenses(this.adapter, args[0], args[1], this.adminObj);
+            }
+            else if (name === 'getCompactInstances') {
+                promiseOne = adminCommonSocket_1.default.getCompactInstances(this.adapter);
+            }
+            else if (name === 'getCompactSystemRepositories') {
+                promiseOne = adminCommonSocket_1.default.getCompactSystemRepositories(this.adapter);
+            }
+            else if (name === 'getCompactAdapters') {
+                promiseOne = adminCommonSocket_1.default.getCompactAdapters(this.adapter);
+            }
+            else if (name === 'getCompactInstalled') {
+                promiseResult = adminCommonSocket_1.default.getCompactInstalled(this.adapter, args[0] || this.adminObj?.common.host || this.adapter.common.host).then(data => ({ sid: message.sid, d: [_type, id, name, [data]] }));
+            }
+            else if (name === 'getCompactSystemConfig') {
+                promiseOne = adminCommonSocket_1.default.getCompactSystemConfig(this.adapter);
+            }
+            else if (name === 'getCompactRepository') {
+                promiseResult = adminCommonSocket_1.default.getCompactRepository(this.adapter, args[0] || this.adminObj?.common.host || this.adapter.common.host).then(data => ({ sid: message.sid, d: [_type, id, name, [data]] }));
+            }
+            else if (name === 'getCompactHosts') {
+                promiseOne = adminCommonSocket_1.default.getCompactHosts(this.adapter);
+            }
+            else if (name === 'readLogs') {
+                promiseOne = adminCommonSocket_1.default.readLogs(this.adapter, args[0] || this.adminObj?.common.host || this.adapter.common.host);
+            }
+            else if (name === 'eventsThreshold') {
                 promiseOne = Promise.resolve(NONE);
-            } else if (name === 'getRatings') {
-                promiseOne = AdminSocket.getRatings(this.adapter, args[0]);
-            } else if (name === 'getUserPermissions') {
+            }
+            else if (name === 'getRatings') {
+                promiseOne = adminCommonSocket_1.default.getRatings(this.adapter, args[0], args[1]);
+            }
+            else if (name === 'getUserPermissions') {
                 this.adapter.log.error(`[REMOTE] getUserPermissions not implemented!!!!!!!!!!!!!!!!!!!!!`);
-            } else if (name === 'listPermissions') {
-                promiseResult = AdminSocket.listPermissions(this.adapter)
-                    .then(commandsPermissions =>
-                        this._sendResponse(message.sid, _type, id, name, [commandsPermissions]),
-                    )
+            }
+            else if (name === 'listPermissions') {
+                promiseResult = adminCommonSocket_1.default.listPermissions(this.adapter)
+                    .then(commandsPermissions => this._sendResponse(message.sid, _type, id, name, [commandsPermissions]))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'sendToHost') {
+            }
+            else if (name === 'sendToHost') {
                 const [host, command, msg] = args;
                 this.adapter.log.debug(`[REMOTE] SEND_TO_HOST: ${command}`);
                 // check if the host is alive
-                promiseResult = AdminSocket.sendToHost(this.adapter, host, command, msg)
+                promiseResult = adminCommonSocket_1.default.sendToHost(this.adapter, host, command, msg)
                     .then(data => this._sendResponse(message.sid, _type, id, name, [data], message.wu, message.ru))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'sendTo') {
+            }
+            else if (name === 'sendTo') {
                 const [adapterInstance, command, message] = args;
-                promiseResult = AdminSocket.sendTo(this.adapter, adapterInstance, command, message)
+                promiseResult = adminCommonSocket_1.default.sendTo(this.adapter, adapterInstance, command, message)
                     .then(data => this._sendResponse(message.sid, _type, id, name, [data], message.wu, message.ru))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
-            } else if (name === 'getAllObjects') {
-                promiseOne = AdminSocket.getAllObjects(this.adapter);
             }
-
+            else if (name === 'getAllObjects') {
+                promiseOne = adminCommonSocket_1.default.getAllObjects(this.adapter);
+            }
             // MESSAGE is the only one-way message and no answer is expected
             if (_type === MESSAGE_TYPES.MESSAGE || _type === MESSAGE_TYPES.COMBINED_MESSAGE) {
                 promiseResult = promiseOne ? promiseOne.then(() => NONE) : Promise.resolve(NONE);
-            } else if (!promiseResult && promiseOne) {
+            }
+            else if (!promiseResult && promiseOne) {
                 promiseResult = promiseOne
-                    .then(result =>
-                        this._sendResponse(message.sid, _type, id, name, [null, result], message.wu, message.ru),
-                    )
+                    .then(result => this._sendResponse(message.sid, _type, id, name, [null, result], message.wu, message.ru))
                     .catch(error => ({ sid: message.sid, d: [_type, id, name, [error]] }));
             }
-
             if (!promiseResult) {
                 this.adapter.log.warn(`[REMOTE] Received unknown command: ${name}`);
                 promiseResult = Promise.resolve({ sid: message.sid, d: [_type, id, name, ['Unknown command']] });
             }
-
             return promiseResult.then(result => {
                 if (result !== NONE && result.d && result.d[0] !== MESSAGE_TYPES.WAIT) {
-                    setImmediate(async (result, message) => await this._sendEvent(result, message), result, message);
+                    setImmediate(async (_result, _message) => await this._sendEvent(_result, _message), result, message);
                 }
-
                 return NONE;
             });
-        } else {
-            return Promise.reject('Null message');
         }
+        return Promise.reject(new Error('Null message'));
     }
 }
-
-module.exports = RemoteAccess;
+exports.default = RemoteAccess;
+//# sourceMappingURL=remote.js.map