homebridge-smartsystem 7.1.21 → 7.1.23

package/accessories/accessory.js

@@ -49,7 +49,7 @@ class Accessory {
     getState(next) {
         if (this.unit) {
             (0, logger_1.log)("accessory", "getState was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status);
-            next(null, this.unit.status);
+            next(null, !!this.unit.status);
         }
         else {
             next(new Error("accessory - getState needs to be overridden if no unit is provided."));
@@ -81,7 +81,7 @@ class Accessory {
             next(new Error("accessory - setState needs to be overridden if no unit is provided."));
     }
     updateState() {
-        this.me.getCharacteristic(this.homebridge.Characteristic.On).updateValue(this.unit.status);
+        this.me.getCharacteristic(this.homebridge.Characteristic.On).updateValue(!!this.unit.status);
         (0, logger_1.log)("accessory", "Received status change -> update accessory -> " + this.unit.getName() + " -> on = " + this.unit.status);
     }
 }

package/accessories/dimmer.js

@@ -28,9 +28,10 @@ class Dimmer extends accessory_1.Accessory {
         return [lightbulbService];
     }
     getBrightness(next) {
+        var _a;
         if (this.unit) {
             (0, logger_1.log)("accessory", "getBrightness was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
-            next(null, this.unit.value);
+            next(null, (_a = this.unit.value) !== null && _a !== void 0 ? _a : 0);
         }
         else {
             next(new Error("accessory - getBrightness needs to be overridden if no unit is provided."));

package/accessories/temperature.js

@@ -21,9 +21,10 @@ class Temperature extends accessory_1.Accessory {
         return [temperatureService];
     }
     getTemperature(next) {
+        var _a;
         if (this.unit) {
             (0, logger_1.log)("accessory", "getTemperature was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
-            const limited = Math.max(-100, Math.min(100, this.unit.value / 10.0));
+            const limited = Math.max(-100, Math.min(100, ((_a = this.unit.value) !== null && _a !== void 0 ? _a : 0) / 10.0));
             next(null, limited);
         }
         else {

package/duotecno/types.js

@@ -424,7 +424,11 @@ exports.Sanitizers = {
         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) || "";
         c.masterPort = (config === null || config === void 0 ? void 0 : config.masterPort) || ((_b = system === null || system === void 0 ? void 0 : system.cmasters[0]) === null || _b === void 0 ? void 0 : _b.port) || 5001;
-        c.uniqueId = (config === null || config === void 0 ? void 0 : config.uniqueId) || proxy_1.kEmptyProxy.uniqueId;
+        c.masterConfigPort = (config === null || config === void 0 ? void 0 : config.masterConfigPort) || proxy_1.kEmptyProxy.masterConfigPort;
+        c.installationId = (config === null || config === void 0 ? void 0 : config.installationId) || proxy_1.kEmptyProxy.installationId;
+        c.nodeNumber = (typeof (config === null || config === void 0 ? void 0 : config.nodeNumber) === "number") ? config.nodeNumber : proxy_1.kEmptyProxy.nodeNumber;
+        c.httpEnabled = !!(config === null || config === void 0 ? void 0 : config.httpEnabled);
+        c.gatewayPhysicalId = (config === null || config === void 0 ? void 0 : config.gatewayPhysicalId) || proxy_1.kEmptyProxy.gatewayPhysicalId;
         c.kind = "gw";
         return c;
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-smartsystem",
   "displayname": "Duotecno Bridge",
-  "version": "7.1.21",
+  "version": "7.1.23",
   "description": "SmartServer (Proxy TCP sockets to the cloud, Smappee MQTT, Duotecno IP Nodes, Homekit interface)",
   "main": "index.js",
   "author": "Johan Coppieters",
@@ -36,7 +36,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/Duotecno-developer/smartsocket.git"
+    "url": "git+https://github.com/Duotecno-developer/smartsocket.git"
   },
   "dependencies": {
     "bonjour-service": "^1.3.0",

package/server/platform.js

@@ -125,7 +125,7 @@ class Platform extends base_1.Base {
         }
         // 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)) {
+        if (this.config.proxy && ((_a = this.config.proxy) === null || _a === void 0 ? void 0 : _a.installationId)) {
             this.config.proxy.kind = "gw";
             (0, proxy_1.setProxyConfig)(this.config.proxy);
             (0, proxy_1.cleanStart)(true);

package/server/proxy.js

@@ -9,19 +9,81 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.gCloudConnections = exports.setProxyConfig = exports.setWebApp = exports.kEmptyProxy = void 0;
+exports.Context = exports.cleanStart = exports.makeNewCloudConnection = exports.gCloudConnections = exports.setProxyConfig = exports.setWebApp = exports.kEmptyProxy = exports.gatewayHttpPort = exports.makeDeviceId = exports.kMasterNodeNumber = void 0;
 const net = require("net");
+const os = require("os");
 const child_process_1 = require("child_process");
 const process_1 = require("process");
+const config_1 = require("../duotecno/config");
+// Fixed, non-configurable logical node number every Duotecno master identifies itself with
+// on the bus -- used for both of the master's own registrations (raw protocol + Config API).
+exports.kMasterNodeNumber = 0xfc;
+// Registered names follow: [installationId].[node number as 2-digit hex].[protocol]:[port]
+// e.g. "gm.coppieters.be.ff.http:80" (gateway web UI), "gm.coppieters.be.fc.tcp:5001" (master)
+function makeDeviceId(config, nodeNumber, protocol, port) {
+    const nodeHex = (nodeNumber !== null && nodeNumber !== void 0 ? nodeNumber : 0xff).toString(16).padStart(2, '0');
+    return `${config.installationId}.${nodeHex}.${protocol}:${port}`;
+}
+exports.makeDeviceId = makeDeviceId;
+// Best-effort read of the local HTTP port the gateway's own web UI is listening on.
+function gatewayHttpPort() {
+    const port = gWebApp === null || gWebApp === void 0 ? void 0 : gWebApp.port;
+    if (Array.isArray(port))
+        return port[0] || 80;
+    return port || 80;
+}
+exports.gatewayHttpPort = gatewayHttpPort;
+// The cloud server can tell apart two different physical devices that were accidentally
+// registered under the same unique id (instead of assuming a reconnect and evicting the
+// other one), given a "physical address" -- 1-8 hex digits, formatted "0x..." -- alongside
+// the unique id at registration. Masters have a real one: the Duotecno bus physical address
+// of their own logical node (kMasterNodeNumber). Returns '' if not known yet (e.g. the master
+// hasn't finished its initial discovery), in which case no physical address is sent for this
+// registration, same as old firmware.
+function masterPhysicalAddress() {
+    const system = gWebApp === null || gWebApp === void 0 ? void 0 : gWebApp.system;
+    const master = (system === null || system === void 0 ? void 0 : system.findMaster) ? system.findMaster(config.masterAddress, config.masterPort) : null;
+    const node = (master === null || master === void 0 ? void 0 : master.findNode) ? master.findNode(exports.kMasterNodeNumber) : null;
+    const phys = node === null || node === void 0 ? void 0 : node.physicalAddress;
+    return (typeof phys === "number" && phys > 0) ? "0x" + phys.toString(16) : '';
+}
+// The gateway itself has no Duotecno bus address of its own. Prefer the last two groups of a
+// non-internal IPv6 address (8 hex digits total, e.g. "2afa:23fa:b95:9ebf" -> last two groups
+// "b95:9ebf" -> "0x0b959ebf") if one is available on this machine; otherwise fall back to a
+// random id generated once and persisted in config.json, so it stays stable across restarts
+// and lets the cloud tell two different physical gateways apart even if they were accidentally
+// given the same installation id.
+function gatewayPhysicalAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const name in interfaces) {
+        for (const iface of interfaces[name] || []) {
+            if ((iface.family === "IPv6" || iface.family === 6) && !iface.internal) {
+                const groups = iface.address.split(":").filter(g => g.length > 0);
+                if (groups.length >= 2) {
+                    const last2 = groups.slice(-2).map(g => g.padStart(4, '0')).join('');
+                    return "0x" + last2;
+                }
+            }
+        }
+    }
+    if (!config.gatewayPhysicalId) {
+        config.gatewayPhysicalId = "0x" + Math.floor(Math.random() * 0x100000000).toString(16).padStart(8, '0');
+        (0, config_1.setSubConfig)("proxy", config);
+        (0, config_1.setAPIConfig)();
+        log(`[PROXY] No IPv6 address available, generated and stored a random physical id for this gateway: ${config.gatewayPhysicalId}`);
+    }
+    return config.gatewayPhysicalId;
+}
 exports.kEmptyProxy = {
     cloudServer: "masters.duotecno.eu",
     cloudPort: 5097,
-    configPort: 5099,
     masterAddress: "",
     masterPort: 5001,
     masterConfigPort: 8080,
-    uniqueId: "",
-    configUniqueId: "",
+    installationId: "",
+    nodeNumber: 0xff,
+    httpEnabled: false,
+    gatewayPhysicalId: "",
     debug: false,
     kind: "gw" // default running under the gateway or other process manager -> don't restart yourself
 };
@@ -37,12 +99,13 @@ 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.installationId = c.installationId || exports.kEmptyProxy.installationId;
+        config.nodeNumber = (typeof c.nodeNumber === "number") ? c.nodeNumber : exports.kEmptyProxy.nodeNumber;
+        config.httpEnabled = !!c.httpEnabled;
+        config.gatewayPhysicalId = c.gatewayPhysicalId || exports.kEmptyProxy.gatewayPhysicalId;
         config.debug = !!c.debug;
         config.kind = c.kind || exports.kEmptyProxy.kind;
     }
@@ -85,27 +148,40 @@ catch (e) {
     setProxyConfig();
     log("[PROXY] No config-proxy.json found, waiting for Platform to start proxy...");
 }
-function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count = 1) {
+function makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count = 1, isGateway = false) {
     // retry making a cloud connection
     function reconnect(err) {
         error(`[PROXY] → [CLOUD] Failed to connect ${count} times to the Cloud server: ${err.code || err.message}`);
         if (count < 3) {
             setTimeout(() => {
-                makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count + 1);
+                makeNewCloudConnection(master, masterPort, server, serverPort, uniqueId, count + 1, isGateway);
             }, 1000 * count * count); // exponential backoff: 1 second, 4 seconds, 9 seconds -> give up
             // we check every 16 seconds for a free connection, if none found -> restart
         }
     }
+    // lets the cloud tell two genuinely different physical devices apart if they were ever
+    // accidentally configured with the same unique id, instead of assuming a reconnect
+    const physicalAddress = isGateway ? gatewayPhysicalAddress() : masterPhysicalAddress();
     const cloudSocket = new net.Socket();
     cloudSocket.once('error', reconnect);
-    log(`[PROXY] → [CLOUD] Attempt ${count} to start a new free connection for ${config.uniqueId} to the Cloud at ${server}:${serverPort}`);
+    // net.Socket.connect() has no default timeout: if the TCP handshake to the cloud gets
+    // silently dropped (packet loss, a flaky hop, no RST/FIN ever coming back), the socket
+    // just hangs forever with none of 'connect'/'error'/'close' ever firing, so this attempt
+    // would otherwise never retry and permanently lose this uniqueId's slot. Force it through
+    // the existing reconnect/backoff path instead.
+    cloudSocket.setTimeout(10000);
+    cloudSocket.once('timeout', () => {
+        cloudSocket.destroy(new Error('connection attempt timed out'));
+    });
+    log(`[PROXY] → [CLOUD] Attempt ${count} to start a new free connection for ${uniqueId} to the Cloud at ${server}:${serverPort}`);
     cloudSocket.connect(serverPort, server, () => {
         log(`[PROXY] → [CLOUD] Connected to Cloud at ${server}:${serverPort}`);
+        cloudSocket.setTimeout(0); // connected -- no longer subject to the connect-attempt timeout
         cloudSocket.removeListener('error', reconnect);
-        // Send unique ID as the first message to identify this proxy/device
-        cloudSocket.write(`[${uniqueId}]`);
-        debug(`[PROXY] → [CLOUD] Sent unique ID: ${uniqueId}`);
-        const context = new Context(cloudSocket, master, masterPort, server, serverPort, uniqueId);
+        // Send unique ID (and physical address, if known) as the first message to identify this proxy/device
+        cloudSocket.write(physicalAddress ? `[${uniqueId}][${physicalAddress}]` : `[${uniqueId}]`);
+        debug(`[PROXY] → [CLOUD] Sent unique ID: ${uniqueId}` + (physicalAddress ? ` physical address: ${physicalAddress}` : ''));
+        const context = new Context(cloudSocket, master, masterPort, server, serverPort, uniqueId, isGateway);
         exports.gCloudConnections.push(context);
         log(`[PROXY] → [CLOUD] New free connection #${exports.gCloudConnections.length} to the Cloud at ${server}:${serverPort}`);
     });
@@ -127,25 +203,35 @@ function cleanStart(restart = false) {
     if (restart) {
         log(`[PROXY] → [CLOUD] Restarting proxy...`);
         let connectionsStarted = 0;
-        // Start connection for the master device if uniqueId is configured
-        if (config.uniqueId && config.masterAddress) {
-            const masterId = `${config.uniqueId}:${config.masterPort}`;
+        // Start connection for the master device's raw protocol port if an installation ID is configured.
+        // Masters always register under the fixed master node number (kMasterNodeNumber), not the
+        // gateway's own (configurable) nodeNumber.
+        if (config.installationId && config.masterAddress) {
+            const masterId = makeDeviceId(config, exports.kMasterNodeNumber, "tcp", config.masterPort);
             log(`[PROXY] Starting proxy for master device: ${masterId}`);
             makeNewCloudConnection(config.masterAddress, config.masterPort, config.cloudServer, config.cloudPort, masterId);
             connectionsStarted++;
         }
-        else if (config.uniqueId) {
-            log(`[PROXY] → [CLOUD] Master uniqueId configured but no masterAddress, skipping master connection.`);
+        else if (config.installationId) {
+            log(`[PROXY] → [CLOUD] Installation ID 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}`);
+        // Start a proxy for the master's Config API port -- this is an HTTP API, so it's tagged
+        // "http" rather than "tcp" even though the tunnel itself just relays raw bytes either way.
+        if (config.installationId && config.masterAddress && config.masterConfigPort) {
+            const configId = makeDeviceId(config, exports.kMasterNodeNumber, "http", config.masterConfigPort);
+            log(`[PROXY] Starting 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++;
         }
+        // Register the gateway's own web UI (EJS) through the cloud, if enabled
+        if (config.installationId && config.httpEnabled) {
+            const httpPort = gatewayHttpPort();
+            const httpId = makeDeviceId(config, config.nodeNumber, "http", httpPort);
+            log(`[PROXY] Starting HTTP proxy for gateway web UI: ${httpId} -> localhost:${httpPort}`);
+            makeNewCloudConnection("localhost", httpPort, config.cloudServer, config.cloudPort, httpId, 1, true);
+            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
@@ -170,7 +256,15 @@ function cleanStart(restart = false) {
 }
 exports.cleanStart = cleanStart;
 class Context {
-    constructor(cloudSocket, master, masterPort, server, serverPort, uniqueId) {
+    constructor(cloudSocket, master, masterPort, server, serverPort, uniqueId, isGateway = false) {
+        // guards against handling the same unexpected drop twice (a socket error fires both
+        // 'error' and 'close') -- see handleUnexpectedClose()
+        this.closeHandled = false;
+        // deviceSocket is created synchronously but connect()s asynchronously; any further bytes of
+        // the SAME client request that arrive from the cloud before it's 'open' (a request split
+        // across TCP segments, or just event-loop timing under load) get buffered here and flushed
+        // once connected, instead of being silently dropped -- see handleDataFromCloud().
+        this.pendingDeviceData = [];
         this.deviceSocket = null;
         this.master = master;
         this.masterPort = masterPort;
@@ -178,8 +272,8 @@ 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 === "";
+        // Gateway connections forward to the gateway's own local web UI, not a Duotecno master
+        this.isGateway = isGateway;
         this.deviceStatus = {
             connected: false,
             lastAttempt: null,
@@ -196,19 +290,39 @@ class Context {
         });
         this.cloudSocket.on('close', () => {
             warning('[CLOUD] Connection closed');
-            if (this.deviceSocket) {
-                this.deviceSocket.end();
-                this.deviceSocket = null;
-            }
+            this.handleUnexpectedClose();
         });
         this.cloudSocket.on('error', err => {
             error(`[CLOUD] Error: ${err.message}`);
-            if (this.deviceSocket) {
-                this.deviceSocket.end();
-                this.deviceSocket = null;
-            }
+            this.handleUnexpectedClose();
         });
     }
+    // Fires only for a drop we did NOT initiate ourselves: cleanupSockets() (the normal end-of-life
+    // path, used both after a consumed connection finishes and during a full cleanStart()) always
+    // calls cloudSocket.removeAllListeners() before closing it, so these 'close'/'error' handlers
+    // never see that. What they DO see is the cloud server closing/erroring a still-FREE (not yet
+    // consumed) connection out from under us -- e.g. a missed heartbeat while we're busy serving a
+    // burst of requests. Previously that silently dropped the registration for its uniqueId with
+    // nothing replacing it, until either an unrelated connection happened to replenish it or the
+    // 16s "no free connection anywhere" safety net forced a full, disruptive restart of every
+    // registration. Replenish immediately instead.
+    handleUnexpectedClose() {
+        if (this.closeHandled)
+            return; // 'error' is always followed by 'close' -- only act once
+        this.closeHandled = true;
+        const wasFree = !this.deviceSocket;
+        if (this.deviceSocket) {
+            this.deviceSocket.end();
+            this.deviceSocket = null;
+        }
+        const index = exports.gCloudConnections.indexOf(this);
+        if (index !== -1)
+            exports.gCloudConnections.splice(index, 1);
+        if (wasFree) {
+            warning(`[PROXY] → [CLOUD] Free connection for ${this.uniqueId} dropped unexpectedly, registering a replacement.`);
+            makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId, 1, this.isGateway);
+        }
+    }
     handleDataFromCloud(data) {
         debug(`[CLOUD] → [PROXY]: Data from Cloud: ${data.toString()}`);
         if (!this.deviceSocket) {
@@ -226,20 +340,11 @@ class Context {
             }
             else {
                 // 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);
-                }
+                // 1) create a new (free) connection to the cloud server for the next client
+                // 2) connect to the local target (gateway web UI, or the master device) and send the initial data
+                log(`[PROXY] → [CLOUD] New client connection, creating new free connection for this proxy/${this.isGateway ? "gateway" : "device"}: ${this.uniqueId}.`);
+                makeNewCloudConnection(this.master, this.masterPort, this.server, this.serverPort, this.uniqueId, 1, this.isGateway);
+                this.makeDeviceConnection(this.master, this.masterPort, data);
             }
         }
         else if (this.deviceSocket.readyState === 'open') {
@@ -247,7 +352,9 @@ class Context {
             debug(`[PROXY] → [DEVICE] forwarding data to device: ${data.toString().trim()}`);
         }
         else {
-            warning(`[PROXY] → [DEVICE] Device socket is not open yet, waiting for connection... what to do with the data??`);
+            // still connecting to the local device -- buffer, don't drop; flushed in makeDeviceConnection()
+            debug(`[PROXY] → [DEVICE] Device socket not open yet, buffering ${data.length} bytes.`);
+            this.pendingDeviceData.push(data);
         }
     }
     makeDeviceConnection(address, port, data) {
@@ -262,17 +369,26 @@ class Context {
                 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
+                // The cloud already removed this tunnel from its free list the moment the client
+                // connected through it, so it's gone from its side regardless of what we do here --
+                // a fresh registration for this uniqueId was already kicked off back when this
+                // connection was first consumed. What we must NOT do is leave this Context sitting in
+                // gCloudConnections with deviceSocket === null: connectionChecker's "is there a free
+                // connection?" check would then mistake this dead entry for a healthy one (its
+                // cloudSocket may still be open) and never notice the tunnel is actually gone.
+                log(`[DEVICE] → [PROXY] Connection failed, cleaning up this tunnel.`);
+                this.removeConnection();
+            });
+            // give up (and clean up, same as an error) if connecting to our own local target hangs
+            this.deviceSocket.setTimeout(15000);
+            this.deviceSocket.once('timeout', () => {
+                var _a;
+                (_a = this.deviceSocket) === null || _a === void 0 ? void 0 : _a.destroy(new Error('connection attempt timed out'));
             });
             // Connect to local device and send the data that came in from the cloud
             this.deviceSocket.connect(port, address, () => {
+                var _a, _b;
+                (_a = this.deviceSocket) === null || _a === void 0 ? void 0 : _a.setTimeout(0); // connected -- no longer subject to the connect timeout
                 // Check if socket is still valid (not cleaned up by removeConnection)
                 if (!this.deviceSocket) {
                     warning(`[PROXY] → [DEVICE] Device socket was cleaned up before connection completed`);
@@ -287,6 +403,13 @@ class Context {
                 this.setUpDeviceSocket();
                 log(`[PROXY] → [DEVICE] Sending initial message: ${data.toString().trim()}`);
                 this.deviceSocket.write(data);
+                // flush anything that arrived from the cloud while we were still connecting, in order
+                if (this.pendingDeviceData.length) {
+                    debug(`[PROXY] → [DEVICE] Flushing ${this.pendingDeviceData.length} buffered chunk(s).`);
+                    for (const chunk of this.pendingDeviceData)
+                        (_b = this.deviceSocket) === null || _b === void 0 ? void 0 : _b.write(chunk);
+                    this.pendingDeviceData = [];
+                }
             });
         }
         else if (this.deviceSocket.readyState === 'open') {
@@ -314,23 +437,31 @@ class Context {
         // Note: error handler is already added in makeDeviceConnection()
         // Don't add duplicate error handler here
     }
+    // socket.write() only queues bytes -- it does not guarantee they've reached the network yet.
+    // end() politely flushes-then-closes, but destroy() called right after it does a hard abort
+    // that discards anything still sitting in the send buffer. The local (loopback) leg of a
+    // request finishes near-instantly, well before the remote (real internet) leg has actually
+    // finished transmitting a large response, so destroying immediately after end() was silently
+    // truncating every larger response (e.g. min.js/min.css) at whatever had made it out before
+    // cleanup ran. Give end() a real chance to drain; only force-destroy as a fallback in case a
+    // peer never acknowledges, so a socket can't linger forever either.
+    gracefulEnd(socket) {
+        if (socket.destroyed)
+            return;
+        socket.removeAllListeners();
+        socket.end();
+        setTimeout(() => { if (!socket.destroyed)
+            socket.destroy(); }, 5000);
+    }
     cleanupSockets() {
         // Clean up the device socket
         if (this.deviceSocket) {
-            if (!this.deviceSocket.destroyed) {
-                this.deviceSocket.removeAllListeners();
-                this.deviceSocket.end();
-                this.deviceSocket.destroy();
-            }
+            this.gracefulEnd(this.deviceSocket);
             this.deviceSocket = null;
         }
         // Clean up the cloud socket
         if (this.cloudSocket) {
-            if (!this.cloudSocket.destroyed) {
-                this.cloudSocket.removeAllListeners();
-                this.cloudSocket.end();
-                this.cloudSocket.destroy();
-            }
+            this.gracefulEnd(this.cloudSocket);
             this.cloudSocket = null;
         }
     }

package/server/smartapp.js

@@ -48,6 +48,18 @@ const kPin = { name: "pin", type: "string", default: "577-03-001" };
 // Mac file system -> write locally
 const isMac = (0, fs_1.existsSync)("/Volumes");
 const kDHCPConfigFile = isMac ? "./config.dhcpcd" : "/etc/dhcpcd.conf";
+// Simple minifier for our own hand-authored CSS (never run over vendor files, which ship
+// pre-minified): strips comments and collapses whitespace around punctuation. Not safe for
+// arbitrary CSS (e.g. strings containing "/*", or spacing-sensitive calc()) but fine for the
+// plain rules in custom.css.
+function minifyCSS(css) {
+    return css
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\s+/g, " ")
+        .replace(/\s*([{}:;,])\s*/g, "$1")
+        .replace(/;}/g, "}")
+        .trim();
+}
 class SmartApp extends webapp_1.WebApp {
     constructor(system, power, platform) {
         super("smartapp");
@@ -108,7 +120,46 @@ class SmartApp extends webapp_1.WebApp {
         this.addFile("materializeJS", __dirname + "/views/assets/materialize.min.js", "text/javascript");
         this.addFile("favicon", __dirname + "/views/assets/favicon.ico", "image/x-icon");
         this.addFile("logoWhite", __dirname + "/views/assets/Duotecno_logo_white.svg", "image/svg+xml");
+        this.addFile("customCSS", __dirname + "/views/assets/custom.css", "text/css");
         this.addFile("proxy", __dirname + "/views/proxy.ejs", "text/html");
+        this.buildBundle();
+    }
+    // Merge everything a page needs to look/behave right (Materialize CSS+JS, our own layout
+    // CSS, the Material Icons webfont) into a single cacheable /files/bundle.<version>.js so a
+    // page load needs at most 2 HTTP requests (the HTML itself, plus this bundle once per
+    // browser cache lifetime) instead of one per asset -- requests that get dropped when served
+    // through a flaky/limited proxy. It's loaded as a blocking <script> in <head> so it can
+    // inject the CSS (as a <style> element) before the body is parsed, avoiding a flash of
+    // unstyled content.
+    buildBundle() {
+        const fontBase64 = (0, fs_1.readFileSync)(__dirname + "/views/assets/material-icons.woff2").toString("base64");
+        const fontFaceCSS = `@font-face{font-family:'Material Icons';font-style:normal;font-weight:400;` +
+            `src:url(data:font/woff2;base64,${fontBase64}) format('woff2')}` +
+            `.material-icons{font-family:'Material Icons';font-weight:normal;font-style:normal;font-size:24px;` +
+            `line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;` +
+            `word-wrap:normal;direction:ltr;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased}`;
+        // materializeCSS/JS are already minified vendor files -- left untouched. Only our own
+        // hand-authored custom.css and the snippet below get compacted, since we know exactly
+        // what's in them (no url()/content: strings, every JS statement already ; or } terminated).
+        const bundleCSS = this.getFile("materializeCSS").content + "\n" + minifyCSS(this.getFile("customCSS").content) + "\n" + fontFaceCSS;
+        const customJS = `function hex(val){var num=parseInt(val,10);if(isNaN(num))return "0x0";return "0x"+num.toString(16);}
+function ajax(url,success){var xhr=window.XMLHttpRequest?new XMLHttpRequest():new ActiveXObject('Microsoft.XMLHTTP');xhr.open('GET',url);xhr.onreadystatechange=function(){if(xhr.readyState>3&&xhr.status==200)success(xhr.responseText);};xhr.setRequestHeader('X-Requested-With','XMLHttpRequest');xhr.send();return xhr;}
+document.addEventListener("keyup",function(e){if(e.key=="Enter")e.preventDefault();});
+function SmartSocketInit(message){
+  Array.prototype.forEach.call(document.getElementsByClassName("indeterminate"),function(element){element.indeterminate=true;});
+  M.AutoInit();
+  var sidenavElems=document.querySelectorAll('.sidenav');
+  M.Sidenav.init(sidenavElems,{edge:'right',draggable:true});
+  if(message)M.toast({html:message});
+  console.log("Ready to rock & roll");
+}`.replace(/\n\s*/g, "");
+        const bundleJS = `(function(){var s=document.createElement('style');s.textContent=${JSON.stringify(bundleCSS)};document.head.appendChild(s);})();\n` +
+            this.getFile("materializeJS").content + "\n" + customJS;
+        this.addContent("bundle", bundleJS, "application/javascript", "bundle.js");
+        const logoSvg = this.getFile("logoWhite").content.replace("<svg ", '<svg class="brand-logo-svg" ');
+        this.addContent("logoWhiteInline", logoSvg, "image/svg+xml", "logo.svg");
+        const faviconBase64 = (0, fs_1.readFileSync)(__dirname + "/views/assets/favicon.ico").toString("base64");
+        this.addContent("faviconDataUri", `data:image/x-icon;base64,${faviconBase64}`, "text/plain", "favicon.ico");
     }
     // Override to use config.system.debug for template caching control
     isDebugMode() {
@@ -330,12 +381,13 @@ 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" });
+                config.installationId = context.getParam({ name: "installationId", type: "string" });
+                config.nodeNumber = context.getParam({ name: "nodeNumber", type: "string" })
+                    ? parseInt(context.getParam({ name: "nodeNumber", type: "string" }), 16) : proxy_1.kEmptyProxy.nodeNumber;
+                config.httpEnabled = !!context.getParam({ name: "httpEnabled", type: "string" });
                 this.write("proxy", config);
                 (0, proxy_1.setProxyConfig)(config);
                 // Automatically restart proxy with new config
@@ -353,7 +405,14 @@ class SmartApp extends webapp_1.WebApp {
                 registrationError: this.mdnsService.registrationError,
                 registrationStatus: this.mdnsService.registrationStatus
             } : null;
-            return this.ejs("proxy", context, { config, connections: proxy_1.gCloudConnections, mdnsStatus });
+            // Names this gateway will register on the cloud server with the current config.
+            // The master's two connections always use the fixed master node number, not config.nodeNumber.
+            const deviceIds = {
+                tcp: (0, proxy_1.makeDeviceId)(config, proxy_1.kMasterNodeNumber, "tcp", config.masterPort || proxy_1.kEmptyProxy.masterPort),
+                configHttp: (0, proxy_1.makeDeviceId)(config, proxy_1.kMasterNodeNumber, "http", config.masterConfigPort || proxy_1.kEmptyProxy.masterConfigPort || 8080),
+                http: (0, proxy_1.makeDeviceId)(config, config.nodeNumber, "http", (0, proxy_1.gatewayHttpPort)()),
+            };
+            return this.ejs("proxy", context, { config, connections: proxy_1.gCloudConnections, mdnsStatus, deviceIds });
         });
     }
     //////////////
@@ -1563,7 +1622,15 @@ class SmartApp extends webapp_1.WebApp {
     //////////////////////////////
     renderAssets(context) {
         const file = context.action;
-        if ((file === "min.css") || (file === "materialize.min.css") || (file === "materialize.css")) {
+        if (file.startsWith("bundle.") && file.endsWith(".js")) {
+            // filename carries the plugin version so a release automatically busts old caches
+            const bundle = this.getFile("bundle");
+            return {
+                status: 200, type: bundle.type, data: bundle.content,
+                header: { "Cache-Control": "public, max-age=31536000, immutable" }
+            };
+        }
+        else if ((file === "min.css") || (file === "materialize.min.css") || (file === "materialize.css")) {
             return this.file("materializeCSS");
         }
         else if ((file === "min.js") || (file === "materialize.min.js") || (file === "materialize.js")) {