@iobroker/socket-classes 2.6.2 → 2.7.1

package/build/lib/socketCommands.js

@@ -1,7 +1,18 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SocketCommands = exports.COMMANDS_PERMISSIONS = void 0;
 const adapter_core_1 = require("@iobroker/adapter-core"); // Get common adapter utils
+/**
+ * The events that are waiting for the database to say whether their socket may see them.
+ *
+ * Kept per connection and per event, and only ever the **latest** one: while the first event of an id
+ * waits for its answer, a newer value of the same state would otherwise overtake it and the client
+ * would end up with the older one. What is kept is how to deliver it - the event goes through
+ * `publish`/`publishFile` again, so a subscription that was given up in the meantime still counts. It
+ * lives in a `WeakMap`, so a connection that goes away takes its waiting events with it.
+ */
+const pendingEvents = new WeakMap();
 exports.COMMANDS_PERMISSIONS = {
     getObject: { type: 'object', operation: 'read' },
     getObjects: { type: 'object', operation: 'list' },
@@ -70,6 +81,21 @@ class SocketCommands {
     subscribes = {};
     #logEnabled = false;
     #clientSubscribes = {};
+    /**
+     * What each user may read, by object id. Filled while the events flow, emptied where an object -
+     * or the rights themselves - change. Per user, because every browser tab of one person would
+     * otherwise ask the same question again.
+     */
+    #readable = new Map();
+    /** Questions that are with the database right now, so the same id is asked only once at a time */
+    #deciding = new Map();
+    /**
+     * Counts how often the decisions were thrown away. An answer that was asked for before the last
+     * change arrives too late to be trusted and is dropped instead of being remembered.
+     */
+    #readableGeneration = 0;
+    /** Whether this instance watches the objects for the sake of its own decisions - see `#rememberDecision` */
+    #watchingObjects = false;
     #updateSession;
     adapterName;
     _sendToHost;
@@ -196,41 +222,41 @@ class SocketCommands {
         if (socket._acl?.user !== 'system.user.admin') {
             // type: file, object, state, other
             // operation: create, read, write, list, delete, sendto, execute, sendToHost, readLogs
-            if (SocketCommands.COMMANDS_PERMISSIONS[_command]) {
+            if (_a.COMMANDS_PERMISSIONS[_command]) {
                 // If permission required
-                const commandType = SocketCommands.COMMANDS_PERMISSIONS[_command].type;
+                const commandType = _a.COMMANDS_PERMISSIONS[_command].type;
                 if (commandType) {
                     if (commandType === 'object') {
-                        const operation = SocketCommands.COMMANDS_PERMISSIONS[_command].operation;
+                        const operation = _a.COMMANDS_PERMISSIONS[_command].operation;
                         if (socket._acl?.object?.[operation]) {
                             return true;
                         }
                     }
                     else if (commandType === 'state') {
-                        const operation = SocketCommands.COMMANDS_PERMISSIONS[_command].operation;
+                        const operation = _a.COMMANDS_PERMISSIONS[_command].operation;
                         if (socket._acl?.state?.[operation]) {
                             return true;
                         }
                     }
                     else if (commandType === 'users') {
-                        const operation = SocketCommands.COMMANDS_PERMISSIONS[_command].operation;
+                        const operation = _a.COMMANDS_PERMISSIONS[_command].operation;
                         if (socket._acl?.users?.[operation]) {
                             return true;
                         }
                     }
                     else if (commandType === 'other') {
-                        const operation = SocketCommands.COMMANDS_PERMISSIONS[_command].operation;
+                        const operation = _a.COMMANDS_PERMISSIONS[_command].operation;
                         if (socket._acl?.other?.[operation]) {
                             return true;
                         }
                     }
                     else if (commandType === 'file') {
-                        const operation = SocketCommands.COMMANDS_PERMISSIONS[_command].operation;
+                        const operation = _a.COMMANDS_PERMISSIONS[_command].operation;
                         if (socket._acl?.file?.[operation]) {
                             return true;
                         }
                     }
-                    this.adapter.log.warn(`No permission for "${socket._acl?.user}" to call ${_command}. Need "${commandType}"."${SocketCommands.COMMANDS_PERMISSIONS[_command].operation}"`);
+                    this.adapter.log.warn(`No permission for "${socket._acl?.user}" to call ${_command}. Need "${commandType}"."${_a.COMMANDS_PERMISSIONS[_command].operation}"`);
                 }
                 else {
                     return true;
@@ -240,29 +266,269 @@ class SocketCommands {
                 this.adapter.log.warn(`No rule for command: ${_command}`);
             }
             if (typeof callback === 'function') {
-                callback(SocketCommands.ERROR_PERMISSION);
+                callback(_a.ERROR_PERMISSION);
             }
             else {
-                if (SocketCommands.COMMANDS_PERMISSIONS[_command]) {
-                    socket.emit(SocketCommands.ERROR_PERMISSION, {
+                if (_a.COMMANDS_PERMISSIONS[_command]) {
+                    socket.emit(_a.ERROR_PERMISSION, {
                         command,
-                        type: SocketCommands.COMMANDS_PERMISSIONS[_command].type,
-                        operation: SocketCommands.COMMANDS_PERMISSIONS[_command].operation,
+                        type: _a.COMMANDS_PERMISSIONS[_command].type,
+                        operation: _a.COMMANDS_PERMISSIONS[_command].operation,
                         args,
                     });
                 }
                 else {
-                    socket.emit(SocketCommands.ERROR_PERMISSION, { command: _command, args });
+                    socket.emit(_a.ERROR_PERMISSION, { command: _command, args });
                 }
             }
             return false;
         }
         return true;
     }
+    /**
+     * Whether this connection belongs to somebody who may see everything.
+     *
+     * The administrator group is the whole point of the administrator group, and with authentication
+     * switched off every connection is the configured default user - usually exactly that one. So this
+     * is the answer for almost every connection there is, and it costs a look at an ACL that the
+     * socket layer calculated when the connection was opened.
+     *
+     * @param socket the connection in question
+     */
+    static #seesEverything(socket) {
+        const acl = socket?._acl;
+        return acl?.user === 'system.user.admin' || !!acl?.groups?.includes('system.group.administrator');
+    }
+    /**
+     * Whether the user of this connection may read `id`, as far as it is already known.
+     *
+     * `undefined` means "not decided yet" - the caller has to let `#decideReadable` ask the database
+     * and come back. Decisions are kept per user, not per connection: three browser tabs of the same
+     * person ask once.
+     *
+     * @param socket the connection the event would go to
+     * @param question what the event is about
+     */
+    #mayRead(socket, question) {
+        const user = socket?._acl?.user;
+        if (!user) {
+            // a connection without a user has no rights at all, not even to be told that `id` exists
+            return false;
+        }
+        if (_a.#seesEverything(socket)) {
+            return true;
+        }
+        return this.#readable.get(user)?.get(_a.#questionKey(question));
+    }
+    /** What one question is remembered under: the kind, the id, and for a file its name */
+    static #questionKey(question) {
+        return question.fileName
+            ? `${question.type}####${question.id}####${question.fileName}`
+            : `${question.type}####${question.id}`;
+    }
+    /**
+     * Ask the database whether the user may read `id`, and remember the answer.
+     *
+     * The database owns this decision - the ACL of the object, its owner, the groups of the user and
+     * the default ACL of the system all go into it, and a second implementation here would drift away
+     * from it sooner or later. Everybody who is waiting for the same id is answered together.
+     *
+     * @param socket the connection the event would go to
+     * @param question what the event is about
+     * @param andThen what to do once it is decided, with the decision
+     */
+    #decideReadable(socket, question, andThen) {
+        // a connection without a user never gets this far: `#mayRead` refuses it outright
+        const user = socket._acl.user;
+        const questionKey = _a.#questionKey(question);
+        const key = `${user}####${questionKey}`;
+        const waiting = this.#deciding.get(key);
+        if (waiting) {
+            waiting.push(andThen);
+            return;
+        }
+        this.#deciding.set(key, [andThen]);
+        const generation = this.#readableGeneration;
+        const answer = (allowed) => {
+            if (generation === this.#readableGeneration) {
+                this.#rememberDecision(user, questionKey, allowed);
+            }
+            /*
+             * An answer that is too old to be remembered still answers the events that waited for it:
+             * a "no" drops them, a "yes" sends them back through `publish`, which - with nothing in
+             * memory - asks again under the rights as they are now.
+             */
+            const callbacks = this.#deciding.get(key) || [];
+            this.#deciding.delete(key);
+            for (const callback of callbacks) {
+                callback(allowed);
+            }
+        };
+        const mayRead = this.adapter.mayRead;
+        if (mayRead) {
+            /*
+             * The controller answers this itself from js-controller 8.0 on, and it is the only place
+             * that knows the whole truth: the ACL of a state rather than of its object, the mode of a
+             * single file rather than of the adapter it belongs to.
+             */
+            mayRead.call(this.adapter, { ...question, user }).then(answer, (e) => {
+                this.adapter.log.warn(`Cannot check what "${user}" may read of "${question.id}": ${e.message}`);
+                answer(false);
+            });
+            return;
+        }
+        /*
+         * An older controller cannot be asked, so the object has to stand in for all three. It is
+         * coarser - the right on the object instead of the one on the state, the adapter instead of
+         * the single file - but it errs the same way: only a refusal of the database counts as "no".
+         * That an object does not exist is not a refusal, and `mayRead` of a newer controller says the
+         * same, because such a state can be read by anybody.
+         */
+        // the callback form also returns a promise, which nobody here waits for
+        void this.adapter.getForeignObject(question.id, { user }, (error) => answer(!error));
+    }
+    /**
+     * Keep one decision, and make sure the object changes that would invalidate it arrive here.
+     *
+     * Nothing of this is needed as long as everybody who is connected sees everything anyway, which is
+     * the normal case - so the subscription is taken out where the first decision is made and not
+     * before. The events themselves reach `publish` the way every other object change does.
+     *
+     * @param user whose decision it is
+     * @param questionKey what was asked - the kind, the id and for a file its name
+     * @param allowed what was decided
+     */
+    #rememberDecision(user, questionKey, allowed) {
+        let decisions = this.#readable.get(user);
+        if (!decisions) {
+            decisions = new Map();
+            this.#readable.set(user, decisions);
+        }
+        decisions.set(questionKey, allowed);
+        if (!this.#watchingObjects) {
+            this.#watchingObjects = true;
+            /*
+             * The ACL of an object can change at any time, and without this the decision above would
+             * be kept until the connection goes away. The watch counts as one more subscriber of `*`:
+             * a client that subscribed to all objects and gives them up again would otherwise take
+             * the subscription of the database away from under it.
+             */
+            this.subscribes.objectChange ||= {};
+            if (this.subscribes.objectChange['*'] === undefined) {
+                this.subscribes.objectChange['*'] = 1;
+                this.adapter
+                    .subscribeForeignObjectsAsync('*')
+                    .catch(e => this.adapter.log.warn(`Cannot watch the objects for the permissions of the clients: ${e.message}`));
+            }
+            else {
+                this.subscribes.objectChange['*']++;
+            }
+        }
+    }
+    /** Forget what was decided about `id`, because the object - and with it its ACL - changed. */
+    #forgetReadable(id) {
+        this.#readableGeneration++;
+        if (id.startsWith('system.user.') || id.startsWith('system.group.') || id === 'system.config') {
+            // the rights themselves moved, so nothing that was decided with them still counts
+            this.#readable.clear();
+            return;
+        }
+        for (const decisions of this.#readable.values()) {
+            // everything that was decided about this id, whatever was asked about it
+            for (const questionKey of decisions.keys()) {
+                if (questionKey.endsWith(`####${id}`) || questionKey.includes(`####${id}####`)) {
+                    decisions.delete(questionKey);
+                }
+            }
+        }
+    }
+    /**
+     * Hold one event until it is decided whether its connection may see it.
+     *
+     * Only the latest event of the same kind and id waits; a newer one replaces it, so nothing can
+     * overtake it. The question is asked once - every further event of that id joins the one that is
+     * already open.
+     *
+     * @param socket the connection the event would go to
+     * @param question what the decision is about
+     * @param key what identifies this event - its kind and what it is about
+     * @param deliver how to send it once it is decided
+     */
+    #holdUntilDecided(socket, question, key, deliver) {
+        let waiting = pendingEvents.get(socket);
+        if (!waiting) {
+            waiting = new Map();
+            pendingEvents.set(socket, waiting);
+        }
+        const first = !waiting.has(key);
+        waiting.set(key, deliver);
+        if (first) {
+            this.#decideReadable(socket, question, allowed => this.#flushPending(socket, key, allowed));
+        }
+    }
+    /**
+     * Send the event that waited for a decision, if it may go out after all.
+     *
+     * What is sent is whatever arrived last while the question was open - a client that subscribes to
+     * a state wants its value, not the one it had a moment ago. It goes through `publish`/`publishFile`
+     * again: the subscription may have been given up in the meantime. Usually the decision is in memory
+     * by then and the event goes out; only where the object changed while the question was open was
+     * the answer not remembered, and the event waits once more for a fresh one.
+     *
+     * @param socket the connection that waited
+     * @param key what identifies the event
+     * @param allowed what was decided
+     */
+    #flushPending(socket, key, allowed) {
+        const waiting = pendingEvents.get(socket);
+        const deliver = waiting?.get(key);
+        if (!deliver || !waiting) {
+            return;
+        }
+        waiting.delete(key);
+        if (allowed) {
+            deliver();
+        }
+    }
+    /**
+     * Give one event to one connection, if it is subscribed to it and may see it.
+     *
+     * Returns whether the event is on its way to this client: `true` where it was sent, and also
+     * where it is waiting for the database to decide whether this user may read the object - the
+     * answer to that is not worth holding up every other connection for. `false` means the client is
+     * not subscribed to it, or may not see it.
+     *
+     * @param socket the connection
+     * @param type what kind of event it is
+     * @param id the object it is about
+     * @param obj the state or object as it is sent to the client
+     */
     publish(socket, type, id, obj) {
+        if (type === 'objectChange') {
+            // the ACL of the object travelled with it, so what was decided about it is out of date
+            this.#forgetReadable(id);
+        }
         if (socket?.subscribe?.[type] && this.#updateSession(socket)) {
             return !!socket.subscribe[type].find(sub => {
                 if (sub.regex.test(id)) {
+                    /*
+                     * Who may know that this exists? A subscription says which ids a client is
+                     * interested in, never which ids it may see - `subscribe` only asks whether the
+                     * user may read states at all, so whoever subscribed to `*` was told about every
+                     * state of the system, the ACL of the single objects notwithstanding.
+                     */
+                    const question = { type: type === 'objectChange' ? 'object' : 'state', id };
+                    const allowed = this.#mayRead(socket, question);
+                    if (allowed === false) {
+                        return false;
+                    }
+                    if (allowed === undefined) {
+                        // the first event of an id for this user waits for the answer instead of
+                        // being guessed at
+                        this.#holdUntilDecided(socket, question, `${type}####${id}`, () => this.publish(socket, type, id, obj));
+                        // on its way: either it goes out in a moment, or the user may not see it
+                        return true;
+                    }
                     // replace language
                     if (this.context.language &&
                         id === 'system.config' &&
@@ -276,11 +542,36 @@ class SocketCommands {
         }
         return false;
     }
+    /**
+     * Give one file event to one connection, if it is subscribed to it and may see it.
+     *
+     * The decision is taken per file and user. Where the controller has `mayRead`, it answers for the
+     * single file, with its own owner and mode as `chownFile` and `chmodFile` set them. An older
+     * controller cannot be asked about a file, so the meta object the files belong to - `vis.0` for
+     * every file of vis - stands in for it: still one question per file, but every one of them about
+     * the adapter. That also works where the file the event is about has just been deleted.
+     *
+     * The answer means the same as in {@link publish}: `true` where the event is on its way.
+     *
+     * @param socket the connection
+     * @param id the adapter the file belongs to, e.g. `vis.0`
+     * @param fileName the path of the file inside it
+     * @param size how big it is now, or null where it is gone
+     */
     publishFile(socket, id, fileName, size) {
         if (socket?.subscribe?.fileChange && this.#updateSession(socket)) {
             const key = `${id}####${fileName}`;
             return !!socket.subscribe.fileChange.find(sub => {
                 if (sub.regex.test(key)) {
+                    const question = { type: 'file', id, fileName };
+                    const allowed = this.#mayRead(socket, question);
+                    if (allowed === false) {
+                        return false;
+                    }
+                    if (allowed === undefined) {
+                        this.#holdUntilDecided(socket, question, `fileChange####${key}`, () => this.publishFile(socket, id, fileName, size));
+                        return true;
+                    }
                     socket.emit('fileChange', id, fileName, size);
                     return true;
                 }
@@ -288,17 +579,30 @@ class SocketCommands {
         }
         return false;
     }
+    /**
+     * The send options for a message triggered by this socket: the user it is sent on behalf of.
+     *
+     * Objects, states and files have always been read and written with `{ user }` so the database
+     * applies the ACLs of the logged-in user. A message had no such channel: the receiving instance saw
+     * `from` and nothing else, so every adapter reachable over `sendTo` had to act with its own rights,
+     * and could not tell one caller from another. The user travels with the message now: js-controller
+     * 7.2.5 and newer put it into the message as `obj.user`, older ones ignore the option, so nothing
+     * breaks. A receiver treats the field as optional - where nobody was named there is nothing to
+     * check against, which is how every message looked before.
+     *
+     * @param socket the socket the command came in on
+     */
+    static sendOptionsOf(socket) {
+        const user = socket?._acl?.user;
+        return user ? { user } : undefined;
+    }
     publishInstanceMessage(socket, sourceInstance, messageType, data) {
         if (this.#clientSubscribes[socket.id]?.[sourceInstance]?.includes(messageType)) {
             socket.emit('im', messageType, sourceInstance, data);
             return true;
         }
         // inform instance about missing subscription
-        this.adapter.sendTo(sourceInstance, 'clientSubscribeError', {
-            type: messageType,
-            sid: socket.id,
-            reason: 'no one subscribed',
-        });
+        this.adapter.sendTo(sourceInstance, 'clientSubscribeError', { type: messageType, sid: socket.id, reason: 'no one subscribed' }, undefined, _a.sendOptionsOf(socket));
         return false;
     }
     _showSubscribes(socket, type) {
@@ -550,7 +854,7 @@ class SocketCommands {
             return;
         }
         // inform all instances about disconnected socket, also if the socket has never subscribed to anything
-        this.#informAboutDisconnect(socket.id);
+        this.#informAboutDisconnect(socket);
         if (!socket.subscribe) {
             return;
         }
@@ -859,18 +1163,18 @@ class SocketCommands {
          */
         this.commands.checkFeatureSupported = (_socket, feature, callback) => {
             if (feature === 'INSTANCE_MESSAGES') {
-                SocketCommands._fixCallback(callback, null, true);
+                _a._fixCallback(callback, null, true);
             }
             else if (feature === 'PARTIAL_OBJECT_TREE') {
-                SocketCommands._fixCallback(callback, null, true);
+                _a._fixCallback(callback, null, true);
             }
             else if (feature === 'OBJECTS_COUNT') {
                 // only the admin variant of these commands has it, and a client that asks must not
                 // send a command that nobody answers - it would sit there until its timeout
-                SocketCommands._fixCallback(callback, null, !!this.commands.getObjectsCount);
+                _a._fixCallback(callback, null, !!this.commands.getObjectsCount);
             }
             else {
-                SocketCommands._fixCallback(callback, null, this.adapter.supportsFeature(feature));
+                _a._fixCallback(callback, null, this.adapter.supportsFeature(feature));
             }
         };
         /**
@@ -894,11 +1198,11 @@ class SocketCommands {
                 options.user = socket._acl?.user;
                 options.aggregate ||= 'none';
                 try {
-                    this.adapter.getHistory(id, options, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.getHistory(id, options, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[getHistory] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -936,7 +1240,7 @@ class SocketCommands {
         this.commands.sendTo = (socket, adapterInstance, command, message, callback) => {
             if (this._checkPermissions(socket, 'sendTo', callback, command)) {
                 try {
-                    this.adapter.sendTo(adapterInstance, command, message, res => typeof callback === 'function' && setImmediate(() => callback(res)));
+                    this.adapter.sendTo(adapterInstance, command, message, res => typeof callback === 'function' && setImmediate(() => callback(res)), _a.sendOptionsOf(socket));
                 }
                 catch (error) {
                     if (typeof callback === 'function') {
@@ -971,7 +1275,7 @@ class SocketCommands {
          * @param callback callback `(result: { error?: string; result?: any }) => void`
          */
         this.commands.sendToHost = (socket, host, command, message, callback) => {
-            if (this._checkPermissions(socket, protectedCommands.includes(command) ? 'cmdExec' : 'sendToHost', (error) => callback({ error: error || SocketCommands.ERROR_PERMISSION }), command)) {
+            if (this._checkPermissions(socket, protectedCommands.includes(command) ? 'cmdExec' : 'sendToHost', (error) => callback({ error: error || _a.ERROR_PERMISSION }), command)) {
                 // Try to decode this file locally as redis has a limitation for files bigger than 20MB
                 if (command === 'writeDirAsZip' && message && message.data.length > 1024 * 1024) {
                     let buffer;
@@ -1002,7 +1306,10 @@ class SocketCommands {
                 }
                 else {
                     try {
-                        this.adapter.sendToHost(host, command, message, callback);
+                        // the 5th parameter exists from js-controller 7.2.5 on; an older one
+                        // ignores the extra argument
+                        const sendToHost = this.adapter.sendToHost;
+                        sendToHost.call(this.adapter, host, command, message, callback, _a.sendOptionsOf(socket));
                     }
                     catch (error) {
                         if (callback) {
@@ -1101,7 +1408,7 @@ class SocketCommands {
          */
         this.commands.listPermissions = (_socket, callback) => {
             if (typeof callback === 'function') {
-                callback(SocketCommands.COMMANDS_PERMISSIONS);
+                callback(_a.COMMANDS_PERMISSIONS);
             }
             else {
                 this.adapter.log.warn('[listPermissions] Invalid callback');
@@ -1173,11 +1480,11 @@ class SocketCommands {
         this.commands.readFile = (socket, adapter, fileName, callback) => {
             if (this._checkPermissions(socket, 'readFile', callback, fileName)) {
                 try {
-                    this.adapter.readFile(adapter, fileName, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.readFile(adapter, fileName, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[readFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1226,7 +1533,7 @@ class SocketCommands {
                 }
                 catch (error) {
                     this.adapter.log.error(`[readFile64] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1255,16 +1562,16 @@ class SocketCommands {
             }
             if (this._checkPermissions(socket, 'writeFile64', callback, fileName)) {
                 if (!data64) {
-                    return SocketCommands._fixCallback(callback, 'No data provided');
+                    return _a._fixCallback(callback, 'No data provided');
                 }
                 // Convert base 64 to buffer
                 try {
                     const buffer = Buffer.from(data64, 'base64');
-                    this.adapter.writeFile(adapter, fileName, buffer, _options, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.writeFile(adapter, fileName, buffer, _options, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[writeFile64] Cannot convert data: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, `Cannot convert data: ${error.toString()}`);
+                    _a._fixCallback(callback, `Cannot convert data: ${error.toString()}`);
                 }
             }
         };
@@ -1297,11 +1604,11 @@ class SocketCommands {
                 }
                 this.adapter.log.debug('writeFile deprecated. Please use writeFile64');
                 try {
-                    this.adapter.writeFile(adapter, fileName, data, _options, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.writeFile(adapter, fileName, data, _options, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[writeFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1318,12 +1625,12 @@ class SocketCommands {
             if (this._checkPermissions(socket, 'unlink', callback, name)) {
                 try {
                     this.#unlink(adapter, name, { user: socket._acl?.user })
-                        .then(() => SocketCommands._fixCallback(callback, undefined))
-                        .catch(error => SocketCommands._fixCallback(callback, error));
+                        .then(() => _a._fixCallback(callback, undefined))
+                        .catch(error => _a._fixCallback(callback, error));
                 }
                 catch (error) {
                     this.adapter.log.error(`[unlink] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1339,11 +1646,11 @@ class SocketCommands {
         this.commands.deleteFile = (socket, adapter, name, callback) => {
             if (this._checkPermissions(socket, 'unlink', callback, name)) {
                 try {
-                    this.adapter.unlink(adapter, name, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.unlink(adapter, name, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[deleteFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1360,12 +1667,12 @@ class SocketCommands {
             if (this._checkPermissions(socket, 'unlink', callback, name)) {
                 try {
                     this.#unlink(adapter, name, { user: socket._acl?.user })
-                        .then(() => SocketCommands._fixCallback(callback, null))
-                        .catch(error => SocketCommands._fixCallback(callback, error));
+                        .then(() => _a._fixCallback(callback, null))
+                        .catch(error => _a._fixCallback(callback, error));
                 }
                 catch (error) {
                     this.adapter.log.error(`[deleteFolder] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1382,11 +1689,11 @@ class SocketCommands {
         this.commands.renameFile = (socket, adapter, oldName, newName, callback) => {
             if (this._checkPermissions(socket, 'rename', callback, oldName)) {
                 try {
-                    this.adapter.rename(adapter, oldName, newName, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.rename(adapter, oldName, newName, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[renameFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1404,12 +1711,12 @@ class SocketCommands {
             if (this._checkPermissions(socket, 'rename', callback, oldName)) {
                 try {
                     this.#rename(adapter, oldName, newName, { user: socket._acl?.user })
-                        .then(() => SocketCommands._fixCallback(callback, undefined))
-                        .catch(error => SocketCommands._fixCallback(callback, error));
+                        .then(() => _a._fixCallback(callback, undefined))
+                        .catch(error => _a._fixCallback(callback, error));
                 }
                 catch (error) {
                     this.adapter.log.error(`[rename] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1425,11 +1732,11 @@ class SocketCommands {
         this.commands.mkdir = (socket, adapter, dirName, callback) => {
             if (this._checkPermissions(socket, 'mkdir', callback, dirName)) {
                 try {
-                    this.adapter.mkdir(adapter, dirName, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.mkdir(adapter, dirName, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[mkdir] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1449,11 +1756,11 @@ class SocketCommands {
             }
             if (this._checkPermissions(socket, 'readDir', callback, dirName)) {
                 try {
-                    this.adapter.readDir(adapter, dirName, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.readDir(adapter, dirName, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[readDir] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1475,16 +1782,16 @@ class SocketCommands {
             }
             else {
                 this.adapter.log.error(`[chownFile] ERROR: no options`);
-                SocketCommands._fixCallback(callback, 'no options');
+                _a._fixCallback(callback, 'no options');
                 return;
             }
             if (this._checkPermissions(socket, 'chmodFile', callback, fileName)) {
                 try {
-                    this.adapter.chmodFile(adapter, fileName, _options, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.chmodFile(adapter, fileName, _options, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[chmodFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1507,16 +1814,16 @@ class SocketCommands {
             }
             else {
                 this.adapter.log.error(`[chownFile] ERROR: no options`);
-                SocketCommands._fixCallback(callback, 'no options');
+                _a._fixCallback(callback, 'no options');
                 return;
             }
             if (this._checkPermissions(socket, 'chownFile', callback, fileName)) {
                 try {
-                    this.adapter.chownFile(adapter, fileName, _options, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.chownFile(adapter, fileName, _options, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[chownFile] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1532,11 +1839,11 @@ class SocketCommands {
         this.commands.fileExists = (socket, adapter, fileName, callback) => {
             if (this._checkPermissions(socket, 'fileExists', callback, fileName)) {
                 try {
-                    this.adapter.fileExists(adapter, fileName, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.fileExists(adapter, fileName, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[fileExists] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1603,7 +1910,7 @@ class SocketCommands {
                     }
                     catch (error) {
                         this.adapter.log.error(`[getAdapterInstances] ERROR: ${error.toString()}`);
-                        SocketCommands._fixCallback(callback, error);
+                        _a._fixCallback(callback, error);
                     }
                 }
             }
@@ -1627,11 +1934,11 @@ class SocketCommands {
                 }
                 if (typeof callback === 'function') {
                     try {
-                        this.adapter.getForeignStates(pattern || '*', { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                        this.adapter.getForeignStates(pattern || '*', { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                     }
                     catch (error) {
                         this.adapter.log.error(`[getStates] ERROR: ${error.toString()}`);
-                        SocketCommands._fixCallback(callback, error);
+                        _a._fixCallback(callback, error);
                     }
                 }
                 else {
@@ -1669,15 +1976,15 @@ class SocketCommands {
                         try {
                             void this.adapter
                                 .getForeignStateAsync(id, { user: socket._acl?.user })
-                                .then(state => SocketCommands._fixCallback(callback, null, state))
+                                .then(state => _a._fixCallback(callback, null, state))
                                 .catch(error => {
                                 this.adapter.log.error(`[getState] ERROR: ${error.toString()}`);
-                                SocketCommands._fixCallback(callback, error);
+                                _a._fixCallback(callback, error);
                             });
                         }
                         catch (error) {
                             this.adapter.log.error(`[getState] ERROR: ${error.toString()}`);
-                            SocketCommands._fixCallback(callback, error);
+                            _a._fixCallback(callback, error);
                         }
                     }
                 }
@@ -1705,11 +2012,11 @@ class SocketCommands {
                     delete this.states[id];
                 }
                 try {
-                    this.adapter.setForeignState(id, state, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    this.adapter.setForeignState(id, state, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[setState] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1810,12 +2117,12 @@ class SocketCommands {
                         if (this.context.language && id === 'system.config' && obj?.common) {
                             obj.common.language = this.context.language;
                         }
-                        SocketCommands._fixCallback(callback, error, obj);
+                        _a._fixCallback(callback, error, obj);
                     });
                 }
                 catch (error) {
                     this.adapter.log.error(`[getObject] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -1837,11 +2144,11 @@ class SocketCommands {
                 if (this._checkPermissions(socket, 'getObject', callback)) {
                     if (typeof callback === 'function') {
                         try {
-                            this.adapter.getForeignObjects(list, { user: socket._acl?.user }, (error, objs) => SocketCommands._fixCallback(callback, error, objs));
+                            this.adapter.getForeignObjects(list, { user: socket._acl?.user }, (error, objs) => _a._fixCallback(callback, error, objs));
                         }
                         catch (error) {
                             this.adapter.log.error(`[getObjects] ERROR: ${error.toString()}`);
-                            SocketCommands._fixCallback(callback, error);
+                            _a._fixCallback(callback, error);
                         }
                     }
                     else {
@@ -1879,7 +2186,7 @@ class SocketCommands {
                             if (this.context.language && result['system.config']?.common) {
                                 result['system.config'].common.language = this.context.language;
                             }
-                            SocketCommands._fixCallback(callback, error, result);
+                            _a._fixCallback(callback, error, result);
                         });
                     }
                     else {
@@ -1888,7 +2195,7 @@ class SocketCommands {
                 }
                 catch (error) {
                     this.adapter.log.error(`[getObjects] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -2045,7 +2352,7 @@ class SocketCommands {
                     }
                     catch (error) {
                         this.adapter.log.error(`[getObjectView] ERROR: ${error.toString()}`);
-                        SocketCommands._fixCallback(callback, error);
+                        _a._fixCallback(callback, error);
                     }
                 }
             }
@@ -2065,11 +2372,11 @@ class SocketCommands {
         this.commands.setObject = (socket, id, obj, callback) => {
             if (this._checkPermissions(socket, 'setObject', callback, id)) {
                 try {
-                    void this.adapter.setForeignObject(id, obj, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                    void this.adapter.setForeignObject(id, obj, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                 }
                 catch (error) {
                     this.adapter.log.error(`[setObject] ERROR: ${error.toString()}`);
-                    SocketCommands._fixCallback(callback, error);
+                    _a._fixCallback(callback, error);
                 }
             }
         };
@@ -2087,16 +2394,16 @@ class SocketCommands {
             if (id.startsWith('flot.') || id.startsWith('fullcalendar.')) {
                 if (this._checkPermissions(socket, 'delObject', callback, id)) {
                     try {
-                        this.adapter.delForeignObject(id, { user: socket._acl?.user }, (error, ...args) => SocketCommands._fixCallback(callback, error, ...args));
+                        this.adapter.delForeignObject(id, { user: socket._acl?.user }, (error, ...args) => _a._fixCallback(callback, error, ...args));
                     }
                     catch (error) {
                         this.adapter.log.error(`[delObject] ERROR: ${error.toString()}`);
-                        SocketCommands._fixCallback(callback, error);
+                        _a._fixCallback(callback, error);
                     }
                 }
             }
             else {
-                SocketCommands._fixCallback(callback, SocketCommands.ERROR_PERMISSION);
+                _a._fixCallback(callback, _a.ERROR_PERMISSION);
             }
         };
         /**
@@ -2131,7 +2438,7 @@ class SocketCommands {
                 this.#clientSubscribes[sid][targetInstance].push(messageType);
             }
             // inform instance about new subscription
-            this.adapter.sendTo(targetInstance, 'clientSubscribe', { type: messageType, sid, data }, result => SocketCommands._fixCallback(callback, null, result));
+            this.adapter.sendTo(targetInstance, 'clientSubscribe', { type: messageType, sid, data }, result => _a._fixCallback(callback, null, result), _a.sendOptionsOf(socket));
         };
         /**
          * #DOCUMENTATION commands
@@ -2157,16 +2464,12 @@ class SocketCommands {
                 if (pos !== -1) {
                     this.#clientSubscribes[sid][targetInstance].splice(pos, 1);
                     // inform instance about unsubscription
-                    this.adapter.sendTo(targetInstance, 'clientUnsubscribe', {
-                        type: [messageType],
-                        sid,
-                        reason: 'client',
-                    });
-                    SocketCommands._fixCallback(callback, null, true);
+                    this.adapter.sendTo(targetInstance, 'clientUnsubscribe', { type: [messageType], sid, reason: 'client' }, undefined, _a.sendOptionsOf(socket));
+                    _a._fixCallback(callback, null, true);
                     return;
                 }
             }
-            SocketCommands._fixCallback(callback, null, false);
+            _a._fixCallback(callback, null, false);
         };
         /**
          * #DOCUMENTATION commands
@@ -2190,7 +2493,7 @@ class SocketCommands {
                         obj.native ||= {};
                         obj.native.vendor = vendor;
                     }
-                    SocketCommands._fixCallback(callback, error, obj);
+                    _a._fixCallback(callback, error, obj);
                 });
             }
         };
@@ -2202,15 +2505,26 @@ class SocketCommands {
         this._initCommandsStates();
         this._initCommandsFiles();
     }
-    #informAboutDisconnect(socketId) {
+    /**
+     * Tell every instance this socket had subscribed to that it is gone.
+     *
+     * Carries the user of the connection like the explicit `clientUnsubscribe` does: an instance that
+     * keeps something per user - a recording, a session, a pending request - learns whose it was,
+     * instead of only which socket id disappeared.
+     *
+     * @param socket the socket that went away
+     */
+    #informAboutDisconnect(socket) {
+        const socketId = socket.id;
         // say to all instances that this socket was disconnected
         if (this.#clientSubscribes[socketId]) {
+            const options = _a.sendOptionsOf(socket);
             Object.keys(this.#clientSubscribes[socketId]).forEach(targetInstance => {
                 this.adapter.sendTo(targetInstance, 'clientUnsubscribe', {
                     type: this.#clientSubscribes[socketId][targetInstance],
                     sid: socketId,
                     reason: 'disconnect',
-                });
+                }, undefined, options);
             });
             delete this.#clientSubscribes[socketId];
         }
@@ -2220,7 +2534,7 @@ class SocketCommands {
             // Check if the authentication is still valid. Announcing a new access token is the only way
             // to make an expired session valid again, so that command must pass the check - otherwise
             // a client whose token has expired could never recover without reloading the page.
-            if (SocketCommands.COMMANDS_WITHOUT_SESSION_CHECK.includes(command) || this.#updateSession(socket)) {
+            if (_a.COMMANDS_WITHOUT_SESSION_CHECK.includes(command) || this.#updateSession(socket)) {
                 this.commands[command](socket, ...args);
             }
             else {
@@ -2236,4 +2550,5 @@ class SocketCommands {
     }
 }
 exports.SocketCommands = SocketCommands;
+_a = SocketCommands;
 //# sourceMappingURL=socketCommands.js.map