@iobroker/js-controller-adapter 7.2.3 → 7.2.5

package/build/cjs/lib/_Types.d.ts

@@ -388,6 +388,8 @@ export interface InternalAddChannelToEnumOptions {
 export interface SendToOptions {
     /** Method throws or calls error cb, if callback not called in time, works for single targets only */
     timeout?: number;
+    /** The user on whose behalf the message is sent */
+    user?: ioBroker.ObjectIDs.User;
 }
 export interface InternalSendToOptions {
     instanceName: string;
@@ -411,6 +413,7 @@ export interface InternalSendToHostOptions {
     command: string;
     message: any;
     callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo;
+    options?: SendToOptions;
 }
 export interface InternalGetStateOptions {
     id: string;

package/build/cjs/lib/adapter/adapter.d.ts

@@ -162,7 +162,7 @@ export interface AdapterClass {
      * Sends a message to a specific host or all hosts.
      */
     sendToHostAsync(hostName: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
-    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload, options?: SendToOptions): Promise<ioBroker.Message | undefined>;
     /**
      * Sends a message to a specific instance or all instances of some specific adapter.
      */
@@ -338,6 +338,8 @@ export declare class AdapterClass extends EventEmitter {
     namespace: `${string}.${number}`;
     name: string;
     private _systemSecret?;
+    /** Attributes of `encryptedNative`: their values in `this.config` are decrypted on start */
+    private _decryptedNativeAttributes;
     /** Whether the adapter has already terminated */
     private terminated;
     /** The cache of usernames */
@@ -491,6 +493,15 @@ export declare class AdapterClass extends EventEmitter {
      *
      */
     disable(): ioBroker.SetObjectPromise;
+    /**
+     * Reads a parameter which is stored encrypted and returns its decrypted value.
+     *
+     * An attribute listed in `encryptedNative` is already decrypted in `this.config` when the adapter
+     * starts, and is returned as it is.
+     *
+     * @param attribute the config attribute to decrypt
+     * @param callback return result
+     */
     getEncryptedConfig(attribute: string, callback?: GetEncryptedConfigCallback): Promise<string | string[] | void>;
     private _getEncryptedConfig;
     /**
@@ -711,7 +722,7 @@ export declare class AdapterClass extends EventEmitter {
     sendTo(instanceName: string, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo, options?: SendToOptions): void;
     private _sendTo;
     sendToHost(hostName: string | null, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
-    sendToHost(hostName: string | null, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    sendToHost(hostName: string | null, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo, options?: SendToOptions): void;
     private _sendToHost;
     sendToUI(options: SendToUserInterfaceClientOptions): Promise<void>;
     registerNotification<Scope extends keyof ioBroker.NotificationScopes>(scope: Scope, category: ioBroker.NotificationScopes[Scope] | null, message: string, options?: NotificationOptions): Promise<void>;

package/build/cjs/lib/adapter/adapter.js

@@ -110,6 +110,8 @@ class AdapterClass extends import_node_events.EventEmitter {
   namespace;
   name;
   _systemSecret;
+  /** Attributes of `encryptedNative`: their values in `this.config` are decrypted on start */
+  _decryptedNativeAttributes = new Array();
   /** Whether the adapter has already terminated */
   terminated = false;
   /** The cache of usernames */
@@ -361,7 +363,6 @@ class AdapterClass extends import_node_events.EventEmitter {
     this.readFileAsync = import_js_controller_common.tools.promisify(this.readFile, this, ["file", "mimeType"]);
     this.writeFileAsync = import_js_controller_common.tools.promisify(this.writeFile, this);
     this.fileExistsAsync = import_js_controller_common.tools.promisify(this.fileExists, this);
-    this.sendToHostAsync = import_js_controller_common.tools.promisifyNoError(this.sendToHost, this);
     this.setStateAsync = import_js_controller_common.tools.promisify(this.setState, this);
     this.setStateChangedAsync = import_js_controller_common.tools.promisify(this.setStateChanged, this, ["id", "notChanged"]);
     this.setForeignStateAsync = import_js_controller_common.tools.promisify(this.setForeignState, this);
@@ -479,7 +480,12 @@ class AdapterClass extends import_node_events.EventEmitter {
       this._logger.info(`${this.namespaceLog} getSession not processed because States database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(options.callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
     }
-    this.#states.getSession(options.id, options.callback);
+    this.#states.getSession(options.id, (err, session) => {
+      if (err) {
+        this._logger.error(`${this.namespaceLog} Cannot read session "${options.id}": ${err.message}`);
+      }
+      return import_js_controller_common.tools.maybeCallback(options.callback, session || null);
+    });
   }
   // unknown implementation guards
   setSession(id, ttl, data, callback) {
@@ -1389,7 +1395,7 @@ class AdapterClass extends import_node_events.EventEmitter {
     return this.setForeignObjectAsync(configObjId, obj);
   }
   /**
-   * Reads the encrypted parameter from config.
+   * Reads a parameter which is stored encrypted and returns its decrypted value.
    *
    * It returns promise if no callback is provided.
    *
@@ -1404,14 +1410,12 @@ class AdapterClass extends import_node_events.EventEmitter {
   async _getEncryptedConfig(options) {
     const { attribute, callback } = options;
     const value = (0, import_utils.getObjectAttribute)(this.config, attribute);
+    if ((Array.isArray(value) || typeof value === "string") && this._decryptedNativeAttributes.includes(attribute)) {
+      return import_js_controller_common.tools.maybeCallbackWithError(callback, null, value);
+    }
     if (Array.isArray(value)) {
       const secret = await this.getSystemSecret();
-      const result = [];
-      for (let i = 0; i < value.length; i++) {
-        if (typeof value[i] === "string") {
-          result[i] = import_js_controller_common.tools.decrypt(secret, value[i]);
-        }
-      }
+      const result = value.map((item) => typeof item === "string" ? import_js_controller_common.tools.decrypt(secret, item) : item);
       return import_js_controller_common.tools.maybeCallbackWithError(callback, null, result);
     } else if (typeof value === "string") {
       const secret = await this.getSystemSecret();
@@ -4706,13 +4710,27 @@ class AdapterClass extends import_node_events.EventEmitter {
       this.sendTo(instanceName, command, message, callback, options);
     });
   }
+  /**
+   * The `user` field of an outbound message, from the `user` of the send options.
+   *
+   * Spread into the envelope, so a send without a user leaves the field out entirely instead of
+   * putting an empty one in: a receiver that checks `obj.user` must be able to tell "nobody named a
+   * user" from "the user is known", and an empty string is neither.
+   *
+   * @param options the send options the caller passed, if any
+   */
+  #userOf(options) {
+    const user = options?.user;
+    return typeof user === "string" && user ? { user } : {};
+  }
   async _sendTo(_options) {
     const { command, message, callback, options } = _options;
     let { instanceName } = _options;
     const obj = {
       command,
       message,
-      from: `system.adapter.${this.namespace}`
+      from: `system.adapter.${this.namespace}`,
+      ...this.#userOf(options)
     };
     if (!instanceName) {
       return import_js_controller_common.tools.maybeCallbackWithError(callback, "No instanceName provided or not a string");
@@ -4812,8 +4830,10 @@ class AdapterClass extends import_node_events.EventEmitter {
    *              if (!result) adapter.log.error('No response received');
    *            }
    *        ```
+   * @param options optional send options: a `timeout` for the answer, or the `user` this message is
+   * sent on behalf of - the host sees it as `obj.user`
    */
-  sendToHost(hostName, command, message, callback) {
+  sendToHost(hostName, command, message, callback, options) {
     if (typeof message === "undefined") {
       message = command;
       command = "send";
@@ -4825,17 +4845,57 @@ class AdapterClass extends import_node_events.EventEmitter {
     if (!import_js_controller_common.tools.isObject(callback)) {
       import_validator.Validator.assertOptionalCallback(callback, "callback");
     }
+    if (options !== void 0) {
+      import_validator.Validator.assertObject(options, "options");
+    }
     return this._sendToHost({
       hostName,
       command,
       message,
+      options,
       callback
     });
   }
+  /**
+   * Async version of sendToHost
+   *
+   * Resolves with whatever the host answered - like the promisified version it replaces, an error
+   * of the host reaches the caller as the resolved value, and that is left alone: an adapter that
+   * awaits this today must not start seeing rejections.
+   *
+   * It rejects in one case: a `timeout` was asked for in the send options and elapsed, which is
+   * how `sendToAsync` reports the same thing. Whoever passes that option is writing against an
+   * option that did not exist before and can expect it; whoever passes none keeps the old
+   * behaviour, including a host that never answers and a caller that waits for ever.
+   *
+   * @param hostName name of the host where the message must be sent to. E.g. "myPC" or "system.host.myPC". If argument is null, the message will be sent to all hosts.
+   * @param command command name. One of: "cmdExec", "getRepository", "getInstalled", ...
+   * @param message object that will be given as argument for request
+   * @param options optional send options: a `timeout` for the answer, or the `user` the message is sent for
+   */
+  sendToHostAsync(hostName, command, message, options) {
+    const timeout = options?.timeout;
+    return new Promise((resolve, reject) => {
+      this.sendToHost(
+        hostName,
+        command,
+        message,
+        // The answer of a host travels through the states database and is therefore never an
+        // `Error` instance; one can only come from here, and only where a budget was named.
+        (result) => timeout && result instanceof Error ? reject(result) : resolve(result),
+        options
+      );
+    });
+  }
   async _sendToHost(_options) {
-    const { command, message, callback } = _options;
+    const { command, message, callback, options } = _options;
     let { hostName } = _options;
-    const obj = { command, message, from: `system.adapter.${this.namespace}` };
+    const obj = {
+      command,
+      message,
+      from: `system.adapter.${this.namespace}`,
+      ...this.#userOf(options)
+    };
     if (!this.#states) {
       this._logger.info(`${this.namespaceLog} sendToHost not processed because States database not connected`);
       return import_js_controller_common.tools.maybeCallbackWithError(callback, import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
@@ -4884,7 +4944,18 @@ class AdapterClass extends import_node_events.EventEmitter {
           if (this._callbackId >= 4294967295) {
             this._callbackId = 1;
           }
-          this.messageCallbacks.set(obj.callback.id, { cb: callback, time: Date.now() });
+          const callbackId = obj.callback.id;
+          let timer;
+          if (options?.timeout) {
+            timer = setTimeout(() => {
+              const callbackObj = this.messageCallbacks.get(callbackId);
+              if (callbackObj) {
+                callbackObj.cb(new Error("Timeout exceeded"));
+                this.messageCallbacks.delete(callbackId);
+              }
+            }, options.timeout);
+          }
+          this.messageCallbacks.set(callbackId, { cb: callback, time: Date.now(), timer });
         } else {
           obj.callback = callback;
           obj.callback.ack = true;
@@ -5238,6 +5309,9 @@ class AdapterClass extends import_node_events.EventEmitter {
     return options;
   }
   _checkState(obj, options, command) {
+    if (options.groups?.includes(import_constants.SYSTEM_ADMIN_GROUP)) {
+      return true;
+    }
     const limitToOwnerRights = options.limitToOwnerRights === true;
     if (obj?.acl) {
       obj.acl.state = obj.acl.state || obj.acl.object;
@@ -7746,12 +7820,15 @@ class AdapterClass extends import_node_events.EventEmitter {
       this.oObjects = await this.getAdapterObjectsAsync();
       await this.subscribeObjectsAsync("*");
     }
-    await this.getSystemSecret();
-    const promises = [];
+    const secret = await this.getSystemSecret();
     if (Array.isArray(adapterConfig.encryptedNative)) {
+      this._decryptedNativeAttributes = new Array();
       for (const attr of adapterConfig.encryptedNative) {
-        if (typeof this.config[attr] === "string") {
-          promises.push(this.getEncryptedConfig(attr).then((decryptedValue) => (0, import_utils.setObjectAttribute)(this.config, attr, decryptedValue)).catch((e) => this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`)));
+        try {
+          (0, import_utils.decryptArray)({ obj: this.config, secret, keys: [attr] });
+          this._decryptedNativeAttributes.push(attr);
+        } catch (e) {
+          this._logger.error(`${this.namespaceLog} Can not decrypt attribute ${attr}: ${e.message}`);
         }
       }
     } else {
@@ -7760,7 +7837,6 @@ class AdapterClass extends import_node_events.EventEmitter {
         this.SUPPORTED_FEATURES.splice(idx, 1);
       }
     }
-    await Promise.all(promises);
     if (!this.#states) {
       return;
     }