homebridge-smartsystem 6.8.13 → 7.0.1

package/server/webapp.ts

@@ -10,8 +10,9 @@ import * as qs from "querystring";
 import { Base } from './base';
 import * as types from "../duotecno/types";
 import * as logger from "../duotecno/logger";
-import { log } from "../duotecno/logger";
+import { log, err } from "../duotecno/logger";
 import { exec } from "child_process";
+import { MDNSService } from './mDNS';
 
 export interface Params {[key: string]: string | Array<string>};
 
@@ -87,6 +88,7 @@ export class Context {
   date = types.date;
   datetime = types.datetime;
   makeInt = types.makeInt;
+  cap = types.cap;
 
 
   constructor(body: string, req: http.IncomingMessage, res: http.ServerResponse) {
@@ -272,11 +274,12 @@ try {
 
 export class WebApp extends Base {
   files: {[filename: string]: WebAppFile};         // hashmap for serving files, including ejs files for rendering
-  server: http.Server;
-  port: number;
+  servers: http.Server[];                          // array to hold all HTTP servers when listening on one or multiple ports
+  port: number | number[];
   token = "";  // "$#@!" + new Date().getTime() + "!@#$";  // should never match
   user = "";
   password = "";
+  mdnsService: any | null = null;                  // mDNS service for hostname and service discovery
 
   constructor(type: string) {
     super(type);
@@ -284,8 +287,27 @@ export class WebApp extends Base {
 
     log("server", "Creating http server");
     this.files = {};
+    this.servers = [];
 
-    this.server = http.createServer( (req: http.IncomingMessage, res: http.ServerResponse) => {
+    // Note: Server will be fully configured in serve() method
+    // We don't create it here anymore since we might need multiple servers
+  }
+
+  // Override this in subclasses to control template caching behavior
+  // Return true to always reload templates from disk (development mode)
+  // Return false to use preloaded cached templates (production mode)
+  protected isDebugMode(): boolean {
+    return false;  // Default: use cached templates for performance
+  }
+
+  serve(onConnected?: () => void) {
+    // Handle both single port and multiple ports
+    const ports = Array.isArray(this.port) ? this.port : [this.port];
+    
+    log("server", "WebApp - Start serving http on port(s): " + ports.join(", "));
+    
+    // Create the request handler function (shared across all servers)
+    const requestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => {
       this.doServe(req, res).then( 
         result => {
           res.writeHead(result.status, {'Content-Type': result.type || 'text/html', ...result.header});
@@ -299,16 +321,146 @@ export class WebApp extends Base {
           res.end();
         }
       );
+    };
+
+    // Track how many servers are listening for the callback
+    let listeningCount = 0;
+    const totalPorts = ports.length;
+    
+    const onListening = (port: number) => {
+      log("server", `WebApp - Listening on port ${port}`);
+      listeningCount++;
+      
+      // Call onConnected only after ALL servers are listening
+      if (listeningCount === totalPorts && onConnected) {
+        onConnected();
+      }
+    };
+
+    // Create a server for each port (each http.Server can only listen on ONE port)
+    ports.forEach((port) => {
+      const server = http.createServer(requestHandler);
+      
+      // Set socket options to allow port reuse (prevents EADDRINUSE on restart)
+      server.on('listening', () => {
+        const address = server.address();
+        if (address && typeof address === 'object') {
+          onListening(address.port);
+        }
+      });
+      
+      this.servers.push(server);
+      
+      // Listen with options to reuse address
+      server.listen({
+        port: port,
+        host: '::',  // Listen on all IPv6 addresses (includes IPv4)
+        exclusive: false  // Allow multiple processes to bind (for cluster mode)
+      });
     });
   }
 
-  serve(onConnected?: () => void) {
-    log("server", "WebApp - Start serving http on port " + this.port);
-    this.server.listen(this.port, onConnected);
+  /**
+   * Close all HTTP servers and cleanup
+   * Call this before restarting or shutting down
+   */
+  async closeServers(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.servers.length === 0) {
+        resolve();
+        return;
+      }
+
+      let closedCount = 0;
+      const totalServers = this.servers.length;
+
+      const onClosed = () => {
+        closedCount++;
+        if (closedCount === totalServers) {
+          log("server", "All HTTP servers closed");
+          this.servers = [];
+          resolve();
+        }
+      };
+
+      // Close each server
+      this.servers.forEach((server, index) => {
+        if (server.listening) {
+          server.close((error) => {
+            if (error) {
+              logger.err("server", `Error closing server ${index}: ${error.message}`);
+            } else {
+              log("server", `Server ${index} closed`);
+            }
+            onClosed();
+          });
+        } else {
+          onClosed();
+        }
+      });
+    });
+  }
+
+  /**
+   * Initialize mDNS service with the given name and version
+   * Call this before serve() or during initialization
+   */
+  initMDNS(name: string, version?: string) {
+    try {
+      const ports = Array.isArray(this.port) ? this.port : [this.port];
+      
+      this.mdnsService = new MDNSService({
+        name,
+        port: ports,
+        version: version || '1.0.0'
+      });
+
+      this.mdnsService.init();
+      log("webapp", "mDNS service initialized");
+    } catch (e) {
+      err("webapp", `Failed to initialize mDNS: ${e.message}`);
+      this.mdnsService = null;
+    }
+  }
+
+  /**
+   * Register mDNS service and hostname
+   * Call this after server is listening (e.g., in onConnected callback)
+   */
+  registerMDNS() {
+    if (!this.mdnsService) {
+      err("webapp", "mDNS service not initialized, cannot register");
+      return;
+    }
+
+    try {
+      this.mdnsService.register();
+    } catch (e) {
+      err("webapp", `Failed to register mDNS service: ${e.message}`);
+    }
+  }
+
+  /**
+   * Stop and cleanup mDNS service
+   */
+  destroyMDNS() {
+    if (this.mdnsService) {
+      try {
+        this.mdnsService.destroy();
+        this.mdnsService = null;
+      } catch (e) {
+        err("webapp", `Failed to destroy mDNS service: ${e.message}`);
+      }
+    }
   }
 
   addFile(name: string, filename: string, type?: string, enc?: BufferEncoding) {
-    this.addContent(name, fs.readFileSync(filename, {encoding: enc || 'utf-8'}), type || "text/html", filename);
+    // Ensure HTML files have charset specified
+    let contentType = type || "text/html";
+    if (contentType === "text/html" || contentType.startsWith("text/html")) {
+      contentType = "text/html; charset=utf-8";
+    }
+    this.addContent(name, fs.readFileSync(filename, {encoding: enc || 'utf-8'}), contentType, filename);
   }
   addContent(name: string, content: string, type: string, filename: string) {
     this.files[name] = { content, type, filename };
@@ -329,19 +481,19 @@ export class WebApp extends Base {
     return { status: 200, data: file.content, type: file.type };
   }
   html(html: string): HttpResponse {
-    return { status: 200, data: html, type: "text/html" }
+    return { status: 200, data: html, type: "text/html; charset=utf-8" }
   }
   ejs(name: string, context: Context, objects: object, header = {}): HttpResponse {
     // types.debug("webapp", context); !! circular ref in socket/http
 
-    // try to get cached file
-    let file = this.getFile(name);
+    // In debug mode, always reload from disk to see changes without restart
+    let file = this.isDebugMode() ? null : this.getFile(name);
 
-    // for non cached files
+    // for non cached files or debug mode
     if (!file) {
       try {
         const filename = __dirname + "/views/" + name;
-        file = { content: fs.readFileSync(filename, {encoding: 'utf-8'}), type: "text/html", filename};
+        file = { content: fs.readFileSync(filename, {encoding: 'utf-8'}), type: "text/html; charset=utf-8", filename};
       } catch(e) {
         return this.error(context, e.toString());
       }
@@ -352,7 +504,7 @@ export class WebApp extends Base {
       for (const key in objects) context[key] = objects[key];
       try {
         const html = ejs.render(file.content, context, { root: __dirname, filename: file.filename });
-        return { status: 200, type: file.type, data: html, header };
+        return { status: 200, type: file.type || "text/html; charset=utf-8", data: html, header };
 
       } catch(e) {
         return this.error(context, e.toString());

package/{index.spec.js → testHB.js}

@@ -38,4 +38,4 @@ catch (err) {
 //   u = new Unit(n, Sanitizers.unitInfo({name: "unit|20", type: 1}));
 //   log("spec", "Testing names -> getName = " + u.getName() + ", getDisplayname = " + u.getDisplayName() + ", type " + u.type + ", extType = " + u.extendedType + ", getTypeName = " + u.typeName());
 // }
-//# sourceMappingURL=index.spec.js.map
+//# sourceMappingURL=testHB.js.map

package/{run.js → testProxy.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const socapp_1 = require("./server/socapp");
-console.log("run.ts - running in directory: " + process.cwd());
+console.log("testProxy.ts - running in directory: " + process.cwd());
 const socServer = new socapp_1.SocApp(null, "server");
 socServer.serve();
-//# sourceMappingURL=run.js.map
+//# sourceMappingURL=testProxy.js.map

package/{run.ts → testProxy.ts}

@@ -1,6 +1,6 @@
 import { SocApp } from "./server/socapp";
 
-console.log("run.ts - running in directory: " + process.cwd());
+console.log("testProxy.ts - running in directory: " + process.cwd());
 
 const socServer = new SocApp(null, "server");
 socServer.serve();

package/testWS.js

@@ -0,0 +1,137 @@
+"use strict";
+// WebSocket Test Client for Device Control
+// Tests the SmartApp WebSocket device control functionality
+// 
+// Usage: ts-node testWS.ts [ws://host:port/devices]
+//
+// Johan Coppieters, Nov 2025
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebSocket = require("ws");
+class WebSocketDeviceTest {
+    constructor(url) {
+        this.devices = [];
+        this.pollInterval = null;
+        this.randomInterval = null;
+        this.url = url;
+    }
+    connect() {
+        console.log(`\n🔌 Connecting to WebSocket server: ${this.url}`);
+        this.ws = new WebSocket(this.url);
+        this.ws.on('open', () => {
+            console.log('✅ Connected to WebSocket server\n');
+            this.startPolling();
+            this.startRandomControl();
+        });
+        this.ws.on('message', (data) => {
+            try {
+                console.log('\n📥 Received message from server:');
+                console.log(data.toString());
+                const devices = JSON.parse(data.toString());
+                this.devices = devices;
+                console.log(`\n📊 Received ${devices.length} device(s):`);
+                console.log('═'.repeat(100));
+                console.log('ID  | Name                 | Power(W) | Current(A) | Voltage(V) | Relay | Measured');
+                console.log('─'.repeat(100));
+                devices.forEach(device => {
+                    const relayState = device.relay ? '🟢 ON ' : '🔴 OFF';
+                    const measuredFlag = device.measured ? 'YES' : 'MANUAL';
+                    console.log(`${String(device.id).padEnd(4)}| ` +
+                        `${device.name.padEnd(20)} | ` +
+                        `${device.power.toFixed(1).padStart(8)} | ` +
+                        `${device.current.toFixed(2).padStart(10)} | ` +
+                        `${device.voltage.toFixed(1).padStart(10)} | ` +
+                        `${relayState} | ${measuredFlag}`);
+                });
+                console.log('═'.repeat(100));
+            }
+            catch (e) {
+                console.error('❌ Error parsing message:', e.message);
+            }
+        });
+        this.ws.on('close', () => {
+            console.log('\n🔌 Connection closed');
+            this.stopIntervals();
+        });
+        this.ws.on('error', (error) => {
+            console.error('❌ WebSocket error:', error.message);
+            this.stopIntervals();
+        });
+    }
+    startPolling() {
+        // Send keep-alive every 5 seconds
+        this.pollInterval = setInterval(() => {
+            if (this.ws.readyState === WebSocket.OPEN) {
+                console.log('\n⏱️  Sending keep-alive poll...');
+                this.ws.send('[]');
+            }
+        }, 5000);
+    }
+    startRandomControl() {
+        // Send random relay control every 10-15 seconds
+        this.randomInterval = setInterval(() => {
+            if (this.ws.readyState === WebSocket.OPEN && this.devices.length > 0) {
+                this.sendRandomControl();
+            }
+        }, 10000 + Math.random() * 5000);
+    }
+    sendRandomControl() {
+        if (this.devices.length === 0) {
+            console.log('⚠️  No devices available for control');
+            return;
+        }
+        // Pick 1-3 random devices
+        const numDevices = Math.min(this.devices.length, Math.floor(Math.random() * 3) + 1);
+        const shuffled = [...this.devices].sort(() => Math.random() - 0.5);
+        const selectedDevices = shuffled.slice(0, numDevices);
+        const commands = selectedDevices.map(device => ({
+            id: device.id,
+            relay: Math.random() > 0.5 // Random ON/OFF
+        }));
+        console.log('\n🎲 Sending random control commands:');
+        commands.forEach(cmd => {
+            const device = this.devices.find(d => d.id === cmd.id);
+            const action = cmd.relay ? '🟢 ON' : '🔴 OFF';
+            const node = Math.floor(cmd.id / 256);
+            const unit = cmd.id % 256;
+            console.log(`   → ${device === null || device === void 0 ? void 0 : device.name} (node=${node}, unit=${unit}, id=${cmd.id}): ${action}`);
+        });
+        console.log('📤 Sending commands to server...');
+        console.log(JSON.stringify(commands, null, 2));
+        this.ws.send(JSON.stringify(commands));
+    }
+    stopIntervals() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+        if (this.randomInterval) {
+            clearInterval(this.randomInterval);
+            this.randomInterval = null;
+        }
+    }
+    disconnect() {
+        console.log('\n🔌 Disconnecting...');
+        this.stopIntervals();
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+}
+// Main
+const args = process.argv.slice(2);
+const url = args[0] || 'ws://localhost:5002/devices';
+console.log('╔════════════════════════════════════════════════════════════════════╗');
+console.log('║   WebSocket Device Control Test Client                            ║');
+console.log('║   Press Ctrl+C to exit                                             ║');
+console.log('╚════════════════════════════════════════════════════════════════════╝');
+const client = new WebSocketDeviceTest(url);
+client.connect();
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.log('\n\n👋 Shutting down gracefully...');
+    client.disconnect();
+    setTimeout(() => process.exit(0), 500);
+});
+// Keep the process running
+process.stdin.resume();
+//# sourceMappingURL=testWS.js.map

package/testWS.ts

@@ -0,0 +1,174 @@
+// WebSocket Test Client for Device Control
+// Tests the SmartApp WebSocket device control functionality
+// 
+// Usage: ts-node testWS.ts [ws://host:port/devices]
+//
+// Johan Coppieters, Nov 2025
+
+import * as WebSocket from 'ws';
+
+interface Device {
+  id: number;
+  name: string;
+  power: number;
+  energy: number;
+  voltage: number;
+  current: number;
+  relay: boolean;
+  measured: boolean;
+}
+
+class WebSocketDeviceTest {
+  private ws: WebSocket;
+  private devices: Device[] = [];
+  private url: string;
+  private pollInterval: NodeJS.Timeout | null = null;
+  private randomInterval: NodeJS.Timeout | null = null;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  connect() {
+    console.log(`\n🔌 Connecting to WebSocket server: ${this.url}`);
+    
+    this.ws = new WebSocket(this.url);
+
+    this.ws.on('open', () => {
+      console.log('✅ Connected to WebSocket server\n');
+      this.startPolling();
+      this.startRandomControl();
+    });
+
+    this.ws.on('message', (data: string) => {
+      try {
+        console.log('\n📥 Received message from server:');
+        console.log(data.toString());
+        const devices: Device[] = JSON.parse(data.toString());
+        this.devices = devices;
+        
+        console.log(`\n📊 Received ${devices.length} device(s):`);
+        console.log('═'.repeat(100));
+        console.log('ID  | Name                 | Power(W) | Current(A) | Voltage(V) | Relay | Measured');
+        console.log('─'.repeat(100));
+        
+        devices.forEach(device => {
+          const relayState = device.relay ? '🟢 ON ' : '🔴 OFF';
+          const measuredFlag = device.measured ? 'YES' : 'MANUAL';
+          console.log(
+            `${String(device.id).padEnd(4)}| ` +
+            `${device.name.padEnd(20)} | ` +
+            `${device.power.toFixed(1).padStart(8)} | ` +
+            `${device.current.toFixed(2).padStart(10)} | ` +
+            `${device.voltage.toFixed(1).padStart(10)} | ` +
+            `${relayState} | ${measuredFlag}`
+          );
+        });
+        console.log('═'.repeat(100));
+        
+      } catch (e) {
+        console.error('❌ Error parsing message:', e.message);
+      }
+    });
+
+    this.ws.on('close', () => {
+      console.log('\n🔌 Connection closed');
+      this.stopIntervals();
+    });
+
+    this.ws.on('error', (error) => {
+      console.error('❌ WebSocket error:', error.message);
+      this.stopIntervals();
+    });
+  }
+
+  startPolling() {
+    // Send keep-alive every 5 seconds
+    this.pollInterval = setInterval(() => {
+      if (this.ws.readyState === WebSocket.OPEN) {
+        console.log('\n⏱️  Sending keep-alive poll...');
+        this.ws.send('[]');
+      }
+    }, 5000);
+  }
+
+  startRandomControl() {
+    // Send random relay control every 10-15 seconds
+    this.randomInterval = setInterval(() => {
+      if (this.ws.readyState === WebSocket.OPEN && this.devices.length > 0) {
+        this.sendRandomControl();
+      }
+    }, 10000 + Math.random() * 5000);
+  }
+
+  sendRandomControl() {
+    if (this.devices.length === 0) {
+      console.log('⚠️  No devices available for control');
+      return;
+    }
+
+    // Pick 1-3 random devices
+    const numDevices = Math.min(this.devices.length, Math.floor(Math.random() * 3) + 1);
+    const shuffled = [...this.devices].sort(() => Math.random() - 0.5);
+    const selectedDevices = shuffled.slice(0, numDevices);
+    
+    const commands = selectedDevices.map(device => ({
+      id: device.id,
+      relay: Math.random() > 0.5  // Random ON/OFF
+    }));
+
+    console.log('\n🎲 Sending random control commands:');
+    commands.forEach(cmd => {
+      const device = this.devices.find(d => d.id === cmd.id);
+      const action = cmd.relay ? '🟢 ON' : '🔴 OFF';
+      const node = Math.floor(cmd.id / 256);
+      const unit = cmd.id % 256;
+      console.log(`   → ${device?.name} (node=${node}, unit=${unit}, id=${cmd.id}): ${action}`);
+    });
+    
+    console.log('📤 Sending commands to server...');
+    console.log(JSON.stringify(commands, null, 2));
+    this.ws.send(JSON.stringify(commands));
+  }
+
+  stopIntervals() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    if (this.randomInterval) {
+      clearInterval(this.randomInterval);
+      this.randomInterval = null;
+    }
+  }
+
+  disconnect() {
+    console.log('\n🔌 Disconnecting...');
+    this.stopIntervals();
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+}
+
+// Main
+const args = process.argv.slice(2);
+const url = args[0] || 'ws://localhost:5002/devices';
+
+console.log('╔════════════════════════════════════════════════════════════════════╗');
+console.log('║   WebSocket Device Control Test Client                            ║');
+console.log('║   Press Ctrl+C to exit                                             ║');
+console.log('╚════════════════════════════════════════════════════════════════════╝');
+
+const client = new WebSocketDeviceTest(url);
+client.connect();
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Shutting down gracefully...');
+  client.disconnect();
+  setTimeout(() => process.exit(0), 500);
+});
+
+// Keep the process running
+process.stdin.resume();

package/run9998.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const socapp_1 = require("./server/socapp");
-console.log("run.ts - running in directory: " + process.cwd());
-const socServer = new socapp_1.SocApp(null, "server", 9998);
-socServer.serve();
-//# sourceMappingURL=run9998.js.map

package/run9998.ts

@@ -1,6 +0,0 @@
-import { SocApp } from "./server/socapp";
-
-console.log("run.ts - running in directory: " + process.cwd());
-
-const socServer = new SocApp(null, "server", 9998);
-socServer.serve();

package/run9999.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const socapp_1 = require("./server/socapp");
-console.log("run.ts - running in directory: " + process.cwd());
-const socServer = new socapp_1.SocApp(null, "server", 9999);
-socServer.serve();
-//# sourceMappingURL=run9999.js.map

package/run9999.ts

@@ -1,6 +0,0 @@
-import { SocApp } from "./server/socapp";
-
-console.log("run.ts - running in directory: " + process.cwd());
-
-const socServer = new SocApp(null, "server", 9999);
-socServer.serve();