homebridge-smartsystem 6.8.13 → 7.0.1

package/server/mDNS.js

@@ -0,0 +1,168 @@
+"use strict";
+// mDNS Service Manager
+// Purpose: Handle mDNS service discovery and hostname publishing
+// Similar to ESP32's MDNS.begin() functionality
+//
+// Johan Coppieters, Nov 2025
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MDNSService = void 0;
+const Bonjour = require("bonjour-service");
+const mdns = require("multicast-dns");
+const os = require("os");
+const logger_1 = require("../duotecno/logger");
+class MDNSService {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Initialize mDNS service (call this before registering)
+     */
+    init() {
+        try {
+            this.bonjour = new Bonjour.Bonjour();
+            (0, logger_1.log)("mDNS", "Service initialized");
+        }
+        catch (e) {
+            (0, logger_1.err)("mDNS", `Failed to initialize: ${e.message}`);
+            throw e;
+        }
+    }
+    /**
+     * Register both HTTP service and hostname (like ESP32 MDNS.begin())
+     */
+    register() {
+        if (!this.bonjour) {
+            (0, logger_1.err)("mDNS", "Service not initialized, call init() first");
+            return;
+        }
+        try {
+            const { name, port, version } = this.config;
+            const ports = Array.isArray(port) ? port : [port];
+            const primaryPort = ports[0];
+            // Register the HTTP service using bonjour
+            const service = this.bonjour.publish({
+                name,
+                type: 'http',
+                port: primaryPort,
+                txt: {
+                    version: version || '1.0.0',
+                    ports: ports.join(','),
+                    path: '/'
+                }
+            });
+            (0, logger_1.log)("mDNS", `HTTP service registered: ${name}.local on port(s) ${ports.join(', ')}`);
+            // Handle service errors
+            service.on('error', (error) => {
+                (0, logger_1.err)("mDNS", `Service error: ${error.message}`);
+            });
+            // Publish the hostname A record (like ESP32 MDNS.begin())
+            this.publishHostname(name);
+        }
+        catch (e) {
+            (0, logger_1.err)("mDNS", `Failed to register service: ${e.message}`);
+        }
+    }
+    /**
+     * Publish hostname as A/AAAA records (ESP32-style hostname publishing)
+     */
+    publishHostname(hostname) {
+        try {
+            // Create multicast DNS instance
+            this.mdns = mdns();
+            // Get local IP addresses
+            const addresses = this.getLocalIPAddresses();
+            if (addresses.length === 0) {
+                (0, logger_1.err)("mDNS", "No network interfaces found, cannot publish hostname");
+                return;
+            }
+            (0, logger_1.log)("mDNS", `Publishing hostname ${hostname}.local with IPs: ${addresses.join(', ')}`);
+            // Respond to mDNS queries for our hostname (like ESP32 MDNS.begin())
+            this.mdns.on('query', (query) => {
+                // Check if someone is asking for our hostname
+                const hostnameQuery = query.questions.find(q => q.name === `${hostname}.local` && (q.type === 'A' || q.type === 'AAAA' || q.type === 'ANY'));
+                if (hostnameQuery) {
+                    // Respond with A records for all our IP addresses
+                    const answers = addresses.map(ip => {
+                        const isIPv6 = ip.includes(':');
+                        return {
+                            name: `${hostname}.local`,
+                            type: isIPv6 ? 'AAAA' : 'A',
+                            ttl: 120,
+                            data: ip
+                        };
+                    });
+                    this.mdns.respond(answers, () => {
+                        (0, logger_1.debug)("mDNS", `Responded to query for ${hostname}.local`);
+                    });
+                }
+            });
+            // Send announcement (like ESP32 does on startup)
+            this.announceHostname(hostname, addresses);
+            (0, logger_1.log)("mDNS", `Hostname responder started for ${hostname}.local`);
+        }
+        catch (e) {
+            (0, logger_1.err)("mDNS", `Failed to publish hostname: ${e.message}`);
+        }
+    }
+    /**
+     * Send unsolicited announcement (like ESP32 mDNS does on startup)
+     */
+    announceHostname(hostname, addresses) {
+        const answers = addresses.map(ip => {
+            const isIPv6 = ip.includes(':');
+            return {
+                name: `${hostname}.local`,
+                type: isIPv6 ? 'AAAA' : 'A',
+                ttl: 120,
+                data: ip
+            };
+        });
+        this.mdns.respond(answers, () => {
+            (0, logger_1.log)("mDNS", `Announced ${hostname}.local on the network`);
+        });
+    }
+    /**
+     * Get local IPv4 addresses (excluding loopback and virtual interfaces)
+     */
+    getLocalIPAddresses() {
+        const addresses = [];
+        const interfaces = os.networkInterfaces();
+        for (const name in interfaces) {
+            const iface = interfaces[name];
+            if (!iface)
+                continue;
+            for (const addr of iface) {
+                // Skip internal (loopback) and non-IPv4 addresses
+                if (addr.internal || addr.family !== 'IPv4')
+                    continue;
+                // Skip docker and virtual interfaces
+                if (name.startsWith('docker') || name.startsWith('veth'))
+                    continue;
+                addresses.push(addr.address);
+            }
+        }
+        return addresses;
+    }
+    /**
+     * Stop and cleanup mDNS services
+     */
+    destroy() {
+        try {
+            if (this.mdns) {
+                this.mdns.destroy();
+                this.mdns = null;
+                (0, logger_1.log)("mDNS", "Hostname responder stopped");
+            }
+            if (this.bonjour) {
+                this.bonjour.destroy();
+                this.bonjour = null;
+                (0, logger_1.log)("mDNS", "Service discovery stopped");
+            }
+        }
+        catch (e) {
+            (0, logger_1.err)("mDNS", `Error during cleanup: ${e.message}`);
+        }
+    }
+}
+exports.MDNSService = MDNSService;
+//# sourceMappingURL=mDNS.js.map

package/server/mDNS.ts

@@ -0,0 +1,198 @@
+// mDNS Service Manager
+// Purpose: Handle mDNS service discovery and hostname publishing
+// Similar to ESP32's MDNS.begin() functionality
+//
+// Johan Coppieters, Nov 2025
+
+import * as Bonjour from 'bonjour-service';
+import * as mdns from 'multicast-dns';
+import * as os from 'os';
+import { log, debug, err } from '../duotecno/logger';
+
+export interface MDNSConfig {
+  name: string;
+  port: number | number[];
+  version?: string;
+}
+
+export class MDNSService {
+  private bonjour: any;
+  private mdns: any;
+  private config: MDNSConfig;
+
+  constructor(config: MDNSConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Initialize mDNS service (call this before registering)
+   */
+  init() {
+    try {
+      this.bonjour = new Bonjour.Bonjour();
+      log("mDNS", "Service initialized");
+    } catch (e) {
+      err("mDNS", `Failed to initialize: ${e.message}`);
+      throw e;
+    }
+  }
+
+  /**
+   * Register both HTTP service and hostname (like ESP32 MDNS.begin())
+   */
+  register() {
+    if (!this.bonjour) {
+      err("mDNS", "Service not initialized, call init() first");
+      return;
+    }
+
+    try {
+      const { name, port, version } = this.config;
+      const ports = Array.isArray(port) ? port : [port];
+      const primaryPort = ports[0];
+
+      // Register the HTTP service using bonjour
+      const service = this.bonjour.publish({
+        name,
+        type: 'http',
+        port: primaryPort,
+        txt: {
+          version: version || '1.0.0',
+          ports: ports.join(','),
+          path: '/'
+        }
+      });
+
+      log("mDNS", `HTTP service registered: ${name}.local on port(s) ${ports.join(', ')}`);
+
+      // Handle service errors
+      service.on('error', (error) => {
+        err("mDNS", `Service error: ${error.message}`);
+      });
+
+      // Publish the hostname A record (like ESP32 MDNS.begin())
+      this.publishHostname(name);
+
+    } catch (e) {
+      err("mDNS", `Failed to register service: ${e.message}`);
+    }
+  }
+
+  /**
+   * Publish hostname as A/AAAA records (ESP32-style hostname publishing)
+   */
+  private publishHostname(hostname: string) {
+    try {
+      // Create multicast DNS instance
+      this.mdns = mdns();
+
+      // Get local IP addresses
+      const addresses = this.getLocalIPAddresses();
+      
+      if (addresses.length === 0) {
+        err("mDNS", "No network interfaces found, cannot publish hostname");
+        return;
+      }
+
+      log("mDNS", `Publishing hostname ${hostname}.local with IPs: ${addresses.join(', ')}`);
+
+      // Respond to mDNS queries for our hostname (like ESP32 MDNS.begin())
+      this.mdns.on('query', (query) => {
+        // Check if someone is asking for our hostname
+        const hostnameQuery = query.questions.find(q => 
+          q.name === `${hostname}.local` && (q.type === 'A' || q.type === 'AAAA' || q.type === 'ANY')
+        );
+
+        if (hostnameQuery) {
+          // Respond with A records for all our IP addresses
+          const answers = addresses.map(ip => {
+            const isIPv6 = ip.includes(':');
+            return {
+              name: `${hostname}.local`,
+              type: isIPv6 ? 'AAAA' : 'A',
+              ttl: 120,
+              data: ip
+            };
+          });
+
+          this.mdns.respond(answers, () => {
+            debug("mDNS", `Responded to query for ${hostname}.local`);
+          });
+        }
+      });
+
+      // Send announcement (like ESP32 does on startup)
+      this.announceHostname(hostname, addresses);
+
+      log("mDNS", `Hostname responder started for ${hostname}.local`);
+
+    } catch (e) {
+      err("mDNS", `Failed to publish hostname: ${e.message}`);
+    }
+  }
+
+  /**
+   * Send unsolicited announcement (like ESP32 mDNS does on startup)
+   */
+  private announceHostname(hostname: string, addresses: string[]) {
+    const answers = addresses.map(ip => {
+      const isIPv6 = ip.includes(':');
+      return {
+        name: `${hostname}.local`,
+        type: isIPv6 ? 'AAAA' : 'A',
+        ttl: 120,
+        data: ip
+      };
+    });
+
+    this.mdns.respond(answers, () => {
+      log("mDNS", `Announced ${hostname}.local on the network`);
+    });
+  }
+
+  /**
+   * Get local IPv4 addresses (excluding loopback and virtual interfaces)
+   */
+  private getLocalIPAddresses(): string[] {
+    const addresses: string[] = [];
+    const interfaces = os.networkInterfaces();
+
+    for (const name in interfaces) {
+      const iface = interfaces[name];
+      if (!iface) continue;
+
+      for (const addr of iface) {
+        // Skip internal (loopback) and non-IPv4 addresses
+        if (addr.internal || addr.family !== 'IPv4') continue;
+        
+        // Skip docker and virtual interfaces
+        if (name.startsWith('docker') || name.startsWith('veth')) continue;
+        
+        addresses.push(addr.address);
+      }
+    }
+
+    return addresses;
+  }
+
+  /**
+   * Stop and cleanup mDNS services
+   */
+  destroy() {
+    try {
+      if (this.mdns) {
+        this.mdns.destroy();
+        this.mdns = null;
+        log("mDNS", "Hostname responder stopped");
+      }
+
+      if (this.bonjour) {
+        this.bonjour.destroy();
+        this.bonjour = null;
+        log("mDNS", "Service discovery stopped");
+      }
+    } catch (e) {
+      err("mDNS", `Error during cleanup: ${e.message}`);
+    }
+  }
+}

package/server/platform.js

@@ -83,6 +83,9 @@ class Platform extends base_1.Base {
             try {
                 this.smartapp = new smartapp_1.SmartApp(this.system, this.power, this);
                 this.smartapp.serve();
+                // Register webapp with proxy for graceful shutdown
+                const { setWebApp } = require('./proxy');
+                setWebApp(this.smartapp);
             }
             catch (err) {
                 (0, logger_1.log)("homebridge", err);
@@ -111,6 +114,8 @@ class Platform extends base_1.Base {
         else {
             (0, logger_1.log)("homebridge", "platform - No SocApp configured.");
         }
+        // Always set proxy kind to "gw" when running under Platform/HomeBridge
+        // This prevents auto-restart on errors even if proxy is not configured
         if (this.config.proxy && ((_a = this.config.proxy) === null || _a === void 0 ? void 0 : _a.uniqueId)) {
             this.config.proxy.kind = "gw";
             (0, proxy_1.setProxyConfig)(this.config.proxy);
@@ -119,6 +124,8 @@ class Platform extends base_1.Base {
         }
         else {
             (0, logger_1.log)("homebridge", "platform - No Proxy configured.");
+            // Still set kind to "gw" to prevent auto-restart on web server errors
+            (0, proxy_1.setProxyConfig)(Object.assign(Object.assign({}, this.config.proxy), { kind: "gw" }));
         }
     }
     startPower(type, PowerMgr) {

package/server/platform.ts

@@ -89,6 +89,10 @@ export class Platform extends Base {
       try {
         this.smartapp = new SmartApp(this.system, this.power, this);
         this.smartapp.serve();
+        
+        // Register webapp with proxy for graceful shutdown
+        const { setWebApp } = require('./proxy');
+        setWebApp(this.smartapp);
 
       } catch(err) {
         log("homebridge", err);
@@ -117,6 +121,8 @@ export class Platform extends Base {
       log("homebridge", "platform - No SocApp configured.");
     }
 
+    // Always set proxy kind to "gw" when running under Platform/HomeBridge
+    // This prevents auto-restart on errors even if proxy is not configured
     if (this.config.proxy && this.config.proxy?.uniqueId) {
       this.config.proxy.kind = "gw";
       setProxyConfig(this.config.proxy);
@@ -124,6 +130,8 @@ export class Platform extends Base {
       log("homebridge", "platform - Proxy configured: " + JSON.stringify(this.config.proxy, null, 2));
     } else {
       log("homebridge", "platform - No Proxy configured.");
+      // Still set kind to "gw" to prevent auto-restart on web server errors
+      setProxyConfig({ ...this.config.proxy, kind: "gw" });
     }
   }
 

package/server/proxy.js

@@ -1,6 +1,15 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.setProxyConfig = exports.kEmptyProxy = void 0;
+exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.setProxyConfig = exports.setWebApp = exports.kEmptyProxy = void 0;
 const net = require("net");
 const child_process_1 = require("child_process");
 const process_1 = require("process");
@@ -14,6 +23,12 @@ exports.kEmptyProxy = {
     kind: "solo" // default running under PM2 or other process manager -> don't restart yourself
 };
 const config = Object.assign({}, exports.kEmptyProxy);
+// Store reference to the webapp so we can close servers before restarting
+let gWebApp = null;
+function setWebApp(webapp) {
+    gWebApp = webapp;
+}
+exports.setWebApp = setWebApp;
 function setProxyConfig(c) {
     // set the proxy config
     if (c) {
@@ -60,7 +75,18 @@ function error(str) {
 ///////////////////////////////
 // Start up the proxy server //
 ///////////////////////////////
-cleanStart(true);
+// Only auto-start if we have a config-proxy.json file (standalone mode)
+// When running under Platform/HomeBridge, let Platform control the startup
+try {
+    require.resolve('../config-proxy.json');
+    // config-proxy.json exists, we're running standalone -> start the proxy
+    log("[PROXY] Running in standalone mode (config-proxy.json found), starting proxy...");
+    cleanStart(true);
+}
+catch (e) {
+    // No config-proxy.json, we're probably running under Platform/HomeBridge
+    log("[PROXY] No config-proxy.json found, waiting for Platform to start proxy...");
+}
 function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count = 1) {
     // retry making a cloud connection
     function reconnect(err) {
@@ -312,23 +338,36 @@ function restart() {
 }
 // Graceful shutdown handler
 function handleShutdown(signal) {
-    log(`[PROXY] → [SYSTEM] Received ${signal}, shutting down gracefully...`);
-    if (connectionChecker) {
-        clearInterval(connectionChecker);
-        connectionChecker = null;
-    }
-    // Close all cloud connections
-    gCloudConnections.forEach(ctx => ctx.cleanupSockets());
-    gCloudConnections.splice(0, gCloudConnections.length);
-    log(`[PROXY] → [SYSTEM] All connections closed. Exiting.`);
-    if (config.kind === "solo") {
-        log(`[PROXY] → [SYSTEM] Restarting proxy in solo mode...`);
-        restart();
-    }
-    else {
-        log(`[PROXY] → [SYSTEM] Exiting without restart.`);
-        setTimeout(() => process.exit(0), 100);
-    }
+    return __awaiter(this, void 0, void 0, function* () {
+        log(`[PROXY] → [SYSTEM] Received ${signal}, shutting down gracefully...`);
+        if (connectionChecker) {
+            clearInterval(connectionChecker);
+            connectionChecker = null;
+        }
+        // Close all cloud connections
+        gCloudConnections.forEach(ctx => ctx.cleanupSockets());
+        gCloudConnections.splice(0, gCloudConnections.length);
+        // Close HTTP servers if available
+        if (gWebApp && typeof gWebApp.closeServers === 'function') {
+            log(`[PROXY] → [SYSTEM] Closing HTTP servers...`);
+            try {
+                yield gWebApp.closeServers();
+            }
+            catch (e) {
+                error(`[PROXY] → [SYSTEM] Error closing servers: ${e.message}`);
+            }
+        }
+        log(`[PROXY] → [SYSTEM] All connections closed. Exiting.`);
+        if (config.kind === "solo") {
+            log(`[PROXY] → [SYSTEM] Restarting proxy in solo mode...`);
+            restart();
+        }
+        else {
+            log(`[PROXY] → [SYSTEM] Exiting without restart.`);
+            // Give OS time to release ports before exit (helps prevent EADDRINUSE on restart)
+            setTimeout(() => process.exit(0), 500);
+        }
+    });
 }
 // Listen for termination signals
 process.on('SIGINT', () => handleShutdown('SIGINT'));

package/server/proxy.ts

@@ -28,6 +28,13 @@ export const kEmptyProxy: ProxyConfig = {
 
 const config = {...kEmptyProxy};
 
+// Store reference to the webapp so we can close servers before restarting
+let gWebApp: any = null;
+
+export function setWebApp(webapp: any) {
+  gWebApp = webapp;
+}
+
 export function setProxyConfig(c?: ProxyConfig): ProxyConfig {
   // set the proxy config
   if (c) {
@@ -81,7 +88,17 @@ function error(str: string) {
 ///////////////////////////////
 // Start up the proxy server //
 ///////////////////////////////
-cleanStart(true);
+// Only auto-start if we have a config-proxy.json file (standalone mode)
+// When running under Platform/HomeBridge, let Platform control the startup
+try {
+  require.resolve('../config-proxy.json');
+  // config-proxy.json exists, we're running standalone -> start the proxy
+  log("[PROXY] Running in standalone mode (config-proxy.json found), starting proxy...");
+  cleanStart(true);
+} catch (e) {
+  // No config-proxy.json, we're probably running under Platform/HomeBridge
+  log("[PROXY] No config-proxy.json found, waiting for Platform to start proxy...");
+}
 
 
 export function makeNewCloudConnection(master: string, masterPort: number, server: string, serverPort: number, uniqueId: string, count = 1) {
@@ -389,7 +406,7 @@ function restart() {
 
 
 // Graceful shutdown handler
-function handleShutdown(signal: string) {
+async function handleShutdown(signal: string) {
   log(`[PROXY] → [SYSTEM] Received ${signal}, shutting down gracefully...`);
 
   if (connectionChecker) {
@@ -401,6 +418,16 @@ function handleShutdown(signal: string) {
   gCloudConnections.forEach(ctx => ctx.cleanupSockets());
   gCloudConnections.splice(0, gCloudConnections.length);
 
+  // Close HTTP servers if available
+  if (gWebApp && typeof gWebApp.closeServers === 'function') {
+    log(`[PROXY] → [SYSTEM] Closing HTTP servers...`);
+    try {
+      await gWebApp.closeServers();
+    } catch (e) {
+      error(`[PROXY] → [SYSTEM] Error closing servers: ${e.message}`);
+    }
+  }
+
   log(`[PROXY] → [SYSTEM] All connections closed. Exiting.`);
 
   if (config.kind === "solo") {
@@ -408,7 +435,8 @@ function handleShutdown(signal: string) {
     restart();
   } else {
     log(`[PROXY] → [SYSTEM] Exiting without restart.`);
-    setTimeout(() => process.exit(0), 100);
+    // Give OS time to release ports before exit (helps prevent EADDRINUSE on restart)
+    setTimeout(() => process.exit(0), 500);
   }
 }