isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/src/ISY.ts

@@ -1,47 +1,46 @@
-import { writeFile } from 'fs';
-
 import axios, { type AxiosRequestConfig } from 'axios';
+import chalk from 'chalk';
 import { EventEmitter } from 'events';
-import { format, Logger, loggers, type LeveledLogMethod } from 'winston';
+import { format, Logger, loggers } from 'winston';
 import WebSocket from 'ws';
-import { Parser, type ParserOptions } from 'xml2js';
+import { type ParserOptions, Parser } from 'xml2js';
 import { parseBooleans, parseNumbers } from 'xml2js/lib/processors.js';
 import { DeviceFactory } from './Devices/DeviceFactory.js';
 import { ELKAlarmPanelDevice } from './Devices/Elk/ElkAlarmPanelDevice.js';
 import { ElkAlarmSensorDevice } from './Devices/Elk/ElkAlarmSensorDevice.js';
-import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
+import { Message } from './ISY.js';
+import { IWebSocketMessageHandler, ISYWebSocketEndpoint } from './ISYWebSocketEndpoint.js';
 import { EventType } from './Events/EventType.js';
-import { VariableType } from './ISYConstants.js';
-import { type ISYDevice } from './ISYDevice.js';
+import { ISYDevice } from './ISYDevice.js';
 import { ISYNode } from './ISYNode.js';
-import { ISYScene } from './ISYScene.js';
 import { ISYVariable } from './ISYVariable.js';
 import type { NodeInfo } from './Model/NodeInfo.js';
+import { ISYScene } from './Scenes/ISYScene.js';
+import { VariableType } from './VariableType.js';
 
 import * as Utils from './Utils.js';
 
 import { X2jOptions, XMLParser } from 'fast-xml-parser';
 import type { ClientRequestArgs } from 'http';
 import path from 'path';
-import { NodeFactory } from './Devices/NodeFactory.js';
-import { ISYError } from './ISYError.js';
-import type { Config } from './Model/Config.js';
-import { findPackageJson } from './Utils.js';
-import { GenericNode } from './Devices/GenericNode.js';
-import { CompositeDevice } from './Devices/CompositeDevice.js';
-
-type InitStep = 'config' | 'loadNodes' | 'readFolders' | 'readDevices' | 'readScenes' | 'variables' | 'websocket' | 'refreshStatuses' | 'initialize';
 
-class ISYInitializationError extends ISYError {
-	step: InitStep;
-	constructor(message: string, step: InitStep);
-	constructor(error: Error, step: InitStep);
-	constructor(messageOrError: string | Error, step: InitStep) {
-		super(messageOrError as any);
-		this.name = 'ISYInitializationError';
-		this.step = step;
-	}
-}
+import type { JsonPrimitive } from 'type-fest';
+import { Family, UnitOfMeasure } from './Definitions/index.js';
+import { GenericNode } from './Devices/GenericNode.js';
+import { ISYError, ISYInitializationError } from './ISYError.js';
+import type { Config } from './Model/Config.js';
+import { emphasize, isPrimitive, writeDebugFile } from './Utils.js';
+
+type InitStep =
+	| 'config'
+	| 'loadNodes'
+	| 'readFolders'
+	| 'readDevices'
+	| 'readScenes'
+	| 'variables'
+	| 'websocket'
+	| 'refreshStatuses'
+	| 'initialize';
 
 const defaultParserOptions: ParserOptions = {
 	explicitArray: false,
@@ -49,7 +48,7 @@ const defaultParserOptions: ParserOptions = {
 
 	attrValueProcessors: [parseNumbers, parseBooleans],
 	valueProcessors: [parseNumbers, parseBooleans],
-	tagNameProcessors: [(tagName) => (tagName === 'st' || tagName === 'cmd' || tagName === 'nodeDef' ? '' : tagName)]
+	tagNameProcessors: [tagName => (tagName === 'st' || tagName === 'cmd' || tagName === 'nodeDef' ? '' : tagName)],
 };
 
 const defaultXMLParserOptions: X2jOptions = {
@@ -74,7 +73,7 @@ const defaultXMLParserOptions: X2jOptions = {
 	isArray(tagName, jPath, isLeafNode, isAttribute) {
 		if (tagName === 'property') return true;
 		return false;
-	}
+	},
 };
 
 axios.defaults.transitional.forcedJSONParsing = false;
@@ -96,38 +95,44 @@ interface ISYConfig {
 	username: string;
 	socketPath?: string;
 	axiosOptions?: AxiosRequestConfig;
-	webSocketOptions?: WebSocket.ClientOptions & ClientRequestArgs;
+	webSocketOptions?: WebSocket.ClientOptions & ClientRequestArgs & { guardianInterval?: number };
+
+	apiOnly: boolean;
+
+	logUnsubscribedNodeEvents?: boolean;
 	// #endregion Properties (8)
 }
 
-export class ISY extends EventEmitter implements Disposable {
+export class ISY
+	extends EventEmitter<{ nodeAdded: [ISYNode<any>]; initializeCompleted: [] }>
+	implements Disposable, AsyncDisposable, IWebSocketMessageHandler
+{
 	// #region Properties (30)
 
 	public readonly credentials: { username: string; password: string };
 
-	public readonly deviceList: Map<string, ISYDevice<any, any, any, any>> = new Map();
-	public readonly deviceMap: Map<string, string[]> = new Map();
+	public readonly devices: Map<string, ISYDevice<any, any, any, any>> = new Map();
 	public readonly displayNameFormat: string;
 	public readonly elkEnabled: boolean;
 	public readonly enableWebSocket: boolean;
 	public readonly folderMap: Map<string, string> = new Map();
 	public readonly host: string;
-	public readonly nodeMap: Map<string, ISYNode<any, any, any, any>> = new Map();
+	public readonly nodes: Map<string, ISYNode<any, any, any, any>> = new Map();
 	public readonly port: number;
 	public readonly protocol: string;
-	public readonly sceneList: Map<string, ISYScene> = new Map();
+	public readonly scenes: Map<string, ISYScene> = new Map();
 	public readonly storagePath: string;
-	public readonly variableList: Map<string, ISYVariable<VariableType>> = new Map();
+	public readonly variables: Map<string, ISYVariable<VariableType>> = new Map();
 	public readonly wsprotocol: 'ws' | 'wss' = 'ws';
 	public readonly zoneMap: Map<string, ElkAlarmSensorDevice> = new Map();
 
 	public static instance: ISY;
 
 	public configInfo: Config;
+
+	public readonly config: ISYConfig;
 	public elkAlarmPanel: ELKAlarmPanelDevice;
-	public guardianTimer: any;
 	public id: string;
-	public lastActivity: any;
 	public logger: Logger;
 	public model: any;
 	public nodesLoaded: boolean = false;
@@ -141,37 +146,56 @@ export class ISY extends EventEmitter implements Disposable {
 
 	socketPath: string;
 
+	xmlParser: XMLParser;
+
 	public axiosOptions: AxiosRequestConfig;
+	guardianInterval: number;
+
+	public logUnsubscribedNodeEvents: boolean = false;
+	webSocketEndpoint: ISYWebSocketEndpoint;
+
+	public static async create(config: ISYConfig, logger?: Logger, storagePath?: string): Promise<ISY> {
+		if (!config.apiOnly) {
+			if (!ISY.instance) {
+				ISY.instance = new ISY(config, logger, storagePath);
+				await ISY.instance.initialize();
+			}
+			return ISY.instance;
+		}
+		return new ISY(config, logger, storagePath);
+	}
 
 	// #endregion Properties (30)
 
 	// #region Constructors (1)
 
-	constructor(config: ISYConfig, logger: Logger = new Logger(), storagePath?: string) {
+	private constructor(config: ISYConfig, logger: Logger = new Logger(), storagePath?: string) {
 		super();
-
+		this.config = config;
 		this.enableWebSocket = config.enableWebSocket ?? true;
 		this.storagePath = storagePath ?? './';
 		this.displayNameFormat = config.displayNameFormat ?? '${location ?? folder} ${spokenName ?? name}';
 		this.host = config.host;
 		this.port = config.port;
+		this.guardianInterval = config.webSocketOptions?.guardianInterval ?? 60000;
 
 		this.credentials = {
 			username: config.username,
-			password: config.password
+			password: config.password,
 		};
 		this.protocol = config.protocol;
 		this.wsprotocol = config.protocol === 'https' ? 'wss' : 'ws';
 		this.socketPath = config.socketPath;
 		this.axiosOptions = {
-			baseURL: `${this.protocol}://${this.host}:${this.port}`,
-			validateStatus: (status) => status >= 200 && status < 300
+			validateStatus: status => status >= 200 && status < 300,
 		};
 
 		if (this.socketPath) {
 			this.axiosOptions.socketPath = this.socketPath;
+			this.axiosOptions.baseURL = 'http://dummy/'; //Workaround for Bug with Axios 1.7.5+
 		} else {
-			this.axiosOptions.auth = { username: this.credentials.username, password: this.credentials.password };
+			((this.axiosOptions.baseURL = `${this.protocol}://${this.host}:${this.port}`),
+				(this.axiosOptions.auth = { username: this.credentials.username, password: this.credentials.password }));
 		}
 
 		this.webSocketOptions = { origin: 'com.universal-devices.websockets.isy' };
@@ -181,26 +205,66 @@ export class ISY extends EventEmitter implements Disposable {
 		} else {
 			this.webSocketOptions.auth = `${this.credentials.username}:${this.credentials.password}`;
 		}
+		this.xmlParser = new XMLParser({ ...defaultXMLParserOptions });
 
 		//this.elkEnabled = config.elkEnabled ?? false;
 
 		this.nodesLoaded = false;
-		var fopts = format((info) => {
-			info.message = JSON.stringify(info.message);
-			return info;
-		})({ label: 'ISY' });
+
 		this.logger = loggers.add('isy', {
 			transports: logger.transports,
 			levels: logger.levels,
-			format: format.label({ label: 'ISY' })
+			format: format.label({ label: chalk.white.bold('ISY') }),
 		});
 
-		this.guardianTimer = null;
 		if (this.elkEnabled) {
 			this.elkAlarmPanel = new ELKAlarmPanelDevice(this, 1);
 		}
-		ISY.instance = this;
+		//ISY.instance = this;
+	}
+	[Symbol.dispose](): void {
+		if (ISY.instance === this) {
+			ISY.instance = null;
+		}
+		this.close();
+		this.logger.info(emphasize('ISY instance disposed.'));
+	}
+
+	async [Symbol.asyncDispose](): Promise<void> {
+		return new Promise(async resolve => {
+			this.logger.on('close', () => resolve());
+			try {
+				const p = new Promise<void>(resolve =>
+					this.webSocket.once('close', (x, y) => {
+						resolve();
+					})
+				);
+				/*if (this.guardianTimer) {
+					clearInterval(this.guardianTimer);
+				}*/
+				//this.webSocket?.close();
+				await p;
+				await this.webSocketEndpoint?.close();
+				this.logger.info('WebSocket connection closed during async dispose.');
+			} catch (e) {
+				this.logger.error(`Error during async dispose: ${e.message}`);
+			} finally {
+				if (ISY.instance === this) {
+					ISY.instance = null;
+				}
+				this.logger.info(emphasize('ISY instance asynchronously disposed.'));
+				if (!this.logger.closed) {
+					this.logger.close();
+				} else {
+					resolve();
+				}
+			}
+		});
 	}
+	/*[Symbol.asyncDispose](): PromiseLike<void> {
+		this.webSocket?.close();
+		return Promise.resolve();
+	}*/
 
 	// #endregion Constructors (1)
 
@@ -218,23 +282,29 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #region Public Methods (24)
 
-	[Symbol.dispose](): void {
+	/*[Symbol.dispose](): void {
+		if (ISY.instance === this) {
+			ISY.instance = null;
+		}
 		this.close();
-	}
+	}*/
 
-	public override emit(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', node?: ISYNode<any, any, any, any>): boolean {
+	/*public override emit(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', node?: ISYNode<any, any, any, any>): boolean {
 		return super.emit(event, node);
-	}
+	}*/
 
-	public getDevice<T extends ISYDevice<any, any, any, any> = ISYDevice<any, any, any, any>>(address: string, parentsOnly = false): T {
-		let s = this.deviceList.get(address);
+	public getDevice<T extends ISYDevice<any, any, any, any> = ISYDevice<any, any, any, any>>(
+		address: string,
+		parentsOnly = false
+	): T {
+		let s = this.devices.get(address);
 		if (!parentsOnly) {
 			if (s === null) {
-				s = this.deviceList[`${address.substr(0, address.length - 1)} 1`];
+				s = this.devices[`${address.substr(0, address.length - 1)} 1`];
 			}
 		} else {
-			while (s.parentAddress !== undefined && s.parentAddress !== s.address && s.parentAddress !== null) {
-				s = this.deviceList[s.parentAddress];
+			while (s?.parentAddress !== undefined && s?.parentAddress !== s?.address && s?.parentAddress !== null) {
+				s = this.devices[s?.parentAddress];
 			}
 		}
 
@@ -245,15 +315,18 @@ export class ISY extends EventEmitter implements Disposable {
 		return this.elkAlarmPanel;
 	}
 
-	public getNode<T extends ISYNode<any, any, any, any> = ISYNode<any, any, any, any>>(address: string, parentsOnly = false): T {
-		let s = this.nodeMap.get(address);
+	public getNode<T extends ISYNode<any, any, any, any> = ISYNode<any, any, any, any>>(
+		address: string,
+		parentsOnly = false
+	): T {
+		let s = this.nodes.get(address);
 		if (!parentsOnly) {
 			if (s === null) {
-				s = this.nodeMap[`${address.substr(0, address.length - 1)} 1`];
+				s = this.nodes[`${address.substr(0, address.length - 1)} 1`];
 			}
 		} else {
-			while (s.parentAddress !== undefined && s.parentAddress !== s.address && s.parentAddress !== null) {
-				s = this.nodeMap[s.parentAddress];
+			while (s?.parentAddress !== undefined && s?.parentAddress !== s?.address && s?.parentAddress !== null) {
+				s = this.nodes[s?.parentAddress];
 			}
 		}
 
@@ -261,105 +334,108 @@ export class ISY extends EventEmitter implements Disposable {
 	}
 
 	public getScene(address: string) {
-		return this.sceneList.get(address);
+		return this.scenes.get(address);
 	}
 
 	public getVariable<P extends VariableType>(type: P, id: number): ISYVariable<P> {
 		const key = this.#createVariableKey(type, id);
-		if (this.variableList.has(key)) {
-			return this.variableList[key];
+		if (this.variables.has(key)) {
+			return this.variables[key];
 		}
 		return null;
 	}
 
 	public getVariableList() {
-		return this.variableList;
+		return this.variables;
 	}
 
 	public async handleInitializeError(step: string, reason: any): Promise<any> {
 		this.logger.error(`Error initializing ISY (${step}): ${Utils.logStringify(reason)}`);
+
 		return Promise.reject(reason);
 	}
 
 	public handleWebSocketMessage(event: { data: any }) {
-		this.lastActivity = new Date();
-
-		parser.parseString(event.data, (err: any, res: { Event: any }) => {
+		let that = this;
+		parser.parseString(event.data, (err: any, res: { Event: Message<any> }) => {
 			if (err) {
-				throw err;
-			}
-			const evt = res.Event;
-			if (evt === undefined || evt.control === undefined) {
+				that.logger.error(`Error parsing ISY WebSocket message: ${err} - ${event.data}`);
 				return;
 			}
-			let actionValue = 0;
-			if (evt.action instanceof Object) {
-				actionValue = evt.action._;
-			} else if (evt.action instanceof Number || evt.action instanceof String) {
-				actionValue = Number(evt.action);
-			}
-			const stringControl = Number((evt.control as string)?.replace('_', ''));
-			switch (stringControl) {
-				case EventType.Elk:
-					if (actionValue === 2) {
-						this.elkAlarmPanel.handleEvent(event);
-					} else if (actionValue === 3) {
-						const zeElement = evt.eventInfo.ze;
-						const zoneId = zeElement.zone;
-						const zoneDevice = this.zoneMap[zoneId];
-						if (zoneDevice !== null) {
-							if (zoneDevice.handleEvent(event)) {
-								this.nodeChangedHandler(zoneDevice);
+			try {
+				const evt = res?.Event;
+				if (evt === undefined || evt.control === undefined) {
+					return;
+				}
+				let actionValue = 0;
+				if (evt.action instanceof Object) {
+					actionValue = Number(evt.action._);
+				} else if (typeof evt.action === 'string') {
+					actionValue = Number(evt.action);
+				}
+				const stringControl = Number((evt.control as string)?.replace('_', ''));
+				switch (stringControl) {
+					case EventType.Elk:
+						if (actionValue === 2) {
+							this.elkAlarmPanel.handleEvent(event);
+						} else if (actionValue === 3) {
+							const zeElement = evt.eventInfo.ze;
+							const zoneId = zeElement.zone;
+							const zoneDevice = this.zoneMap[zoneId];
+							if (zoneDevice !== null) {
+								if (zoneDevice.handleEvent(event)) {
+									this.nodeChangedHandler(zoneDevice);
+								}
 							}
 						}
-					}
 
-					break;
+						break;
 
-				case EventType.Trigger:
-					if (actionValue === 6) {
-						const varNode = evt.eventInfo.var;
-						const id = varNode.id;
-						const type = varNode.type;
-						this.getVariable(type, id)?.handleEvent(evt);
-					}
-					break;
-				case EventType.Heartbeat:
-					this.logger.debug(`Received ${EventType[Number(stringControl)]} Signal from ISY: ${JSON.stringify(evt)}`);
-					break;
-
-				default:
-					if (evt.node !== '' && evt.node !== undefined && evt.node !== null) {
-						//
-						const impactedDevice = this.getNode(evt.node);
-						if (impactedDevice !== undefined && impactedDevice !== null) {
-							try {
-								impactedDevice.handleEvent(evt);
-							} catch (e) {
-								this.logger.error(`Error handling event for ${impactedDevice.name}: ${e.message}`);
+					case EventType.Trigger:
+						if (actionValue === 6) {
+							const varNode = evt.eventInfo.var;
+							const id = varNode.id;
+							const type = varNode.type;
+							this.getVariable(type, id)?.handleEvent(evt);
+						}
+						break;
+					case EventType.Heartbeat:
+						this.logger.debug(`Received ${EventType[EventType.Heartbeat]} Signal from ISY: ${JSON.stringify(evt)}`);
+						break;
+					case EventType.SystemStatusChanged:
+					case EventType.ProgressReport:
+						this.logger.silly(`${EventType[stringControl]} Message: ${JSON.stringify(evt)}`);
+						break;
+					default:
+						if (evt.node !== '' && evt.node !== undefined && evt.node !== null) {
+							//
+							const impactedNode = this.getNode(evt.node);
+							if (impactedNode !== undefined && impactedNode !== null) {
+								try {
+									impactedNode.handleEvent(evt);
+								} catch (e) {
+									this.logger.error(`Error handling message for ${impactedNode.name}: ${e.message}`);
+								}
+							} else {
+								this.logger.silly(`${stringControl} Message for Unidentified Device: ${JSON.stringify(evt)}`);
 							}
 						} else {
-							this.logger.debug(`${EventType[stringControl]} Event for Unidentified Device: ${JSON.stringify(evt)}`);
-						}
-					} else {
-						if (stringControl === EventType.NodeChanged) {
-							this.logger.debug(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);
+							/*else if (stringControl === EventType.NodeChanged) {
+						this.logger.debug(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);*/
+							this.logger.debug(`${EventType[stringControl]} Message: ${JSON.stringify(evt)}`);
 						}
-						this.logger.debug(`${EventType[Number(stringControl)]} Event: ${JSON.stringify(evt)}`);
-					}
 
-					break;
+						break;
+				}
+			} catch (e) {
+				this.logger.error(`Error handling WebSocket message: ${e.message} - ${JSON.stringify(event)}`);
 			}
 		});
 	}
 
 	public async initialize(): Promise<boolean> {
 		const that = this;
-		try {
-			this.apiVersion = (await findPackageJson()).version;
-		} catch (e) {
-			this.logger.error(`Unable to read package.json: ${e.message}`);
-		}
+
 		try {
 			await this.loadConfig();
 			await this.loadNodes();
@@ -391,8 +467,23 @@ export class ISY extends EventEmitter implements Disposable {
 	webSocketOptions: WebSocket.ClientOptions & ClientRequestArgs;
 
 	public async initializeWebSocket() {
+		if (!this.enableWebSocket) {
+			this.logger.warn('WebSocket is disabled. Skipping initialization.');
+			return;
+		}
 		try {
-			const that = this;
+			const webSocketConfig = {
+				...this.config,
+				socketPath: this.socketPath,
+				enableWebSocket: true,
+				webSocketOptions: this.webSocketOptions,
+				wsprotocol: this.wsprotocol,
+				credentials: this.credentials,
+				guardianInterval: this.guardianInterval,
+			};
+			this.webSocketEndpoint = new ISYWebSocketEndpoint(webSocketConfig, this.logger, this);
+			await this.webSocketEndpoint.initialize();
+			/*const that = this;
 
 			//const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
 			let address = `${this.wsprotocol}://${this.address}/rest/subscribe`;
@@ -403,38 +494,40 @@ export class ISY extends EventEmitter implements Disposable {
 			this.logger.info('Using the following websocket options: ' + JSON.stringify(this.webSocketOptions));
 			if (this.webSocket) {
 				try {
-					this.webSocket.close();
+					if (this.webSocket.readyState === WebSocket.OPEN) this.webSocket.close();
+					this.webSocket = null;
 				} catch (e) {
 					this.logger.warn(`Error closing existing websocket: ${e.message}`);
 				}
 			}
 
-			/*headers: {
-					Origin: 'com.universal-devices.websockets.isy',
-					auth
-				},
+			let p = new Promise<WebSocket>((resolve, reject) => {
+				let webSocket = new WebSocket(`${address}`, ['ISYSUB'], this.webSocketOptions);
 
-				ping: 10*/
-			let p = new Promise<void>((resolve, reject) => {
-				this.webSocket = new WebSocket(`${address}`, ['ISYSUB'], this.webSocketOptions);
-				this.lastActivity = new Date();
 				//this.webSocket.onmessage = (event) => {this.handleWebSocketMessage()
-				this.webSocket
+				webSocket
 					.on('open', () => {
-						this.logger.info('Websocket connection open');
-						resolve();
+						this.logger.info(emphasize('Websocket subscription open'));
+
+						this.guardianTimer = setTimeout(async () => {
+							this.logger.warn('WebSocket Guardian Timer expired. Closing WebSocket.');
+							webSocket.terminate();
+							await this.initializeWebSocket();
+						}, this.guardianInterval ?? 60000);
+						resolve(webSocket);
 					})
 					.on('message', (data, b) => {
 						that.logger.silly(`Received message: ${Utils.logStringify(data, 1)}`);
+						this.guardianTimer.refresh();
 						that.handleWebSocketMessage({ data: data });
 					})
 					.on('error', (err: any, response: any) => {
 						that.logger.warn(`Websocket subscription error: ${err}`);
-						return reject(new ISYInitializationError('Websocket subscription error', 'websocket'));
+						reject(new ISYInitializationError('Websocket subscription error', 'websocket'));
 					})
 					.on('fail', (data: string, response: any) => {
 						that.logger.warn(`Websocket subscription failure: ${data}`);
-						return reject(new Error('Websocket subscription failure'));
+						reject(new Error('Websocket subscription failure'));
 					})
 					.on('abort', () => {
 						that.logger.warn('Websocket subscription aborted.');
@@ -442,11 +535,27 @@ export class ISY extends EventEmitter implements Disposable {
 					})
 					.on('timeout', (ms: string) => {
 						that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
-						return reject(new Error('Timeout contacting ISY'));
+						reject(new Error('Timeout contacting ISY'));
 						//throw new Error('Timeout contacting ISY');
+					})
+					.on('close', (code: number, reason: string) => {
+						that.logger.info(emphasize(`Websocket subscription closed: ${code} - ${reason}`));
+						if (this.guardianTimer) {
+							clearTimeout(this.guardianTimer);
+						}
+						if (code !== 1005) {
+							this.logger.warn(`WebSocket closed with code ${code}: ${reason}. Forcing to terminate.`);
+							if (webSocket) {
+								webSocket.terminate();
+							}
+						}
+						if (webSocket) {
+							webSocket.removeAllListeners();
+						}
 					});
 			});
-			return p;
+			this.webSocket = await p;
+			*/
 		} catch (e) {
 			throw new ISYInitializationError(e, 'websocket');
 		}
@@ -457,7 +566,7 @@ export class ISY extends EventEmitter implements Disposable {
 			this.logger.info('Loading ISY Config');
 			const configuration = (await this.sendRequest('config')).configuration as Config;
 			if (this.isDebugEnabled) {
-				writeFile(path.resolve(this.storagePath, 'ISYConfigDump.json'), JSON.stringify(configuration), this.logger.error);
+				writeDebugFile(JSON.stringify(configuration), 'ISYConfig.json', this.logger, this.storagePath);
 			}
 
 			const controls = configuration.controls;
@@ -486,7 +595,8 @@ export class ISY extends EventEmitter implements Disposable {
 		try {
 			this.logger.info('Loading ISY Nodes');
 			const result = await this.sendRequest('nodes');
-			if (this.isDebugEnabled) writeFile(this.storagePath + '/ISYNodesDump.json', JSON.stringify(result), this.logger.error);
+			if (this.isDebugEnabled)
+				await writeDebugFile(JSON.stringify(result), 'ISYNodes.json', this.logger, this.storagePath);
 			await this.#readFolderNodes(result);
 			await this.#readDeviceNodes(result);
 			await this.#readSceneNodes(result);
@@ -504,12 +614,12 @@ export class ISY extends EventEmitter implements Disposable {
 		try {
 			const that = this;
 			this.logger.info(`Loading ISY Variables of type: ${type}`);
-			return this.sendRequest(`vars/definitions/${type}`)
-				.then((result) => that.#createVariables(type, result))
-				.then(() => that.sendRequest(`vars/get/${type}`))
-				.then(that.#setVariableValues.bind(that));
+			let defs = await this.sendRequest(`vars/definitions/${type}`);
+			this.#createVariables(type, defs);
+			let vals = await this.sendRequest(`vars/get/${type}`);
+			this.#setVariableValues(vals);
 		} catch {
-			this.logger.warn('error loading variables');
+			this.logger.warn('error loading variables of type: ' + VariableType[type]);
 		}
 	}
 
@@ -523,11 +633,11 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	public override on(event: 'initializeCompleted', listener: () => void): this;
+	/*public override on(event: 'initializeCompleted', listener: () => void): this;
 	public override on(event: 'nodeAdded' | 'nodeRemoved' | 'nodeChanged', listener: (node?: ISYNode<any, any, any, any>) => void): this;
 	override on(event: 'initializeCompleted' | 'nodeAdded' | 'nodeRemoved' | 'nodeChanged', listener: (node?: ISYNode<any, any, any, any>) => void): this {
-		return super.on(event, listener);
-	}
+		return super.on('nodeAdded',listener)
+	}*/
 
 	public async refreshStatuses() {
 		try {
@@ -535,7 +645,7 @@ export class ISY extends EventEmitter implements Disposable {
 			const that = this;
 			const result = await that.sendRequest('status');
 			if (that.isDebugEnabled) {
-				writeFile(that.storagePath + '/ISYStatusDump.json', JSON.stringify(result), this.logger.error);
+				await writeDebugFile(result, 'ISYStatus.json', this.logger, this.storagePath);
 			}
 			//this.logger.debug(result);
 			for (const node of result.nodes.node) {
@@ -551,7 +661,7 @@ export class ISY extends EventEmitter implements Disposable {
 
 	public async sendGetVariable(id: any, type: any, handleResult: (arg0: number, arg1: number) => void) {
 		const uriToUse = `vars/get/${type}/${id}`;
-		return this.sendRequest(uriToUse).then((p) => handleResult(p.val, p.init));
+		return this.sendRequest(uriToUse).then(p => handleResult(p.val, p.init));
 	}
 
 	public async sendISYCommand(path: string): Promise<any> {
@@ -560,64 +670,129 @@ export class ISY extends EventEmitter implements Disposable {
 
 		return this.sendRequest(path);
 	}
+	#formatParameter(name: string, value?: Utils.MaybeWithUOM<JsonPrimitive>): string {
+		if (value === undefined) return '';
+		if (Utils.hasUOM(value)) {
+			const [val, uom] = value;
+			if (val === undefined || val === null) return '';
+			return `${name}.uom${uom}=${this.#formatParamValue(val)}`;
+		}
+		return `${name}=${this.#formatParamValue(value)}`;
+	}
 
-	public async sendNodeCommand<P extends string | symbol, N extends ISYNode<any, any, any, any>>(node: N, command: string, parameters?: Record<P, string | number> | string | number): Promise<any> {
-		let uriToUse = `nodes/${node.address}/cmd/${command}`;
+	#formatDefaultParameter(value: Utils.MaybeWithUOM<JsonPrimitive>): string {
+		if (value === undefined) return '';
+		if (Utils.hasUOM(value)) {
+			const [val, uom] = value;
+			if (val === undefined || val === null) return '';
+			return `${this.#formatParamValue(val, uom)}/${uom}`;
+		}
+		return `${this.#formatParamValue(value)}`;
+	}
+	#formatParamValue(param: JsonPrimitive, uom?: UnitOfMeasure): string {
+		if (typeof param === 'string') return param;
+		if (typeof param === 'number') return param.toString();
+		if (typeof param === 'boolean') {
+			if (uom == UnitOfMeasure.OffOn) return param ? '100' : '0';
+			if (uom == UnitOfMeasure.Percent) return param ? '100' : '0';
+			if (uom == UnitOfMeasure.LevelFrom0To255) return param ? '255' : '0';
+			return param ? '1' : '0';
+		}
+	}
+	public async sendNodeCommand<P extends string | symbol, N extends ISYNode<any, any, any, any>>(
+		node: N,
+		command: string,
+		defaultParameter?: Utils.MaybeWithUOM,
+		parameters?: Record<P, Utils.MaybeWithUOM<JsonPrimitive> | undefined> | Utils.MaybeWithUOM<JsonPrimitive>
+	): Promise<any> {
+		let uriToUse = `nodes/${node.address}/cmd/${command}?`;
+		if (defaultParameter !== null && defaultParameter !== undefined) {
+			if (Array.isArray(defaultParameter) || isPrimitive(defaultParameter)) {
+				uriToUse += `/${this.#formatDefaultParameter(defaultParameter)}?`;
+			}
+		}
 		if (parameters !== null && parameters !== undefined) {
-			if (typeof parameters == 'object') {
-				var q = parameters as Record<P, string | number>;
+			if (typeof parameters === 'object' && !Array.isArray(parameters)) {
+				var q = parameters as Record<P, Utils.MaybeWithUOM<JsonPrimitive> | undefined>;
 				for (const paramName in q) {
+					let s = q[paramName];
 					if (paramName === 'value' || paramName === 'default') {
-						uriToUse += `/${q[paramName]}`;
+						uriToUse += `/${this.#formatDefaultParameter(s)}?`;
 						continue;
-					} else if (typeof q[paramName] === 'string' || typeof q[paramName] === 'number') uriToUse += `/${paramName}/${q[paramName]}`;
+					} else {
+						let p = this.#formatParameter(paramName, s);
+						if (p === '') continue;
+						uriToUse += `${p}&`;
+					}
 				}
 
 				//uriToUse += `/${q[((p : Record<string,number|number>) => `${p[]}/${p.paramValue}` ).join('/')}`;
-			} else if (typeof parameters == 'number' || typeof parameters == 'string') {
-				uriToUse += `/${parameters}`;
+			} else {
+				uriToUse += `/${this.#formatDefaultParameter(parameters)}`;
 			}
 		}
+		uriToUse = uriToUse.endsWith('?')
+			? uriToUse.slice(0, -1)
+			: uriToUse.endsWith('&')
+				? uriToUse.slice(0, -1)
+				: uriToUse;
+		uriToUse = uriToUse.replace('?/', '/');
 		this.logger.info(`${node.name}: sending ${command} command: ${uriToUse}`);
-		return this.sendRequest(uriToUse);
+		return this.sendRequest(uriToUse, { requestLogLevel: 'info' });
 	}
 
-	public async sendRequest(
+	public async sendRequest<T = any>(
 		url: string,
 		options: {
-			parserOptions?: ParserOptions;
-			trailingSlash: boolean;
+			parserOptions?: ParserOptions | X2jOptions;
+			trailingSlash?: boolean;
 			requestLogLevel?: Utils.LogLevel;
 			responseLogLevel?: Utils.LogLevel;
 			errorLogLevel?: Utils.LogLevel;
 			throwOnError?: boolean;
 		} & Utils.ISYRequestConfig = { trailingSlash: true }
-	): Promise<any> {
+	): Promise<T> {
 		const requestLogLevel = options.requestLogLevel ?? 'debug';
 		const responseLogLevel = options.responseLogLevel ?? 'silly';
-		const finalUrl = `${this.protocol}://${this.address}/rest/${url}${options.trailingSlash ? '/' : ''}`;
-		this.logger.log(requestLogLevel, `Sending request: ${finalUrl}`);
-		const reqOps = { ...this.axiosOptions, ...options, url: path.join('/rest', url) };
+		url = `${url}${options.trailingSlash && !url.endsWith('/') ? '/' : ''}`;
+		const finalUrl = `${this.protocol}://${this.address}/rest/${url}`;
+
+		const reqOps = { ...this.axiosOptions, ...options };
+		this.logger.log(
+			requestLogLevel,
+			`Sending request to ${path.join('/rest', url)} with options: ${Utils.logStringify(reqOps, 0)}`
+		);
 		/*{
 				auth: { username: this.credentials.username, password: this.credentials.password },
 				baseURL: `${this.protocol}://${this.address}`,
 
 			}*/
 		try {
-			const response = await axios.get(finalUrl, reqOps);
+			delete reqOps.trailingSlash;
+			delete reqOps.requestLogLevel;
+			const response = await axios.get(reqOps.socketPath ? path.join('/rest', url) : finalUrl, reqOps);
 			if (response.data) {
 				if (response.headers['content-type'].toString().includes('xml')) {
-					let curParser = parser;
-					if (options.parserOptions) curParser = new Parser({ ...defaultParserOptions, ...options.parserOptions });
-					var altParser = new XMLParser(defaultXMLParserOptions);
+					let altParser = this.xmlParser;
+					if (options.parserOptions) {
+						if (typeof options.parserOptions === 'object') {
+							this.logger.info('Using custom parser options');
+							altParser = new XMLParser({ ...defaultXMLParserOptions, ...options.parserOptions });
+						}
+					}
+					//	{curParser = new Parser({ ...defaultParserOptions, ...options.parserOptions });
+					//var altParser = new XMLParser({ ...defaultXMLParserOptions, ...options.parserOptions });
 					var s = altParser.parse(response.data);
-					this.logger.log(requestLogLevel ?? 'debug', `Response: ${JSON.stringify(s)}`);
+					this.logger.log(responseLogLevel ?? 'debug', `Response: ${JSON.stringify(s)}`);
 					return s;
 				} else if (response.headers['content-type'].toString().includes('json')) {
 					this.logger.log(responseLogLevel, `Response: ${JSON.stringify(response.data)}`);
 					return JSON.parse(response.data);
 				} else {
-					this.logger.log(responseLogLevel, `Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
+					this.logger.log(
+						responseLogLevel,
+						`Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`
+					);
 					return response.data;
 				}
 			}
@@ -634,7 +809,12 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	public async sendSetVariable(id: any, type: any, value: any, handleResult: { (success: any): void; (arg0: boolean): void; (arg0: boolean): void }) {
+	public async sendSetVariable(
+		id: any,
+		type: any,
+		value: any,
+		handleResult: { (success: any): void; (arg0: boolean): void; (arg0: boolean): void }
+	) {
 		const uriToUse = `/rest/vars/set/${type}/${id}/${value}`;
 		this.logger.info(`Sending ISY command...${uriToUse}`);
 
@@ -645,9 +825,18 @@ export class ISY extends EventEmitter implements Disposable {
 		this.logger.info(`Variable: ${variable.id} (${variable.type}) changed`);
 	}
 
-	public close() {
+	public async close() {
 		try {
+			/*let p = new Promise<void>(resolve =>
+				this.webSocket?.once('close', (x, y) => {
+					resolve();
+				})
+			);
+
 			this.webSocket?.close();
+			await p;*/
+			await this.webSocketEndpoint?.close();
+			this.logger.info('WebSocket connection closed.');
 		} catch (e) {
 			this.logger.error(`Error closing websocket: ${e.message}`);
 		}
@@ -658,7 +847,11 @@ export class ISY extends EventEmitter implements Disposable {
 	// #region Private Methods (11)
 
 	#checkForFailure(response: any): boolean {
-		return response === null || response instanceof Error || (response.RestResponse !== undefined && response.RestResponse.status !== 200);
+		return (
+			response === null ||
+			response instanceof Error ||
+			(response.RestResponse !== undefined && response.RestResponse.status !== 200)
+		);
 	}
 
 	#createVariableKey(type: VariableType, id: number) {
@@ -670,7 +863,7 @@ export class ISY extends EventEmitter implements Disposable {
 			const id = Number(variable.id);
 			const name = variable.name;
 			const newVariable = new ISYVariable(this, id, name, type);
-			this.variableList.set(this.#createVariableKey(type, id), newVariable);
+			this.variables.set(this.#createVariableKey(type, id), newVariable);
 		}
 	}
 
@@ -683,62 +876,14 @@ export class ISY extends EventEmitter implements Disposable {
 				// 	this.deviceList[this.elkAlarmPanel.address] = this.elkAlarmPanel;
 				// }
 				if (this.enableWebSocket) {
-					this.guardianTimer = setInterval(this.#guardian.bind(this), 60000);
-					return this.initializeWebSocket();
+					await this.initializeWebSocket();
+					//this.guardianTimer = setInterval(this.#guardian.bind(this), this.guardianInterval);
 				}
+				this.emit('initializeCompleted');
 			}
 		}
 	}
 
-	async #guardian() {
-		const timeNow = new Date();
-
-		if (Number(timeNow) - Number(this.lastActivity) > 60000) {
-			this.logger.info('Guardian: Detected no activity in more then 60 seconds. Reinitializing web sockets');
-			await this.refreshStatuses();
-			await this.initializeWebSocket();
-		}
-	}
-
-	#loadElkInitialStatus(result: any) {
-		const p = new Parser({
-			explicitArray: false,
-			mergeAttrs: true
-		});
-		p.parseString(result, (err: any, res: { ae: any; ze: any }) => {
-			if (err) {
-				throw err;
-			}
-
-			for (const nodes of res.ae) {
-				this.elkAlarmPanel.setFromAreaUpdate(nodes);
-			}
-			for (const nodes of res.ze) {
-				const id = nodes.zone;
-				const zoneDevice = this.zoneMap[id];
-				if (zoneDevice !== null) {
-					zoneDevice.setFromZoneUpdate(nodes);
-					if (this.deviceList[zoneDevice.address] === null && zoneDevice.isPresent()) {
-						this.deviceList[zoneDevice.address] = zoneDevice;
-						// this.deviceIndex[zoneDevice.address] = zoneDevice;
-					}
-				}
-			}
-		});
-	}
-
-	/* #loadElkNodes(result: any) {
-		const document = new XmlDocument(result);
-		const nodes = document.childNamed('areas').childNamed('area').childrenNamed('zone');
-		for (let index = 0; index < nodes.length; index++) {
-			const id = nodes[index].attr.id;
-			const name = nodes[index].attr.name;
-			const alarmDef = nodes[index].attr.alarmDef;
-			const newDevice = new ElkAlarmSensorDevice(this, name, 1, id TODO: Handle CO Sensor vs. Door/Window Sensor );
-			this.zoneMap[newDevice.zone] = newDevice;
-		}
-	} */
-
 	async #readDeviceNodes(obj: { nodes: { node: NodeInfo[] } }) {
 		try {
 			this.logger.info('Reading Device Nodes');
@@ -746,7 +891,19 @@ export class ISY extends EventEmitter implements Disposable {
 			for (const nodeInfo of obj.nodes.node) {
 				try {
 					this.logger.debug(`Loading Device Node: ${JSON.stringify(nodeInfo)}`);
-					if (!this.deviceMap.has(nodeInfo.pnode)) {
+					if (nodeInfo.enabled) {
+						let newDevice = await DeviceFactory.create(this, nodeInfo);
+						if (!newDevice && nodeInfo.pnode == nodeInfo.address) {
+							this.logger.warn(
+								`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`
+							);
+							newDevice = new GenericNode(this, nodeInfo);
+						}
+						if (newDevice) {
+							if (this.devices.set) this.devices.set(newDevice.address, newDevice);
+						}
+
+						/* if (!this.deviceMap.has(nodeInfo.pnode)) {
 						const address = nodeInfo.address;
 						this.deviceMap[nodeInfo.pnode] = {
 							address
@@ -775,7 +932,6 @@ export class ISY extends EventEmitter implements Disposable {
 					if (cls) {
 						try {
 							newDevice = new cls(this, nodeInfo);
-
 						} catch (e) {
 							this.logger.error(`Error creating device ${nodeInfo.name} with type ${nodeInfo.type} and nodedef ${nodeInfo.nodeDefId}: ${e.message}`);
 							continue;
@@ -799,7 +955,7 @@ export class ISY extends EventEmitter implements Disposable {
 								this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);
 							}
 							try {
-								await newDevice.refreshNotes();
+								//await newDevice.refreshNotes();
 							} catch (e) {
 								this.logger.debug('No notes found.');
 							}
@@ -811,11 +967,9 @@ export class ISY extends EventEmitter implements Disposable {
 						} else {
 						}
 						this.nodeMap.set(newDevice.address, CompositeDevice.isComposite(newDevice) ? newDevice.root : newDevice);
-						if(CompositeDevice.isComposite(newDevice))
-						{
-							if(this.deviceList.set)
-								this.deviceList.set(newDevice.address, newDevice);
-						}
+						if (CompositeDevice.isComposite(newDevice)) {
+							if (this.deviceList.set) this.deviceList.set(newDevice.address, newDevice);
+						} */
 					} else {
 						this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
 					}
@@ -823,22 +977,25 @@ export class ISY extends EventEmitter implements Disposable {
 					this.logger.error(`Error loading device node: ${e.message}`);
 				}
 			}
-			this.logger.info(`${this.nodeMap.size} nodes added.`);
-			for(const node of this.nodeMap.values()) {
-				if(node.parentAddress !== node.address) {
-					let parent = this.deviceList.get(node.parentAddress) as unknown as CompositeDevice<any,any>;
-					if(parent && CompositeDevice.isComposite(parent))
-						parent.addNode(node);
 
+			await DeviceFactory.addChildNodes(this);
+			this.logger.info(`${this.nodes.size} nodes added.`);
+			for (const node of this.nodes.values()) {
+				try {
+					//await node.refreshNotes();
+				} catch (e) {
+					this.logger.silly('No notes found.');
 				}
-				else if(!this.deviceList.has(node.address))
-				{
+			}
+			/*for (const node of this.nodeMap.values()) {
+				if (node.parentAddress !== node.address) {
+					let parent = this.deviceList.get(node.parentAddress) as unknown as CompositeDevice<any, any>;
+					if (parent && CompositeDevice.isComposite(parent)) parent.addNode(node);
+				} else if (!this.deviceList.has(node.address)) {
 					this.deviceList.set(node.address, node as unknown as ISYDevice<any, any, any, any>);
 				}
-
-
-			}
-			this.logger.info(`${this.deviceList.size} unique devices added.`);
+			}*/
+			this.logger.info(`${this.devices.size} unique devices added.`);
 		} catch (e) {
 			throw new ISYInitializationError(e, 'readDevices');
 		}
@@ -868,13 +1025,13 @@ export class ISY extends EventEmitter implements Disposable {
 
 				const newScene = new ISYScene(this, scene);
 				try {
-					await newScene.refreshNotes();
+					//await newScene.refreshNotes();
 				} catch (e) {
 					this.logger.debug('No notes found.');
 				}
-				this.sceneList.set(newScene.address, newScene);
+				this.scenes.set(newScene.address, newScene);
 			}
-			this.logger.info(`${this.sceneList.size} scenes added.`);
+			this.logger.info(`${this.scenes.size} scenes added.`);
 		} catch (e) {
 			throw new ISYInitializationError(e, 'readScenes');
 		}
@@ -895,7 +1052,23 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #endregion Private Methods (11)
 }
+export { CompositeDevice } from './Devices/CompositeDevice.js';
+export { ISYDeviceNode as DeviceNode } from './Devices/ISYDeviceNode.js';
+export { ISYNode as Node } from './ISYNode.js';
+
+export * from './Converters.js';
+export * from './Definitions/index.js';
+export * as Devices from './Devices/index.js';
+export * from './ISYError.js';
+export { ISYError } from './ISYError.js';
+export { ISYVariable as Variable } from './ISYVariable.js';
+export * from './Model/index.js';
+export { ISYScene as Scene } from './Scenes/ISYScene.js';
+export * from './Utils.js';
+export { VariableType } from './VariableType.js';
 
 export namespace ISY {
 	export interface Config extends ISYConfig {}
+
+	export type Device<F extends Family, D, C, E> = ISYDevice<F, D, C, E>;
 }