loupedeck-commander 1.0.1 → 1.2.0

package/config-test.json

@@ -0,0 +1,9 @@
+{
+    "application": "TEST",
+    "profiles": [
+        {
+            "name": "profile1",
+            "file": "profile-2.json"
+        }
+    ]
+}

package/eslint.config.mjs

@@ -0,0 +1,9 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  {languageOptions: { globals: globals.browser }},
+  pluginJs.configs.recommended,
+];

package/{ExampleDeviceHandler.mjs → example/ExampleDeviceHandler.mjs}

@@ -1,9 +1,8 @@
-import pkg from 'loupedeck'
-import { BaseLoupeDeckHandler } from './common/BaseLoupeDeckHandler.mjs'
-const { HAPTIC } = pkg
+import { HAPTIC } from 'loupedeck'
+import { BaseLoupeDeckHandler } from '../common/BaseLoupeDeckHandler.mjs'
 
 /**
- * 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

@@ -0,0 +1,21 @@
+import { ExampleDeviceHandler } from './ExampleDeviceHandler.mjs'
+
+const handler = new ExampleDeviceHandler('config.json')
+
+
+/**
+ * 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 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,57 @@
+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 = {}) {
+    return format(cmd, options)
+  }
+
+  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){
+    console.error(args)
+  }
+
+  LogInfo(...args){
+    if (this.options && this.options.verbose)
+      console.log(args)
+  }
+
+}
+
+

package/interfaces/httpif.mjs

@@ -0,0 +1,86 @@
+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 (exception) {
+      console.error('error with URL', exception)
+      return false
+    }
+    return true
+  }
+
+  async stop(){
+    console.log("Stopping HTTPif")
+    
+  }
+
+  Check(options) {
+    var res= super.Check(options)
+    if (res <0)
+        return res
+    if (!options.hostname)
+        return -21
+    /*if (!options.port)
+        return -22
+    if (!options.pathname)
+        return -23*/
+    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
+      }
+    }
+
+    if (this.options.verbose)
+      console.log('HTTPIf call URL:', myURL, getOptions)
+    
+
+    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) => {
+        console.warn(`ignore other errors like ERRNOTCONNECTED: ${e.message}`)
+        return false
+      });
+    }).catch(function (error) { // (*)
+        return false
+    })
+  }
+}

package/interfaces/opcuaif.mjs

@@ -0,0 +1,287 @@
+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();
+
+        console.log("OPCUAIf Constructed");
+      }
+
+    async stop(){
+        if (!this.#client)
+            return
+        
+        console.log("Stopping OPC/UA")
+        await this.#client.closeSession(this.#session,true)
+        await this.#client.disconnect()
+        this.#connected = false
+        this.#client = null
+        console.log("Stopped OPC/UA")
+    }
+
+    async init( options = {},config = {},callbackFunction){
+        var res = this.Check(options)
+        if (res<0){
+            console.error("OpcuaIf init: Missing essential options in dictionary => Quitting\n",res,options)
+        }
+        try{
+            this.#endpointurl = options.endpointurl
+            this.#callback = callbackFunction
+            this.monitoreditems = {}
+            this.buttons = {}
+            console.log("OPCUAIf init",this.#endpointurl);
+        
+            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) {
+        console.log(' Error', error)
+        }
+    }
+
+    async call (opcuaNode, options = {}) {
+        var res = this.Check(options)
+        if (res<0){
+            console.error("OpcuaIf call: Missing essential options in dictionary => Quitting\n",res,options)
+            return false
+        }
+
+        var nodeId = super.formatString(opcuaNode, options)
+        var value = super.formatString(options.value, options)
+
+        console.log("OPCUAIf:write", nodeId, value)
+        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){
+            console.log("Disconnect !");
+            await this.#client.Disconnect()
+            console.log("Done !");
+        }
+    }
+    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: 2500,
+                initialDelay: 100
+            },
+    
+            defaultSecureTokenLifetime: 20000,
+            tokenRenewalInterval: 1000
+        });
+    
+        this.#client.on("backoff", (retry, delay) => {
+            console.log("Backoff ", retry, " next attempt in ", delay, "ms", self.#endpointurl);
+        });
+    
+        this.#client.on("connection_lost", () => {
+            console.log("Connection lost");
+        });
+    
+        this.#client.on("connection_reestablished", () => {
+            console.log("Connection re-established");
+        });
+    
+        this.#client.on("connection_failed", () => {
+            console.log("Connection failed");
+        });
+        this.#client.on("start_reconnection", () => {
+            console.log("Starting reconnection");
+        });
+    
+        this.#client.on("after_reconnection", (err) => {
+            console.log("After Reconnection event =>", err);
+        });
+        this.#client.on("security_token_renewed", () => {
+            //console.log("security_token_renewed =>");
+            //console.log(this.#client.toString());
+        })
+        this.#client.on("lifetime_75", (token) => {
+            //// /*ChannelSecurityToken*/
+            //console.log("lifetime_75 =>", token.toString());
+        })
+    
+        console.log("connecting client to url",url);//, this.#session.toString());
+        await this.#client.connect(url);
+    
+        this.#session = await this.#client.createSession();
+    
+        this.#session.on("session_closed", (statusCode) => {
+            console.log(" Session has been closed with statusCode = ", statusCode.toString());
+        })
+        this.#session.on("session_restored", () => {
+            console.log(" Session has been restored");
+        });
+        this.#session.on("keepalive", (lastKnownServerState) => {
+            console.log("KeepAlive lastKnownServerState", lastKnownServerState);
+        });
+        this.#session.on("keepalive_failure", () => {
+            console.log("KeepAlive failure");
+        });
+    
+        this.#sub = await this.#session.createSubscription2({
+            maxNotificationsPerPublish: 9000,
+            publishingEnabled: true,
+            requestedLifetimeCount: 10,
+            requestedMaxKeepAliveCount: 10,
+            requestedPublishingInterval: 1000
+        });
+
+        this.LogInfo("session created\n");//, this.#session.toString());
+        this.LogInfo("client\n", this.#client.toString());
+        this.LogInfo("subscription\n",this.#sub.toString());
+        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(" not register monitored items",itemToMonitor);
+            return
+        }
+        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
+        var self=this
+        //monitoredItem.on("changed", this.MonitoredItemUpdate)
+        monitoredItem.on("changed", function (dataValue) {
+            var nodeId = self.monitoreditems[this.monitoredItemId]
+            var buttonID = self.buttons[this.monitoredItemId]
+            //console.log("monitored item changed:  ", this.monitoredItemId,nodeId, dataValue.value.value);
+            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(" not connected, cannot read",nodeID);
+            return
+        }
+        const dataValue2 = await this.#session.read(nodeToRead, 0);
+        this.LogError("read: nodeID ",nodeID, dataValue2.toString());
+        return dataValue2
+    }
+
+    async Write(nodeID,value,datatype=DataType.String) {
+        let self = this
+        if (!this.#connected){
+            self.LogError(" not connected, cannot write",nodeID, value);
+            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("status", statusCodes);
+                }else{
+                    self.LogInfo(" write ok",nodeID, value);
+                }
+            }else{
+                self.LogError(" write NOT ok",nodeID, value);
+                self.LogError(err)
+            }
+        });  
+    }
+}
+  

package/interfaces/opcuaif_test.mjs

@@ -0,0 +1,31 @@
+import * as opcuaif from '../interfaces/opcuaif.mjs'
+
+
+var opcuainterface = new opcuaif.OPCUAIf()
+import {
+    DataType
+} from "node-opcua";
+
+var call = {
+
+}
+
+var option = {
+    "id" : "touch-0",
+    "key" : "1",
+    "state" : "off",
+    "min":  "0",
+    "max":  "0",
+    "color":  "0",
+    "image":  "0",
+    "endpointurl": "opc.tcp://localhost:4840",
+    "nodeid": "ns=4;s=Is{key}.Kvm.in.Source",
+    "value": "{key}"
+}
+
+await opcuainterface.call(call,option)
+await opcuainterface.Subscribe("ns=4;s=Is1.Kvm.out.Source")
+await opcuainterface.Subscribe("ns=4;s=Is1.Kvm.out.Turret")
+await opcuainterface.Write("ns=4;s=Is1.Kvm.out.Turret",1,DataType.Int16)
+await opcuainterface.Write("ns=4;s=Is1.Kvm.out.Source","hello",DataType.String)
+//await opcuainterface.Write("ns=4;s=Is1.Kvm.state",2,DataType.Int32)

package/interfaces/pubel.js

@@ -0,0 +1,95 @@
+import {
+    OPCUAClient,
+    BrowseDirection,
+    AttributeIds,
+    NodeClassMask,
+    makeBrowsePath,
+    resolveNodeId,
+    TimestampsToReturn,
+    coerceInt32,
+    coerceByteString
+} from "node-opcua";
+import { BaseIf } from './baseif.mjs'
+
+var endpointUrl = "opc.tcp://localhost:4840";
+const subscriptionParameters = {
+    maxNotificationsPerPublish: 1000,
+    publishingEnabled: true,
+    requestedLifetimeCount: 100,
+    requestedMaxKeepAliveCount: 10,
+    requestedPublishingInterval: 1000
+};
+var client
+var GlobalSession
+var GlobalSub
+
+
+async function Connect() {
+    client = OPCUAClient.create({
+        endpointMustExist: false
+    });
+    client.on("backoff", (retry, delay) =>
+        console.log("still trying to connect to ", endpointUrl, ": retry =", retry, "next attempt in ", delay / 1000, "seconds")
+    );
+    
+
+    //await client.connect(endpointUrl)    
+    var self=this
+    await client.withSubscriptionAsync(endpointUrl, subscriptionParameters, async (session, subscription) => {
+        GlobalSession = session
+        GlobalSub = subscription
+        console.log("Session initialized")
+
+        // wait  until CTRL+C is pressed
+        console.log("CTRL+C to stop");
+        await new Promise((resolve) => process.once("SIGINT", resolve));
+    }    )
+}
+
+async function Subscribe(nodeID) {
+    // install monitored item
+
+    nodeID = "ns=4;s=Is1.Kvm.in.Source"
+    const itemToMonitor = {
+        nodeId: resolveNodeId(nodeID),
+        attributeId: AttributeIds.Value
+    };
+    const monitoringParameters = {
+        samplingInterval: 100,
+        discardOldest: true,
+        queueSize: 10
+    };
+
+    const monitoredItem = await GlobalSub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+    monitoredItem.on("changed", function (dataValue) {
+        //console.log("monitored item changed:  ", coerceInt32(dataValue.value.value), "bytes");
+        console.log("monitored item changed:  ", nodeID, dataValue.value.value);
+    });
+}
+
+async function Read(nodeID) {
+    if client
+    const maxAge = 0;
+    const nodeToRead = {
+        nodeId: "ns=4;s=Is1.Kvm.in.Receiver",
+        attributeId: AttributeIds.Value
+    };
+    
+    const dataValue2 = await GlobalSession.read(nodeToRead, maxAge);
+    console.log(" nodeID ",nodeID, dataValue2.toString());
+}
+
+Connect();
+//await Read("ns=4;s=Is1.Kvm.in.Receiver")
+await Subscribe("ns=4;s=Is1.Kvm.in.Receiver")
+await new Promise((resolve) => process.once("SIGINT", resolve));
+
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class OPCUAIf extends BaseIf {
+    async call (callString, options = {}) {
+    }
+}
+  

package/interfaces/shellif.mjs

@@ -0,0 +1,46 @@
+import { exec } from '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(){
+    console.log("Stopping SHELLif")
+  }
+
+  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) {
+    if (this.options.verbose)
+      console.log('ShellIf call', cmd)
+
+    return new Promise(function (resolve, reject) {
+      exec(cmd, (err, stdout, stderr) => {
+        if (stdout.length>0)
+          console.log(`SHELLif Out: ${stdout}`)
+        if (stderr.length>0)
+          console.log(`SHELLif Err: ${stderr}`)
+        if (err) {
+          reject(err)
+        } else {
+          resolve({ stdout, stderr })
+        }
+      })
+    })
+  }
+}