zwave-js-ui 9.3.2

package/server/lib/jsonStore.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageHelper = exports.STORE_BACKUP_PREFIX = void 0;
+const jsonfile_1 = require("jsonfile");
+const app_1 = require("../config/app");
+const logger_1 = require("./logger");
+const utils = __importStar(require("./utils"));
+const merge_1 = require("merge");
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const logger = (0, logger_1.module)('Store');
+exports.STORE_BACKUP_PREFIX = 'store-backup_';
+/**
+Constructor
+**/
+class StorageHelper {
+    _store;
+    config;
+    get store() {
+        return this._store;
+    }
+    constructor() {
+        this._store = {};
+    }
+    async init(config) {
+        this.config = config;
+        for (const model in config) {
+            const res = await this._getFile(config[model]);
+            this._store[res.file] = res.data;
+        }
+        return this._store;
+    }
+    async backup(res) {
+        const backupFile = `${exports.STORE_BACKUP_PREFIX}${utils.fileDate()}.zip`;
+        await (0, fs_extra_1.mkdirp)(app_1.storeBackupsDir);
+        const fileStream = (0, fs_1.createWriteStream)(utils.joinPath(app_1.storeBackupsDir, backupFile));
+        return new Promise((resolve, reject) => {
+            const archive = (0, archiver_1.default)('zip');
+            archive.on('error', (err) => {
+                reject(err);
+            });
+            // on stream closed we can end the request
+            archive.on('end', () => {
+                resolve(backupFile);
+            });
+            if (res) {
+                res.set({
+                    'Content-Type': 'application/json',
+                    'Content-Disposition': `attachment; filename="${backupFile}"`,
+                });
+                archive.pipe(res);
+            }
+            archive.pipe(fileStream);
+            // backup zwavejs files too
+            archive.glob('*.jsonl', {
+                cwd: app_1.storeDir,
+            });
+            for (const model in this.config) {
+                const config = this.config[model];
+                const filePath = utils.joinPath(app_1.storeDir, config.file);
+                if ((0, fs_extra_1.existsSync)(filePath)) {
+                    archive.file(filePath, {
+                        name: config.file,
+                    });
+                }
+            }
+            void archive.finalize();
+        });
+    }
+    async _getFile(config) {
+        let err;
+        let data;
+        try {
+            data = await (0, jsonfile_1.readFile)(utils.joinPath(app_1.storeDir, config.file));
+        }
+        catch (error) {
+            err = error;
+        }
+        // ignore ENOENT error
+        if (err) {
+            if (err.code !== 'ENOENT') {
+                logger.error('Error reading file: ' + config.file, err);
+            }
+            else {
+                logger.warn(`${config.file} not found`);
+            }
+        }
+        // replace data with default
+        if (!data) {
+            data = config.default;
+        }
+        else {
+            data = Array.isArray(data) ? data : (0, merge_1.recursive)(config.default, data);
+        }
+        return { file: config.file, data: data };
+    }
+    get(model) {
+        if (this._store[model.file]) {
+            return this._store[model.file];
+        }
+        else {
+            throw Error('Requested file not present in store: ' + model.file);
+        }
+    }
+    async put(model, data) {
+        await (0, jsonfile_1.writeFile)(utils.joinPath(app_1.storeDir, model.file), data);
+        this._store[model.file] = data;
+        return data;
+    }
+}
+exports.StorageHelper = StorageHelper;
+exports.default = new StorageHelper();

package/server/lib/logger.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAll = exports.module = exports.setupLogger = exports.customTransports = exports.customFormat = exports.sanitizedConfig = exports.disableColors = exports.defaultLogFile = void 0;
+const winston_daily_rotate_file_1 = __importDefault(require("@zwave-js/winston-daily-rotate-file"));
+const fs_extra_1 = require("fs-extra");
+const winston_1 = __importDefault(require("winston"));
+const app_1 = require("../config/app");
+const utils_1 = require("./utils");
+const path = __importStar(require("path"));
+const { format, transports, addColors } = winston_1.default;
+const { combine, timestamp, label, printf, colorize, splat } = format;
+exports.defaultLogFile = 'z-ui_%DATE%.log';
+exports.disableColors = process.env.NO_LOG_COLORS === 'true';
+// ensure store and logs directories exist
+(0, fs_extra_1.ensureDirSync)(app_1.storeDir);
+(0, fs_extra_1.ensureDirSync)(app_1.logsDir);
+// custom colors for timestamp and module
+addColors({
+    time: 'grey',
+    module: 'bold',
+});
+const colorizer = colorize();
+/**
+ * Generate logger configuration starting from settings.gateway
+ */
+function sanitizedConfig(module, config) {
+    config = config || {};
+    const filePath = (0, utils_1.joinPath)(app_1.logsDir, config.logFileName || exports.defaultLogFile);
+    return {
+        module: module || '-',
+        enabled: config.logEnabled !== undefined ? config.logEnabled : true,
+        level: config.logLevel || 'info',
+        logToFile: config.logToFile !== undefined ? config.logToFile : false,
+        filePath: filePath,
+    };
+}
+exports.sanitizedConfig = sanitizedConfig;
+/**
+ * Return a custom logger format
+ */
+function customFormat(config, noColor = false) {
+    noColor = noColor || exports.disableColors;
+    const formats = [
+        splat(),
+        timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
+        format((info) => {
+            info.level = info.level.toUpperCase();
+            return info;
+        })(),
+        label({ label: config.module.toUpperCase() }),
+    ];
+    if (!noColor) {
+        formats.push(colorize({ level: true }));
+    }
+    // must be added at last
+    formats.push(printf((info) => {
+        if (!noColor) {
+            info.timestamp = colorizer.colorize('time', info.timestamp);
+            info.label = colorizer.colorize('module', info.label || '-');
+        }
+        return `${info.timestamp} ${info.level} ${info.label}: ${info.message}${info.stack ? '\n' + info.stack : ''}`;
+    }));
+    return combine(...formats);
+}
+exports.customFormat = customFormat;
+/**
+ * Create the base transports based on settings provided
+ */
+function customTransports(config) {
+    const transportsList = [];
+    if (process.env.ZUI_NO_CONSOLE !== 'true') {
+        transportsList.push(new transports.Console({
+            format: customFormat(config),
+            level: config.level,
+            stderrLevels: ['error'],
+        }));
+    }
+    if (config.logToFile) {
+        let fileTransport;
+        if (process.env.DISABLE_LOG_ROTATION === 'true') {
+            fileTransport = new transports.File({
+                format: customFormat(config, true),
+                filename: config.filePath,
+                level: config.level,
+            });
+        }
+        else {
+            fileTransport = new winston_daily_rotate_file_1.default({
+                filename: config.filePath,
+                auditFile: (0, utils_1.joinPath)(app_1.logsDir, 'zui-logs.audit.json'),
+                datePattern: 'YYYY-MM-DD',
+                createSymlink: true,
+                symlinkName: path
+                    .basename(config.filePath)
+                    .replace(`_%DATE%`, '_current'),
+                zippedArchive: true,
+                maxFiles: process.env.ZUI_LOG_MAXFILES || '7d',
+                maxSize: process.env.ZUI_LOG_MAXSIZE || '50m',
+                level: config.level,
+                format: customFormat(config, true),
+            });
+        }
+        transportsList.push(fileTransport);
+    }
+    return transportsList;
+}
+exports.customTransports = customTransports;
+/**
+ * Setup a logger
+ */
+function setupLogger(container, module, config) {
+    const sanitized = sanitizedConfig(module, config);
+    // Winston automatically reuses an existing module logger
+    const logger = container.add(module);
+    logger.configure({
+        format: combine(format.errors({ stack: true }), format.json()),
+        silent: !sanitized.enabled,
+        level: sanitized.level,
+        transports: customTransports(sanitized),
+    });
+    logger.module = module;
+    logger.setup = (cfg) => setupLogger(container, module, cfg);
+    return logger;
+}
+exports.setupLogger = setupLogger;
+const logContainer = new winston_1.default.Container();
+/**
+ * Create a new logger for a specific module
+ */
+function module(module) {
+    return setupLogger(logContainer, module);
+}
+exports.module = module;
+/**
+ * Setup all loggers starting from config
+ */
+function setupAll(config) {
+    logContainer.loggers.forEach((logger) => {
+        logger.setup(config);
+    });
+}
+exports.setupAll = setupAll;
+exports.default = logContainer.loggers;

package/server/lib/utils.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJSON = exports.allSettled = exports.buffer2hex = exports.bufferFromHex = exports.isBufferAsHex = exports.verifyPsw = exports.hashPsw = exports.humanSize = exports.hasProperty = exports.removeSlash = exports.sanitizeTopic = exports.getVersion = exports.num2hex = exports.copy = exports.isValueId = exports.joinProps = exports.joinPath = exports.getPath = exports.basePath = exports.fileDate = exports.deepEqual = exports.padNumber = exports.applyMixin = exports.pkgJson = void 0;
+const path_1 = __importStar(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = require("fs");
+// don't use import here, it will break the build
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+exports.pkgJson = require('../../package.json');
+let VERSION;
+function applyMixin(target, mixin, includeConstructor = false) {
+    // Figure out the inheritance chain of the mixin
+    const inheritanceChain = [mixin];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const current = inheritanceChain[0];
+        const base = Object.getPrototypeOf(current);
+        if (base?.prototype) {
+            inheritanceChain.unshift(base);
+        }
+        else {
+            break;
+        }
+    }
+    for (const ctor of inheritanceChain) {
+        for (const prop of Object.getOwnPropertyNames(ctor.prototype)) {
+            // Do not override the constructor
+            if (includeConstructor || prop !== 'constructor') {
+                Object.defineProperty(target.prototype, prop, Object.getOwnPropertyDescriptor(ctor.prototype, prop) ??
+                    Object.create(null));
+            }
+        }
+    }
+}
+exports.applyMixin = applyMixin;
+function padNumber(num, digits) {
+    return num ? num.toString().padStart(digits, '0') : 'unknown';
+}
+exports.padNumber = padNumber;
+function deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+exports.deepEqual = deepEqual;
+function fileDate(date) {
+    date = date || new Date();
+    return date.toISOString().slice(-24).replace(/\D/g, '').slice(0, 14);
+}
+exports.fileDate = fileDate;
+/** Where package.json is */
+exports.basePath = (0, path_1.resolve)(__dirname, '..', '..');
+/**
+ *  Get the base root path to application directory. When we are in a `pkg` environment
+ *  the path of the snapshot is not writable
+ */
+function getPath(write) {
+    if (write && hasProperty(process, 'pkg'))
+        return process.cwd();
+    else
+        return exports.basePath;
+}
+exports.getPath = getPath;
+/**
+ * path.join wrapper, the first option can be a boolean and it will automatically fetch the root path
+ * passing the boolean to getPath
+ */
+function joinPath(write, ...paths) {
+    if (typeof write === 'boolean') {
+        write = getPath(write);
+    }
+    return path_1.default.join(write, ...paths);
+}
+exports.joinPath = joinPath;
+/**
+ * Join props with a `_` and skips undefined props
+ */
+function joinProps(...props) {
+    props = props || [];
+    let ret = props[0].toString() || '';
+    for (let i = 1; i < props.length; i++) {
+        const p = props[i];
+        if (p !== null && p !== undefined && p !== '') {
+            ret += '_' + (typeof p === 'number' ? p.toString() : p);
+        }
+    }
+    return ret;
+}
+exports.joinProps = joinProps;
+/**
+ * Checks if an object is a valueId, returns error otherwise
+ */
+function isValueId(v) {
+    if (typeof v.commandClass !== 'number' || v.commandClass < 0) {
+        return 'invalid `commandClass`';
+    }
+    if (v.endpoint !== undefined && v.endpoint < 0) {
+        return 'invalid `endpoint`';
+    }
+    if (v.property === undefined ||
+        (typeof v.property !== 'string' && typeof v.property !== 'number')) {
+        return 'invalid `property`';
+    }
+    if (v.propertyKey !== undefined &&
+        typeof v.propertyKey !== 'string' &&
+        typeof v.propertyKey !== 'number') {
+        return 'invalid `propertyKey`';
+    }
+    return true;
+}
+exports.isValueId = isValueId;
+/**
+ * Deep copy of an object
+ */
+function copy(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+exports.copy = copy;
+/**
+ * Converts a decimal to an hex number of 4 digits and `0x` as prefix
+ */
+function num2hex(num) {
+    const hex = num >= 0 ? num.toString(16) : 'XXXX';
+    return '0x' + '0'.repeat(4 - hex.length) + hex;
+}
+exports.num2hex = num2hex;
+/**
+ * Gets the actual package.json version with also the git revision number at the end of it
+ */
+function getVersion() {
+    if (!VERSION) {
+        try {
+            // try to get short sha of last commit
+            let rev = (0, fs_1.readFileSync)('.git/HEAD').toString().trim();
+            if (rev.indexOf(':') !== -1) {
+                rev = (0, fs_1.readFileSync)('.git/' + rev.substring(5))
+                    .toString()
+                    .trim();
+            }
+            VERSION = `${exports.pkgJson.version}${rev ? '.' + rev.substring(0, 7) : ''}`;
+        }
+        catch {
+            VERSION = exports.pkgJson.version;
+        }
+    }
+    return VERSION;
+}
+exports.getVersion = getVersion;
+/**
+ * Sanitize chars of a string to use in a topic
+ *
+ */
+function sanitizeTopic(str, sanitizeSlash = false) {
+    if (typeof str === 'number' || !str)
+        return str.toString();
+    if (sanitizeSlash) {
+        str = removeSlash(str);
+    }
+    // replace spaces with '_'
+    str = str.replace(/\s/g, '_');
+    // remove special chars
+    return str.replace(/[^A-Za-z0-9-_À-ÖØ-öø-ÿ/]/g, '');
+}
+exports.sanitizeTopic = sanitizeTopic;
+/**
+ * Removes `/` chars from strings
+ */
+function removeSlash(str) {
+    return typeof str === 'number' ? str.toString() : str.replace(/\//g, '-');
+}
+exports.removeSlash = removeSlash;
+/**
+ * Check if an object has a property
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function hasProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+exports.hasProperty = hasProperty;
+/**
+ * Gets the size in a human readable form starting from bytes
+ */
+function humanSize(bytes) {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0) {
+        return 'n/a';
+    }
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    if (i === 0) {
+        return bytes + ' ' + sizes[i];
+    }
+    return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + sizes[i];
+}
+exports.humanSize = humanSize;
+async function hashPsw(password) {
+    return new Promise((resolve, reject) => {
+        const salt = crypto_1.default.randomBytes(8).toString('hex');
+        crypto_1.default.scrypt(password, salt, 64, (err, derivedKey) => {
+            if (err)
+                reject(err);
+            resolve(salt + ':' + derivedKey.toString('hex'));
+        });
+    });
+}
+exports.hashPsw = hashPsw;
+async function verifyPsw(password, hash) {
+    return new Promise((resolve, reject) => {
+        const [salt, key] = hash.split(':');
+        crypto_1.default.scrypt(password, salt, 64, (err, derivedKey) => {
+            if (err)
+                reject(err);
+            resolve(key === derivedKey.toString('hex'));
+        });
+    });
+}
+exports.verifyPsw = verifyPsw;
+/**
+ * Checks if a string is a hex buffer
+ */
+function isBufferAsHex(str) {
+    return /^0x([a-fA-F0-9]{2})+$/.test(str);
+}
+exports.isBufferAsHex = isBufferAsHex;
+/**
+ * Parses a buffer from a string has the form 0x[a-f0-9]+
+ */
+function bufferFromHex(hex) {
+    return Buffer.from(hex.substr(2), 'hex');
+}
+exports.bufferFromHex = bufferFromHex;
+/**
+ * Converts a buffer to an hex string
+ */
+function buffer2hex(buffer) {
+    if (buffer.length === 0)
+        return '';
+    return `0x${buffer.toString('hex')}`;
+}
+exports.buffer2hex = buffer2hex;
+function allSettled(promises) {
+    const wrappedPromises = promises.map((p) => Promise.resolve(p).then((val) => ({ status: 'fulfilled', value: val }), (err) => ({ status: 'rejected', reason: err })));
+    return Promise.all(wrappedPromises);
+}
+exports.allSettled = allSettled;
+/** Parses a string to json with buffer decode support */
+function parseJSON(str) {
+    return JSON.parse(str, (k, v) => {
+        if (v !== null &&
+            typeof v === 'object' &&
+            'type' in v &&
+            v.type === 'Buffer' &&
+            'data' in v &&
+            Array.isArray(v.data)) {
+            return Buffer.from(v.data);
+        }
+        return v;
+    });
+}
+exports.parseJSON = parseJSON;

package/snippets/access-store-dir.js

@@ -0,0 +1,12 @@
+const { logger, zwaveClient, require } = this
+const fs = require('fs')
+const { join } = require('path')
+const { storeDir } = require('../config/app')
+// read file
+const content = fs.readFileSync(join(storeDir, 'test.log'), 'utf8')
+
+// write file
+fs.writeFileSync(join(storeDir, 'test-copy.log'), content)
+
+// read directory
+const files = fs.readdirSync(storeDir)

package/snippets/clone-config.js

@@ -0,0 +1,17 @@
+// replace `undefined` with the id of the node you want to clone
+const node = driver.controller.nodes.get(undefined);
+
+// list here all the nodes ids you want to copy configuration to
+const clonedNodes = [].map(n => driver.controller.nodes.get(n));
+
+const values = node.getDefinedValueIDs()
+
+for (const clonedNode of clonedNodes) {
+  for(const v of values) {
+  	if(v.commandClass === 112) {
+  		await clonedNode.setValue(v, 
+  		  node.getValue(v)
+  		)
+  	}
+  }
+}

package/snippets/pingNodes.js

@@ -0,0 +1,14 @@
+/**
+ * This snippet can be used to ping dead nodes in your network
+ * ATTENTION: Be aware that this is not a good practise, if your nodes
+ * become dead, you should try to find out why as you will likely have connectivity
+ * issues. More info here: https://zwave-js.github.io/node-zwave-js/#/troubleshooting/connectivity-issues
+ */
+
+driver.controller.nodes.forEach(async (node) => {
+    // if node is Dead
+    if (node.status === 3) {
+        // pinging it
+        await node.ping()
+    }
+})