isy-nodejs 1.0.1-alpha.6 → 1.0.2-alpha.0

package/src/ISY.ts

@@ -3,80 +3,45 @@ import { writeFile } from 'fs';
 
 import { Parser, type ParserOptions } from 'xml2js';
 import { parseBooleans, parseNumbers } from 'xml2js/lib/processors.js';
-import { XmlDocument } from 'xmldoc';
 
-import axios from 'axios';
+import axios, { type AxiosRequestConfig } from 'axios';
 import { EventEmitter } from 'events';
-import winston, { format, Logger, loggers, type LeveledLogMethod } from 'winston';
-import { Category } from './Definitions/Global/Categories.js';
-import { Family } from './Definitions/Global/Families.js';
-import type { NodeInfo } from './Model/NodeInfo.js';
+import { format, Logger, loggers, type LeveledLogMethod } from 'winston';
 import { DeviceFactory } from './Devices/DeviceFactory.js';
 import { ELKAlarmPanelDevice } from './Devices/Elk/ElkAlarmPanelDevice.js';
 import { ElkAlarmSensorDevice } from './Devices/Elk/ElkAlarmSensorDevice.js';
-import { InsteonBaseDevice } from './Devices/Insteon/InsteonBaseDevice.js';
-import { InsteonOutletDevice } from './Devices/Insteon/InsteonDevice.js';
-import { InsteonDimmableDevice } from './Devices/Insteon/InsteonDimmableDevice.js';
-import { InsteonDimmerOutletDevice } from './Devices/Insteon/InsteonDimmerOutletDevice.js';
-import { InsteonDimmerSwitchDevice } from './Devices/Insteon/InsteonDimmerSwitchDevice.js';
-import { InsteonDoorWindowSensorDevice } from './Devices/Insteon/InsteonDoorWindowSensorDevice.js';
-import { InsteonFanDevice, InsteonFanMotorDevice } from './Devices/Insteon/InsteonFanDevice.js';
-import { InsteonKeypadButtonDevice } from './Devices/Insteon/InsteonKeypadDevice.js';
-import { InsteonKeypadDimmerDevice } from './Devices/Insteon/InsteonKeypadDimmerDevice.js';
-import { InsteonKeypadRelayDevice } from './Devices/Insteon/InsteonKeypadRelayDevice.js';
-import { InsteonLeakSensorDevice } from './Devices/Insteon/InsteonLeakSensorDevice.js';
-import { InsteonLockDevice } from './Devices/Insteon/InsteonLockDevice.js';
-import { InsteonMotionSensorDevice } from './Devices/Insteon/InsteonMotionSensorDevice.js';
-import { InsteonOnOffOutletDevice } from './Devices/Insteon/InsteonOnOffOutletDevice.js';
-import { InsteonRelayDevice } from './Devices/Insteon/InsteonRelayDevice.js';
-import { InsteonSmokeSensorDevice } from './Devices/Insteon/InsteonSmokeSensorDevice.js';
-import { InsteonThermostatDevice } from './Devices/Insteon/InsteonThermostatDevice.js';
-import { EventType } from './Events/EventType.js';
-import { NodeType, Props, States, VariableType } from './ISYConstants.js';
-import { ISYNode } from './ISYNode.js';
 import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
+import { EventType } from './Events/EventType.js';
+import { VariableType } from './ISYConstants.js';
 import { type 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 * as Utils from './Utils.js';
 
 import { X2jOptions, XMLParser } from 'fast-xml-parser';
+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';
+
 
-export {
-	Category as Categories,
-	ELKAlarmPanelDevice,
-	ElkAlarmSensorDevice,
-	Family,
-	InsteonBaseDevice,
-	InsteonDimmableDevice,
-	InsteonDimmerOutletDevice,
-	InsteonDimmerSwitchDevice,
-	InsteonDoorWindowSensorDevice,
-	InsteonFanDevice,
-	InsteonFanMotorDevice,
-	InsteonKeypadButtonDevice,
-	InsteonKeypadDimmerDevice,
-	InsteonKeypadRelayDevice,
-	InsteonLeakSensorDevice,
-	InsteonLockDevice,
-	InsteonMotionSensorDevice,
-	InsteonOnOffOutletDevice,
-	InsteonOutletDevice,
-	InsteonRelayDevice,
-	InsteonSmokeSensorDevice,
-	InsteonThermostatDevice,
-	ISYDeviceNode as ISYDevice,
-	ISYNode,
-	ISYScene,
-	ISYVariable,
-	NodeType,
-	Props,
-	States,
-	Utils,
-	VariableType
-};
+
+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;
+	}
+}
 
 const defaultParserOptions: ParserOptions = {
 	explicitArray: false,
@@ -118,10 +83,28 @@ const parser = new Parser(defaultParserOptions);
 
 export let Controls = {};
 
+interface ISYConfig {
+	// #region Properties (8)
+
+	displayNameFormat?: string;
+	elkEnabled?: boolean;
+	enableWebSocket?: boolean;
+	host: string;
+	password: string;
+	port: number;
+	protocol: 'http' | 'https';
+	username: string;
+
+	socketPath?: string;
+
+	// #endregion Properties (8)
+}
+
 export class ISY extends EventEmitter implements Disposable {
 	// #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 displayNameFormat: string;
@@ -140,7 +123,7 @@ export class ISY extends EventEmitter implements Disposable {
 
 	public static instance: ISY;
 
-	public configInfo: any;
+	public configInfo: Config;
 	public elkAlarmPanel: ELKAlarmPanelDevice;
 	public guardianTimer: any;
 	public id: string;
@@ -150,41 +133,48 @@ export class ISY extends EventEmitter implements Disposable {
 	public nodesLoaded: boolean = false;
 	public productId = 5226;
 	public productName = 'eisy';
-	public serverVersion: any;
+	public firmwareVersion: any;
 	public vendorName = 'Universal Devices, Inc.';
 	public webSocket: WebSocket.Client;
 
+	public apiVersion: string;
+
+	socketPath: string;
+
+	public axiosOptions: AxiosRequestConfig;
+
 	// #endregion Properties (30)
 
 	// #region Constructors (1)
 
-	constructor(
-		config: {
-			host: string;
-			port: number;
-			protocol: 'http' | 'https';
-			username: string;
-			password: string;
-			enableWebSocket?: boolean;
-			displayNameFormat?: string;
-			elkEnabled?: boolean;
-		},
-		logger: Logger = new Logger(),
-		storagePath?: string
-	) {
+	constructor(config: ISYConfig, logger: Logger = new Logger(), storagePath?: string) {
 		super();
+
 		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.credentials = {
 			username: config.username,
 			password: config.password
 		};
 		this.protocol = config.protocol;
 		this.wsprotocol = config.protocol === 'https' ? 'wss' : 'ws';
-		this.elkEnabled = config.elkEnabled ?? false;
+
+		this.axiosOptions = {
+			baseURL: `${this.protocol}://${this.host}:${this.port}`,
+			validateStatus: (status) => status >= 200 && status < 300
+		};
+
+		if (this.socketPath) {
+			this.axiosOptions.socketPath = this.socketPath;
+		} else {
+			this.axiosOptions.auth = { username: this.credentials.username, password: this.credentials.password };
+		}
+
+		//this.elkEnabled = config.elkEnabled ?? false;
 
 		this.nodesLoaded = false;
 		var fopts = format((info) => {
@@ -218,7 +208,11 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #endregion Public Getters And Setters (2)
 
-	// #region Public Methods (22)
+	// #region Public Methods (24)
+
+	[Symbol.dispose](): void {
+		this.close();
+	}
 
 	public override emit(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', node?: ISYNode<any, any, any, any>): boolean {
 		return super.emit(event, node);
@@ -239,6 +233,10 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
+	public getElkAlarmPanel() {
+		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);
 		if (!parentsOnly) {
@@ -254,10 +252,6 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
-	public getElkAlarmPanel() {
-		return this.elkAlarmPanel;
-	}
-
 	public getScene(address: string) {
 		return this.sceneList.get(address);
 	}
@@ -275,7 +269,7 @@ export class ISY extends EventEmitter implements Disposable {
 	}
 
 	public async handleInitializeError(step: string, reason: any): Promise<any> {
-		this.logger.error(`Error initializing ISY (${step}): ${JSON.stringify(reason)}`);
+		this.logger.error(`Error initializing ISY (${step}): ${Utils.logStringify(reason)}`);
 		return Promise.reject(reason);
 	}
 
@@ -323,7 +317,7 @@ export class ISY extends EventEmitter implements Disposable {
 					}
 					break;
 				case EventType.Heartbeat:
-					this.logger.debug(`Received ${EventType[Number(stringControl)]} Signal from ISY: ${JSON.stringify(evt)}`);
+					this.logger.debug(`Received ${EventType[Number(stringControl)]} Signal from ISY: ${Utils.logStringify(evt)}`);
 					break;
 
 				default:
@@ -337,13 +331,13 @@ export class ISY extends EventEmitter implements Disposable {
 								this.logger.error(`Error handling event for ${impactedDevice.name}: ${e.message}`);
 							}
 						} else {
-							this.logger.warn(`${EventType[stringControl]} Event for Unidentified Device: ${JSON.stringify(evt)}`);
+							this.logger.debug(`${EventType[stringControl]} Event for Unidentified Device: ${JSON.stringify(evt)}`);
 						}
 					} else {
 						if (stringControl === EventType.NodeChanged) {
-							this.logger.info(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);
+							this.logger.debug(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);
 						}
-						this.logger.debug(`${EventType[Number(stringControl)]} Event: ${JSON.stringify(evt)}`);
+						this.logger.debug(`${EventType[Number(stringControl)]} Event: ${Utils.logStringify(evt)}`);
 					}
 
 					break;
@@ -351,8 +345,13 @@ export class ISY extends EventEmitter implements Disposable {
 		});
 	}
 
-	public async initialize(): Promise<any> {
+	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();
@@ -360,76 +359,83 @@ export class ISY extends EventEmitter implements Disposable {
 			await this.loadVariables(VariableType.State);
 			await this.refreshStatuses();
 			await this.#finishInitialize(true);
+			return true;
 		} catch (e) {
-			this.handleInitializeError('initialize', e);
+			if (e instanceof ISYInitializationError) {
+				this.logger.error(`Error initializing ISY during (${e.step}): ${e.message}`);
+			} else {
+				this.logger.error(`Error initializing ISY: ${e.message}`);
+			}
+			throw e;
 		} finally {
 			if (this.nodesLoaded !== true) {
 				that.#finishInitialize(false);
 			}
 		}
-		return Promise.resolve(true);
 	}
 
-	public initializeWebSocket() {
-		const that = this;
-		const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
-		this.logger.info(`Opening webSocket: ${this.wsprotocol}://${this.address}/rest/subscribe`);
-		if (this.webSocket) {
-			try {
-				this.webSocket.close();
-			} catch (e) {
-				this.logger.warn(`Error closing existing websocket: ${e.message}`);
+	public async initializeWebSocket() {
+		try {
+			const that = this;
+			const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
+			this.logger.info(`Opening webSocket: ${this.wsprotocol}://${this.address}/rest/subscribe`);
+			if (this.webSocket) {
+				try {
+					this.webSocket.close();
+				} catch (e) {
+					this.logger.warn(`Error closing existing websocket: ${e.message}`);
+				}
 			}
-		}
-		this.webSocket = new WebSocket.Client(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], {
-			headers: {
-				Origin: 'com.universal-devices.websockets.isy',
-				Authorization: auth
-			},
-			ping: 10
-		});
-
-		this.lastActivity = new Date();
-
-		this.webSocket
-			.on('message', (event: any) => {
-				that.logger.silly(`Received message: ${JSON.stringify(event.data, null, 2)}`);
-				that.handleWebSocketMessage(event);
-			})
-			.on('error', (err: any, response: any) => {
-				that.logger.warn(`Websocket subscription error: ${JSON.stringify(err.message)}`);
-				/// throw new Error('Error calling ISY' + err);
-			})
-			.on('fail', (data: string, response: any) => {
-				that.logger.warn(`Websocket subscription failure: ${data}`);
-				throw new Error('Failed calling ISY');
-			})
-			.on('abort', () => {
-				that.logger.warn('Websocket subscription aborted.');
-				throw new Error('Call to ISY was aborted');
-			})
-			.on('timeout', (ms: string) => {
-				that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
-				throw new Error('Timeout contacting ISY');
+			this.webSocket = new WebSocket.Client(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], {
+				headers: {
+					Origin: 'com.universal-devices.websockets.isy',
+					Authorization: auth
+				},
+				ping: 10
 			});
+
+			this.lastActivity = new Date();
+
+			this.webSocket
+				.on('message', (event: any) => {
+					that.logger.silly(`Received message: ${Utils.logStringify(event.data, 1)}`);
+					that.handleWebSocketMessage(event);
+				})
+				.on('error', (err: any, response: any) => {
+					that.logger.warn(`Websocket subscription error: ${Utils.logStringify(err, 1)}`);
+				})
+				.on('fail', (data: string, response: any) => {
+					that.logger.warn(`Websocket subscription failure: ${data}`);
+					throw new Error('Websocket subscription failure');
+				})
+				.on('abort', () => {
+					that.logger.warn('Websocket subscription aborted.');
+					throw new Error('Websocket subscription aborted.');
+				})
+				.on('timeout', (ms: string) => {
+					that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
+					throw new Error('Timeout contacting ISY');
+				});
+		} catch (e) {
+			throw new ISYInitializationError(e, 'websocket');
+		}
 	}
 
 	public async loadConfig(): Promise<any> {
 		try {
 			this.logger.info('Loading ISY Config');
-			const configuration = (await this.sendRequest('config')).configuration;
+			const configuration = (await this.sendRequest('config')).configuration as Config;
 			if (this.isDebugEnabled) {
-				writeFile(this.storagePath + '/ISYConfigDump.json', JSON.stringify(configuration), this.logger.error);
+				writeFile(path.resolve(this.storagePath, 'ISYConfigDump.json'), JSON.stringify(configuration), this.logger.error);
 			}
 
 			const controls = configuration.controls;
 			this.model = configuration.deviceSpecs.model;
-			this.serverVersion = configuration.app_version;
+			this.firmwareVersion = configuration.app_full_version;
 			this.vendorName = configuration.deviceSpecs.make;
 			this.productId = configuration.product.id;
 			this.productName = configuration.product.desc;
 			this.id = configuration.root.id;
-			// TODO: Check Installed Features
 			// this.logger.info(result.configuration);
 			if (controls !== undefined) {
 				// this.logger.info(controls.control);
@@ -441,27 +447,31 @@ export class ISY extends EventEmitter implements Disposable {
 			}
 			return configuration;
 		} catch (e) {
-			this.handleInitializeError('config', e);
-			throw Error(`Error Loading Config: ${(e as Error).message}`);
+			throw new ISYInitializationError(e, 'config');
 		}
 	}
 
 	public async loadNodes(): Promise<any> {
 		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);
-
-			await this.#readFolderNodes(result).catch((p) => this.logger.error('Error Loading Folders', p));
-			await this.#readDeviceNodes(result).catch((p) => this.logger.error('Error Loading Devices', p));
-			await this.#readSceneNodes(result).catch((p) => this.logger.error('Error Loading Scenes', p));
+			await this.#readFolderNodes(result);
+			await this.#readDeviceNodes(result);
+			await this.#readSceneNodes(result);
 			return result;
 		} catch (e) {
-			throw new Error(`Error loading nodes: ${(e as Error).message}`);
+			if (e instanceof ISYInitializationError) {
+				throw e;
+			} else {
+				throw new ISYInitializationError(e, 'loadNodes');
+			}
 		}
 	}
 
 	public async loadVariables(type: VariableType): Promise<any> {
 		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}`))
@@ -478,7 +488,9 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	public override on(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', listener: (node?: ISYNode<any, any, any, any>) => 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);
 	}
 
@@ -489,40 +501,11 @@ export class ISY extends EventEmitter implements Disposable {
 			if (that.isDebugEnabled) {
 				writeFile(that.storagePath + '/ISYStatusDump.json', JSON.stringify(result), this.logger.error);
 			}
-			this.logger.debug(result);
+			//this.logger.debug(result);
 			for (const node of result.nodes.node) {
-				this.logger.debug(node);
-				let device = that.getDevice(node.id) as unknown as ISYNode<any, any, any, any>;
+				let device = that.getNode(node.id) as unknown as ISYNode<any, any, any, any>;
 				if (device !== null && device !== undefined) {
-					//   let child = device.children.find((p) => p.address === node.id);
-					//   if (child) {
-					//     //Case FanLinc where we treat the light as a child of the fan.
-					//     device = child;
-					//   }
 					device.parseResult(node.property);
-
-					//   if (Array.isArray(node.property)) {
-					//     for (let prop of node.property) {
-					// 		device.applyStatus(prop)
-					//     //   device.local[prop.id] = device.convertFrom(prop.value, prop.uom);
-					//     //   device.formatted[prop.id] = prop.formatted;
-					//     //   device.uom[prop.id] = prop.uom;
-					//     //   device.logger(
-					//     //     `Property ${Controls[prop.id].label} (${prop.id}) initialized to: ${device.local[prop.id]} (${
-					//     //       device.formatted[prop.id]
-					//     //     })`
-					//     //   );
-					//     }
-					//   } else if (node.property) {
-					//     device.local[node.property.id] = device.convertFrom(node.property.value, node.property.uom);
-					//     device.formatted[node.property.id] = node.property.formatted;
-					//     device.uom[node.property.id] = node.property.uom;
-					//     device.logger(
-					//       `Property ${Controls[node.property.id].label} (${node.property.id}) initialized to: ${
-					//         device.local[node.property.id]
-					//       } (${device.formatted[node.property.id]})`
-					//     );
-					//   }
 				}
 			}
 		} catch (e) {
@@ -531,9 +514,7 @@ export class ISY extends EventEmitter implements Disposable {
 	}
 
 	public async sendGetVariable(id: any, type: any, handleResult: (arg0: number, arg1: number) => void) {
-		const uriToUse = `${this.protocol}://${this.address}/rest/vars/get/${type}/${id}`;
-		this.logger.info(`Sending ISY command...${uriToUse}`);
-
+		const uriToUse = `vars/get/${type}/${id}`;
 		return this.sendRequest(uriToUse).then((p) => handleResult(p.val, p.init));
 	}
 
@@ -550,7 +531,11 @@ export class ISY extends EventEmitter implements Disposable {
 			if (typeof parameters == 'object') {
 				var q = parameters as Record<P, string | number>;
 				for (const paramName of Object.getOwnPropertyNames(q)) {
-					uriToUse += `/${paramName}/${q[paramName]}`;
+					if (paramName === 'value') {
+						uriToUse += `/${q[paramName]}`;
+						continue;
+					}
+					if (typeof q[paramName] === 'string' || typeof q[paramName] === 'number') uriToUse += `/${paramName}/${q[paramName]}`;
 				}
 
 				//uriToUse += `/${q[((p : Record<string,number|number>) => `${p[]}/${p.paramValue}` ).join('/')}`;
@@ -567,37 +552,50 @@ export class ISY extends EventEmitter implements Disposable {
 		options: {
 			parserOptions?: ParserOptions;
 			trailingSlash: boolean;
-			requestLogLevel?: any;
-			responseLogLevel?: any;
-		} = { trailingSlash: true }
+			requestLogLevel?: Utils.LogLevel;
+			responseLogLevel?: Utils.LogLevel;
+			errorLogLevel?: Utils.LogLevel;
+			throwOnError?: boolean;
+		} & Utils.ISYRequestConfig = { trailingSlash: true }
 	): Promise<any> {
 		const requestLogLevel = options.requestLogLevel ?? 'debug';
 		const responseLogLevel = options.responseLogLevel ?? 'silly';
-		url = `${this.protocol}://${this.address}/rest/${url}${options.trailingSlash ? '/' : ''}`;
-		this.logger.log(requestLogLevel, `Sending request: ${url}`);
+		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) };
+		/*{
+				auth: { username: this.credentials.username, password: this.credentials.password },
+				baseURL: `${this.protocol}://${this.address}`,
+
+			}*/
 		try {
-			const response = await axios.get(url, {
-				auth: { username: this.credentials.username, password: this.credentials.password }
-			});
+			const response = await axios.get(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);
 					var s = altParser.parse(response.data);
-					this.logger.log(requestLogLevel ?? 'debug',`Response: ${JSON.stringify(s)}`);
+					this.logger.log(requestLogLevel ?? 'debug', `Response: ${JSON.stringify(s)}`);
 					return s;
 				} else if (response.headers['content-type'].toString().includes('json')) {
-					this.logger.log(responseLogLevel ?? 'debug', `Response: ${JSON.stringify(response.data)}`);
+					this.logger.log(responseLogLevel, `Response: ${JSON.stringify(response.data)}`);
 					return JSON.parse(response.data);
 				} else {
-					this.logger.log(responseLogLevel ?? 'debug',`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;
 				}
 			}
 		} catch (error) {
-			this.logger.error(`Error sending request to ISY: ${error?.message}`);
-			throw new Error(`Error sending request to ISY: ${JSON.stringify(error)}`);
+			if (options.throwOnError) {
+				throw error;
+			} else {
+				if (options.errorLogLevel) {
+					this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+				} else {
+					this.logger.error(`Error sending request to ISY: ${error?.message}`);
+				}
+			}
 		}
 	}
 
@@ -608,11 +606,19 @@ export class ISY extends EventEmitter implements Disposable {
 		return this.sendRequest(uriToUse);
 	}
 
-	public variableChangedHandler(variable: { id: string; type: string }) {
+	#variableChangedHandler(variable: { id: string; type: string }) {
 		this.logger.info(`Variable: ${variable.id} (${variable.type}) changed`);
 	}
 
-	// #endregion Public Methods (22)
+	public close() {
+		try {
+			this.webSocket?.close();
+		} catch (e) {
+			this.logger.error(`Error closing websocket: ${e.message}`);
+		}
+	}
+
+	// #endregion Public Methods (24)
 
 	// #region Private Methods (11)
 
@@ -649,12 +655,13 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	#guardian() {
+	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');
-			this.initializeWebSocket();
+			await this.refreshStatuses();
+			await this.initializeWebSocket();
 		}
 	}
 
@@ -685,107 +692,138 @@ export class ISY extends EventEmitter implements Disposable {
 		});
 	}
 
-	#loadElkNodes(result: any) {
+	/* #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 */);
+			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[] } }) {
-		this.logger.info('Loading Device Nodes');
-
-		for (const nodeInfo of obj.nodes.node) {
-			try {
-				this.logger.debug(`Loading Device Node: ${JSON.stringify(nodeInfo)}`);
-				if (!this.deviceMap.has(nodeInfo.pnode)) {
-					const address = nodeInfo.address;
-					this.deviceMap[nodeInfo.pnode] = {
-						address
-					};
-				} else {
-					this.deviceMap[nodeInfo.pnode].push(nodeInfo.address);
-				}
-				let newDevice: ISYDeviceNode<any, any, any, any> = null;
-
-				// let deviceTypeInfo = this.isyTypeToTypeName(device.type, device.address);
-				// this.logger.info(JSON.stringify(deviceTypeInfo));
-
-				const enabled = nodeInfo.enabled ?? true;
-				const d = await NodeFactory.get(nodeInfo);
-				const m = DeviceFactory.getDeviceDetails(nodeInfo);
-
-				if (d) {
-					newDevice = new d(this, nodeInfo) as ISYDeviceNode<any, any, any, any>;
-				}
-				if (m) {
-					newDevice = newDevice ?? (new m.class(this, nodeInfo) as unknown as ISYDeviceNode<any, any, any, any>);
-					newDevice.productName = m.name;
-					newDevice.model = `(${m.modelNumber}) ${m.name} v.${m.version}`;
-					newDevice.modelNumber = m.modelNumber;
-					newDevice.version = m.version;
-				}
-				if (enabled) {
-					if (newDevice === null) {
-						this.logger.warn(`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`);
-						newDevice = new ISYDeviceNode<any, any, any, any>(this, nodeInfo);
-					} else if (newDevice !== null) {
-						if (m.unsupported) {
-							this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);
+		try {
+			this.logger.info('Reading Device Nodes');
+
+			for (const nodeInfo of obj.nodes.node) {
+				try {
+					this.logger.debug(`Loading Device Node: ${JSON.stringify(nodeInfo)}`);
+					if (!this.deviceMap.has(nodeInfo.pnode)) {
+						const address = nodeInfo.address;
+						this.deviceMap[nodeInfo.pnode] = {
+							address
+						};
+					} else {
+						this.deviceMap[nodeInfo.pnode].push(nodeInfo.address);
+					}
+					let newDevice: ISYDeviceNode<any, any, any, any> = null;
+
+					// let deviceTypeInfo = this.isyTypeToTypeName(device.type, device.address);
+					// this.logger.info(JSON.stringify(deviceTypeInfo));
+
+					const enabled = nodeInfo.enabled ?? true;
+					const d = await NodeFactory.get(nodeInfo);
+					const m = DeviceFactory.getDeviceDetails(nodeInfo);
+					const cls = m?.class ?? d;
+					nodeInfo.property = Array.isArray(nodeInfo.property) ? nodeInfo.property : [nodeInfo.property];
+					nodeInfo.state = nodeInfo.property.reduce((acc, p) => {
+						if (p && p?.id) {
+							p.name = p.name == '' ? undefined : p.name;
+							acc[p.id] = p;
 						}
+						return acc;
+					}, {});
+
+					if(cls)
+					{
 						try {
-							await newDevice.refreshNotes();
-						} catch (e) {
-							this.logger.debug('No notes found.');
+							newDevice = new cls(this, nodeInfo) as ISYDeviceNode<any, any, any, any>;
+						}
+						catch(e)
+						{
+							this.logger.error(`Error creating device ${nodeInfo.name} with type ${nodeInfo.type} and nodedef ${nodeInfo.nodeDefId}: ${e.message}`);
+							continue;
 						}
+						//newDevice = new cls(this, nodeInfo) as ISYDeviceNode<any, any, any, any>;
+					}
+
+					if (m) {
+						newDevice.productName = m.name;
+						newDevice.model = `(${m.modelNumber}) ${m.name} v.${m.version}`;
+						newDevice.modelNumber = m.modelNumber;
+						newDevice.version = m.version;
+					}
+
+					if (enabled) {
+						if (newDevice === null) {
+							this.logger.warn(`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`);
+							newDevice = new ISYDeviceNode<any, any, any, any>(this, nodeInfo);
+						} else if (newDevice !== null) {
+							if (m.unsupported) {
+								this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);
+							}
+							try {
+								await newDevice.refreshNotes();
+							} catch (e) {
+								this.logger.debug('No notes found.');
+							}
 
-						// if (!newDevice.hidden) {
-						// }
+							// if (!newDevice.hidden) {
+							// }
 
-						// this.deviceList.push(newDevice);
+							// this.deviceList.push(newDevice);
+						} else {
+						}
+						this.nodeMap.set(newDevice.address, newDevice);
 					} else {
+						this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
 					}
-					this.nodeMap.set(newDevice.address, newDevice);
-				} else {
-					this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
+				} catch (e) {
+					this.logger.error(`Error loading device node: ${e.message}`);
 				}
-			} catch (e) {
-				this.logger.error(`Error loading device node: ${e.message}`);
 			}
+			this.logger.info(`${this.nodeMap.size} devices added.`);
+		} catch (e) {
+			throw new ISYInitializationError(e, 'readDevices');
 		}
-
-		this.logger.info(`${this.nodeMap.size} devices added.`);
 	}
 
 	async #readFolderNodes(result: { nodes: { folder: any } }) {
-		this.logger.info('Loading Folder Nodes');
-		if (result?.nodes?.folder) {
-			for (const folder of result.nodes.folder) {
-				this.logger.info(`Loading Folder Node: ${JSON.stringify(folder)}`);
-				this.folderMap.set(folder.address, folder.name);
+		try {
+			this.logger.info('Reading Folder Nodes');
+			if (result?.nodes?.folder) {
+				for (const folder of result.nodes.folder) {
+					this.logger.debug(`Loading Folder Node: ${JSON.stringify(folder)}`);
+					this.folderMap.set(folder.address, folder.name);
+				}
 			}
+		} catch (e) {
+			throw new ISYInitializationError(e, 'readFolders');
 		}
 	}
 
 	async #readSceneNodes(result: { nodes: { group: any } }) {
-		this.logger.info('Loading Scene Nodes');
-		for (const scene of result.nodes?.group) {
-			if (scene.name === 'ISY' || scene.name === 'IoX' || scene.name === 'Auto DR') {
-				continue;
-			} // Skip ISY & Auto DR Scenes
-
-			const newScene = new ISYScene(this, scene);
-			try {
-				await newScene.refreshNotes();
-			} catch (e) {
-				this.logger.debug('No notes found.');
+		try {
+			this.logger.info('Loading Scene Nodes');
+			for (const scene of result.nodes?.group) {
+				if (scene.name === 'ISY' || scene.name === 'IoX' || scene.name === 'Auto DR') {
+					continue;
+				} // Skip ISY & Auto DR Scenes
+
+				const newScene = new ISYScene(this, scene);
+				try {
+					await newScene.refreshNotes();
+				} catch (e) {
+					this.logger.debug('No notes found.');
+				}
+				this.sceneList.set(newScene.address, newScene);
 			}
-			this.sceneList.set(newScene.address, newScene);
+			this.logger.info(`${this.sceneList.size} scenes added.`);
+		} catch (e) {
+			throw new ISYInitializationError(e, 'readScenes');
 		}
 	}
 
@@ -802,13 +840,9 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	[Symbol.dispose](): void {
-		try {
-			this.webSocket.close();
-		} catch (e) {
-			this.logger.error(`Error closing websocket: ${e.message}`);
-		}
-	}
-
 	// #endregion Private Methods (11)
 }
+
+export namespace ISY {
+	export interface Config extends ISYConfig {}
+}