isy-nodejs 1.0.1-alpha.27 → 1.0.1-alpha.28

package/src/ISY.ts

@@ -4,34 +4,15 @@ import { writeFile } from 'fs';
 import { Parser, type ParserOptions } from 'xml2js';
 import { parseBooleans, parseNumbers } from 'xml2js/lib/processors.js';
 
-import axios from 'axios';
+import axios, { type AxiosRequestConfig } from 'axios';
 import { EventEmitter } from 'events';
-import { format, Logger, loggers } from 'winston';
-import { Category } from './Definitions/Global/Categories.js';
-import { Family } from './Definitions/Global/Families.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 { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { EventType } from './Events/EventType.js';
-import { NodeType, Props, States, VariableType } from './ISYConstants.js';
+import { VariableType } from './ISYConstants.js';
 import { type ISYDevice } from './ISYDevice.js';
 import { ISYNode } from './ISYNode.js';
 import { ISYScene } from './ISYScene.js';
@@ -46,39 +27,54 @@ import { NodeFactory } from './Devices/NodeFactory.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
-};
+
+class ISYError extends Error {
+	constructor(message: string)
+	constructor(error: Error)
+	constructor(messageOrError: string | Error) {
+		if(messageOrError instanceof Error) {
+			super(messageOrError.message);
+			this.stack = messageOrError.stack;
+			this.cause = messageOrError;
+			this.name = 'ISYError';
+
+		}
+		else if(typeof messageOrError === 'string') {
+			super(messageOrError);
+			this.name = 'ISYError';
+		}
+
+
+	}
+}
+
+class ISYNodeError extends ISYError {
+
+	constructor(message: string, node: ISYNode)
+	constructor(error:Error, node: ISYNode)
+	constructor(messageOrError: string | Error, node: ISYNode)
+	{
+		super(messageOrError as any);
+		this.name = 'ISYNodeError';
+		this.node = node;
+	}
+
+	node: ISYNode;
+}
+
+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,
@@ -132,6 +128,8 @@ interface ISYConfig {
 	protocol: 'http' | 'https';
 	username: string;
 
+	socketPath?: string;
+
 	// #endregion Properties (8)
 }
 
@@ -139,6 +137,7 @@ 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;
@@ -173,6 +172,21 @@ export class ISY extends EventEmitter implements Disposable {
 
 	public apiVersion: string;
 
+	socketPath: string;
+
+	public get axiosOptions():  AxiosRequestConfig
+	{
+		return {
+			baseURL: `${this.protocol}://${this.host}:${this.port}`,
+			auth: {
+				username: this.credentials.username,
+				password: this.credentials.password
+			},
+			socketPath: this.socketPath,
+			validateStatus: (status) => status >= 200 && status < 300,
+
+		}
+	}
 	// #endregion Properties (30)
 
 	// #region Constructors (1)
@@ -185,6 +199,7 @@ export class ISY extends EventEmitter implements Disposable {
 		this.displayNameFormat = config.displayNameFormat ?? '${location ?? folder} ${spokenName ?? name}';
 		this.host = config.host;
 		this.port = config.port;
+
 		this.credentials = {
 			username: config.username,
 			password: config.password
@@ -362,68 +377,80 @@ 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();
 			await this.loadVariables(VariableType.Integer);
 			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> {
@@ -452,27 +479,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}`))
@@ -502,40 +533,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) {
@@ -544,9 +546,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));
 	}
 
@@ -584,19 +584,24 @@ export class ISY extends EventEmitter implements Disposable {
 		options: {
 			parserOptions?: ParserOptions;
 			trailingSlash: boolean;
-			requestLogLevel?: any;
-			responseLogLevel?: any;
-			errorLogLevel?: 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 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(url,reqOps);
 			if (response.data) {
 				if (response.headers['content-type'].toString().includes('xml')) {
 					let curParser = parser;
@@ -606,18 +611,22 @@ export class ISY extends EventEmitter implements Disposable {
 					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) {
-			if (options.errorLogLevel) {
-				this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+			if (options.throwOnError) {
+				throw error;
 			} else {
-				this.logger.error(`Error sending request to ISY: ${error?.message}`);
+				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}`);
+				}
 			}
 		}
 	}
@@ -728,101 +737,113 @@ export class ISY extends EventEmitter implements Disposable {
 	} */
 
 	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);
-				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;
+		try {
+			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);
 					}
-					return acc;
-				}, {});
-				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.');
+					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;
+					}, {});
+					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.debug(`Loading Folder Node: ${JSON.stringify(folder)}`);
-				this.folderMap.set(folder.address, folder.name);
+		try {
+			this.logger.info('Loading 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');
 		}
 	}
 

package/src/ISYDevice.ts

@@ -1,8 +1,9 @@
 import type { Command } from './Definitions/Global/Commands.js';
 import type { Driver } from './Definitions/Global/Drivers.js';
 import type { UnitOfMeasure } from './Definitions/Global/UOM.js';
-import type { Family, ISY } from './ISY.js';
-import type {  ISYNode } from './ISYNode.js';
+import type { Family } from './Definitions/index.js';
+import type { ISY } from './ISY.js';
+import type { ISYNode } from './ISYNode.js';
 import type { ISYScene } from './ISYScene.js';
 import type { DriverState } from './Model/DriverState.js';
 import type { StringKeys } from './Utils.js';