homebridge-smartsystem 6.8.13 → 7.0.1

package/server/smartapp.js

@@ -29,6 +29,7 @@ const config_1 = require("../duotecno/config");
 const HB_1 = require("./HB");
 const HA_API_1 = require("./HA-API");
 const proxy_1 = require("./proxy");
+const WebSocket = require("ws");
 const kMaster = { name: "master", type: "string", default: "0.0.0.0:5001" };
 const kAddress = { name: "address", type: "string", default: "0.0.0.0" };
 const kAddresses = { name: "addresses", type: "string", default: "[0.0.0.0]" };
@@ -56,15 +57,37 @@ class SmartApp extends webapp_1.WebApp {
         this.system.emitter.on('update', this.informLinks.bind(this));
         this.system.emitter.on('plug', this.alertSwitch.bind(this));
         // get some configurated params
-        this.port = this.config.port || this.port || 80;
+        const configuredPort = this.config.port || 80;
         this.password = platform.config.password || this.config.password || "";
         this.user = platform.config.user || this.config.user || "pi";
+        // Set up multi-port listening if port is not 80
+        // Note: Port 80 requires root/sudo on Unix-like systems
+        // For development on macOS/Linux without sudo, use only configured port
+        if (configuredPort !== 80) {
+            // Check if we're running with appropriate privileges (process.getuid exists only on Unix)
+            const canBindPort80 = process.platform === 'win32' || (process.getuid && process.getuid() === 0);
+            if (canBindPort80) {
+                (0, logger_1.log)("smartapp", `Configured for dual-port mode: ${configuredPort} and 80`);
+                this.port = [80, configuredPort];
+            }
+            else {
+                (0, logger_1.log)("smartapp", `Running without root privileges - listening only on port ${configuredPort}`);
+                (0, logger_1.log)("smartapp", `To enable port 80, run with sudo or use: sudo setcap 'cap_net_bind_service=+ep' $(which node)`);
+                this.port = configuredPort;
+            }
+        }
+        else {
+            this.port = 80;
+        }
+        // Initialize mDNS service
+        this.setupMDNS();
         this.system = system;
         this.power = power;
         this.platform = platform;
         // when all masters are loaded -> attach units to the switches
         this.system.emitter.on('ready', this.initSwitchUnits.bind(this));
         this.system.emitter.on('ready', this.initLinks.bind(this));
+        this.system.emitter.on('ready', this.initDeviceUnits.bind(this));
         this.addFile("unitList", __dirname + "/views/unit-list.ejs", "application/json");
         this.addFile("masterList", __dirname + "/views/master-list.ejs", "text/html");
         this.addFile("masterDetail", __dirname + "/views/master-detail.ejs", "text/html");
@@ -77,17 +100,77 @@ class SmartApp extends webapp_1.WebApp {
         this.addFile("switchList", __dirname + "/views/switch-list.ejs", "text/html");
         this.addFile("linkDetail", __dirname + "/views/link-details.ejs", "text/html");
         this.addFile("linkList", __dirname + "/views/link-list.ejs", "text/html");
+        this.addFile("deviceDetail", __dirname + "/views/device-details.ejs", "text/html");
+        this.addFile("deviceList", __dirname + "/views/device-list.ejs", "text/html");
         this.addFile("powerRule", __dirname + "/views/power-rule.ejs", "text/html");
         this.addFile("powerBinding", __dirname + "/views/power-binding.ejs", "text/html");
         this.addFile("materializeCSS", __dirname + "/views/assets/materialize.min.css", "text/css");
         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("proxy", __dirname + "/views/proxy.ejs", "text/html");
     }
+    // Override to use config.system.debug for template caching control
+    isDebugMode() {
+        var _a, _b;
+        return ((_b = (_a = this.system) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.debug) === true;
+    }
+    setupMDNS() {
+        // Read settings to get configured mDNS name
+        const settings = this.read("settings");
+        const mdnsName = (settings === null || settings === void 0 ? void 0 : settings.mdnsName) || "duotecno-gateway";
+        const version = require('../package.json').version;
+        // Initialize mDNS through parent class
+        this.initMDNS(mdnsName, version);
+    }
+    serve(onConnected) {
+        // Initialize WebSocket servers array
+        this.wsServers = [];
+        // Call parent serve method
+        super.serve(() => {
+            // Set up WebSocket servers on the HTTP servers
+            this.setupWebSocketServers();
+            // Register mDNS service after server is listening
+            this.registerMDNS();
+            // Call the original callback if provided
+            if (onConnected) {
+                onConnected();
+            }
+        });
+    }
+    setupWebSocketServers() {
+        // Get all HTTP servers
+        this.servers.forEach((httpServer, index) => {
+            const wss = new WebSocket.Server({ server: httpServer, path: '/devices' });
+            this.wsServers.push(wss);
+            wss.on('connection', (ws) => {
+                (0, logger_1.log)("smartapp", `WebSocket client connected on server ${index}`);
+                // Send initial device list
+                this.sendDeviceList(ws);
+                ws.on('message', (message) => {
+                    try {
+                        const data = JSON.parse(message.toString());
+                        this.handleDeviceMessage(ws, data);
+                    }
+                    catch (e) {
+                        (0, logger_1.err)("smartapp", `Invalid WebSocket message: ${e.message}`);
+                    }
+                });
+                ws.on('close', () => {
+                    (0, logger_1.log)("smartapp", `WebSocket client disconnected from server ${index}`);
+                });
+                ws.on('error', (error) => {
+                    (0, logger_1.err)("smartapp", `WebSocket error on server ${index}: ${error.message}`);
+                });
+            });
+            (0, logger_1.log)("smartapp", `WebSocket server ${index} set up on path /devices`);
+        });
+    }
     writeConfig() {
         // copy switches into config, eliminate the runtime stuff (like unit)
         this.config.switches = this.switches.map(s => types_1.Sanitizers.makeSwitchConfig(s));
         this.config.links = this.links.map(s => types_1.Sanitizers.makeLinkConfig(s));
+        this.config.devices = this.devices.map(d => types_1.Sanitizers.makeDeviceConfig(d));
         super.writeConfig();
     }
     readConfig() {
@@ -95,6 +178,7 @@ class SmartApp extends webapp_1.WebApp {
         // copy switches from config
         this.switches = this.config.switches.map(s => types_1.Sanitizers.switchConfig(s));
         this.links = this.config.links.map(s => types_1.Sanitizers.linkConfig(s));
+        this.devices = (this.config.devices || []).map(d => types_1.Sanitizers.deviceConfig(d));
     }
     checkReady(context) {
         if (this.platform && !this.platform.ready) {
@@ -140,7 +224,7 @@ class SmartApp extends webapp_1.WebApp {
     // Router                   //
     //////////////////////////////
     needsLogin(context) {
-        const noNeed = ((context.request === "units") || (context.request === "switches") || (context.request === "links")) &&
+        const noNeed = ((context.request === "units") || (context.request === "switches")) &&
             ((context.action == "press") || (context.action == "get") || (context.action == "set"));
         return super.needsLogin(context) && (context.request != "files") && (!noNeed);
     }
@@ -181,6 +265,9 @@ class SmartApp extends webapp_1.WebApp {
             else if (context.request === "links") {
                 return this.doLinks(context);
             }
+            else if (context.request === "devices") {
+                return this.doDevices(context);
+            }
             else if (context.request === "switches") {
                 return this.doSwitches(context);
             }
@@ -261,32 +348,55 @@ class SmartApp extends webapp_1.WebApp {
     doSettings(context) {
         return __awaiter(this, void 0, void 0, function* () {
             let config = this.read("settings");
+            let message = "";
             if (context.action === "save") {
                 config = this.scrapeSettings(context);
                 this.write("settings", config);
+                message = "Settings saved successfully. Restart the server for changes to take effect.";
+                // Re-register mDNS with new name if changed
+                if (this.mdnsService) {
+                    // Note: Full restart recommended for mDNS changes to take effect properly
+                    (0, logger_1.log)("smartapp", "Settings saved. mDNS name updated to: " + config.mdnsName);
+                }
             }
             else if (context.action === "restart") {
                 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, config);
+                this.writeDHCP(context, <SettingsConfig>config);
+                */
             }
             else if (context.action === "reset") {
-                config = Object.assign({}, types_1.kEmptySettings);
+                // 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
             }
-            return this.ejs("settings", context, { config });
+            return this.ejs("settings", context, { config, message });
         });
     }
     scrapeSettings(context) {
@@ -297,7 +407,8 @@ class SmartApp extends webapp_1.WebApp {
                 nameservers: context.getParam({ name: "nameservers", type: "string" }),
                 ip2: context.getParam({ name: "ip2", type: "string" }),
                 gateway2: context.getParam({ name: "gateway2", type: "string" })
-            }
+            },
+            mdnsName: context.getParam({ name: "mdnsName", type: "string", default: "duotecno-gateway" })
         });
     }
     writeDHCP(context, config) {
@@ -462,19 +573,24 @@ class SmartApp extends webapp_1.WebApp {
                 if (u.isUnit(link.masterAddress, link.masterPort, link.logicalNodeAddress, link.logicalAddress)) {
                     const hbValue = (0, HB_1.dt2hbvalue)(u, link.hbValue, link.min, link.max);
                     if (typeof hbValue != "undefined") {
-                        if (hbValue === -1) {
-                            (0, logger_1.log)("smartapp", "-> Virtual unit send 'stop' for accessory: " + link.accName + " of Duotecno unit: " + u.getDisplayName());
-                            const val = yield (0, HB_1.hbStop)(this.config.apiHost + ":" + this.config.apiPort, link.accId, link.accService, this.token);
-                            if (typeof val != "undefined")
-                                link.hbValue = val;
-                        }
-                        else if (hbValue !== link.hbValue) {
-                            (0, logger_1.log)("smartapp", "-> Setting HB value for accessory: " + link.accName + " to " + hbValue + " of Duotecno unit: " + u.getDisplayName() + " with value " + u.value);
-                            link.hbValue = hbValue;
-                            yield (0, HB_1.hbSetState)(this.config.apiHost + ":" + this.config.apiPort, link.accId, link.accService, hbValue, this.token);
+                        try {
+                            if (hbValue === -1) {
+                                (0, logger_1.log)("smartapp", "-> Virtual unit send 'stop' for accessory: " + link.accName + " of Duotecno unit: " + u.getDisplayName());
+                                const val = yield (0, HB_1.hbStop)(this.config.apiHost + ":" + this.config.apiPort, link.accId, link.accService, this.token);
+                                if (typeof val != "undefined")
+                                    link.hbValue = val;
+                            }
+                            else if (hbValue !== link.hbValue) {
+                                (0, logger_1.log)("smartapp", "-> Setting HB value for accessory: " + link.accName + " to " + hbValue + " of Duotecno unit: " + u.getDisplayName() + " with value " + u.value);
+                                link.hbValue = hbValue;
+                                yield (0, HB_1.hbSetState)(this.config.apiHost + ":" + this.config.apiPort, link.accId, link.accService, hbValue, this.token);
+                            }
+                            else {
+                                (0, logger_1.debug)("smartapp", "-> No change for accessory: " + link.accName + " to " + u.value + " / " + u.status);
+                            }
                         }
-                        else {
-                            (0, logger_1.debug)("smartapp", "-> No change for accessory: " + link.accName + " to " + u.value + " / " + u.status);
+                        catch (e) {
+                            (0, logger_1.err)("smartapp", "informLinks: failed to set HB value for accessory " + link.accName + " -> " + e.toString());
                         }
                     }
                 }
@@ -568,6 +684,266 @@ class SmartApp extends webapp_1.WebApp {
             this.writeConfig();
         }
     }
+    /////////////
+    // Devices //
+    /////////////
+    initDeviceUnits() {
+        (0, logger_1.log)("smartapp", "Init " + this.devices.length + " Devices -> add units");
+        this.devices.forEach(device => {
+            device.unit || (device.unit = this.system.findUnit(this.system.findMaster(device.masterAddress, device.masterPort), device.logicalNodeAddress, device.logicalAddress));
+            if (device.unit) {
+                device.relay = device.unit.status > 0;
+            }
+            else {
+                (0, logger_1.log)("smartapp", "** error ** missing device unit: " + (0, types_1.hex)(device.logicalNodeAddress) + "/" + (0, types_1.hex)(device.logicalAddress) + " **");
+            }
+        });
+    }
+    doDevices(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let inx = parseInt(context.id);
+            const units = this.system.allUsedUnits();
+            let message;
+            try {
+                if (context.action === "add") {
+                    this.devices.push(Object.assign(Object.assign({}, types_1.kEmptyDevice), { measured: false }));
+                    inx = this.devices.length - 1;
+                    return this.ejs("deviceDetail", context, { device: this.devices[inx], id: inx,
+                        masters: this.system.masters, units });
+                }
+                else if (context.action === "edit") {
+                    return this.ejs("deviceDetail", context, { device: this.devices[inx], id: inx,
+                        masters: this.system.masters, units });
+                }
+                else if (context.action === "delete") {
+                    this.deleteDevice(inx);
+                }
+                else if (context.action === "change") {
+                    this.updateDevice(inx, this.scrapeDevice(context));
+                }
+                else {
+                    // possible new IP Nodes, hence Units could be online
+                    this.initDeviceUnits();
+                }
+            }
+            catch (e) {
+                message = e.toString();
+            }
+            return this.ejs("deviceList", context, { masters: this.system.masters, devices: this.devices, message });
+        });
+    }
+    scrapeDevice(context) {
+        const { masterAddress, masterPort, logicalAddress, logicalNodeAddress } = this.scrapeUnit(context, '');
+        const name = context.getParam({ name: "name", type: "string", default: "Device" });
+        const powerSource = context.getParam({ name: "powerSource", type: "string", default: "none" });
+        const powerChannel = context.getParam({ name: "powerChannel", type: "string", default: "" });
+        const estimatedPower = context.getParam({ name: "estimatedPower", type: "integer", default: 0 });
+        // Calculate ID from node/unit
+        const id = logicalNodeAddress * 256 + logicalAddress;
+        // Measured is true if powerSource is not "none"
+        const measured = powerSource !== "none";
+        return {
+            id,
+            name,
+            masterAddress,
+            masterPort,
+            logicalAddress,
+            logicalNodeAddress,
+            measured,
+            powerSource: powerSource,
+            powerChannel,
+            estimatedPower,
+            power: 0,
+            energy: 0,
+            voltage: 230.0,
+            current: 0,
+            relay: false
+        };
+    }
+    updateDevice(inx, device) {
+        if ((inx >= 0) && (inx < this.devices.length)) {
+            this.devices[inx] = device;
+            this.initDeviceUnits();
+            this.writeConfig();
+        }
+    }
+    deleteDevice(inx) {
+        if ((inx >= 0) && (inx < this.devices.length)) {
+            this.devices.splice(inx, 1);
+            this.initDeviceUnits();
+            this.writeConfig();
+        }
+    }
+    //////////////////////
+    // Device - sockets //
+    //////////////////////
+    sendDeviceList(ws) {
+        const devices = this.getDeviceList();
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(devices));
+        }
+    }
+    getDeviceList() {
+        return this.devices.map(device => {
+            // Get current relay state from unit if available
+            let relayState = device.relay || false;
+            if (device.unit) {
+                relayState = device.unit.status > 0;
+            }
+            // Get power measurements based on power source
+            let power = 0;
+            let energy = 0;
+            let voltage = 230.0;
+            let current = 0;
+            let measured = false;
+            if (device.powerSource === types_1.PowerSource.kSmappee && this.power.smappee) {
+                // Get power from Smappee
+                const smappeePower = this.getPowerFromSmappee(device.powerChannel);
+                if (smappeePower !== null) {
+                    power = smappeePower;
+                    measured = true;
+                    current = power / voltage;
+                }
+            }
+            else if (device.powerSource === types_1.PowerSource.kP1 && this.power.p1) {
+                // Get power from P1 meter
+                const p1Power = this.getPowerFromP1(device.powerChannel);
+                if (p1Power !== null) {
+                    power = p1Power;
+                    measured = true;
+                    current = power / voltage;
+                }
+            }
+            else if (device.powerSource === types_1.PowerSource.kShelly && this.power.shelly) {
+                // Get power from Shelly
+                const shellyPower = this.getPowerFromShelly(device.powerChannel);
+                if (shellyPower !== null) {
+                    power = shellyPower;
+                    measured = true;
+                    current = power / voltage;
+                }
+            }
+            else if (device.powerSource === types_1.PowerSource.kNone || !device.powerSource) {
+                // Use estimated power when relay is on
+                power = relayState ? (device.estimatedPower || 0) : 0;
+                measured = false;
+            }
+            return {
+                id: device.id,
+                name: device.name,
+                power: power,
+                energy: energy,
+                voltage: voltage,
+                current: current,
+                relay: relayState,
+                measured: measured
+            };
+        });
+    }
+    getPowerFromSmappee(channel) {
+        if (!this.power.smappee)
+            return null;
+        try {
+            // Channel format could be "0", "0+1", "0+1+2", etc.
+            const channels = channel.split('+').map(c => parseInt(c.trim()));
+            let totalPower = 0;
+            for (const ch of channels) {
+                const binding = this.power.smappee.bindings.find(b => b.channel.includes(ch.toString()));
+                if (binding && binding.value !== undefined) {
+                    totalPower += binding.value;
+                }
+            }
+            return totalPower;
+        }
+        catch (e) {
+            (0, logger_1.err)("smartapp", `Error getting Smappee power for channel ${channel}: ${e.message}`);
+            return null;
+        }
+    }
+    getPowerFromP1(channel) {
+        if (!this.power.p1)
+            return null;
+        try {
+            // P1 meter typically has single power value
+            const binding = this.power.p1.bindings.find(b => b.channel.includes(channel));
+            if (binding && binding.value !== undefined) {
+                return binding.value;
+            }
+            return null;
+        }
+        catch (e) {
+            (0, logger_1.err)("smartapp", `Error getting P1 power for channel ${channel}: ${e.message}`);
+            return null;
+        }
+    }
+    getPowerFromShelly(channel) {
+        if (!this.power.shelly)
+            return null;
+        try {
+            // Shelly channel format similar to Smappee
+            const channels = channel.split('+').map(c => parseInt(c.trim()));
+            let totalPower = 0;
+            for (const ch of channels) {
+                const binding = this.power.shelly.bindings.find(b => b.channel.includes(ch.toString()));
+                if (binding && binding.value !== undefined) {
+                    totalPower += binding.value;
+                }
+            }
+            return totalPower;
+        }
+        catch (e) {
+            (0, logger_1.err)("smartapp", `Error getting Shelly power for channel ${channel}: ${e.message}`);
+            return null;
+        }
+    }
+    handleDeviceMessage(ws, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Array.isArray(data)) {
+                (0, logger_1.err)("smartapp", "WebSocket message must be an array");
+                return;
+            }
+            // Empty array = keep-alive / poll
+            if (data.length === 0) {
+                this.sendDeviceList(ws);
+                return;
+            }
+            // Process relay control commands
+            for (const cmd of data) {
+                if (cmd.id && cmd.relay !== undefined) {
+                    yield this.setDeviceRelay(cmd.id, cmd.relay);
+                }
+            }
+            // Send updated device list
+            this.sendDeviceList(ws);
+        });
+    }
+    setDeviceRelay(id, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Convert ID to node/unit (id = node * 256 + unit)
+            const node = Math.floor(id / 256);
+            const unit = id % 256;
+            (0, logger_1.log)("smartapp", `Setting device ${id} (node=${node}, unit=${unit}) to ${state}`);
+            // Get the first master
+            const master = this.system.masters[0];
+            if (!master) {
+                (0, logger_1.err)("smartapp", "No master available");
+                return;
+            }
+            // Find the unit
+            const nodeObj = master.nodes.find(n => n.logicalAddress === node);
+            if (!nodeObj) {
+                (0, logger_1.err)("smartapp", `Node ${node} not found`);
+                return;
+            }
+            const unitObj = nodeObj.units.find(u => u.logicalAddress === unit);
+            if (!unitObj) {
+                (0, logger_1.err)("smartapp", `Unit ${unit} in node ${node} not found`);
+                return;
+            }
+            // Set the unit state (convert boolean to 0/100 for dimmer/switch)
+            yield master.setUnitStatus(unitObj, state ? 100 : 0);
+        });
+    }
     setLink(inx, newstate, newvalue) {
         return __awaiter(this, void 0, void 0, function* () {
             // find the switch if an index is given
@@ -1172,6 +1548,9 @@ class SmartApp extends webapp_1.WebApp {
         else if (file === "favicon.ico") {
             return this.file("favicon");
         }
+        else if (file === "Duotecno_logo_white.svg") {
+            return this.file("logoWhite");
+        }
         else
             return this.notFound();
     }