isy-nodejs 1.0.1-alpha.2 → 1.0.1-alpha.20

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -11,11 +11,11 @@ import internal from 'stream';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
 import { ISY, type Family, type ISYNode } from '../../ISY.js';
 import type { ISYDevice } from '../../ISYDevice.js';
-import { DeviceToClusterMap, MappingRegistry, type ClusterMapping } from '../../Model/ClusterMap.js';
+import { DeviceToClusterMap, MappingRegistry, type ClusterMapping, type BehaviorMapping } from '../../Model/ClusterMap.js';
 
 
 type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
-export class ISYBridgedDeviceBehavior extends Behavior {
+export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D extends ISYNode.DriverSignatures = ISYNode.DriverSignatures> extends Behavior {
 	static override readonly id = 'isyNode';
 
 	static override readonly early = true;
@@ -23,16 +23,24 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 	declare internal: ISYBridgedDeviceBehavior.Internal;
 	declare state: ISYBridgedDeviceBehavior.State;
 
-	declare events: ISYBridgedDeviceBehavior.Events;
+	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N["drivers"]>;
 
 	override async initialize(_options?: {}) {
 		await super.initialize(_options);
 		var address = this.state.address;
-		this.internal.device = ISY.instance.nodeMap.get(this.state.address);
-		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYDevice<Family, any, any, any>);
+		const d = ISY.instance.nodeMap.get(this.state.address);
+		this.internal.device = d;
+		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYNode<Family, any, any, any>);
 		ISY.instance.logger.debug(`Initializing ${this.constructor.name} for ${this.internal.device.constructor.name} ${this.internal.device.name} with address ${address}`);
-		if (this.internal.device) {
-			this.internal.device.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+		if (d) {
+			d.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+			for(const f in d.drivers)
+			{
+				let evt = `${d.drivers[f].name}Changed`;
+				this.events[evt] = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+				//@ts-ignore
+				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
+			}
 		}
 	}
 
@@ -44,15 +52,15 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 		return this.internal.map;
 	}
 
-	mapForBehavior<B extends { cluster: unknown }>(behavior: B): ClusterMapping<B['cluster'], typeof this.internal.device> {
-		return this.map[behavior.cluster['name']];
+	mapForBehavior<B extends ClusterBehavior>(behavior: B): BehaviorMapping<B, typeof this.internal.device> {
+		return this.map.mapping[behavior.cluster['name']];
 	}
 
 	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
 		this.events.propertyChanged.emit({ driver, newValue, oldValue, formattedValue });
 	}
 
-	[Symbol.asyncDispose]() {
+	override [Symbol.asyncDispose]() {
 		this.internal.device = null;
 		return super[Symbol.asyncDispose]();
 	}
@@ -64,8 +72,18 @@ export namespace ISYBridgedDeviceBehavior {
 		map?: DeviceToClusterMap<typeof this.device, any>;
 	}
 
-	export class Events extends EventEmitter {
+	export type EventsFor<D extends {[x: string]: Driver<any,any,any>}> = {
+		[s in keyof D as `${D[s]["name"]}Changed`] : Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
+	}
+
+
+
+
+	export class Events extends EventEmitter{
 		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+
+
+
 	}
 
 	export class State {

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -1,38 +1,50 @@
-import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
-
-import type { DriversOf, ISYNode } from '../../ISYNode.js';
-
 import type { Behavior } from '@project-chip/matter.js/behavior';
+import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
 import type { LevelControlBehavior } from '@project-chip/matter.js/behaviors/level-control';
 import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
 import type { Cluster, ClusterServerHandlers, ClusterType as CT } from '@project-chip/matter.js/cluster';
 import '@project-chip/matter.js/device';
 import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { DriverType } from '../../Definitions/Global/Drivers.js';
+import { Converter } from '../../Converters.js';
+import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import type { RelaxTypes } from '../../Devices/MapsTo.js';
 import { ISY, type ISYDevice } from '../../ISY.js';
-import { MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
-
+import type { DriversOf, ISYNode } from '../../ISYNode.js';
+import { BehaviorMapping, MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
 
-type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
+// #region Type aliases (6)
 
+export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
 export type ConstructedType<B extends Constructor<any>> = B extends Constructor<infer C> ? C : never;
+// <reference path="MatterDevice.js" />
+// @ts-ignore
+export type DeviceBehavior<P extends ISYNode, T extends { cluster? }> = {
+	device: P;
 
-export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
+	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
-type t = ClusterForBehavior<LevelControlBehavior>;
+	//ts-ignore
+	map: BehaviorMapping<T, P>;
 
+	handlePropertyChange(chg: PropertyChange<P>): void;
+};
+type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
 export type PropertyChange<P extends ISYNode<any, any, any, any>> = {
 	driver: keyof DriversOf<P>;
 	newValue: any;
 	oldValue: any;
 	formattedValue: string;
 };
+type t = ClusterForBehavior<LevelControlBehavior>;
+
+// #endregion Type aliases (6)
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+// #region Functions (1)
+
+export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster }, P extends ISYNode<any, any, any, any>>(
 	base: T,
 	p: Constructor<P>
 ): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } {
@@ -41,30 +53,44 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 
 		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
 
+		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
 
-		map: ClusterMapping<T['cluster'], P>;
+		map: BehaviorMapping<T, P>;
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
-			var behavior = await this.agent.load(ISYBridgedDeviceBehavior);
+			var behavior = (await this.agent.load(ISYBridgedDeviceBehavior)) as ISYBridgedDeviceBehavior<P>;
+			this.bridgedDeviceBehavior = behavior;
 			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
 			this._device = behavior.device as P;
+			//@ts-ignore
 			this.map = behavior.mapForBehavior<T>(this as unknown as T);
 			for (const key2 in this.map.attributes) {
-				if (typeof this.map.attributes[key2] === 'string') {
-					this.handlers[this.map.attributes[key2]] = (newValue, oldValue, formattedValue) => {
+				let val = this.map.attributes[key2];
+				let driverObj = null;
+				if (typeof val === 'string' || typeof val === 'symbol' || typeof val === 'number') {
+					driverObj = this._device.drivers[val];
+					this.handlers[val] = (newValue, oldValue, formattedValue) => {
 						this.state[key2 as string] = newValue;
 					};
-				} else if (this.map.attributes[key2].driver) {
-					let { driver, converter } = this.map.attributes[key2];
+				} else if (val.driver as DriversOf<P>) {
+					driverObj = this._device.drivers[val.driver as string];
+
+					let { driver, converter } = val;
+					const convFunc = Converter.get(converter)?.from;
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
-						this.state[key2 as string] = converter(newValue);
+						if (convFunc) this.state[key2 as string] = convFunc(newValue);
+						else this.state[key2 as string] = newValue;
 					};
 				}
+				if (driverObj) {
+					let evt = `${driverObj.name}Changed`;
+					this.reactTo(behavior.events[evt], this.handlePropertyChange.bind(this), { lock: false });
+				}
 			}
 
-			this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
+			//this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
 
 			//this._device.on("PropertyChanged", this.handlePropertyChange.bind(this));
 		}
@@ -95,13 +121,5 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 		}
 	};
 }
-// <reference path="MatterDevice.js" />
-// @ts-ignore
-
-export type DeviceBehavior<P extends ISYNode, T extends { cluster }> = {
-	device: P;
 
-	map: ClusterMapping<T['cluster'], P>;
-
-	handlePropertyChange(chg: PropertyChange<P>): void;
-};
+// #endregion Functions (1)

package/src/Matter/Behaviors/ISYOnOffBehavior.ts

@@ -1,80 +1,66 @@
-import { InsteonRelayDevice } from "../../Devices/Insteon/InsteonRelayDevice.js"
-import { OnOffLightRequirements } from "@project-chip/matter.js/devices/OnOffLightDevice";
-import { ISYClusterBehavior, ClusterForBehavior, type PropertyChange } from "./ISYClusterBehavior.js";
+import type { LevelControlInterface, LevelControlServer } from '@project-chip/matter.js/behaviors/level-control';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
+import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
 import { OnOffLightSwitchDevice } from '@project-chip/matter.js/devices/OnOffLightSwitchDevice';
 import type { MaybePromise } from '@project-chip/matter.js/util';
-import { MappingRegistry } from '../../Model/ClusterMap.js';
-import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
-import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
-import type { LevelControlServer, LevelControlInterface } from '@project-chip/matter.js/behaviors/level-control';
 import { DriverType } from '../../Definitions/Global/Drivers.js';
-import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
 import { InsteonDimmableDevice } from '../../Devices/Insteon/InsteonDimmableDevice.js';
+import { InsteonRelayDevice } from '../../Devices/Insteon/InsteonRelayDevice.js';
+import { MappingRegistry } from '../../Model/ClusterMap.js';
+import { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from './ISYClusterBehavior.js';
 
-import {Converters} from '../../Converters.js';
-
-
-
-
-
-export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice)
-{
-
-    override async initialize(_options?: {}) {
-        await super.initialize(_options);
-        //this.state.onOff = await this.device.state;
-
-
-
-    }
-
-
-  override on = async () => {
-    await super.on();
-
+import { Converter } from '../../Converters.js';
 
-     //this.device.commands.DON = true;
-  }
+export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		//this.state.onOff = await this.device.state;
+	}
 
-  override async off() {
-    //await super.off();
-    // this.device.drivers = false;
-  }
+	override on = async () => {
+		await super.on();
+		await this.device.on();
 
-  override toggle =  async () => {
-    //this.device.state = !(await this.device.state);
-  }
+		//this.device.commands.DON = true;
+	};
 
-  override async handlePropertyChange({driver, newValue, oldValue, formattedValue}: PropertyChange<InsteonRelayDevice>) {
-    if (driver === "ST") {
-      this.state.onOff = newValue;
+	override async off() {
+		await super.off();
+		await this.device.off();
 
-    }
+		// this.device.drivers = false;
+	}
 
-    return super.handlePropertyChange({driver, newValue, oldValue, formattedValue});
-  }
+	override toggle = async () => {
+		//this.device.state = !(await this.device.state);
+	};
 
+	override async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<InsteonRelayDevice>) {
+		/*if (driver === 'ST') {
+			this.state.onOff = newValue;
+		}*/
 
+		return super.handlePropertyChange({ driver, newValue, oldValue, formattedValue });
+	}
 }
 
-
 export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, InsteonDimmableDevice) {
-  override async initialize(_options?: {}) {
-    await super.initialize(_options);
-    this.state.currentLevel = this.device.drivers.ST.value;
-    //this.state.onLevel = this.device.drivers.OL;
-
-  }
-
-  override setLevel(level: number): MaybePromise<void> {
-    level = Converters.Matter.LevelFrom0To255.LightingLevel.to(level);
-    if(level > 0)
-    {
-        return this.device.sendCommand('DON',level);
-    }
-    else
-    {
-        return this.device.sendCommand('DOF');
-    }
-  }
-}
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		/*this.state.onLevel = Converter.get('Level255toZero.LightingLevel').to(this.device.drivers.OL)*/
+		//this.state.currentLevel = this.device.drivers.ST.value;
+
+		//this.state.onLevel = this.device.drivers.OL;
+	}
+
+	override setLevel(level: number): MaybePromise<void> {
+		level = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
+		if (level > 0) {
+			return this.device.sendCommand('DON', level);
+		} else {
+			return this.device.sendCommand('DOF');
+		}
+	}
+}

package/src/Matter/{Server → Bridge}/Server.ts

@@ -1,54 +1,79 @@
+import '@project-chip/matter-node.js';
 import { NodeJsEnvironment } from '@project-chip/matter-node.js/environment';
 import { StorageBackendDisk } from '@project-chip/matter-node.js/storage';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
 import { VendorId } from '@project-chip/matter.js/datatype';
-import { logEndpoint, OnOffBaseDevice } from '@project-chip/matter.js/device';
+import { logEndpoint } from '@project-chip/matter.js/device';
 import { Endpoint, EndpointServer } from '@project-chip/matter.js/endpoint';
 import { DimmableLightDevice, OnOffLightDevice } from '@project-chip/matter.js/endpoint/definitions';
 import type { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
-import { EndpointType, MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
+import { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
 import { AggregatorEndpoint } from '@project-chip/matter.js/endpoints/AggregatorEndpoint';
-import { Environment, StorageService } from '@project-chip/matter.js/environment';
+import { StorageService } from '@project-chip/matter.js/environment';
 import { Level, levelFromString, Logger as MatterLogger } from '@project-chip/matter.js/log';
 import { ServerNode } from '@project-chip/matter.js/node';
+//@ts-ignore
+import PackageJson from '@project-chip/matter.js/package.json' with { type: 'json' };
 import { QrCode } from '@project-chip/matter.js/schema';
-import { resolve } from 'path';
-import { config } from 'winston';
+import path, { resolve } from 'path';
+import { format, loggers } from 'winston';
+import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
 import { InsteonDimmableDevice, InsteonKeypadButtonDevice, InsteonRelayDevice, ISY } from '../../ISY.js';
 import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.js';
 import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/ISYOnOffBehavior.js';
+import '../Mappings/Insteon.js';
 
-// #region Functions (2)
+// #region Interfaces (1)
 
-//import {clone} from 'isy-nodejs/Utils';
-//let { Utils } = await import ('isy-nodejs');
+export let instance: ServerNode;
 
-// function plainLogFormatter(now: Date, level: Level, facility: string, prefix: string, values: any[]) {
-//     const creator = plaintextCreator();
+//@ts-ignore
+export let version: string = PackageJson.version;
+export interface Config {
+	// #region Properties (8)
 
-//     const formattedValues = renderDiagnostic(values, {
-//         ...creator,
-//         key: text => creator.text(`${text}: `),
-//         value: producer => creator.text(producer()),
-//         strong: producer => creator.text(`*${producer()}*`),
-//         weak: producer => creator.text(producer()),
-//         status: (status, producer) => `${creator.text(statusIcon(status))}${producer()}`,
-//         via: text => creator.text(text),
-//     });
+	discriminator: number;
+	passcode: number;
+	port: number;
+	productId: number;
+	productName?: string;
+	uniqueId: string;
+	vendorId: number;
+	vendorName?: string;
 
-//     return `${formatTime(now)} ${Level[level]} ${facility} ${prefix}${formattedValues}`;
-//
+	// #endregion Properties (8)
+}
 
-//let matterLogger = clone(logger,'matter.js');
+// #endregion Interfaces (1)
 
-//2024-07-03 16:30:43.693
-export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerNode> {
-	var logger = isy.logger;
+// #region Functions (3)
+
+export function create(isy?: ISY, config?: Config): Promise<ServerNode> {
+	return createMatterServer(isy, config);
+}
+
+export async function createMatterServer(isy?: ISY, config?: Config): Promise<ServerNode> {
+	var logger = loggers.add('matter', {
+		transports: isy.logger.transports,
+		levels: isy.logger.levels,
+		format: format.label({ label: 'Matter' })
+	});
+	if (isy === undefined) {
+		isy = ISY.instance;
+	}
 
 	try {
 		MatterLogger.addLogger(
 			'polyLogger',
-			(level, message) => logger.log(Level[level].toLowerCase().replace('notice', 'info'), message.slice(23).remove(Level[level]).trimStart()) /*Preserve existing formatting, but trim off date*/,
+			(lvl, message) => {
+				let msg = message.slice(23).remove(Level[lvl]).trimStart();
+				let level = Level[lvl].toLowerCase().replace('notice', 'info');
+				if (msg.startsWith('EndpointStructureLogger')) {
+					if (lvl === Level.INFO) level = 'debug';
+				}
+				logger.log(level, msg);
+			},
+			/*Preserve existing formatting, but trim off date*/
 			{
 				defaultLogLevel: levelFromString(logger.level),
 				logFormat: 'plain'
@@ -58,11 +83,11 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 		MatterLogger.defaultLogLevel = levelFromString(logger.level);
 	}
 
-	var config = await getConfiguration(isy);
+	config = await initializeConfiguration(isy, config);
 
 	logger.info(`Matter config read: ${JSON.stringify(config)}`);
-
-	const server = await ServerNode.create({
+	MatterLogger.removeLogger('default');
+	let server = await ServerNode.create({
 		// Required: Give the Node a unique ID which is used to store the state of this node
 		id: config.uniqueId,
 
@@ -70,6 +95,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 		// Optional when operating only one device on a host, Default port is 5540
 		network: {
 			port: config.port,
+
 			//ipv4: false,
 			discoveryCapabilities: {
 				onIpNetwork: true
@@ -124,7 +150,8 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 
 	const endpoints: { 0: Endpoint; 1: InsteonRelayDevice }[] = [];
 
-	for (const device of isy.deviceList.values()) {
+	for (const node of isy.nodeMap.values()) {
+		let device = node as ISYDeviceNode<any, any, any>;
 		let serialNumber = `${device.address.replaceAll(' ', '_').replaceAll('.', '_')}`;
 		if (device.enabled && !(device instanceof InsteonKeypadButtonDevice)) {
 			//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
@@ -147,6 +174,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 			}
 
 			if (baseBehavior !== undefined) {
+				//@ts-ignore
 				const endpoint = new Endpoint(baseBehavior, {
 					id: serialNumber,
 					isyNode: {
@@ -192,7 +220,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 	 */
 
 	logger.info('Bringing server online');
-	await server.bringOnline();
+	await server.start();
 
 	logger.info('Matter Server is online');
 	/**
@@ -206,44 +234,44 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 	// logEndpoint(EndpointServer.forEndpoint(server), {logAttributePrimitiveValues: true, logAttributeObjectValues: true});
 	//else if(logger.isDebugEnabled())
 	// {
-	logEndpoint(EndpointServer.forEndpoint(server), { logAttributePrimitiveValues: true, logAttributeObjectValues: false });
+	logEndpoint(EndpointServer.forEndpoint(server), { logAttributePrimitiveValues: true, logAttributeObjectValues: false, logClusterGlobalAttributes: false });
 	// }
 	if (server.lifecycle.isOnline) {
 		const { qrPairingCode, manualPairingCode } = server.state.commissioning.pairingCodes;
 
-		logger.info(QrCode.get(qrPairingCode));
+		logger.info('\n' + QrCode.get(qrPairingCode));
 		logger.info(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
 		logger.info(`Manual pairing code: ${manualPairingCode}`);
 	}
 	/*for(let e of endpoints)
-    {
-      e[1].initialize(e[0] as any);
-    }*/
-
+	{
+	  e[1].initialize(e[0] as any);
+	}*/
+	instance = server;
 	return server;
+}
 
-	function createBaseBehavior(): any {
-		let baseBehavior: any;
-		return baseBehavior;
-	}
+type PairingCodeData = {
+	qrPairingCode: string;
+	manualPairingCode: string;
+	renderedQrPairingCode: string;
+	url: string | URL;
+};
+
+export function getPairingCode(server: ServerNode = instance): PairingCodeData {
+	let codes = server.state.commissioning.pairingCodes as PairingCodeData;
+	codes.renderedQrPairingCode = QrCode.get(codes.qrPairingCode);
+	codes.url = `https://project-chip.github.io/connectedhomeip/qrcode.html?data=${codes.qrPairingCode}`;
+	return codes;
 }
 
-async function getConfiguration(isy: ISY) {
+async function initializeConfiguration(isy: ISY, config?: Config): Promise<Config> {
 	var logger = isy.logger;
-	/**
-	 * Collect all needed data
-	 *
-	 * This block collects all needed data from cli, environment or storage. Replace this with where ever your data come from.
-	 *
-	 * Note: This example uses the matter.js process storage system to store the device parameter data for convenience
-	 * and easy reuse. When you also do that be careful to not overlap with Matter-Server own storage contexts
-	 * (so maybe better not do it ;-)).
-	 */
 
 	const environment = NodeJsEnvironment();
 
 	const storageService = environment.get(StorageService);
-	environment.vars.set('storage.path', ISY.instance.storagePath + '/matter');
+	environment.vars.set('storage.path', path.resolve(isy.storagePath, 'matter'));
 	environment.vars.use(() => {
 		const location = environment.vars.get('storage.path', environment.vars.get('path.root', '.'));
 		storageService.location = location;
@@ -254,15 +282,15 @@ async function getConfiguration(isy: ISY) {
 	const deviceStorage = (await storageService.open('device')).createContext('data');
 
 	const vendorName = isy.vendorName;
-	const passcode = environment.vars.number('passcode') ?? (await deviceStorage.get('passcode', 20202021));
-	const discriminator = environment.vars.number('discriminator') ?? (await deviceStorage.get('discriminator', 3840));
+	const passcode = config.passcode ?? environment.vars.number('passcode') ?? (await deviceStorage.get('passcode', 20202021));
+	const discriminator = config.discriminator ?? environment.vars.number('discriminator') ?? (await deviceStorage.get('discriminator', 3840));
 	// product name / id and vendor id should match what is in the device certificate
-	const vendorId = environment.vars.number('vendorid') ?? (await deviceStorage.get('vendorid', 0xfff1));
-	const productId = environment.vars.number('productid') ?? (await deviceStorage.get('productid', 0x8000));
+	const vendorId = config.vendorId ?? environment.vars.number('vendorid') ?? (await deviceStorage.get('vendorid', 0xfff1));
+	const productId = config.productId ?? environment.vars.number('productid') ?? (await deviceStorage.get('productid', 0x8000));
 	const productName = isy.productName;
-	const port = environment.vars.number('port') ?? 5540;
+	const port = config.port ?? environment.vars.number('port') ?? 5540;
 
-	const uniqueId = isy.id;
+	const uniqueId = isy.id.replaceAll(':', '_');
 	//environment.vars.string("uniqueid") ?? (await deviceStorage.get("uniqueid", Time.nowMs().toString()));
 
 	// Persist basic data to keep them also on restart
@@ -287,4 +315,4 @@ async function getConfiguration(isy: ISY) {
 	};
 }
 
-// #endregion Functions (2)
+// #endregion Functions (3)