loupedeck-commander 1.5.0 → 1.5.1

package/common/button.mjs

@@ -40,12 +40,7 @@ export class Button {
     this.#keys = []
 
     this.id = id
-    //this.#index = 0
-    //this.#enforcedIndex = -1
-    //this.#enforcedBlink = false
-
-    // console.info(`  Button ${id.padEnd(10, ' ')} Size: ${width} x ${height}`)
-
+    
     this.#profile = profile
     this.#params = {
       "key": key,
@@ -338,7 +333,7 @@ export class Button {
     this.#index++
 
     if (this.#enforcedIndex >= 0 && this.#index != this.#enforcedIndex) {
-      console.log("Enforced Index", this.#enforcedIndex)
+      console.log(`${this.id}: Enforced Index Change from ${this.#index} -> ${this.#enforcedIndex}`)
       this.#index = this.#enforcedIndex
     }
 
@@ -382,7 +377,7 @@ export class Button {
 
     if (this.#enforcedIndex >= 0 && this.#enforcedIndex != this.#index) {
       // If we have an enforced index, we set it to the enforced index:
-      console.log("Enforcing Index", this.#enforcedIndex, "instead of", this.#index)
+      console.log(`${this.id}: Enforced Index Change from ${this.#index} -> ${this.#enforcedIndex}`)
       this.#index = this.#enforcedIndex
     }
 
@@ -437,10 +432,10 @@ export class Button {
         let valStr = val.toString()
         // check if the state-name is same as the value we get from outside:
         if (valStr == stateStr) {
-          //if (i !== this.#index) {
-          //console.info("enforce State index", this.id, nodeid, val, i)
-          this.#enforcedIndex = i;
-          //}
+          if (i !== this.#index) {
+            console.log(`${this.id} - enforced Index change from ${this.#index} -> ${this.#enforcedIndex} (State Changed) in ${nodeid}`)
+            this.#enforcedIndex = i;
+          }
           break;
         }
       }
@@ -448,8 +443,6 @@ export class Button {
       this.#index = this.#enforcedIndex;
       this.inversed = false
       this.pressActive = false
-      //console.info("enforce State index", this.id, nodeid, val, i)
-      //this.#enforcedIndex = this.#index;
     }
 
 

package/common/logger.mjs

@@ -0,0 +1,19 @@
+// logger.js
+const originalLog = console.log;
+const originalInfo = console.info;
+const originalError = console.error;
+
+console.log = (...args) => {
+    const timestamp = new Date().toISOString(); // Format: 2026-05-18T14:55:00.000Z
+    originalLog(`${timestamp} [INF]`, ...args);
+};
+
+console.info = (...args) => {
+    const timestamp = new Date().toISOString(); // Format: 2026-05-18T14:55:00.000Z
+    originalInfo(`${timestamp} [INF]`, ...args);
+};
+
+console.error = (...args) => {
+    const timestamp = new Date().toISOString(); // Format: 2026-05-18T14:55:00.000Z
+    originalError(`${timestamp} [ERR]`, ...args);
+};

package/common/main.cjs

@@ -1,4 +1,5 @@
 // index.cjs
+require('./logger.mjs'); // Aktiviert den Wrapper global
 const { hostname } = require('os')
 let config = ''
 var myHost = hostname();

package/interfaces/baseif.mjs

@@ -51,20 +51,17 @@ export class BaseIf extends EventEmitter {
   }
 
   LogError(...args){
-    let str = new String(args)
-    process.stderr.write(str.toString())
+    console.error(...args)
 }
 
   LogDebug(...args){
     if (this.options && this.options.verbose){
-      let str = args.join(' ')
-      process.stdout.write(str.toString())
+      console.log(...args)
     }
   }
 
   LogInfo(...args){
-    let str = new String(args)
-    process.stdout.write(str.toString())
+    console.info(...args)
   }
 }
 

package/interfaces/opcuaif.mjs

@@ -40,7 +40,7 @@ export class OPCUAIf extends BaseIf {
     async init(options = {}, config = {}) {
         var res = this.Check(options)
         if (res < 0) {
-            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
+            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options`)
         }
         try {
             this.#endpointurl = this.formatString(options.endpointurl, options)
@@ -48,19 +48,19 @@ export class OPCUAIf extends BaseIf {
                 this.#publishingInterval = options.publishingInterval
             else {
                 this.#publishingInterval = 250;
-                this.LogInfo(`OPCUAIf init using default publishingInterval: ${this.#publishingInterval}ms\n`);
+                this.LogInfo(`OPCUAIf init using default publishingInterval: ${this.#publishingInterval}ms`);
             }
             if (options.samplingInterval)
                 this.#samplingInterval = options.samplingInterval
             else {
                 this.#samplingInterval = 100;
-                this.LogInfo(`OPCUAIf init using default samplingInterval: ${this.#samplingInterval}ms\n`);
+                this.LogInfo(`OPCUAIf init using default samplingInterval: ${this.#samplingInterval}ms`);
             }
             this.options = options
             this.monitoreditems = {}
             this.types = {}
             this.buttons = {}
-            this.LogInfo(`OPCUAIf init ${this.#endpointurl}\n`);
+            this.LogInfo(`OPCUAIf init ${this.#endpointurl}`);
 
             await this.Connect(this.#endpointurl);
 
@@ -131,7 +131,7 @@ export class OPCUAIf extends BaseIf {
                 }
             }
         } catch (error) {
-            this.LogError(`OPCUAIf: Error\n`, error)
+            this.LogError(`OPCUAIf: Error`, error)
         }
     }
 
@@ -192,7 +192,7 @@ export class OPCUAIf extends BaseIf {
     async call(opcuaNode, options = {}) {
         var res = this.Check(options)
         if (res < 0) {
-            //            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
+            //            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res`)
             return false
         }
 
@@ -213,7 +213,7 @@ export class OPCUAIf extends BaseIf {
             value = super.formatString(options.value, options)
 
         var convertedValue = this.convert(value, type)
-        //this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
+        //this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}`)
         await this.Write(nodeId, convertedValue, type)
 
         var NewState = "waiting"
@@ -223,23 +223,23 @@ export class OPCUAIf extends BaseIf {
     Check(options) {
         var res = super.Check(options)
         if (res < 0) {
-            this.LogError(`OPCUAIf: mandatory parameter missing\n`)
+            this.LogError(`OPCUAIf: mandatory parameter missing`)
             return res
         }
         if (!"endpointurl" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter endpointurl missing\n`)
+            this.LogError(`OPCUAIf: mandatory parameter endpointurl missing`)
             return -11
         }
         if (!"publishingInterval" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter publishingInterval missing\n`)
+            this.LogError(`OPCUAIf: mandatory parameter publishingInterval missing`)
             return -11
         }
         if (!"nodeid" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter nodeid missing\n`)
+            this.LogError(`OPCUAIf: mandatory parameter nodeid missing`)
             return -12
         }
         if (!"value" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter value missing\n`)
+            this.LogError(`OPCUAIf: mandatory parameter value missing`)
             return -13
         }
         return 0
@@ -254,7 +254,7 @@ export class OPCUAIf extends BaseIf {
         if (!this.#client)
             return
         await this.Disconnect()
-        this.LogInfo(`OPCUAIf Stopped\n`)
+        this.LogInfo(`OPCUAIf Stopped`)
     }
 
     /**
@@ -292,55 +292,56 @@ export class OPCUAIf extends BaseIf {
                 initialDelay: 2500
             },
             keepPendingSessionsOnDisconnect: true,
-            defaultSecureTokenLifetime: 20000,
-            tokenRenewalInterval: 1000
+            defaultSecureTokenLifetime: 100000,
+//            tokenRenewalInterval: 1000
         });
 
 
         this.#client.on("backoff", (retry, delay) => {
+            self.LogInfo(`🔄 OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}`);
             //if ((retry % 10) == 0)
-            //    self.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}\n`);
+            //    self.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}`);
         });
 
         this.#client.on("connection_lost", () => {
-            self.LogInfo(`OPCUAIf: Connection lost\n`);
+            self.LogError(`OPCUAIf: Connection lost`);
         });
 
         this.#client.on("connection_reestablished", () => {
-            self.LogInfo(`OPCUAIf: Connection re-established\n`);
+            self.LogInfo(`OPCUAIf: Connection re-established`);
         });
 
         this.#client.on("connection_failed", () => {
-            self.LogInfo(`OPCUAIf: Connection failed\n`);
+            self.LogError(`OPCUAIf: Connection failed`);
         });
         this.#client.on("start_reconnection", () => {
-            self.LogInfo(`OPCUAIf: Starting reconnection\n`);
+            self.LogInfo(`OPCUAIf: Starting reconnection`);
         });
 
         this.#client.on("after_reconnection", (err) => {
-            self.LogInfo(`OPCUAIf: After Reconnection event => ${err}\n`);
+            self.LogInfo(`OPCUAIf: After Reconnection event => ${err}`);
         });
         /*this.#client.on("security_token_renewed", () => {
-            self.LogDebug(`OPCUAIf: security_token_renewed\n`);
+            self.LogDebug(`OPCUAIf: security_token_renewed`);
         })*/
         this.#client.on("lifetime_75", (token) => { })
 
-        this.LogInfo(`OPCUAIf: connecting client to ${url}\n`);//, this.#session.toString());
+        this.LogInfo(`OPCUAIf: connecting client to ${url}`);//, this.#session.toString());
         await this.#client.connect(url);
 
         this.#session = await this.#client.createSession();
 
         this.#session.on("session_closed", (statusCode) => {
-            //self.LogInfo(`OPCUAIf: Session has been closed\n`);
+            //self.LogInfo(`OPCUAIf: Session has been closed`);
         })
         this.#session.on("session_restored", () => {
-            //self.LogInfo(`OPCUAIf: Session has been restored\n`);
+            //self.LogInfo(`OPCUAIf: Session has been restored`);
         });
         this.#session.on("keepalive", (lastKnownServerState) => {
-            self.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}\n`);
+            self.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}`);
         });
         this.#session.on("keepalive_failure", () => {
-            self.LogInfo(`OPCUAIf: KeepAlive failure\n`);
+            self.LogError(`OPCUAIf: KeepAlive failure`);
         });
 
         // create subscription with a custom publishing interval:
@@ -352,9 +353,9 @@ export class OPCUAIf extends BaseIf {
             requestedPublishingInterval: this.#publishingInterval
         });
 
-        this.LogInfo(`OPCUAIf: session created\n`);
-        //        this.LogInfo(`OPCUAIf: client\n`);
-        //        this.LogInfo(`OPCUAIf: subscription\n`);
+        this.LogInfo(`OPCUAIf: session created`);
+        //        this.LogInfo(`OPCUAIf: client`);
+        //        this.LogInfo(`OPCUAIf: subscription`);
         this.#connected = true
         this.#endpointurl = url
     }
@@ -407,15 +408,15 @@ export class OPCUAIf extends BaseIf {
         };
 
         if (!this.#sub) {
-            this.LogError(`OPCUAIf: no subscription - don't register monitored items $itemToMonitor\n`);
+            this.LogError(`OPCUAIf: no subscription - don't register monitored items $itemToMonitor`);
             return
         }
         const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
         this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
         if (monitoredItem.monitoredItemId === undefined) {
-            this.LogError(`OPCUAIf: Error subscribing to node ${nodeID} (attribute ${attribute})\n`)
+            this.LogError(`OPCUAIf: Error subscribing to node ${nodeID} (attribute ${attribute})`)
         } else {
-            this.LogDebug(`OPCUAIf: Subscribe to ${monitoredItem.monitoredItemId},${nodeID},(attribute ${attribute})\n`);
+            this.LogDebug(`OPCUAIf: Subscribe to ${monitoredItem.monitoredItemId},${nodeID},(attribute ${attribute})`);
         }
 
         var self = this
@@ -432,7 +433,7 @@ export class OPCUAIf extends BaseIf {
                 list.push(`${buttonInfo.buttonID}:${buttonInfo.attribute}`)
                 self.emit('monitored item changed', buttonInfo.buttonID, buttonInfo.attribute, nodeId, dataValue.value.value)
             }
-            self.LogInfo(`OPCUAIf: monitored item ${nodeId} changed value: ${dataValue.value.value} - push to buttons: ${list.join(', ')}\n`);
+            self.LogInfo(`OPCUAIf: monitored item ${nodeId} changed value: ${dataValue.value.value} - push to buttons: ${list.join(', ')}`);
         });
 
         return monitoredItem.monitoredItemId;
@@ -444,18 +445,18 @@ export class OPCUAIf extends BaseIf {
             attributeId: AttributeIds.Value
         };
         if (!this.#connected) {
-            this.LogError(`OPCUAIf: not connected, cannot read ${nodeID}\n`);
+            this.LogError(`OPCUAIf: not connected, cannot read ${nodeID}`);
             return
         }
         const dataValue2 = await this.#session.read(nodeToRead, 0);
-        this.LogError("OPCUAIf: read nodeID ", nodeID, dataValue2.toString(), "\n");
+        this.LogDebug("OPCUAIf: read nodeID ", nodeID, dataValue2.toString(), "");
         return dataValue2
     }
 
     async Write(nodeID, value, datatype = DataType.String) {
         let self = this
         if (!this.#connected) {
-            self.LogError("OPCUAIf: not connected, cannot write", nodeID, value, "\n");
+            self.LogError("OPCUAIf: not connected, cannot write", nodeID, value, "");
             return
         }
         var nodesToWrite = [{
@@ -473,16 +474,16 @@ export class OPCUAIf extends BaseIf {
             await this.#session.write(nodesToWrite, function (err, statusCodes) {
                 if (!err) {
                     if (statusCodes && statusCodes[0].value != 0) {
-                        self.LogInfo(`OPCUAIf: error with Node: "${nodeID}", status ${statusCodes[0]}\n`);
+                        self.LogInfo(`OPCUAIf: error with Node: "${nodeID}", status ${statusCodes[0]}`);
                     } else {
-                        self.LogInfo(`OPCUAIf: wrote ${nodeID} => ${value}\n`);
+                        self.LogInfo(`OPCUAIf: wrote ${nodeID} => ${value}`);
                     }
                 } else {
-                    self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
+                    self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}`);
                 }
             });
         } catch (err) {
-            self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
+            self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}`);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loupedeck-commander",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "A system to ease working with LoupeDeck devices using CMD-line, OPC/UA or HTTP-client interfaces",
   "main": "common/main.cjs",
   "scripts": {
@@ -14,10 +14,10 @@
     "json5": "^2.2.3",
     "loupedeck": "^7.0.3",
     "mkdirp": "^3.0.1",
-    "node-opcua": "^2.169.0",
+    "node-opcua": "^2.171.0",
     "postject": "^1.0.0-alpha.6",
     "string-template": "^1.0.0",
-    "yaml": "^2.8.3"
+    "yaml": "^2.9.0"
   },
   "author": "Thomas Schneider",
   "license": "Apache-2.0",