loupedeck-commander 1.0.2 → 1.2.1

package/example/ExampleDeviceHandler.mjs

@@ -1,9 +1,8 @@
-import pkg from 'loupedeck'
+import { HAPTIC } from 'loupedeck'
 import { BaseLoupeDeckHandler } from '../common/BaseLoupeDeckHandler.mjs'
-const { HAPTIC } = pkg
 
 /**
- * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+* Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
  */
 export class ExampleDeviceHandler extends BaseLoupeDeckHandler {
   /**

package/example/example.mjs

@@ -2,12 +2,20 @@ import { ExampleDeviceHandler } from './ExampleDeviceHandler.mjs'
 
 const handler = new ExampleDeviceHandler('config.json')
 
-const stopHandler = () => {
-  console.log('Receiving SIGINT => Stopping processes.')
-  handler.stop()
+
+/**
+ * Stop the handlers when a signal like SIGINT or SIGTERM arrive
+ * @param {*} signal 
+ */
+const stopHandler = async(signal) =>  {
+  console.log(`Receiving ${signal} => Stopping processes.`)
+  await handler.stop()
 }
 
-// Initiating a process
-process.on('SIGINT', stopHandler)
+// Initiating the signal handlers:
+// see https://www.tutorialspoint.com/unix/unix-signals-traps.htm
+process.on('SIGINT', async (signal) => { stopHandler(signal) })
+process.on('SIGTERM', async (signal) => { stopHandler(signal) })
 
+// Initiating a process
 await handler.start()

package/interfaces/baseif.mjs

@@ -0,0 +1,68 @@
+import format from 'string-template'
+
+export class BaseIf {
+  formattedCommand
+  cmd
+  options
+  call (cmd, options = {}) {
+    var res = this.Check(options)
+    if (res < 0){
+      LogError("Missing essential options in dictionary => Quitting\n",res,options)
+      return false
+    }
+
+    this.cmd = cmd
+    this.options = options
+    this.formattedCommand = this.formatString(cmd, options)    
+    return this.formattedCommand
+  }
+
+  async stop (){
+    
+  }
+
+  formatString (cmd, options = {}) {
+    let f =""
+    try{
+      f = format(cmd, options)
+    }catch(e){}
+    return f
+  }
+
+  Check(options) {
+    if (!"id" in options)
+        return -1
+    if (!"key" in options)
+      return -2
+    if (!"state" in options)
+      return -3
+    if (!"min" in options)
+      return -4
+    if (!"max" in options)
+      return -5
+    if (!"color" in options)
+      return -6
+    if (!"image" in options)
+      return -7
+    return 0
+  }
+
+  LogError(...args){
+    let str = new String(args)
+    process.stderr.write(str.toString())
+}
+
+  LogDebug(...args){
+    if (this.options && this.options.verbose){
+      let str = new String(args)
+      process.stdout.write(str.toString())
+    }
+  }
+
+  LogInfo(...args){
+    let str = new String(args)
+    process.stdout.write(str.toString())
+  }
+}
+
+

package/interfaces/httpif.mjs

@@ -0,0 +1,81 @@
+import * as http from 'node:http'
+import url from 'node:url'
+import { BaseIf } from './baseif.mjs'
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class HTTPif extends BaseIf {
+  async call (url1, options = {}) {
+    url1 = super.call(url1, options)
+    let myURL
+    try {
+      myURL = new url.URL(url1)
+      await this.get(myURL, options)
+    } catch (e) {
+      this.LogError(`HTTPif: error with URL: ${e.message}\n`)
+      return false
+    }
+    return true
+  }
+
+  async stop(){
+    this.LogInfo("HTTPif: Stopping\n")
+    
+  }
+
+  Check(options) {
+    var res= super.Check(options)
+    if (res <0)
+        return res
+    if (!options.hostname)
+        return -21
+    return 0
+  }
+
+  /**
+   * Handle a HTTP Get request with Basic Authentification
+   * @param {*} myURL Uri
+   */
+  async get (myURL) {
+    const auth = 'Basic ' + Buffer.from(myURL.username + ':' + myURL.password).toString('base64')
+    const getOptions = {
+      hostname: myURL.hostname,
+      port: myURL.port,
+      path: myURL.pathname,
+      agent: false, // Create a new agent just for this one request
+      headers: {
+        Authorization: auth
+      }
+    }
+
+    this.LogInfo(`HTTPIf: call URL ${myURL} ${getOptions}\n`)
+    
+
+    const prom = new Promise((resolve, reject) => {
+      const req = http.get(getOptions, (response) => {
+        const chunksOfData = []
+
+        response.on('data', (fragments) => {
+          chunksOfData.push(fragments)
+        })
+
+        response.on('end', () => {
+          const responseBody = Buffer.concat(chunksOfData)
+          resolve(responseBody.toString())
+        })
+
+        response.on('error', (error) => {
+          resolve("")
+        })
+      })
+
+      req.on('error', (e) => {
+        this.LogError(`HTTPif: ignore other errors like ERRNOTCONNECTED: ${e.message}\n`)
+        return false
+      });
+    }).catch(function (error) { // (*)
+        return false
+    })
+  }
+}

package/interfaces/opcuaif.mjs

@@ -0,0 +1,283 @@
+import {
+    OPCUAClient,
+    MessageSecurityMode,
+    SecurityPolicy,
+    BrowseDirection,
+    AttributeIds,
+    NodeClassMask,
+    makeBrowsePath,
+    resolveNodeId,
+    TimestampsToReturn,
+    coerceInt32,
+    coerceByteString,
+    DataType
+} from "node-opcua";
+import { EventEmitter } from 'node:events'
+import { BaseIf } from './baseif.mjs'
+
+const subscriptionParameters = {
+    maxNotificationsPerPublish: 1000,
+    publishingEnabled: true,
+    requestedLifetimeCount: 100,
+    requestedMaxKeepAliveCount: 10,
+    requestedPublishingInterval: 1000
+};
+
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class OPCUAIf extends BaseIf {
+
+    #client
+    #session
+    #sub
+    #connected
+    #endpointurl
+    monitoreditems
+    buttons
+    #callback
+    myEmitter
+    constructor() {
+        super()
+        this.myEmitter = new EventEmitter();
+
+        this.LogInfo(`OPCUAIf Constructed`);
+      }
+
+    async stop(){
+        if (!this.#client)
+            return
+        
+        this.LogInfo(`OPCUAIf Stopping`)
+        await this.#client.closeSession(this.#session,true)
+        await this.#client.disconnect()
+        this.#connected = false
+        this.#client = null
+        this.LogInfo(`OPCUAIf Stopped\n`)
+    }
+
+    async init( options = {},config = {},callbackFunction){
+        var res = this.Check(options)
+        if (res<0){
+            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
+        }
+        try{
+            this.#endpointurl = options.endpointurl
+            this.#callback = callbackFunction
+            this.monitoreditems = {}
+            this.buttons = {}
+            this.LogInfo(`OPCUAIf init ${this.#endpointurl}\n`);
+        
+            await this.Connect(this.#endpointurl);
+
+            let field=config.touch.center
+            const keys = Object.keys(field)
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i]
+                const elem = config.touch.center[key]
+                if (elem.nodeid){
+                    let format = this.formatString(elem.nodeid,options)
+                    let monitoredItemId = await this.Subscribe(format)
+                    this.buttons[monitoredItemId] = i
+                }
+
+            }
+        } catch (error) {
+            this.LogError(`OPCUAIf: Error $error\n`)
+        }
+    }
+
+    async call (opcuaNode, options = {}) {
+        var res = this.Check(options)
+        if (res<0){
+            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
+            return false
+        }
+
+        var nodeId = super.formatString(opcuaNode, options)
+        var value = super.formatString(options.value, options)
+
+        this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
+        await this.Write(nodeId,value)
+
+        var NewState = "waiting"
+        return NewState
+    }
+
+    Check(options) {
+        var res= super.Check(options)
+        if (res <0)
+            return res
+        if (!options.endpointurl)
+            return -11
+        if (!options.nodeid)
+            return -12
+        if (!options.value)
+            return -13
+        return 0
+    }
+
+    async Disconnect() {
+        if (this.#client){
+            this.LogInfo(`OPCUAIf: Disconnect\n`);
+            await this.#client.Disconnect()
+            this.LogInfo(`OPCUAIf: Disconnected\n`);
+        }
+    }
+    async Connect(url) {
+        let self = this
+        this.#client = OPCUAClient.create({
+            applicationName: "NodeOPCUA-Client",
+    
+            endpointMustExist: false,
+            // keepSessionAlive: true,
+            requestedSessionTimeout: 60 * 1000,
+            securityMode: MessageSecurityMode.None,
+            securityPolicy: SecurityPolicy.None,
+            connectionStrategy: {
+                maxRetry: -1,
+                maxDelay: 5000,
+                initialDelay: 2500
+            },
+    
+            defaultSecureTokenLifetime: 20000,
+            tokenRenewalInterval: 1000
+        });
+    
+        this.#client.on("backoff", (retry, delay) => {
+            if((retry%10) == 0)
+                this.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}\n`);
+        });
+    
+        this.#client.on("connection_lost", () => {
+            this.LogInfo(`OPCUAIf: Connection lost\n`);
+        });
+    
+        this.#client.on("connection_reestablished", () => {
+            this.LogInfo(`OPCUAIf: Connection re-established\n`);
+        });
+    
+        this.#client.on("connection_failed", () => {
+            this.LogInfo(`OPCUAIf: Connection failed\n`);
+        });
+        this.#client.on("start_reconnection", () => {
+            this.LogInfo(`OPCUAIf: Starting reconnection\n`);
+        });
+    
+        this.#client.on("after_reconnection", (err) => {
+            this.LogInfo(`OPCUAIf: After Reconnection event => ${err}\n`);
+        });
+        this.#client.on("security_token_renewed", () => {
+            this.LogInfo(`OPCUAIf: security_token_renewed\n`);
+        })
+        this.#client.on("lifetime_75", (token) => {})
+    
+        this.LogInfo(`OPCUAIf: connecting client to ${url}\n`);//, this.#session.toString());
+        await this.#client.connect(url);
+    
+        this.#session = await this.#client.createSession();
+    
+        this.#session.on("session_closed", (statusCode) => {
+            this.LogInfo(`OPCUAIf: Session has been closed\n`);
+        })
+        this.#session.on("session_restored", () => {
+            this.LogInfo(`OPCUAIf: Session has been restored\n`);
+        });
+        this.#session.on("keepalive", (lastKnownServerState) => {
+            this.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}\n`);
+        });
+        this.#session.on("keepalive_failure", () => {
+            this.LogInfo(`OPCUAIf: KeepAlive failure\n`);
+        });
+    
+        this.#sub = await this.#session.createSubscription2({
+            maxNotificationsPerPublish: 9000,
+            publishingEnabled: true,
+            requestedLifetimeCount: 10,
+            requestedMaxKeepAliveCount: 10,
+            requestedPublishingInterval: 1000
+        });
+
+        this.LogInfo(`OPCUAIf: session created\n`);//, this.#session.toString());
+        this.LogInfo(`OPCUAIf: client\n`);
+        this.LogInfo(`OPCUAIf: subscription\n`);
+        this.#connected = true
+        this.#endpointurl = url
+    }
+    
+    async Subscribe(nodeID) {
+        // install monitored item
+        const itemToMonitor = {
+            nodeId: resolveNodeId(nodeID),
+            attributeId: AttributeIds.Value
+        };
+        const monitoringParameters = {
+            samplingInterval: 100,
+            discardOldest: true,
+            queueSize: 10
+        };
+    
+        if (!this.#sub){
+            this.LogError(`OPCUAIf: not register monitored items $itemToMonitor\n`);
+            return
+        }
+        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
+        var self=this
+        monitoredItem.on("changed", function (dataValue) {
+            var nodeId = self.monitoreditems[this.monitoredItemId]
+            var buttonID = self.buttons[this.monitoredItemId]
+            this.LogDebug("OPCUAIf: monitored item changed:  ", this.monitoredItemId,nodeId, dataValue.value.value,"\n");
+            self.myEmitter.emit('monitored item changed',buttonID,nodeId, dataValue.value.value)
+        });
+
+        return monitoredItem.monitoredItemId;
+    }
+    
+    async Read(nodeID) {
+        const nodeToRead = {
+            nodeId: nodeID,
+            attributeId: AttributeIds.Value
+        };
+        if (!this.#connected){
+            this.LogError(`OPCUAIf: not connected, cannot read ${nodeID}\n`);
+            return
+        }
+        const dataValue2 = await this.#session.read(nodeToRead, 0);
+        this.LogError("OPCUAIf: read nodeID ",nodeID, dataValue2.toString(),"\n");
+        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");
+            return
+        }
+        var nodesToWrite = [{
+            nodeId: nodeID,
+            attributeId: AttributeIds.Value,
+            indexRange: null,
+            value: { 
+                value: { 
+                    dataType: datatype,
+                    value: value
+                }
+          }
+        }];
+        await this.#session.write(nodesToWrite, function(err,statusCodes) {
+            if (!err) {              
+                if (statusCodes && statusCodes[0].value != 0){
+                    self.LogInfo(`OPCUAIf: status $statusCodes\n`);
+                }else{
+                    self.LogInfo(`OPCUAIf: wrote $nodeID => $value\n`);
+                }
+            }else{
+                self.LogError("OPCUAIf: write NOT ok",nodeID, value,"\n");
+                self.LogError(err)
+            }
+        });  
+    }
+}
+  

package/interfaces/shellif.mjs

@@ -0,0 +1,47 @@
+import { exec } from 'child_process'
+//import { exec } from 'node:child_process'
+import { BaseIf } from './baseif.mjs'
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class SHELLif extends BaseIf {
+  async call (cmd, options = {}) {
+    cmd = super.call(cmd, options)
+    return await this.sh(cmd)
+  }
+
+  async stop(){
+    this.LogInfo("SHELLif: Stopping")
+  }
+
+  Check(options) {
+    var res= super.Check(options)
+    if (res <0)
+        return res
+  }
+
+  /**
+   * Run a Shell command in ASYNC mode
+   * @param {*} cmd 
+   * @returns 
+   */
+  async sh (cmd) {
+    let self = this; 
+    this.LogDebug(`ShellIf: runCmd: ${cmd}\n`)
+    
+    return new Promise(function (resolve, reject) {
+      exec(cmd, (err, stdout, stderr) => {
+        if (stdout.length>0)
+          self.LogInfo(`SHELLif Out: ${stdout}`)
+        if (stderr.length>0)
+          self.LogError(`SHELLif Err: ${stderr}`)
+        if (err) {
+          reject(err)
+        } else {
+          resolve({ stdout, stderr })
+        }
+      })
+    })
+  }
+}

package/package.json

@@ -1,24 +1,19 @@
 {
   "name": "loupedeck-commander",
-  "version": "1.0.2",
-  "description": "A system to ease working with LoupeDeck devices using CMD-line interfaces",
+  "version": "1.2.1",
+  "description": "A system to ease working with LoupeDeck devices using CMD-line, OPC/UA or HTTP-client interfaces",
   "main": "index.mjs",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test.mjs",
+    "start": "node index.mjs"
   },
   "dependencies": {
     "canvas": "^2.11.2",
-    "loupedeck": "^4.3.0",
+    "loupedeck": "^6.0.1",
     "mkdirp": "^3.0.1",
+    "node-opcua": "^2.138.1",
     "string-template": "^1.0.0"
   },
-  "devDependencies": {
-    "eslint": "^8.53.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-n": "^16.3.1",
-    "eslint-plugin-promise": "^6.1.1"
-  },
   "author": "Thomas Schneider",
   "license": "MIT",
   "repository": {
@@ -27,5 +22,8 @@
   },
   "bugs": {
     "url": "https://gitlab.com/keckxde/loupedeck-commander/-/issues"
+  },
+  "devDependencies": {
+    "eslint": "^9.8.0"
   }
-}
+}