homebridge-smartsystem 7.0.4 → 7.1.0

package/README.md

@@ -320,6 +320,8 @@ Homebridge UI version
 ### v7.0.0 - 12/11/2025
 - 0: added mDNS/Bonjour + always port 80 + don't preload EJS files if system.debug == true
 - 4: fixed a bug when shelly has empty list of ip addresses
+- 5: better error handling in the proxy.ts + show connection in the /proxy page
+
 
 ## Hardware 
 A Raspberry Pi that connects to a Duotecno IP Node 

package/duotecno/types.js

@@ -407,7 +407,7 @@ exports.Sanitizers = {
     ///////////
     proxy: function (config, system) {
         var _a, _b;
-        const c = proxy_1.kEmptyProxy;
+        const c = Object.assign({}, proxy_1.kEmptyProxy);
         c.cloudServer = (config === null || config === void 0 ? void 0 : config.cloudServer) || proxy_1.kEmptyProxy.cloudServer;
         c.cloudPort = (config === null || config === void 0 ? void 0 : config.cloudPort) || proxy_1.kEmptyProxy.cloudPort;
         c.masterAddress = (config === null || config === void 0 ? void 0 : config.masterAddress) || ((_a = system === null || system === void 0 ? void 0 : system.cmasters[0]) === null || _a === void 0 ? void 0 : _a.address) || "";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-smartsystem",
   "displayname": "Duotecno Bridge",
-  "version": "7.0.4",
+  "version": "7.1.0",
   "description": "SmartServer (Proxy TCP sockets to the cloud, Smappee MQTT, Duotecno IP Nodes, Homekit interface)",
   "main": "index.js",
   "author": "Johan Coppieters",

package/server/base.js

@@ -35,7 +35,11 @@ class Base {
     write(type, config) {
         (0, config_1.setSubConfig)(type, config);
         // but better to much than not enough
+        // if (os.platform() === "darwin") {
+        //   writeFileSync(__dirname+"/../config.json", JSON.stringify(gPlatformConfig), null, 2));
+        // } else {
         (0, config_1.setAPIConfig)();
+        // }
     }
 }
 exports.Base = Base;

package/server/mDNS.js

@@ -12,6 +12,9 @@ const os = require("os");
 const logger_1 = require("../duotecno/logger");
 class MDNSService {
     constructor(config) {
+        this.registeredName = null; // Actual name registered (may have suffix)
+        this.registrationError = null; // Last error during registration
+        this.registrationStatus = 'pending';
         this.config = config;
     }
     /**
@@ -29,65 +32,132 @@ class MDNSService {
     }
     /**
      * Register both HTTP service and hostname (like ESP32 MDNS.begin())
+     * Tries alternative names with suffixes if the name is already in use
      */
     register() {
         if (!this.bonjour) {
+            this.registrationError = "Service not initialized";
+            this.registrationStatus = 'failed';
             (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
-            // Wrap in try-catch because bonjour can throw synchronously on conflicts
-            let service;
-            try {
-                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(', ')}`);
+        const { name, port, version } = this.config;
+        const ports = Array.isArray(port) ? port : [port];
+        const primaryPort = ports[0];
+        // Set up error handler to prevent crash on "already in use" errors
+        // Note: The error message will still be logged by Node.js, but the app won't crash
+        // The retry logic with suffixes (.2, .3, etc.) will continue to work
+        let handlerActive = true;
+        const globalErrorHandler = (error) => {
+            if (handlerActive && error.message.includes('already in use')) {
+                // Suppress crash - retry logic will handle it
+                return;
+            }
+        };
+        process.prependListener('uncaughtException', globalErrorHandler);
+        setTimeout(() => {
+            handlerActive = false;
+            process.removeListener('uncaughtException', globalErrorHandler);
+        }, 5000);
+        // Try to register with the original name, then try with suffixes .2, .3, .4, .5, .6
+        this.tryRegisterWithSuffix(name, primaryPort, ports, version, 0);
+    }
+    /**
+     * Recursively try to register with different suffixes
+     */
+    tryRegisterWithSuffix(baseName, primaryPort, ports, version, attempt) {
+        if (attempt > 6) {
+            // Exhausted all attempts
+            this.registrationError = `All names from "${baseName}" to "${baseName}.7" are already in use on the network`;
+            this.registrationStatus = 'failed';
+            (0, logger_1.err)("mDNS", this.registrationError);
+            (0, logger_1.err)("mDNS", "Please change the mdnsName in settings or stop other conflicting services");
+            return;
+        }
+        const tryName = attempt === 0 ? baseName : `${baseName}.${attempt + 1}`;
+        let service;
+        let conflictDetected = false;
+        let successTimeout = null;
+        // Create a wrapper to handle conflicts
+        const handleConflict = () => {
+            if (conflictDetected)
+                return;
+            conflictDetected = true;
+            // Clear the success timeout
+            if (successTimeout) {
+                clearTimeout(successTimeout);
+                successTimeout = null;
             }
-            catch (publishError) {
-                if (publishError.message && publishError.message.includes('already in use')) {
-                    (0, logger_1.err)("mDNS", `Service name "${name}" is already in use. This is usually harmless - continuing anyway.`);
-                    (0, logger_1.err)("mDNS", "The old service registration will expire in ~30 seconds.");
+            // Unpublish the conflicting service
+            if (service) {
+                try {
+                    service.stop();
                 }
-                else {
-                    (0, logger_1.err)("mDNS", `Service publish error: ${publishError.message}`);
+                catch (e) {
+                    // Ignore errors during stop
                 }
-                // Continue anyway - service will work once the old registration expires
             }
-            // Handle service errors - especially "already in use" errors
+            (0, logger_1.err)("mDNS", `Name "${tryName}" is already in use, trying next suffix...`);
+            // Try next suffix
+            setImmediate(() => {
+                this.tryRegisterWithSuffix(baseName, primaryPort, ports, version, attempt + 1);
+            });
+        };
+        try {
+            service = this.bonjour.publish({
+                name: tryName,
+                type: 'http',
+                port: primaryPort,
+                txt: {
+                    version: version || '1.0.0',
+                    ports: ports.join(','),
+                    path: '/'
+                }
+            });
+            // Set up error handler on the service
             if (service) {
                 service.on('error', (error) => {
                     if (error.message.includes('already in use')) {
-                        (0, logger_1.err)("mDNS", `Service name "${name}" is already in use. Another instance may be running.`);
-                        (0, logger_1.err)("mDNS", "To fix: 1) Stop other instances, or 2) Change the mdnsName in settings, or 3) Wait 30s for old service to expire");
+                        handleConflict();
                     }
-                    else {
+                    else if (!conflictDetected) {
+                        this.registrationError = error.message;
+                        this.registrationStatus = 'failed';
                         (0, logger_1.err)("mDNS", `Service error: ${error.message}`);
                     }
                 });
             }
-            // Publish the hostname A record (like ESP32 MDNS.begin())
-            this.publishHostname(name);
+            // Wait longer before declaring success - conflicts come from network
+            successTimeout = setTimeout(() => {
+                if (!conflictDetected) {
+                    // Success!
+                    this.registeredName = tryName;
+                    this.registrationStatus = 'success';
+                    this.registrationError = null;
+                    if (attempt > 0) {
+                        (0, logger_1.log)("mDNS", `⚠️  Original name "${baseName}" was taken, registered as "${tryName}.local" instead`);
+                    }
+                    else {
+                        (0, logger_1.log)("mDNS", `✓ HTTP service registered: ${tryName}.local on port(s) ${ports.join(', ')}`);
+                    }
+                    // Publish the hostname A record (like ESP32 MDNS.begin())
+                    this.publishHostname(tryName);
+                }
+            }, 2000); // Wait 2 seconds for network conflict responses
         }
-        catch (e) {
-            if (e.message.includes('already in use')) {
-                (0, logger_1.err)("mDNS", `Service name "${this.config.name}" is already in use on the network`);
-                (0, logger_1.err)("mDNS", "Possible causes: 1) Another instance is running, 2) Previous instance didn't clean up properly");
-                (0, logger_1.err)("mDNS", "Solutions: Stop other instances, or restart with a different service name in settings");
+        catch (publishError) {
+            if (publishError.message && publishError.message.includes('already in use')) {
+                // This name is taken, try the next one
+                (0, logger_1.err)("mDNS", `Name "${tryName}" is taken (sync error), trying next suffix...`);
+                setImmediate(() => {
+                    this.tryRegisterWithSuffix(baseName, primaryPort, ports, version, attempt + 1);
+                });
             }
             else {
-                (0, logger_1.err)("mDNS", `Failed to register service: ${e.message.split('\n')[0]}`);
+                // Different error, stop trying
+                this.registrationError = publishError.message;
+                this.registrationStatus = 'failed';
+                (0, logger_1.err)("mDNS", `Service publish error: ${publishError.message}`);
             }
         }
     }

package/server/platform.js

@@ -48,6 +48,13 @@ class Platform extends base_1.Base {
             (0, logger_1.log)("homebridge", "try doing upgrade from pre v6.2 versions");
             this.doUpgradeV62();
         }
+        // we're running under HomeBridge/Platform -> always set proxy kind to "gw"
+        if (!this.config.proxy) {
+            this.config.proxy = Object.assign({}, proxy_1.kEmptyProxy);
+        }
+        else if (this.config.proxy.kind !== "gw") {
+            this.config.proxy.kind = "gw";
+        }
         (0, logger_1.log)("homebridge", "running in " + ((this.config.debug) ? "debug" : "prod") + " mode in directory: " + process.cwd());
         (0, logger_1.log)("homebridge", "with config:" + JSON.stringify(this.config, null, 2));
         // save config for other components

package/server/proxy.js

@@ -9,18 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.setProxyConfig = exports.setWebApp = exports.kEmptyProxy = void 0;
+exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.gCloudConnections = exports.setProxyConfig = exports.setWebApp = exports.kEmptyProxy = void 0;
 const net = require("net");
 const child_process_1 = require("child_process");
 const process_1 = require("process");
 exports.kEmptyProxy = {
     cloudServer: "masters.duotecno.eu",
     cloudPort: 5097,
+    configPort: 5099,
     masterAddress: "",
     masterPort: 5001,
+    masterConfigPort: 8080,
     uniqueId: "",
+    configUniqueId: "",
     debug: false,
-    kind: "gw" // default running under PM2 or other process manager -> don't restart yourself
+    kind: "gw" // default running under the gateway 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
@@ -34,26 +37,20 @@ function setProxyConfig(c) {
     if (c) {
         config.cloudServer = c.cloudServer || exports.kEmptyProxy.cloudServer;
         config.cloudPort = c.cloudPort || exports.kEmptyProxy.cloudPort;
+        config.configPort = c.configPort || exports.kEmptyProxy.configPort;
         config.masterAddress = c.masterAddress || exports.kEmptyProxy.masterAddress;
         config.masterPort = c.masterPort || exports.kEmptyProxy.masterPort;
+        config.masterConfigPort = c.masterConfigPort || exports.kEmptyProxy.masterConfigPort;
         config.uniqueId = c.uniqueId || exports.kEmptyProxy.uniqueId;
+        config.configUniqueId = c.configUniqueId || exports.kEmptyProxy.configUniqueId;
         config.debug = !!c.debug;
         config.kind = c.kind || exports.kEmptyProxy.kind;
     }
     return config;
 }
 exports.setProxyConfig = setProxyConfig;
-try {
-    const configPath = require.resolve('../config-proxy.json');
-    console.log(`[PROXY] Using config file at: ${configPath}`);
-    setProxyConfig(require(configPath));
-}
-catch (e) {
-    setProxyConfig();
-    log("[PROXY] No config-proxy.json found, using default values from homebridge or other.");
-}
 let connectionChecker = null;
-const gCloudConnections = [];
+exports.gCloudConnections = [];
 const kDebug = config.debug || false; // enable debug mode from config
 /////////////
 // Logging //
@@ -78,13 +75,14 @@ function error(str) {
 // 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');
+    setProxyConfig(require("/../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
+    setProxyConfig();
     log("[PROXY] No config-proxy.json found, waiting for Platform to start proxy...");
 }
 function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count = 1) {
@@ -108,8 +106,8 @@ function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId
         cloudSocket.write(`[${uniqueId}]`);
         debug(`[PROXY] → [CLOUD] Sent unique ID: ${uniqueId}`);
         const context = new Context(cloudSocket, master, masterPort, server, serverPort, uniqueId);
-        gCloudConnections.push(context);
-        log(`[PROXY] → [CLOUD] New free connection #${gCloudConnections.length} to the Cloud at ${server}:${serverPort}`);
+        exports.gCloudConnections.push(context);
+        log(`[PROXY] → [CLOUD] New free connection #${exports.gCloudConnections.length} to the Cloud at ${server}:${serverPort}`);
     });
 }
 exports.makeNewCloudConnection = makeNewCloudConnection;
@@ -117,23 +115,41 @@ exports.makeNewCloudConnection = makeNewCloudConnection;
 // Restarting //
 ////////////////
 function cleanStart(restart = false) {
-    if (gCloudConnections === null || gCloudConnections === void 0 ? void 0 : gCloudConnections.length) {
-        gCloudConnections.forEach(ctx => ctx.cleanupSockets());
-        log(`[PROXY] → [CLOUD] Cleaned up all ${gCloudConnections.length} cloud connections.`);
-        gCloudConnections.splice(0, gCloudConnections.length); // clear the array
+    if (exports.gCloudConnections === null || exports.gCloudConnections === void 0 ? void 0 : exports.gCloudConnections.length) {
+        exports.gCloudConnections.forEach(ctx => ctx.cleanupSockets());
+        log(`[PROXY] → [CLOUD] Cleaned up all ${exports.gCloudConnections.length} cloud connections.`);
+        exports.gCloudConnections.splice(0, exports.gCloudConnections.length); // clear the array
     }
     if (connectionChecker) {
         clearInterval(connectionChecker);
         connectionChecker = null;
     }
     if (restart) {
-        log(`[PROXY] → [CLOUD] Restarting proxy... for ${config.uniqueId}.`);
-        if (config.uniqueId) {
-            log(`[PROXY] Starting proxy with config: ${JSON.stringify(config, null, 2)}`);
+        log(`[PROXY] → [CLOUD] Restarting proxy...`);
+        let connectionsStarted = 0;
+        // Start connection for the master device if uniqueId is configured
+        if (config.uniqueId && config.masterAddress) {
+            log(`[PROXY] Starting proxy for master device: ${config.uniqueId}`);
             makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, config.uniqueId);
+            connectionsStarted++;
+        }
+        else if (config.uniqueId) {
+            log(`[PROXY] → [CLOUD] Master uniqueId configured but no masterAddress, skipping master connection.`);
+        }
+        // Start TCP proxy for Config API if masterConfigPort is configured
+        // Use uniqueId:8080 pattern (or configUniqueId if explicitly set for backward compatibility)
+        if (config.uniqueId && config.masterAddress && config.masterConfigPort) {
+            const configId = config.configUniqueId || `${config.uniqueId}:${config.masterConfigPort}`;
+            log(`[PROXY] Starting TCP proxy for Config API: ${configId} -> ${config.masterAddress}:${config.masterConfigPort}`);
+            // All connections use the same cloud port for WebSocket multiplexing
+            makeNewCloudConnection(config.masterAddress, config.masterConfigPort, config.cloudServer, config.cloudPort, configId);
+            connectionsStarted++;
+        }
+        if (connectionsStarted > 0) {
+            log(`[PROXY] Started ${connectionsStarted} proxy connection(s) with config: ${JSON.stringify(config, null, 2)}`);
             // check every 16 second for a free connection
             connectionChecker = setInterval(() => {
-                const freeConnection = gCloudConnections.find((ctx) => (!ctx.deviceSocket) && ctx.cloudSocket && (ctx.cloudSocket.readyState === 'open'));
+                const freeConnection = exports.gCloudConnections.find((ctx) => (!ctx.deviceSocket) && ctx.cloudSocket && (ctx.cloudSocket.readyState === 'open'));
                 if (freeConnection) {
                     debug(`[PROXY] → [CLOUD] Found free connection #${freeConnection.uniqueId} to the Cloud -> we're still ok.`);
                 }
@@ -144,7 +160,7 @@ function cleanStart(restart = false) {
             }, 16 * 1000);
         }
         else {
-            log(`[PROXY] → [CLOUD] Not restarting, no unique ID configured, not starting the proxy.`);
+            log(`[PROXY] → [CLOUD] Not restarting, no unique IDs configured, not starting the proxy.`);
         }
     }
     else {
@@ -161,6 +177,15 @@ class Context {
         this.server = server;
         this.serverPort = serverPort;
         this.uniqueId = uniqueId;
+        // Gateway connections have no master address (they handle HTTP, not TCP proxy)
+        this.isGateway = !master || master === "";
+        this.deviceStatus = {
+            connected: false,
+            lastAttempt: null,
+            lastSuccess: null,
+            lastError: null,
+            retryCount: 0
+        };
         this.setupCloudSocket();
     }
     setupCloudSocket() {
@@ -199,12 +224,21 @@ class Context {
                 // Handle connection response from the cloud server
             }
             else {
-                // There is real incomming data, it's a fresh connection, so: a new client wants to connect to the device
-                // 1) create a new (free) connection to the cloud server for the next client
-                // 2) connect to the device and send the initial data
-                log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${config.uniqueId}.`);
-                makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId);
-                this.makeDeviceConnection(this.master, this.masterPort, data);
+                // There is real incoming data, it's a fresh connection, so: a new client wants to connect
+                if (this.isGateway) {
+                    // Gateway connection - forward HTTP request to local HTTP gateway on port 5002
+                    log(`[PROXY] → [CLOUD] New client connection for gateway: ${this.uniqueId}.`);
+                    makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId);
+                    this.makeDeviceConnection("localhost", 5002, data);
+                }
+                else {
+                    // Device connection - create TCP proxy to master device
+                    // 1) create a new (free) connection to the cloud server for the next client
+                    // 2) connect to the device and send the initial data
+                    log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/device: ${this.uniqueId}.`);
+                    makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId);
+                    this.makeDeviceConnection(this.master, this.masterPort, data);
+                }
             }
         }
         else if (this.deviceSocket.readyState === 'open') {
@@ -217,8 +251,25 @@ class Context {
     }
     makeDeviceConnection(address, port, data) {
         log(`[PROXY] → [DEVICE] Attempting to connect to local device at ${address}:${port}`);
+        this.deviceStatus.lastAttempt = new Date();
         if (!this.deviceSocket) {
             this.deviceSocket = new net.Socket();
+            // Add error handler BEFORE connecting to prevent uncaught exceptions
+            this.deviceSocket.on('error', (err) => {
+                error(`[DEVICE] → [PROXY] Connection error: ${err.message}`);
+                // Update device status
+                this.deviceStatus.connected = false;
+                this.deviceStatus.lastError = err.message;
+                this.deviceStatus.retryCount++;
+                log(`[DEVICE] → [PROXY] Connection failed. Will retry on next cloud request.`);
+                // Clean up this socket
+                if (this.deviceSocket && !this.deviceSocket.destroyed) {
+                    this.deviceSocket.destroy();
+                }
+                this.deviceSocket = null;
+                // Don't create a new cloud connection - we already have one!
+                // The device connection will be retried when the next data comes from the cloud
+            });
             // Connect to local device and send the data that came in from the cloud
             this.deviceSocket.connect(port, address, () => {
                 // Check if socket is still valid (not cleaned up by removeConnection)
@@ -227,6 +278,11 @@ class Context {
                     return;
                 }
                 log(`[PROXY] → [DEVICE] Connected to local device at ${address}:${port}`);
+                // Update device status
+                this.deviceStatus.connected = true;
+                this.deviceStatus.lastSuccess = new Date();
+                this.deviceStatus.lastError = null;
+                this.deviceStatus.retryCount = 0;
                 this.setUpDeviceSocket();
                 log(`[PROXY] → [DEVICE] Sending initial message: ${data.toString().trim()}`);
                 this.deviceSocket.write(data);
@@ -254,10 +310,8 @@ class Context {
             log(`[DEVICE] → [PROXY] Device socket closed`);
             this.removeConnection();
         });
-        this.deviceSocket.on('error', (err) => {
-            error(`[DEVICE] → [PROXY] Device socket error: ${err.message}`);
-            this.removeConnection();
-        });
+        // Note: error handler is already added in makeDeviceConnection()
+        // Don't add duplicate error handler here
     }
     cleanupSockets() {
         // Clean up the device socket
@@ -280,12 +334,12 @@ class Context {
         }
     }
     removeConnection() {
-        const index = gCloudConnections.indexOf(this);
+        const index = exports.gCloudConnections.indexOf(this);
         if (index !== -1)
-            gCloudConnections.splice(index, 1);
+            exports.gCloudConnections.splice(index, 1);
         this.cleanupSockets();
         log(`[PROXY] → [CLOUD] Closed socket to Cloud and removed context for device ${this.master}`);
-        if (gCloudConnections && gCloudConnections.length === 0) {
+        if (exports.gCloudConnections && exports.gCloudConnections.length === 0) {
             log(`[PROXY] → [CLOUD] No more cloud connections, restarting proxy.`);
             // just to be sure: restart...
             if (config.kind === "pm2") {
@@ -346,9 +400,9 @@ function handleShutdown(signal) {
             connectionChecker = null;
         }
         // Close all cloud connections
-        if (gCloudConnections && gCloudConnections.length > 0) {
-            gCloudConnections.forEach(ctx => ctx.cleanupSockets());
-            gCloudConnections.splice(0, gCloudConnections.length);
+        if (exports.gCloudConnections && exports.gCloudConnections.length > 0) {
+            exports.gCloudConnections.forEach(ctx => ctx.cleanupSockets());
+            exports.gCloudConnections.splice(0, exports.gCloudConnections.length);
         }
         // Close HTTP servers if available
         if (gWebApp && typeof gWebApp.closeServers === 'function') {
@@ -360,15 +414,16 @@ function handleShutdown(signal) {
                 error(`[PROXY] → [SYSTEM] Error closing servers: ${e.message}`);
             }
         }
-        log(`[PROXY] → [SYSTEM] All connections closed. Exiting.`);
+        log(`[PROXY] → [SYSTEM] All connections closed.`);
         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);
+            log(`[PROXY] → [SYSTEM] Running under HomeBridge/Gateway - NOT calling process.exit() to avoid restarting entire system.`);
+            log(`[PROXY] → [SYSTEM] Plugin will remain running. Check /settings page for connection status.`);
+            // Don't call process.exit() when running under HomeBridge!
+            // This would restart the entire HomeBridge + UI system
         }
     });
 }

package/server/smartapp.js

@@ -327,11 +327,16 @@ class SmartApp extends webapp_1.WebApp {
                 // save the proxy config
                 config.cloudServer = context.getParam({ name: "cloudServer", type: "string" });
                 config.cloudPort = context.getParam({ name: "cloudPort", type: "integer" });
+                config.configPort = context.getParam({ name: "configPort", type: "integer" });
                 config.masterAddress = context.getParam({ name: "masterAddress", type: "string" });
                 config.masterPort = context.getParam({ name: "masterPort", type: "integer" });
+                config.masterConfigPort = context.getParam({ name: "masterConfigPort", type: "integer" });
                 config.uniqueId = context.getParam({ name: "uniqueId", type: "string" });
+                config.configUniqueId = context.getParam({ name: "configUniqueId", type: "string" });
                 this.write("proxy", config);
                 (0, proxy_1.setProxyConfig)(config);
+                // Automatically restart proxy with new config
+                (0, proxy_1.cleanStart)(true);
             }
             else if (context.action === "restart") {
                 (0, proxy_1.cleanStart)(true);
@@ -339,7 +344,13 @@ class SmartApp extends webapp_1.WebApp {
             else {
                 // just show the proxy config
             }
-            return this.ejs("proxy", context, { config });
+            // Get mDNS status for display
+            const mdnsStatus = this.mdnsService ? {
+                registeredName: this.mdnsService.registeredName,
+                registrationError: this.mdnsService.registrationError,
+                registrationStatus: this.mdnsService.registrationStatus
+            } : null;
+            return this.ejs("proxy", context, { config, connections: proxy_1.gCloudConnections, mdnsStatus });
         });
     }
     //////////////
@@ -363,36 +374,6 @@ class SmartApp extends webapp_1.WebApp {
                 context.request = "restart";
                 return this.doRestart(false);
             }
-            else if (context.action === "install") {
-                // Network IP configuration - temporarily disabled
-                // TODO: Re-implement DHCP configuration
-                message = "Network IP configuration is temporarily disabled. Use 'Save Settings' for mDNS configuration.";
-                /* Commented out until DHCP implementation is fixed
-                config = this.scrapeSettings(context);
-                context.request = "install";
-                this.write("settings", config);
-                this.writeDHCP(context, <SettingsConfig>config);
-                */
-            }
-            else if (context.action === "reset") {
-                // Reset to DHCP - temporarily disabled
-                // TODO: Re-implement DHCP reset
-                message = "DHCP reset is temporarily disabled.";
-                /* Commented out until DHCP implementation is fixed
-                config = { ...kEmptySettings };
-                this.resetDHCP(context);
-                this.write("settings", config);
-                return this.doReboot(context, false);
-                */
-            }
-            else if (context.action === "reboot") {
-                // System reboot - temporarily disabled
-                // TODO: Re-enable after testing
-                message = "System reboot is temporarily disabled.";
-                /* Commented out until we want to enable system reboot
-                return this.doReboot(context, false);
-                */
-            }
             else {
                 // Just display the settings form
             }
@@ -1389,7 +1370,7 @@ class SmartApp extends webapp_1.WebApp {
     //////////////////////////////
     doUnits(context) {
         return __awaiter(this, void 0, void 0, function* () {
-            // get masterAddress and Port
+            // get master Address and Port into "masterAddress" & "masterPort"
             context.getMaster("action", "node");
             const master = this.system.findMaster(context["masterAddress"], context["masterPort"]);
             if (context.action === "save") {
@@ -1405,6 +1386,15 @@ class SmartApp extends webapp_1.WebApp {
                 context.action = "edit";
                 return this.doRequest(context);
             }
+            else if (context.action === "register") {
+                // master=...&port=...&register=...&value=...
+                if (!master)
+                    return this.error(context, "master not found", true);
+                const register = context.getParam({ name: "register", type: "integer", default: 0 });
+                const value = context.getParam(kValue);
+                yield master.setRegisterValue(register, value);
+                return this.json({ register, value });
+            }
             else if (context.action === "set") {
                 if (!master)
                     return this.error(context, "master not found", true);

package/server/views/head.ejs

@@ -1,5 +1,6 @@
 <meta charset="UTF-8">
 <link type="text/css" rel="stylesheet" href="/files/min.css"  media="screen,projection"/>
+<title>Duotecno Gateway</title>
 
 <!--Let browser know website is optimized for mobile-->
 <meta name="viewport" content="width=device-width, initial-scale=1.0"/>