@iobroker/js-controller-common-db 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

package/build/esm/lib/common/tools.js

@@ -1,30 +1,29 @@
-import fs from 'fs-extra';
 import path from 'node:path';
 import semver from 'semver';
 import os from 'node:os';
-import forge from 'node-forge';
-import deepClone from 'deep-clone';
-import { exec as cpExecAsync } from 'promisify-child-process';
+import crypto from 'node:crypto';
 import { createInterface } from 'node:readline';
 import { PassThrough } from 'node:stream';
-import { detectPackageManager, packageManagers } from '@alcalzone/pak';
-import { EXIT_CODES } from '../../lib/common/exitCodes.js';
 import zlib from 'node:zlib';
-import { password } from '../../lib/common/password.js';
-import jwt from 'jsonwebtoken';
-import axios from 'axios';
-import crypto from 'node:crypto';
-import { exec } from 'node:child_process';
+import { exec, execFile } from 'node:child_process';
 import { URLSearchParams } from 'node:url';
 import events from 'node:events';
-import { maybeCallbackWithError } from '../../lib/common/maybeCallback.js';
-// @ts-expect-error has no types
-import extend from 'node.extend';
 import { setDefaultResultOrder } from 'node:dns';
-import { applyAliasAutoScaling, applyAliasConvenienceConversion, applyAliasTransformer, } from '../../lib/common/aliasProcessing.js';
 import * as url from 'node:url';
 import { createRequire } from 'node:module';
+import forge from 'node-forge';
+import fs from 'fs-extra';
+import deepClone from 'deep-clone';
+import { detectPackageManager, packageManagers, } from '@alcalzone/pak';
+import jwt from 'jsonwebtoken';
+import axios from 'axios';
+// @ts-expect-error has no types
+import extend from 'node.extend';
+import { EXIT_CODES } from '../../lib/common/exitCodes.js';
+import { password } from '../../lib/common/password.js';
+import { applyAliasAutoScaling, applyAliasConvenienceConversion, applyAliasTransformer, } from '../../lib/common/aliasProcessing.js';
 import { DEFAULT_OBJECTS_WARN_LIMIT } from '../../lib/common/constants.js';
+const HASH_TEXT = 'hash';
 // eslint-disable-next-line unicorn/prefer-module
 const thisDir = url.fileURLToPath(new URL('.', import.meta.url || `file://${__filename}`));
 // eslint-disable-next-line unicorn/prefer-module
@@ -47,12 +46,12 @@ const OFFICIAL_DOCKER_FILE = '/opt/scripts/.docker_config/.thisisdocker';
 const DOCKER_INFO_URL = 'https://hub.docker.com/v2/namespaces/iobroker/repositories/iobroker/tags?page_size=1';
 /** Time the image approx. needs to be built and published to DockerHub */
 const DOCKER_HUB_BUILD_TIME_MS = 6 * 60 * 60 * 1_000;
-/** Version of official Docker image which started to support UI upgrade */
+/** Version of the official Docker image that started to support UI upgrade */
 const DOCKER_VERSION_UI_UPGRADE = '8.1.0';
 let lastCalculationOfIps;
 let ownIpArr = [];
 // Here we define all characters that are forbidden in IDs. Since we want to allow multiple
-// unicode character classes, we do that by OR-ing the character classes and negating the result.
+// Unicode character classes, we do that by OR-ing the character classes and negating the result.
 // Also, we can easily whitelist characters this way.
 //
 // We allow:
@@ -161,7 +160,7 @@ export function checkNonEditable(oldObject, newObject) {
     return true;
 }
 /**
- * Checks if a version is up-to-date, throws error on invalid version strings
+ * Checks if a version is up to date, throws error on invalid version strings
  *
  * @param repoVersion version in repository
  * @param installedVersion the current installed version
@@ -170,29 +169,64 @@ export function upToDate(repoVersion, installedVersion) {
     // Check if the installed version is at least the repo version
     return semver.gte(installedVersion, repoVersion);
 }
-// TODO: this is only here for backward compatibility, if MULTIHOST password was still setup with old decryption
-export function decryptPhrase(password, data, callback) {
-    const decipher = crypto.createDecipher('aes192', password);
-    try {
-        let decrypted = '';
-        decipher.on('readable', () => {
-            const data = decipher.read();
-            if (data) {
-                decrypted += data.toString('utf8');
-            }
-        });
-        decipher.on('error', error => {
-            console.error(`Cannot decode secret: ${error.message}`);
-            callback(null);
-        });
-        decipher.on('end', () => callback(decrypted));
-        decipher.write(data, 'hex');
-        decipher.end();
-    }
-    catch (e) {
-        console.error(`Cannot decode secret: ${e.message}`);
-        callback(null);
+/**
+ * Derive the key and IV from a password exactly as the legacy `crypto.createCipher`/`createDecipher`
+ * functions did: OpenSSL's `EVP_BytesToKey` with MD5, a single iteration and no salt. Needed to stay
+ * compatible with data that was encrypted before `createDecipheriv` was used.
+ *
+ * @param password The password to derive the key material from (interpreted as UTF-8, like legacy Node)
+ * @param keyLen Required key length in bytes
+ * @param ivLen Required IV length in bytes
+ * @returns The derived key and IV
+ */
+function evpBytesToKeyMD5(password, keyLen, ivLen) {
+    const passwordBuffer = Buffer.from(password, 'utf8');
+    let material = Buffer.alloc(0);
+    let block = Buffer.alloc(0);
+    while (material.length < keyLen + ivLen) {
+        block = crypto
+            .createHash('md5')
+            .update(Buffer.concat([block, passwordBuffer]))
+            .digest();
+        material = Buffer.concat([material, block]);
     }
+    return {
+        key: material.subarray(0, keyLen),
+        iv: material.subarray(keyLen, keyLen + ivLen),
+    };
+}
+// TODO: this is only here for backward compatibility, if MULTIHOST password was still setup with old decryption
+/**
+ * Decrypt a phrase that was encrypted with the legacy aes192 algorithm
+ *
+ * @param password The password used to derive the decryption key
+ * @param data The encrypted data to decrypt
+ */
+export function decryptPhrase(password, data) {
+    const { key, iv } = evpBytesToKeyMD5(password, 24, 16);
+    const decipher = crypto.createDecipheriv('aes-192-cbc', key, iv);
+    return new Promise(resolve => {
+        try {
+            let decrypted = '';
+            decipher.on('readable', () => {
+                const data = decipher.read();
+                if (data) {
+                    decrypted += data.toString('utf8');
+                }
+            });
+            decipher.on('error', error => {
+                console.error(`Cannot decode secret: ${error.message}`);
+                resolve(null);
+            });
+            decipher.on('end', () => resolve(decrypted));
+            decipher.write(data, 'hex');
+            decipher.end();
+        }
+        catch (e) {
+            console.error(`Cannot decode secret: ${e.message}`);
+            resolve(null);
+        }
+    });
 }
 /**
  * Checks if multiple host objects exists, without using object views
@@ -201,10 +235,10 @@ export function decryptPhrase(password, data, callback) {
  * @returns true if only one host object exists
  */
 export async function isSingleHost(objects) {
-    const res = await objects.getObjectList({
+    const res = (await objects.getObjectList({
         startkey: 'system.host.',
         endkey: 'system.host.\u9999',
-    });
+    }));
     const hostObjs = res.rows.filter(obj => obj.value && obj.value.type === 'host');
     return hostObjs.length <= 1; // on setup no host object is there yet
 }
@@ -226,7 +260,7 @@ export async function isHostRunning(objects, states) {
     res.rows = res.rows.filter(obj => obj.value?.type === 'host');
     for (const hostObj of res.rows) {
         const state = await states.getState(`${hostObj.id}.alive`);
-        if (state && state.val) {
+        if (state?.val) {
             return true;
         }
     }
@@ -272,10 +306,10 @@ export function findIPs() {
     return ownIpArr;
 }
 /**
- * Find the correct path based on given path and url
+ * Find the correct path based on the given path and url
  *
- * @param path
- * @param url
+ * @param path The base path the url may be relative to
+ * @param url The url or relative/absolute path to resolve
  */
 function findPath(path, url) {
     if (!url) {
@@ -293,7 +327,7 @@ function findPath(path, url) {
     return `${thisDir}/../${path}${url}`;
 }
 /**
- * Get MAC address of this host
+ * Get the MAC address of this host
  */
 async function getMac() {
     const macRegex = /(?:[a-z0-9]{2}[:-]){5}[a-z0-9]{2}/gi;
@@ -304,7 +338,7 @@ async function getMac() {
         throw new Error(stderr);
     }
     if (typeof stdout !== 'string') {
-        throw new Error(`Unexpected stdout: ${stdout?.toString()}`);
+        throw new Error(`Unexpected stdout: ${typeof stdout}`);
     }
     let macAddress;
     let match;
@@ -406,40 +440,39 @@ export function isDocker() {
  * @param givenMac the given MAC address
  */
 async function uuid(givenMac) {
-    givenMac = givenMac ?? '';
+    givenMac ??= '';
     const _isDocker = isDocker();
     // return constant UUID for all CI environments to keep the statistics clean
     if (require('ci-info').isCI) {
         return '55travis-pipe-line-cior-githubaction';
     }
-    let mac = givenMac !== null ? givenMac || '' : null;
     let u;
-    if (!_isDocker && mac === '') {
+    if (!_isDocker && !givenMac) {
         const ifaces = os.networkInterfaces();
         // Find first not empty MAC
         for (const iface of Object.values(ifaces)) {
             if (iface) {
                 for (const entry of iface) {
                     if (entry.mac !== '00:00:00:00:00:00') {
-                        mac = entry.mac;
+                        givenMac = entry.mac;
                         break;
                     }
                 }
             }
-            if (mac) {
+            if (givenMac) {
                 break;
             }
         }
     }
-    if (!_isDocker && mac === '') {
+    if (!_isDocker && !givenMac) {
         const mac = await getMac();
         return uuid(mac);
     }
-    if (!_isDocker && mac) {
+    if (!_isDocker && givenMac) {
         const md5sum = crypto.createHash('md5');
-        md5sum.update(mac);
-        mac = md5sum.digest('hex');
-        u = `${mac.substring(0, 8)}-${mac.substring(8, 12)}-${mac.substring(12, 16)}-${mac.substring(16, 20)}-${mac.substring(20)}`;
+        md5sum.update(givenMac);
+        givenMac = md5sum.digest('hex');
+        u = `${givenMac.substring(0, 8)}-${givenMac.substring(8, 12)}-${givenMac.substring(12, 16)}-${givenMac.substring(16, 20)}-${givenMac.substring(20)}`;
     }
     else {
         // Returns a RFC4122 compliant v4 UUID https://gist.github.com/LeverOne/1308368 (DO WTF YOU WANT TO PUBLIC LICENSE)
@@ -549,7 +582,7 @@ export async function createUuid(objects) {
         return;
     }
     // Read vis license
-    const licObj = objects.getObject('system.adapter.vis.0');
+    const licObj = await objects.getObject('system.adapter.vis.0');
     if (!licObj || !licObj.native || !licObj.native.license) {
         return updateUuid('', objects);
     }
@@ -573,13 +606,13 @@ export async function createUuid(objects) {
     console.warn(`Provide following information in email: ${data.email}, invoice: ${data.invoice}`);
 }
 /**
- * Download file to tmp or return file name directly
+ * Download the file to tmp or return the file name directly
  *
- * @param urlOrPath
- * @param fileName
- * @param callback
+ * @param urlOrPath URL to download from, or a local file path
+ * @param fileName Target file name used when the source is downloaded to the tmp directory
+ * @returns The path to the local file
  */
-export async function getFile(urlOrPath, fileName, callback) {
+export async function getFile(urlOrPath, fileName) {
     // If object was read
     if (urlOrPath.substring(0, 'http://'.length) === 'http://' ||
         urlOrPath.substring(0, 'https://'.length) === 'https://') {
@@ -593,150 +626,112 @@ export async function getFile(urlOrPath, fileName, callback) {
                     'Accept-Encoding': 'gzip',
                 },
             });
-            res.data.pipe(fs.createWriteStream(tmpFile)).on('close', () => {
-                console.log(`downloaded ${tmpFile}`);
-                callback && callback(tmpFile);
+            await new Promise((resolve, reject) => {
+                res.data.pipe(fs.createWriteStream(tmpFile)).on('close', resolve).on('error', reject);
             });
+            console.log(`downloaded ${tmpFile}`);
         }
         catch (e) {
             console.log(`Cannot download "${tmpFile}": ${e.message}`);
-            callback && callback(tmpFile);
         }
+        return tmpFile;
     }
-    else {
-        try {
-            if (fs.existsSync(urlOrPath)) {
-                callback && callback(urlOrPath);
-            }
-            else if (fs.existsSync(`${thisDir}/../${urlOrPath}`)) {
-                callback && callback(`${thisDir}/../${urlOrPath}`);
-            }
-            else if (fs.existsSync(`${thisDir}/../tmp/${urlOrPath}`)) {
-                callback && callback(`${thisDir}/../tmp/${urlOrPath}`);
-            }
-            else {
-                console.log(`File not found: ${urlOrPath}`);
-                process.exit(EXIT_CODES.FILE_NOT_FOUND);
-            }
+    try {
+        if (fs.existsSync(urlOrPath)) {
+            return urlOrPath;
         }
-        catch (err) {
-            console.log(`File "${urlOrPath}" could no be read: ${err.message}`);
-            process.exit(EXIT_CODES.FILE_NOT_FOUND);
+        if (fs.existsSync(`${thisDir}/../${urlOrPath}`)) {
+            return `${thisDir}/../${urlOrPath}`;
+        }
+        if (fs.existsSync(`${thisDir}/../tmp/${urlOrPath}`)) {
+            return `${thisDir}/../tmp/${urlOrPath}`;
         }
+        console.log(`File not found: ${urlOrPath}`);
+        process.exit(EXIT_CODES.FILE_NOT_FOUND);
     }
-}
-// Return content of the JSON file. Download it or read directly
-export async function getJson(urlOrPath, agent, callback) {
-    if (typeof agent === 'function') {
-        callback = agent;
-        agent = '';
+    catch (err) {
+        console.log(`File "${urlOrPath}" could no be read: ${err.message}`);
+        process.exit(EXIT_CODES.FILE_NOT_FOUND);
     }
-    agent = agent || '';
-    let sources = {};
+}
+/**
+ * Return the content of a JSON file, downloading it from a URL or reading it directly from disk
+ *
+ * @param urlOrPath URL to download the JSON from, or a local file path
+ * @param agent User agent string used for the download request
+ */
+export async function getJson(urlOrPath, agent) {
+    agent ||= '';
+    let result = {};
     // If object was read
-    if (urlOrPath && typeof urlOrPath === 'object') {
-        if (callback) {
-            callback(urlOrPath);
+    if (!urlOrPath) {
+        console.log('Empty url!');
+        return null;
+    }
+    if (urlOrPath.substring(0, 'http://'.length) === 'http://' ||
+        urlOrPath.substring(0, 'https://'.length) === 'https://') {
+        try {
+            const res = await axios.get(urlOrPath, {
+                headers: { 'Accept-Encoding': 'gzip', timeout: 10000, 'User-Agent': agent },
+            });
+            if (res.status !== 200 || !res.data) {
+                throw new Error(`Invalid response, body: ${res.data}, status code: ${res.status}`);
+            }
+            result = res.data;
+            return result;
+        }
+        catch (e) {
+            console.warn(`Cannot download json from ${urlOrPath}. Error: ${e.message}`);
+            return null;
         }
     }
-    else if (!urlOrPath) {
-        console.log('Empty url!');
-        if (callback) {
-            callback(null);
+    if (fs.existsSync(urlOrPath)) {
+        try {
+            result = fs.readJSONSync(urlOrPath);
+        }
+        catch (e) {
+            console.log(`Cannot parse json file from ${urlOrPath}. Error: ${e.message}`);
+            return null;
         }
+        return result;
     }
-    else {
-        if (urlOrPath.substring(0, 'http://'.length) === 'http://' ||
-            urlOrPath.substring(0, 'https://'.length) === 'https://') {
-            try {
-                const res = await axios.get(urlOrPath, {
-                    headers: { 'Accept-Encoding': 'gzip', timeout: 10000, 'User-Agent': agent },
-                });
-                if (res.status !== 200 || !res.data) {
-                    throw new Error(`Invalid response, body: ${res.data}, status code: ${res.status}`);
-                }
-                sources = res.data;
-                if (callback) {
-                    callback(sources, urlOrPath);
-                }
-            }
-            catch (e) {
-                console.warn(`Cannot download json from ${urlOrPath}. Error: ${e.message}`);
-                if (callback) {
-                    callback(null, urlOrPath);
-                }
-                return;
-            }
+    if (fs.existsSync(`${thisDir}/../${urlOrPath}`)) {
+        try {
+            result = fs.readJSONSync(`${thisDir}/../${urlOrPath}`);
         }
-        else {
-            if (fs.existsSync(urlOrPath)) {
-                try {
-                    sources = fs.readJSONSync(urlOrPath);
-                }
-                catch (e) {
-                    console.log(`Cannot parse json file from ${urlOrPath}. Error: ${e.message}`);
-                    if (callback) {
-                        callback(null, urlOrPath);
-                    }
-                    return;
-                }
-                if (callback) {
-                    callback(sources, urlOrPath);
-                }
-            }
-            else if (fs.existsSync(`${thisDir}/../${urlOrPath}`)) {
-                try {
-                    sources = fs.readJSONSync(`${thisDir}/../${urlOrPath}`);
-                }
-                catch (e) {
-                    console.log(`Cannot parse json file from ${thisDir}/../${urlOrPath}. Error: ${e.message}`);
-                    if (callback) {
-                        callback(null, urlOrPath);
-                    }
-                    return;
-                }
-                if (callback) {
-                    callback(sources, urlOrPath);
-                }
-            }
-            else if (fs.existsSync(`${thisDir}/../tmp/${urlOrPath}`)) {
-                try {
-                    sources = fs.readJSONSync(`${thisDir}/../tmp/${urlOrPath}`);
-                }
-                catch (e) {
-                    console.log(`Cannot parse json file from ${thisDir}/../tmp/${urlOrPath}. Error: ${e.message}`);
-                    if (callback) {
-                        callback(null, urlOrPath);
-                    }
-                    return;
-                }
-                if (callback) {
-                    callback(sources, urlOrPath);
-                }
-            }
-            else {
-                if (callback) {
-                    callback(null, urlOrPath);
-                }
-            }
+        catch (e) {
+            console.log(`Cannot parse json file from ${thisDir}/../${urlOrPath}. Error: ${e.message}`);
+            return null;
+        }
+        return result;
+    }
+    if (fs.existsSync(`${thisDir}/../tmp/${urlOrPath}`)) {
+        try {
+            result = fs.readJSONSync(`${thisDir}/../tmp/${urlOrPath}`);
+        }
+        catch (e) {
+            console.log(`Cannot parse json file from ${thisDir}/../tmp/${urlOrPath}. Error: ${e.message}`);
+            return null;
         }
+        return result;
     }
+    return null;
 }
 /**
- * Return content of the json file. Download it or read directly
+ * Return the content of the json file. Download it or read directly
  *
  * @param urlOrPath URL where the json file could be found
  * @param agent optional agent identifier like "Windows Chrome 12.56"
  * @returns json object
  */
 export async function getJsonAsync(urlOrPath, agent) {
-    agent = agent || '';
+    agent ||= '';
     let sources = {};
     // If object was read
     if (urlOrPath && typeof urlOrPath === 'object') {
         return urlOrPath;
     }
-    else if (!urlOrPath) {
+    if (!urlOrPath) {
         console.log('Empty url!');
         return null;
     }
@@ -789,7 +784,7 @@ export async function getJsonAsync(urlOrPath, agent) {
     }
 }
 /**
- * Scans directory for adapters and adds information to list
+ * Scans the directory for adapters and adds information to list
  *
  * @param dirName name of the directory to scan
  * @param list prefilled list to extend adapters too
@@ -899,334 +894,161 @@ export function getInstalledInfo(hostRunningVersion) {
  * Reads an adapter's npm version
  *
  * @param adapter The adapter to read the npm version from. Null for the root ioBroker packet
- * @param callback
  */
-function getNpmVersion(adapter, callback) {
+async function getNpmVersion(adapter) {
     adapter = adapter ? `${appName}.${adapter}` : appName;
     adapter = adapter.toLowerCase();
     const cliCommand = `npm view ${adapter}@latest version`;
-    exec(cliCommand, { timeout: 2000, windowsHide: true }, (error, stdout, _stderr) => {
-        let version;
-        if (error) {
-            // command failed
-            if (typeof callback === 'function') {
-                callback(error);
-                return;
-            }
-        }
-        else if (stdout) {
-            version = semver.valid(stdout.trim());
-        }
-        if (typeof callback === 'function') {
-            callback(null, version);
-        }
-    });
+    const result = await execAsync(cliCommand, { timeout: 2000, windowsHide: true });
+    let version;
+    if (result?.stdout) {
+        version = semver.valid(result.stdout.trim());
+    }
+    return version || '';
 }
-function getIoPack(sources, name, callback) {
-    getJson(sources[name].meta, '', ioPack => {
-        const packUrl = sources[name].meta.replace('io-package.json', 'package.json');
+async function getIoPack(sources, name, failCounter) {
+    let packSource = sources[name];
+    try {
+        const ioPack = await getJson(packSource.meta);
+        const packUrl = packSource.meta.replace('io-package.json', 'package.json');
         if (!ioPack) {
-            if (sources._helper) {
-                sources._helper.failCounter.push(name);
+            failCounter.push(name);
+            return;
+        }
+        const pack = await getJson(packUrl);
+        const version = packSource.version;
+        const type = packSource.type;
+        // If installed from git or something else,
+        // js-controller is exception, because can be installed from npm and from git
+        if (packSource.url && name !== 'js-controller') {
+            if (ioPack?.common) {
+                sources[name] = extend(true, packSource, ioPack.common);
+                packSource = sources[name];
+                // overwrite type of adapter from repository
+                if (type) {
+                    packSource.type = type;
+                }
+                if (pack?.licenses?.length) {
+                    packSource.license ||= pack.licenses[0].type;
+                    packSource.licenseUrl ||= pack.licenses[0].url;
+                }
             }
-            if (callback) {
-                callback(sources, name);
+            return;
+        }
+        if (ioPack?.common) {
+            sources[name] = extend(true, packSource, ioPack.common);
+            packSource = sources[name];
+            if (pack?.licenses?.length) {
+                packSource.license ||= pack.licenses[0].type;
+                packSource.licenseUrl ||= pack.licenses[0].url;
             }
         }
-        else {
-            setImmediate(() => {
-                getJson(packUrl, '', pack => {
-                    const version = sources[name].version;
-                    const type = sources[name].type;
-                    // If installed from git or something else,
-                    // js-controller is exception, because can be installed from npm and from git
-                    if (sources[name].url && name !== 'js-controller') {
-                        if (ioPack && ioPack.common) {
-                            sources[name] = extend(true, sources[name], ioPack.common);
-                            // overwrite type of adapter from repository
-                            if (type) {
-                                sources[name].type = type;
-                            }
-                            if (pack && pack.licenses && pack.licenses.length) {
-                                if (!sources[name].license) {
-                                    sources[name].license = pack.licenses[0].type;
-                                }
-                                if (!sources[name].licenseUrl) {
-                                    sources[name].licenseUrl = pack.licenses[0].url;
-                                }
-                            }
-                        }
-                        if (callback) {
-                            callback(sources, name);
-                        }
-                    }
-                    else {
-                        if (ioPack && ioPack.common) {
-                            sources[name] = extend(true, sources[name], ioPack.common);
-                            if (pack && pack.licenses && pack.licenses.length) {
-                                if (!sources[name].license) {
-                                    sources[name].license = pack.licenses[0].type;
-                                }
-                                if (!sources[name].licenseUrl) {
-                                    sources[name].licenseUrl = pack.licenses[0].url;
-                                }
-                            }
-                        }
-                        // overwrite type of adapter from repository
-                        if (type) {
-                            sources[name].type = type;
-                        }
-                        if (version) {
-                            sources[name].version = version;
-                            if (callback) {
-                                callback(sources, name);
-                            }
-                        }
-                        else {
-                            if (sources[name].meta.substring(0, 'http://'.length) === 'http://' ||
-                                sources[name].meta.substring(0, 'https://'.length) === 'https://') {
-                                //installed from npm
-                                getNpmVersion(name, (_err, version) => {
-                                    if (version) {
-                                        sources[name].version = version;
-                                    }
-                                    else {
-                                        sources[name].version = 'npm error';
-                                    }
-                                    if (callback) {
-                                        callback(sources, name);
-                                    }
-                                });
-                            }
-                            else {
-                                if (callback) {
-                                    callback(sources, name);
-                                }
-                            }
-                        }
-                    }
-                });
-            });
+        // overwrite type of adapter from repository
+        if (type) {
+            packSource.type = type;
         }
-    });
-}
-function _getRepositoryFile(sources, path, callback) {
-    if (!sources._helper) {
-        let count = 0;
-        for (const _name in sources) {
-            if (!Object.prototype.hasOwnProperty.call(sources, _name)) {
-                continue;
-            }
-            count++;
+        if (version) {
+            packSource.version = version;
+            return;
         }
-        sources._helper = { failCounter: [] };
-        sources._helper.timeout = setTimeout(() => {
-            if (sources._helper) {
-                delete sources._helper;
-                for (const __name of Object.keys(sources)) {
-                    if (sources[__name].processed !== undefined) {
-                        delete sources[__name].processed;
-                    }
+        if (packSource.meta.substring(0, 'http://'.length) === 'http://' ||
+            packSource.meta.substring(0, 'https://'.length) === 'https://') {
+            // installed from npm
+            try {
+                const version = await getNpmVersion(name);
+                if (version) {
+                    packSource.version = version;
                 }
-                if (callback) {
-                    callback(new Error(`Timeout by read all package.json (${count}) seconds`), sources);
+                else {
+                    packSource.version = 'npm error';
                 }
-                callback = undefined;
             }
-        }, count * 1000);
-    }
-    for (const name of Object.keys(sources)) {
-        if (sources[name].processed || name === '_helper') {
-            continue;
-        }
-        sources[name].processed = true;
-        if (sources[name].url) {
-            sources[name].url = findPath(path, sources[name].url);
-        }
-        if (sources[name].meta) {
-            sources[name].meta = findPath(path, sources[name].meta);
-        }
-        if (sources[name].icon) {
-            sources[name].icon = findPath(path, sources[name].icon);
-        }
-        if (!sources[name].name && sources[name].meta) {
-            getIoPack(sources, name, _ignore => {
-                if (sources._helper) {
-                    if (sources._helper.failCounter.length > 10) {
-                        clearTimeout(sources._helper.timeout);
-                        delete sources._helper;
-                        for (const _name of Object.keys(sources)) {
-                            if (sources[_name].processed !== undefined) {
-                                delete sources[_name].processed;
-                            }
-                        }
-                        if (callback) {
-                            callback(new Error('Looks like there is no internet.'), sources);
-                        }
-                        callback = undefined;
-                    }
-                    else {
-                        // process next
-                        setImmediate(() => _getRepositoryFile(sources, path, callback));
-                    }
-                }
-            });
-            return;
-        }
-    }
-    // all packages are processed
-    if (sources._helper) {
-        let err;
-        if (sources._helper.failCounter.length) {
-            err = new Error(`Following packages cannot be read: ${sources._helper.failCounter.join(', ')}`);
-        }
-        clearTimeout(sources._helper.timeout);
-        delete sources._helper;
-        for (const __name of Object.keys(sources)) {
-            if (sources[__name].processed !== undefined) {
-                delete sources[__name].processed;
+            catch {
+                packSource.version = 'npm error';
             }
         }
-        if (callback) {
-            callback(err, sources);
-        }
-        callback = undefined;
     }
-}
-async function _checkRepositoryFileHash(urlOrPath, additionalInfo, callback) {
-    // read hash of file
-    if (urlOrPath.startsWith('http://') || urlOrPath.startsWith('https://')) {
-        urlOrPath = urlOrPath.replace(/\.json$/, '-hash.json');
-        let json = null;
-        try {
-            const res = await axios.get(urlOrPath, { headers: { 'Accept-Encoding': 'gzip', timeout: 10000 } });
-            if (!res.data || res.status !== 200) {
-                throw new Error(`Invalid response, body: ${res.data}, status code: ${res.status}`);
+    catch (e) {
+        console.error(`Cannot prepare repository entry for ${name}: ${e.message}`);
+    }
+}
+async function _getRepositoryFile(sources, path = '') {
+    const names = Object.keys(sources).filter(name => name !== '_helper');
+    const failCounter = [];
+    let aborted = false;
+    // Hard time limit: one second per repository entry. Raced against the processing so a hanging
+    // network request cannot block forever.
+    let timeout;
+    const timeoutPromise = new Promise(resolve => {
+        timeout = setTimeout(() => {
+            aborted = true;
+            resolve(new Error(`Timeout by read all package.json (${names.length}) seconds`));
+        }, names.length * 10_000);
+    });
+    const processPromise = (async () => {
+        for (const name of names) {
+            if (aborted) {
+                // the timeout already won the race; this result is discarded
+                return null;
             }
-            json = res.data;
-        }
-        catch (e) {
-            console.warn(`Cannot download json from ${urlOrPath}. Error: ${e.message}`);
-        }
-        if (json && json.hash) {
-            // The hash download was successful
-            if (additionalInfo && additionalInfo.sources && json.hash === additionalInfo.hash) {
-                // The hash is the same as for the cached sources
-                console.log('hash unchanged, use cached sources');
-                callback(null, additionalInfo.sources, json.hash);
+            const source = sources[name];
+            if (source.url) {
+                source.url = findPath(path, source.url);
             }
-            else {
-                // Either we have no sources cached or the hash changed
-                // => force download of new sources
-                console.log('hash changed or no sources cached => force download of new sources');
-                callback(null, null, json.hash);
+            if (source.meta) {
+                source.meta = findPath(path, source.meta);
+            }
+            if (source.icon) {
+                source.icon = findPath(path, source.icon);
+            }
+            if (!source.name && source.meta) {
+                await getIoPack(sources, name, failCounter);
+                if (failCounter.length > 10) {
+                    return new Error('Looks like there is no internet.');
+                }
             }
         }
-        else {
-            // Could not download new sources, use the old ones
-            console.log('failed to download new sources, use cached sources');
-            callback(null, additionalInfo.sources, '');
-        }
+        return failCounter.length ? new Error(`Following packages cannot be read: ${failCounter.join(', ')}`) : null;
+    })();
+    try {
+        return await Promise.race([processPromise, timeoutPromise]);
     }
-    else {
-        // it is a file and file has not hash
-        callback(null, null, 0);
+    finally {
+        clearTimeout(timeout);
     }
 }
 /**
  * Get a list of all adapters and controller in some repository file or in /conf/source-dist.json
- *
- * @param urlOrPath URL starting with http:// or https:// or local file link
- * @param additionalInfo destination object
- * @param callback function (err, sources, actualHash) { }
  */
-export function getRepositoryFile(urlOrPath, additionalInfo, callback) {
+export async function getRepositoryFile() {
     let sources = {};
-    let _path = '';
-    if (typeof additionalInfo === 'function') {
-        // @ts-expect-error: fix all fun calls then remove
-        callback = additionalInfo;
-        additionalInfo = {};
-    }
-    additionalInfo = additionalInfo || {};
-    if (urlOrPath) {
-        const parts = urlOrPath.split('/');
-        _path = `${parts.splice(0, parts.length - 1).join('/')}/`;
-    }
-    // If an object was read
-    if (urlOrPath && typeof urlOrPath === 'object') {
-        if (typeof callback === 'function') {
-            callback(null, urlOrPath);
+    let controllerDir;
+    try {
+        controllerDir = getControllerDir();
+        if (controllerDir) {
+            sources = fs.readJSONSync(path.join(controllerDir, getDefaultDataDir(), 'sources.json'));
         }
     }
-    else if (!urlOrPath) {
-        try {
-            const controllerDir = getControllerDir();
-            if (controllerDir) {
-                sources = fs.readJSONSync(path.join(controllerDir, getDefaultDataDir(), 'sources.json'));
-            }
-        }
-        catch {
-            sources = {};
-        }
-        try {
-            const controllerDir = getControllerDir();
-            if (controllerDir) {
-                const sourcesDist = fs.readJSONSync(path.join(controllerDir, 'conf', 'sources-dist.json'));
-                sources = extend(true, sourcesDist, sources);
-            }
-        }
-        catch {
-            // continue regardless of error
-        }
-        for (const s of Object.keys(sources)) {
-            if (additionalInfo[s] && additionalInfo[s].published) {
-                sources[s].published = additionalInfo[s].published;
-            }
-        }
-        _getRepositoryFile(sources, _path, err => {
-            if (err) {
-                console.error(`[${new Date().toString()}] ${err.message}`);
-            }
-            if (typeof callback === 'function') {
-                callback(err, sources);
-            }
-        });
+    catch {
+        sources = {};
     }
-    else {
-        let agent = '';
-        if (additionalInfo) {
-            // Add some information to user-agent, like chrome, IE and Firefox do
-            agent = `${additionalInfo.name}, RND: ${additionalInfo.randomID || randomID}, Node:${additionalInfo.node}, V:${additionalInfo.controller}`;
+    try {
+        if (controllerDir) {
+            const sourcesDist = fs.readJSONSync(path.join(controllerDir, 'conf', 'sources-dist.json'));
+            sources = extend(true, sourcesDist, sources);
         }
-        // load hash of file first to not load the whole 1MB of sources
-        _checkRepositoryFileHash(urlOrPath, additionalInfo, (err, sources, actualSourcesHash) => {
-            if (!err && sources) {
-                // Source file was not changed
-                typeof callback === 'function' && callback(err, sources, actualSourcesHash);
-            }
-            else {
-                getJson(urlOrPath, agent, sources => {
-                    if (sources) {
-                        for (const s of Object.keys(sources)) {
-                            if (additionalInfo[s] && additionalInfo[s].published) {
-                                sources[s].published = additionalInfo[s].published;
-                            }
-                        }
-                        setImmediate(() => _getRepositoryFile(sources, _path, err => {
-                            err && console.error(`[${new Date().toString()}] ${err.message}`);
-                            typeof callback === 'function' && callback(err, sources, actualSourcesHash);
-                        }));
-                    }
-                    else {
-                        // return cached sources, because no sources found
-                        console.log(`failed to download new sources, ${additionalInfo.sources ? 'use cached sources' : 'no cached sources available'}`);
-                        return maybeCallbackWithError(callback, `Cannot read "${urlOrPath}"`, additionalInfo.sources, '');
-                    }
-                });
-            }
-        });
     }
+    catch {
+        // continue regardless of error
+    }
+    const error = await _getRepositoryFile(sources);
+    if (error) {
+        console.error(`[${new Date().toString()}] ${error.message}`);
+    }
+    if (!error || Object.keys(sources).length > 0) {
+        return sources;
+    }
+    throw error;
 }
 /**
  * Read on repository
@@ -1237,28 +1059,31 @@ export function getRepositoryFile(urlOrPath, additionalInfo, callback) {
  * @param _actualRepo Actual repository JSON content
  */
 export async function getRepositoryFileAsync(url, hash, force, _actualRepo) {
-    let _hash;
-    let data;
+    let hashResponse;
+    let data = null;
     if (url.startsWith('http://') || url.startsWith('https://')) {
         try {
-            _hash = await axios({ url: url.replace(/\.json$/, '-hash.json'), timeout: 10_000 });
+            hashResponse = await axios({
+                url: url.replace(/\.json$/, `-${HASH_TEXT}.json`),
+                timeout: 10_000,
+            });
         }
         catch {
             // ignore missing hash file
         }
         // If we have the actual repo and the hash matches, return it
-        if (_actualRepo && !force && hash && _hash?.data && _hash.data.hash === hash) {
+        if (_actualRepo && !force && hash && hashResponse?.data?.hash === hash) {
             data = _actualRepo;
         }
         else {
             const agent = `${appName}, RND: ${randomID}, Node:${process.version}, V:${require('@iobroker/js-controller-common/package.json').version}`;
             try {
-                data = await axios({
+                const response = await axios({
                     url,
                     timeout: 10_000,
                     headers: { 'User-Agent': agent },
                 });
-                data = data.data;
+                data = response.data;
             }
             catch (e) {
                 throw new Error(`Cannot download repository file from "${url}": ${e.message}`);
@@ -1280,8 +1105,8 @@ export async function getRepositoryFileAsync(url, hash, force, _actualRepo) {
     }
     return {
         json: data,
-        changed: _hash?.data ? hash !== _hash.data.hash : true,
-        hash: _hash?.data ? _hash.data.hash : '',
+        changed: hashResponse?.data ? hash !== hashResponse.data.hash : true,
+        hash: hashResponse?.data ? hashResponse.data.hash : '',
     };
 }
 /**
@@ -1323,7 +1148,7 @@ export function getAdapterDir(adapter) {
     const possibilities = [`${appName.toLowerCase()}.${adapter}/package.json`, `${appName}.${adapter}/package.json`];
     let adapterPath;
     for (const possibility of possibilities) {
-        // special case to not read adapters from js-controller/node_module/adapter and check first in parent directory
+        // special case to didn't read adapters from js-controller/node_module/adapter and check first in parent directory
         if (fs.existsSync(path.join(getControllerDir(), '..', possibility))) {
             adapterPath = path.join(getControllerDir(), '..', possibility);
         }
@@ -1366,59 +1191,28 @@ export function getHostName() {
     }
 }
 /**
- * Read version of system npm
+ * Read version of system NPM
  *
- * @param callback return result
- *        <pre><code>
- *            function (err, version) {
- *              adapter.log.debug('NPM version is: ' + version);
- *            }
- *        </code></pre>
+ * @returns NPM version
  */
-function getSystemNpmVersion(callback) {
-    const { exec } = require('node:child_process');
-    // remove local node_modules\.bin dir from a path
+async function getSystemNpmVersion() {
+    // remove local node_modules\.bin dir from a path,
     // or we potentially get a wrong npm version
     const newEnv = Object.assign({}, process.env);
-    // @ts-expect-error TODO
-    newEnv.PATH = (newEnv.PATH || newEnv.Path || newEnv.path)
+    newEnv.PATH = (newEnv.PATH || newEnv.Path || newEnv.path || '')
         .split(path.delimiter)
         .filter(dir => {
         dir = dir.toLowerCase();
         return !dir.includes('iobroker') || !dir.includes(path.join('node_modules', '.bin'));
     })
         .join(path.delimiter);
-    try {
-        let timeout = setTimeout(() => {
-            timeout = null;
-            if (callback) {
-                callback(new Error('timeout'));
-                callback = undefined;
-            }
-        }, 10_000);
-        exec('npm -v', { encoding: 'utf8', env: newEnv, windowsHide: true }, (error, stdout) => {
-            //, stderr) {
-            if (timeout) {
-                clearTimeout(timeout);
-                timeout = null;
-            }
-            if (stdout) {
-                stdout = semver.valid(stdout.trim());
-            }
-            if (callback) {
-                callback(error, stdout);
-                callback = undefined;
-            }
-        });
-    }
-    catch (e) {
-        if (callback) {
-            callback(e);
-            callback = undefined;
-        }
+    const result = await execAsync('npm -v', { env: newEnv, timeout: 10_000 });
+    let version;
+    if (result.stdout) {
+        version = semver.valid(result.stdout.trim());
     }
+    return version || null;
 }
-const getSystemNpmVersionAsync = promisify(getSystemNpmVersion);
 /**
  *
  * Figure out which package manager is in charge, but with a fallback to npm.
@@ -1535,7 +1329,7 @@ export async function rebuildNodeModules(options = {}) {
     return pak.rebuild(options.module ? [options.module] : undefined);
 }
 /**
- * Read disk free space
+ * Read the disk-free space
  */
 export async function getDiskInfo() {
     const platform = process.platform;
@@ -1598,7 +1392,7 @@ export async function getDiskInfo() {
 /**
  * Returns information about a certificate
  *
- * @param cert
+ * @param cert The certificate as a PEM string, or a path to the certificate file
  * @returns certificate information object
  */
 export function getCertificateInfo(cert) {
@@ -1735,7 +1529,7 @@ function makeid(length) {
 /**
  * Collects information about host and available adapters
  *
- *  Following info will be collected:
+ *  The following info will be collected:
  *    - available adapters
  *    - node.js --version
  *    - npm --version
@@ -1760,12 +1554,12 @@ export async function getHostInfo(objects) {
             ? systemConfig.common.activeRepo
             : [systemConfig.common.activeRepo];
         repos
-            .filter(repo => systemRepos.native.repositories[repo] && systemRepos.native.repositories[repo].json)
+            .filter(repo => systemRepos.native.repositories[repo]?.json)
             .forEach(repo => Object.assign(allRepos, systemRepos.native.repositories[repo].json));
     }
     if (!npmVersion) {
         try {
-            npmVersion = await getSystemNpmVersionAsync();
+            npmVersion = (await getSystemNpmVersion()) || '';
         }
         catch (e) {
             console.error(`Cannot get NPM version: ${e.message}`);
@@ -1786,7 +1580,7 @@ export async function getHostInfo(objects) {
         time: dateObj.getTime(),
         timeOffset: dateObj.getTimezoneOffset(),
         NPM: npmVersion,
-        'adapters count': Object.keys(allRepos).length,
+        'adapters count': Object.keys(allRepos).filter(id => id !== '_repoInfo').length,
     };
     if (data.Platform === 'win32') {
         data.Platform = 'Windows';
@@ -1817,8 +1611,8 @@ export function getControllerDir() {
     const possibilities = ['iobroker.js-controller', 'ioBroker.js-controller'];
     for (const pkg of possibilities) {
         try {
-            // package.json is guaranteed to be in the module root folder
-            // so once that is resolved, take the dirname and we're done
+            // package.json is guaranteed to be in the module root folder,
+            // so once that is resolved, take the dirname, and we're done
             const possiblePath = require.resolve(`${pkg}/package.json`);
             if (fs.existsSync(possiblePath)) {
                 return path.dirname(possiblePath);
@@ -1865,7 +1659,7 @@ export function isDevServerInstallation() {
 }
 /**
  * All paths are returned always relative to /node_modules/' + appName + '.js-controller
- * the result has always "/" as last symbol
+ * the result has always "/" as the last symbol
  */
 export function getDefaultDataDir() {
     // Allow overriding the data directory with an environment variable
@@ -2045,6 +1839,14 @@ async function _setQualityForStates(states, keys, quality) {
         }
     }
 }
+/**
+ * Set the given quality code on all states belonging to an instance
+ *
+ * @param objects The objects database client
+ * @param states The states database client
+ * @param namespace The instance namespace whose states should be updated (e.g. "admin.0")
+ * @param q The quality code to assign to each state
+ */
 export function setQualityForInstance(objects, states, namespace, q) {
     return new Promise((resolve, reject) => {
         objects.getObjectView('system', 'state', {
@@ -2069,7 +1871,7 @@ export function setQualityForInstance(objects, states, namespace, q) {
                 }
                 // read all values for IDs
                 states.getStates(keys, async (_err, values) => {
-                    // Get only states, that have ack = true
+                    // Get only states that have ack = true
                     keys = keys.filter((_id, i) => values[i] && values[i].ack);
                     // update quality code of the states to new one
                     await _setQualityForStates(states, keys, q);
@@ -2097,8 +1899,7 @@ export function pattern2RegEx(pattern) {
 /**
  * Checks if a pattern is valid
  *
- * @param pattern
- * @pattern pattern to check for validity
+ * @param pattern The pattern to check for validity
  */
 export function isValidPattern(pattern) {
     pattern = pattern.replace(/\*/g, '');
@@ -2179,7 +1980,7 @@ function decryptLegacy(key, value) {
  */
 export function encrypt(key, value) {
     if (!/^[0-9a-f]{48}$/.test(key)) {
-        // key length is not matching for AES-192-CBC or key is no valid hex - fallback to old encryption
+        // key length is not matching for AES-192-CBC, or key is no valid hex - fallback to old encryption
         return encryptLegacy(key, value);
     }
     const iv = crypto.randomBytes(16);
@@ -2248,7 +2049,7 @@ export function measureEventLoopLag(ms, cb) {
         // we use Math.max to handle a case where timers are running efficiently
         // and our callback executes earlier than `ms` due to how timers are
         // implemented. this is ok. it means we're healthy.
-        cb && cb(Math.max(0, t - start - ms));
+        cb?.(Math.max(0, t - start - ms));
         start = t;
         timeout = setTimeout(check, ms);
         timeout.unref();
@@ -2259,10 +2060,10 @@ export function measureEventLoopLag(ms, cb) {
     }
 }
 /**
- * This function convert state values by read and write of aliases. Function is synchronous.
+ * This function converts state values by read and write of aliases. Function is synchronous.
  * On errors, null is returned instead
  *
- * @param options
+ * @param options Source and target common/id definitions, the state to convert and a logger
  */
 export function formatAliasValue(options) {
     const { sourceCommon, sourceId, targetCommon, targetId, state, logger } = options;
@@ -2325,9 +2126,7 @@ export function formatAliasValue(options) {
  * @returns Promise All objects are tried to be updated - reject will happen as soon as one fails with the error of the first fail
  */
 export async function removeIdFromAllEnums(objects, id, allEnums) {
-    if (!allEnums) {
-        allEnums = await getAllEnums(objects);
-    }
+    allEnums ||= await getAllEnums(objects);
     let error = null;
     for (const [enumId, enumObj] of Object.entries(allEnums)) {
         const idx = enumObj.common.members ? enumObj.common.members.indexOf(id) : -1;
@@ -2340,9 +2139,7 @@ export async function removeIdFromAllEnums(objects, id, allEnums) {
                 allEnums[enumId] = enumObj;
             }
             catch (err) {
-                if (!error) {
-                    error = err;
-                }
+                error ||= err;
             }
         }
     }
@@ -2351,7 +2148,7 @@ export async function removeIdFromAllEnums(objects, id, allEnums) {
     }
 }
 /**
- * Parses dependencies to standardized object of form
+ * Parses dependencies to a standardized object of form
  *
  * @param dependencies dependencies array or single dependency
  * @returns parsedDeps parsed dependencies
@@ -2388,7 +2185,7 @@ export function parseDependencies(dependencies) {
  *
  * @param obj an object which will be validated
  * @param extend (optional) if true checks allow more optional cases for extendObject calls
- * @throws Error if a property has the wrong type or `obj.type` is non-existing
+ * @throws {Error} if a property has the wrong type or `obj.type` is non-existing
  */
 export function validateGeneralObjectProperties(obj, extend) {
     if (!obj || (obj.type === undefined && !extend)) {
@@ -2463,12 +2260,13 @@ export function validateGeneralObjectProperties(obj, extend) {
                     throw new Error(`obj.common.min (${obj.common.min}) needs to be less than or equal to obj.common.max (${obj.common.max})`);
                 }
             }
-            // ensure, that default value has correct type
-            if (obj.common.def !== undefined && obj.common.def !== null) {
+            // ensure that default value has correct type
+            if (obj.common.def != null) {
                 // else do what strictObjectChecks does for val
                 if (!((obj.common.type === 'mixed' && typeof obj.common.def !== 'object') ||
                     (obj.common.type !== 'object' && obj.common.type === typeof obj.common.def) ||
                     (obj.common.type === 'array' && typeof obj.common.def === 'string') ||
+                    // @ts-expect-error deprecated
                     (obj.common.type === 'json' && typeof obj.common.def === 'string') ||
                     (obj.common.type === 'object' && typeof obj.common.def === 'string'))) {
                     // types can be 'number', 'string', 'boolean', 'array', 'object', 'mixed', 'json';
@@ -2485,10 +2283,12 @@ export function validateGeneralObjectProperties(obj, extend) {
             }
         }
     }
-    if (obj.common.read !== undefined && typeof obj.common.read !== 'boolean') {
+    if (obj.common.read !== undefined &&
+        typeof obj.common.read !== 'boolean') {
         throw new Error(`obj.common.read has an invalid type! Expected "boolean", received "${typeof obj.common.read}"`);
     }
-    if (obj.common.write !== undefined && typeof obj.common.write !== 'boolean') {
+    if (obj.common.write !== undefined &&
+        typeof obj.common.write !== 'boolean') {
         throw new Error(`obj.common.write has an invalid type! Expected "boolean", received "${typeof obj.common.write}"`);
     }
     if (obj.common.role !== undefined && typeof obj.common.role !== 'string') {
@@ -2497,15 +2297,11 @@ export function validateGeneralObjectProperties(obj, extend) {
     if (obj.common.desc !== undefined && typeof obj.common.desc !== 'string' && typeof obj.common.desc !== 'object') {
         throw new Error(`obj.common.desc has an invalid type! Expected "string" or "object", received "${typeof obj.common.desc}"`);
     }
-    if (obj.type === 'state' &&
-        obj.common.custom !== undefined &&
-        obj.common.custom !== null &&
-        !isObject(obj.common.custom)) {
+    if (obj.type === 'state' && obj.common.custom != null && !isObject(obj.common.custom)) {
         throw new Error(`obj.common.custom has an invalid type! Expected "object", received "${typeof obj.common.custom}"`);
     }
     // common.states needs to be a real object or an array
-    if (obj.common.states !== null && // we allow null for deletion TODO: implement https://github.com/ioBroker/ioBroker.js-controller/issues/1735
-        obj.common.states !== undefined &&
+    if (obj.common.states != null && // we allow null for deletion TODO: implement https://github.com/ioBroker/ioBroker.js-controller/issues/1735
         !isObject(obj.common.states) &&
         !Array.isArray(obj.common.states)) {
         throw new Error(`obj.common.states has an invalid type! Expected "object", received "${typeof obj.common.states}"`);
@@ -2532,10 +2328,8 @@ export async function getAllInstances(adapters, objects) {
                 }
             }
         }
-        else {
-            if (!instances.includes(adapters[i])) {
-                instances.push(adapters[i]);
-            }
+        else if (!instances.includes(adapters[i])) {
+            instances.push(adapters[i]);
         }
     }
     return instances;
@@ -2589,7 +2383,7 @@ export async function getInstances(adapter, objects, withObjects) {
 }
 /**
  * Executes a command asynchronously. On success, the promise resolves with stdout and stderr.
- * On error, the promise rejects with the exit code or signal, as well as stdout and stderr.
+ * In error, the promise rejects with the exit code or signal, as well as stdout and stderr.
  *
  * @param command The command to execute
  * @param execOptions The options for child_process.exec
@@ -2602,7 +2396,59 @@ export function execAsync(command, execOptions) {
         // And we want to capture stdout/stderr
         encoding: 'utf8',
     };
-    return cpExecAsync(command, { ...defaultOptions, ...execOptions });
+    return new Promise((resolve, reject) => {
+        exec(command, { ...defaultOptions, ...execOptions }, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr ? new Error(stderr.toString()) : error);
+            }
+            else {
+                resolve({
+                    stderr: stderr?.toString(),
+                    stdout: stdout?.toString(),
+                });
+            }
+        });
+    });
+}
+/**
+ * Executes a command asynchronously. On success, the promise resolves with stdout and stderr.
+ *
+ * On error it rejects with the error of `child_process.execFile`, whose `code` (the exit code, or `ENOENT` when
+ * the command does not exist), `killed` and `signal` say what happened - a command killed by the `timeout`
+ * option has to stay distinguishable from one that exited non-zero. Only the message is replaced by the output
+ * on stderr when there is any, because that usually says more than "Command failed".
+ *
+ * @param file The command to execute
+ * @param args The arguments to pass to the command
+ * @param execOptions The options for child_process.execFile
+ * @returns child process promise
+ */
+export function execFileAsync(file, args, execOptions) {
+    const defaultOptions = {
+        // we do not want to show the node.js window on Windows
+        windowsHide: true,
+        // And we want to capture stdout/stderr
+        encoding: 'utf8',
+    };
+    return new Promise((resolve, reject) => {
+        execFile(file, [...args], { ...defaultOptions, ...execOptions }, (error, stdout, stderr) => {
+            if (error) {
+                // the error of execFile is an Error carrying `code`, `killed` and `signal` - what the caller
+                // needs to tell a missing command and a timeout apart from a plain non-zero exit
+                const failure = error;
+                if (stderr) {
+                    failure.message = stderr.toString();
+                }
+                reject(failure);
+            }
+            else {
+                resolve({
+                    stderr: stderr?.toString(),
+                    stdout: stdout?.toString(),
+                });
+            }
+        });
+    });
 }
 /**
  * Takes input from one stream and writes it to another as soon as a complete line was read.
@@ -2684,12 +2530,12 @@ export async function resolveAdapterMainFile(adapter) {
 /**
  * Returns the default nodeArgs required to execute the main file, e.g., transpile hooks for TypeScript
  *
- * @param mainFile
+ * @param mainFile Path to the adapter main file that will be executed
  * @returns default node args for cli
  */
 export function getDefaultNodeArgs(mainFile) {
     const ret = [];
-    // Support executing TypeScript files directly
+    // Support for executing TypeScript files directly
     if (mainFile.endsWith('.ts')) {
         ret.push('-r', '@alcalzone/esbuild-register');
     }
@@ -2789,7 +2635,7 @@ export function removePreservedProperties(preserve, oldObj, newObj) {
                 // array, only rm selected subattributes instead of whole attribute
                 for (const rmProp of preserve[prop]) {
                     if (oldObj[prop][rmProp] !== undefined && newObj[prop][rmProp] !== undefined) {
-                        // only delete if conflicting
+                        // only delete it if conflicting
                         delete newObj[prop][rmProp];
                     }
                 }
@@ -3005,6 +2851,11 @@ export function getInstanceIndicatorObjects(namespace, adapterCommon) {
         },
     ];
 }
+/**
+ * Normalize a logger-like object into a complete logger, filling missing log level methods with no-ops
+ *
+ * @param log A logger or partial logger object; if falsy, a no-op logger is created
+ */
 export function getLogger(log) {
     if (!log) {
         log = {
@@ -3044,7 +2895,7 @@ export async function setExecutableCapabilities(execPath, capabilities, modeEffe
     if (os.platform() !== 'linux') {
         return;
     }
-    // if Docker and Admin Capabilities should be set check if we are allowed to do that
+    // if Docker and Admin Capabilities should be set, check if we are allowed to do that
     if (isDocker() && capabilities.includes('cap_net_admin')) {
         try {
             const systemCaps = fs.readFileSync(`/proc/${process.pid}/status`, 'utf-8');
@@ -3132,12 +2983,12 @@ async function _readLicenses(login, password) {
 export async function updateLicenses(objects, login, password) {
     // if login and password provided in the message, just try to read without saving it in system.licenses
     if (login && password) {
-        return _readLicenses(login, password);
+        return await _readLicenses(login, password);
     }
     // get actual object
     const systemLicenses = await objects.getObjectAsync('system.licenses');
     // If password and login exist
-    if (systemLicenses && systemLicenses.native && systemLicenses.native.password && systemLicenses.native.login) {
+    if (systemLicenses?.native?.password && systemLicenses.native.login) {
         try {
             // get the secret to decode the password
             const systemConfig = await objects.getObjectAsync('system.config');
@@ -3172,10 +3023,7 @@ export async function updateLicenses(objects, login, password) {
             // if password is invalid
             if (err.message.includes('Authentication required') || err.message.includes('Cannot decode password:')) {
                 // clear existing licenses if exist
-                if (systemLicenses &&
-                    systemLicenses.native &&
-                    systemLicenses.native.licenses &&
-                    systemLicenses.native.licenses.length) {
+                if (systemLicenses?.native?.licenses?.length) {
                     systemLicenses.native.licenses = [];
                     systemLicenses.native.readTime = new Date().toISOString();
                     await objects.setObjectAsync('system.licenses', systemLicenses);
@@ -3186,10 +3034,7 @@ export async function updateLicenses(objects, login, password) {
     }
     else {
         // if password or login are empty => clear existing licenses if exist
-        if (systemLicenses &&
-            systemLicenses.native &&
-            systemLicenses.native.licenses &&
-            systemLicenses.native.licenses.length) {
+        if (systemLicenses?.native?.licenses?.length) {
             systemLicenses.native.licenses = [];
             systemLicenses.native.readTime = new Date().toISOString();
             await objects.setObjectAsync('system.licenses', systemLicenses);
@@ -3234,7 +3079,7 @@ export function compressFileGZip(inputFilename, outputFilename, options = {}) {
     });
 }
 /**
- * Validate if the dir, is a valid dataDir
+ * Validate if the dir is a valid dataDir
  * Data dirs in node_modules are not allowed, note that dataDirs are relative to js-controller dir or absolute
  *
  * @param dataDir dataDir to check
@@ -3252,7 +3097,7 @@ export function validateDataDir(dataDir) {
     };
 }
 /**
- * If an array is passed it will be stringified, else the parameter is returned
+ * If an array is passed, it will be stringified, else the parameter is returned
  *
  * @param maybeArr parameter which will be stringified if it is an array
  */
@@ -3282,7 +3127,7 @@ function getDNSResolutionOrder() {
     return dnsOrder;
 }
 /**
- * Checks if given ip address is matching ipv4 or ipv6 localhost
+ * Checks if the given ip address is matching ipv4 or ipv6 localhost
  *
  * @param ip ipv4 or ipv6 address
  */
@@ -3291,7 +3136,7 @@ export function isLocalAddress(ip) {
     return localAddresses.includes(ip);
 }
 /**
- * Checks if given ip address is matching ipv4 or ipv6 "listen all" address
+ * Checks if the given ip address is matching ipv4 or ipv6 "listen all" address
  *
  * @param ip ipv4 or ipv6 address
  */
@@ -3306,7 +3151,7 @@ export function getLocalAddress() {
     return dnsOrder === 'ipv4first' ? '127.0.0.1' : '::1';
 }
 /**
- * Get the ip to listen to all addresses according to configured DNS resolution strategy
+ * Get the ip to listen to all addresses according to a configured DNS resolution strategy
  */
 export function getListenAllAddress() {
     const dnsOrder = getDNSResolutionOrder();
@@ -3320,7 +3165,7 @@ export function ensureDNSOrder() {
     setDefaultResultOrder(dnsOrder);
 }
 /**
- * Determine if ioBroker is installed as systemd service
+ * Determine if ioBroker is installed as a systemd service
  */
 export async function isIoBrokerInstalledAsSystemd() {
     try {
@@ -3404,9 +3249,9 @@ export function getPidsFileName() {
     return path.join(getControllerDir(), 'pids.txt');
 }
 /**
- * Get all ioBroker process ids
+ * Get all ioBroker process IDs
  *
- * @returns process ids or empty array if no process running
+ * @returns process IDs or empty array if no process running
  */
 export async function getPids() {
     let pids = [];
@@ -3422,7 +3267,7 @@ export async function getPids() {
     return pids;
 }
 /**
- * Check if given string is a valid loglevel
+ * Check if a given string is a valid loglevel
  *
  * @param level level to validate
  */
@@ -3438,5 +3283,109 @@ export async function getControllerPid() {
     const pids = await getPids();
     return pids.pop();
 }
+/**
+ * Check if a process with the given id currently exists
+ *
+ * @param pid process id to check
+ * @returns true if a process with this id is running
+ */
+export function isProcessRunning(pid) {
+    // 0 and negative values address process groups instead of a single process and would not
+    // throw below, so a corrupt pids file must not slip through here
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        // Signal 0 sends nothing, it only performs the existence and permission check
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // EPERM means the process does exist, it just belongs to another user
+        return e.code === 'EPERM';
+    }
+}
+/**
+ * Check if a command line belongs to a js-controller process
+ *
+ * Only the started script counts, not a mere mention of the controller directory, which also shows
+ * up in the command line of the CLI or of tools working on the installation.
+ *
+ * @param commandLine the full command line of the process
+ * @returns true if the command line looks like the controller
+ */
+function isControllerCommandLine(commandLine) {
+    const command = commandLine.toLowerCase();
+    return (
+    // On POSIX the title the running controller gives itself replaces the command line
+    command.startsWith(`${appNameLowerCase}.js-controller`) ||
+        // "node <path>/controller.js", as started by the CLI, the service or the installer
+        /(^|[\s"'/\\])controller\.js(["'\s]|$)/.test(command) ||
+        // The entry point started directly
+        /[/\\](iobroker\.js-controller|controller)[/\\]build[/\\](esm|cjs)[/\\]main\.js/.test(command));
+}
+/**
+ * Check if a pid is proven to belong to a program which is not the controller
+ *
+ * After a reboot the operating system may hand a recorded pid to an unrelated program, which
+ * Windows in particular does readily, so a live pid alone does not prove the controller is
+ * running. Being a Node.js process proves nothing either - Node-RED, zigbee2mqtt or this very CLI
+ * are Node.js processes too - so the command line has to identify the controller. This only
+ * reports a foreign program when it could actually be identified as one: whenever the process
+ * cannot be inspected, the answer is "no", because acting on a wrong guess would start a second
+ * controller and both would then fail with EADDRINUSE.
+ *
+ * @param pid process id to inspect
+ * @returns true only if the process was identified as a different program
+ */
+export async function isForeignProcess(pid) {
+    // Only a plain positive integer may become part of the PowerShell command below
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    // The stale pid may even have been handed to the process asking right now
+    if (pid === process.pid) {
+        return true;
+    }
+    try {
+        if (os.platform() === 'win32') {
+            // tasklist only knows the image name, which is node.exe for every Node.js program
+            const { stdout } = await execFileAsync('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `[Console]::OutputEncoding = [Text.Encoding]::UTF8; Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' | Select-Object Name, CommandLine | ConvertTo-Json -Compress`,
+            ], { timeout: 10_000 });
+            // No output means the process is gone
+            const output = (stdout || '').trim();
+            if (!output) {
+                return false;
+            }
+            const { Name, CommandLine } = JSON.parse(output);
+            if (!Name) {
+                return false;
+            }
+            if (!Name.toLowerCase().startsWith('node')) {
+                return true;
+            }
+            // Without elevation the command line of another user's process is not readable
+            return CommandLine ? !isControllerCommandLine(CommandLine) : false;
+        }
+        // Unlike comm, args is not truncated and shows the title the controller gives itself
+        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'args='], { timeout: 2000 });
+        const commandLine = (stdout || '').trim();
+        if (!commandLine) {
+            return false;
+        }
+        return !isControllerCommandLine(commandLine);
+    }
+    catch (e) {
+        // Could not inspect the process - assume it is the controller. Say so, because otherwise a machine
+        // where the lookup cannot run at all - no PowerShell, no WMI service, a timeout - keeps answering
+        // "Controller is already running with pid ..." without a hint that nothing was ever checked.
+        console.warn(`Cannot inspect process ${pid}, assuming it belongs to the controller: ${e.message}`);
+        return false;
+    }
+}
 export * from '../../lib/common/maybeCallback.js';
 //# sourceMappingURL=tools.js.map