@rfranzoi/scrypted-mqtt-securitysystem 1.0.15 → 1.0.18

package/dist/main.nodejs.js

@@ -34063,7 +34063,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const mqtt_1 = __importDefault(__webpack_require__(/*! mqtt */ "./node_modules/mqtt/build/index.js"));
-const { systemManager } = sdk_1.default;
+const { systemManager, deviceManager } = sdk_1.default;
+/** utils */
 function truthy(v) {
     if (!v)
         return false;
@@ -34079,20 +34080,24 @@ function falsy(v) {
 function normalize(s) {
     return (s || '').trim().toLowerCase();
 }
-/** Default payloads for PAI/PAI-MQTT-like setups */
+function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+}
+function delay(ms) {
+    return new Promise(res => setTimeout(res, ms));
+}
+/** SecuritySystem outgoing defaults (PAI-like) */
 const DEFAULT_OUTGOING = {
     [sdk_1.SecuritySystemMode.Disarmed]: 'disarm',
     [sdk_1.SecuritySystemMode.HomeArmed]: 'arm_home',
     [sdk_1.SecuritySystemMode.AwayArmed]: 'arm_away',
     [sdk_1.SecuritySystemMode.NightArmed]: 'arm_night',
 };
-/** Common incoming synonyms → SecuritySystemMode
- *  (transitori non alterano la modalità corrente) */
+/** Parse incoming payload -> final mode (ignore transition states) */
 function payloadToMode(payload) {
     if (payload == null)
         return;
     const p = normalize(payload.toString());
-    // final modes
     if (['disarm', 'disarmed', 'off', '0', 'idle', 'ready'].includes(p))
         return sdk_1.SecuritySystemMode.Disarmed;
     if (['arm_home', 'home', 'stay', 'armed_home'].includes(p))
@@ -34106,9 +34111,83 @@ function payloadToMode(payload) {
         return undefined;
     return undefined;
 }
+class BaseMqttSensor extends sdk_1.ScryptedDeviceBase {
+    constructor(nativeId, cfg) {
+        super(nativeId);
+        this.cfg = cfg;
+        this.online = this.online ?? true;
+    }
+    /** Called by parent on each MQTT message */
+    handleMqtt(topic, payload) {
+        const p = payload?.toString() ?? '';
+        const np = normalize(p);
+        // online
+        if (topic === this.cfg.topics.online) {
+            if (truthy(np) || np === 'online')
+                this.online = true;
+            if (falsy(np) || np === 'offline')
+                this.online = false;
+        }
+        // tamper
+        if (topic === this.cfg.topics.tamper) {
+            if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
+                this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+            }
+            else if (falsy(np)) {
+                this.tampered = false;
+            }
+        }
+        // battery
+        if (topic === this.cfg.topics.batteryLevel) {
+            const n = clamp(parseFloat(p), 0, 100);
+            if (isFinite(n))
+                this.batteryLevel = n;
+        }
+        else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
+            // sintetizza se non c'è batteryLevel
+            this.batteryLevel = truthy(np) ? 10 : 100;
+        }
+        // primary handled by subclasses
+        this.handlePrimary(topic, np, p);
+    }
+}
+class ContactMqttSensor extends BaseMqttSensor {
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.contact) {
+            this.entryOpen = truthy(np);
+        }
+    }
+}
+class MotionMqttSensor extends BaseMqttSensor {
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.motion) {
+            this.motionDetected = truthy(np);
+        }
+    }
+}
+class OccupancyMqttSensor extends BaseMqttSensor {
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.occupancy) {
+            this.occupied = truthy(np);
+        }
+    }
+}
+/** ----------------- Main Plugin ----------------- */
 class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     constructor() {
         super();
+        // sensor management
+        this.sensorsCfg = [];
+        this.devices = new Map();
         // (facoltativo) Imposta il device type in UI
         setTimeout(() => {
             try {
@@ -34127,6 +34206,9 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
             ],
         };
         this.online = this.online ?? false;
+        // Load sensors config and announce devices
+        this.loadSensorsFromStorage();
+        this.discoverSensors();
         // Connect on start
         this.connectMqtt().catch(e => this.console.error('MQTT connect error:', e));
         // chiusura pulita del client MQTT ai reload/stop del plugin
@@ -34146,33 +34228,152 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         }
         catch { }
     }
-    // --- Settings UI ---
+    /** ---- Settings UI ---- */
     async getSettings() {
         return [
+            // MQTT Core
             { group: 'MQTT', key: 'brokerUrl', title: 'Broker URL', placeholder: 'mqtt://127.0.0.1:1883', value: this.storage.getItem('brokerUrl') || 'mqtt://127.0.0.1:1883' },
             { group: 'MQTT', key: 'username', title: 'Username', type: 'string', value: this.storage.getItem('username') || '' },
             { group: 'MQTT', key: 'password', title: 'Password', type: 'password', value: this.storage.getItem('password') || '' },
             { group: 'MQTT', key: 'clientId', title: 'Client ID', placeholder: 'scrypted-paradox', value: this.storage.getItem('clientId') || 'scrypted-paradox' },
             { group: 'MQTT', key: 'tls', title: 'Use TLS', type: 'boolean', value: this.storage.getItem('tls') === 'true' },
             { group: 'MQTT', key: 'rejectUnauthorized', title: 'Reject Unauthorized (TLS)', type: 'boolean', value: this.storage.getItem('rejectUnauthorized') !== 'false', description: 'Disattiva solo con broker self-signed.' },
-            { group: 'Topics', key: 'topicSetTarget', title: 'Set Target State (publish)', placeholder: 'paradox/control/partitions/Area_1', value: this.storage.getItem('topicSetTarget') || '' },
-            { group: 'Topics', key: 'topicGetTarget', title: 'Get Target State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/target_state', value: this.storage.getItem('topicGetTarget') || '' },
-            { group: 'Topics', key: 'topicGetCurrent', title: 'Get Current State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/current_state', value: this.storage.getItem('topicGetCurrent') || '' },
-            { group: 'Topics', key: 'topicTamper', title: 'Get Status Tampered (subscribe)', placeholder: 'paradox/states/system/troubles/zone_tamper_trouble', value: this.storage.getItem('topicTamper') || '' },
-            { group: 'Topics', key: 'topicOnline', title: 'Get Online (subscribe)', placeholder: 'paradox/interface/availability', value: this.storage.getItem('topicOnline') || '' },
+            // Alarm Topics
+            { group: 'Alarm Topics', key: 'topicSetTarget', title: 'Set Target State (publish)', placeholder: 'paradox/control/partitions/Area_1', value: this.storage.getItem('topicSetTarget') || '' },
+            { group: 'Alarm Topics', key: 'topicGetTarget', title: 'Get Target State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/target_state', value: this.storage.getItem('topicGetTarget') || '' },
+            { group: 'Alarm Topics', key: 'topicGetCurrent', title: 'Get Current State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/current_state', value: this.storage.getItem('topicGetCurrent') || '' },
+            { group: 'Alarm Topics', key: 'topicTamper', title: 'Get Status Tampered (subscribe)', placeholder: 'paradox/states/system/troubles/zone_tamper_trouble', value: this.storage.getItem('topicTamper') || '' },
+            { group: 'Alarm Topics', key: 'topicOnline', title: 'Get Online (subscribe)', placeholder: 'paradox/interface/availability', value: this.storage.getItem('topicOnline') || '' },
             { group: 'Publish Options', key: 'qos', title: 'QoS', type: 'integer', value: parseInt(this.storage.getItem('qos') || '0') },
             { group: 'Publish Options', key: 'retain', title: 'Retain', type: 'boolean', value: this.storage.getItem('retain') === 'true' },
             { group: 'Outgoing Payloads', key: 'payloadDisarm', title: 'Payload Disarm', value: this.storage.getItem('payloadDisarm') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.Disarmed] },
             { group: 'Outgoing Payloads', key: 'payloadHome', title: 'Payload HomeArmed', value: this.storage.getItem('payloadHome') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.HomeArmed] },
             { group: 'Outgoing Payloads', key: 'payloadAway', title: 'Payload AwayArmed', value: this.storage.getItem('payloadAway') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.AwayArmed] },
             { group: 'Outgoing Payloads', key: 'payloadNight', title: 'Payload NightArmed', value: this.storage.getItem('payloadNight') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.NightArmed] },
+            // Sensors config (JSON)
+            {
+                group: 'Sensors',
+                key: 'sensorsJson',
+                title: 'Sensors JSON (contact/motion/occupancy)',
+                description: 'Definisci i sensori e i topic MQTT (vedi README). Incolla JSON; le interruzioni di riga sono accettate.',
+                type: 'string',
+                value: this.storage.getItem('sensorsJson') || '[\n  {\n    "id": "front-door",\n    "name": "Front Door",\n    "kind": "contact",\n    "topics": { "contact": "SYSTEM/zones/front/contact" }\n  }\n]'
+            },
         ];
     }
     async putSetting(key, value) {
         this.storage.setItem(key, String(value));
-        await this.connectMqtt(true);
+        if (key === 'sensorsJson') {
+            this.loadSensorsFromStorage();
+            await this.discoverSensors();
+            await this.connectMqtt(true);
+        }
+        else {
+            await this.connectMqtt(true);
+        }
+    }
+    /** ---- DeviceProvider ---- */
+    async getDevice(nativeId) {
+        return this.devices.get(nativeId);
+    }
+    async releaseDevice(id, nativeId) {
+        try {
+            const dev = this.devices.get(nativeId);
+            if (dev) {
+                this.devices.delete(nativeId);
+            }
+            try {
+                deviceManager.onDeviceRemoved?.(nativeId);
+            }
+            catch { }
+        }
+        catch (e) {
+            this.console.warn('releaseDevice error', e);
+        }
+    }
+    loadSensorsFromStorage() {
+        try {
+            const raw = this.storage.getItem('sensorsJson') || '[]';
+            const parsed = JSON.parse(raw);
+            // sanitize
+            this.sensorsCfg = (parsed || []).filter(x => x && x.id && x.name && x.kind && x.topics);
+        }
+        catch (e) {
+            this.console.error('Invalid sensorsJson:', e);
+            this.sensorsCfg = [];
+        }
+    }
+    /** ===== discoverSensors con batch/fallback (FIX type) ===== */
+    async discoverSensors() {
+        // Prepara i manifest e istanzia/aggiorna le classi locali
+        const manifests = this.sensorsCfg.map(cfg => {
+            const nativeId = `sensor:${cfg.id}`;
+            let interfaces = [
+                sdk_1.ScryptedInterface.Online,
+                sdk_1.ScryptedInterface.TamperSensor,
+                sdk_1.ScryptedInterface.Battery,
+            ];
+            // Il tipo RESTA generico "Sensor" per compatibilità SDK,
+            // le capacità sono date dalle interfacce.
+            const type = sdk_1.ScryptedDeviceType.Sensor;
+            switch (cfg.kind) {
+                case 'contact':
+                    interfaces = [sdk_1.ScryptedInterface.EntrySensor, ...interfaces];
+                    break;
+                case 'motion':
+                    interfaces = [sdk_1.ScryptedInterface.MotionSensor, ...interfaces];
+                    break;
+                case 'occupancy':
+                    interfaces = [sdk_1.ScryptedInterface.OccupancySensor, ...interfaces];
+                    break;
+            }
+            let dev = this.devices.get(nativeId);
+            if (!dev) {
+                if (cfg.kind === 'contact')
+                    dev = new ContactMqttSensor(nativeId, cfg);
+                else if (cfg.kind === 'motion')
+                    dev = new MotionMqttSensor(nativeId, cfg);
+                else
+                    dev = new OccupancyMqttSensor(nativeId, cfg);
+                this.devices.set(nativeId, dev);
+            }
+            else {
+                dev.cfg = cfg;
+            }
+            return {
+                nativeId,
+                name: cfg.name,
+                type,
+                interfaces,
+            };
+        });
+        // Annuncio in batch se disponibile, altrimenti uno per volta con un piccolo delay
+        const dm = deviceManager;
+        if (typeof dm.onDevicesChanged === 'function') {
+            dm.onDevicesChanged({ devices: manifests });
+            this.console.log('Annunciati (batch):', manifests.map(m => m.nativeId).join(', '));
+        }
+        else {
+            for (const m of manifests) {
+                deviceManager.onDeviceDiscovered(m);
+                this.console.log('Annunciato:', m.nativeId);
+                await new Promise(res => setTimeout(res, 50));
+            }
+        }
+        // Rimuovi eventuali sensori non più presenti
+        const announced = new Set(manifests.map(m => m.nativeId));
+        for (const [nativeId] of this.devices) {
+            if (!announced.has(nativeId)) {
+                try {
+                    this.devices.delete(nativeId);
+                    deviceManager.onDeviceRemoved?.(nativeId);
+                    this.console.log('Rimosso:', nativeId);
+                }
+                catch { }
+            }
+        }
     }
-    // --- MQTT ---
+    /** ---- MQTT ---- */
     getMqttOptions() {
         const url = this.storage.getItem('brokerUrl') || 'mqtt://127.0.0.1:1883';
         const username = this.storage.getItem('username') || undefined;
@@ -34193,12 +34394,25 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         }
         return { url, opts };
     }
+    collectAllSubscriptions() {
+        const subs = new Set();
+        // alarm
+        for (const k of ['topicGetTarget', 'topicGetCurrent', 'topicTamper', 'topicOnline']) {
+            const v = this.storage.getItem(k);
+            if (v)
+                subs.add(v);
+        }
+        // sensors
+        for (const s of this.sensorsCfg) {
+            const t = s.topics;
+            [t.contact, t.motion, t.occupancy, t.batteryLevel, t.lowBattery, t.tamper, t.online]
+                .filter(Boolean)
+                .forEach(x => subs.add(String(x)));
+        }
+        return Array.from(subs);
+    }
     async connectMqtt(reconnect = false) {
-        const tTarget = this.storage.getItem('topicGetTarget') || '';
-        const tCurrent = this.storage.getItem('topicGetCurrent') || '';
-        const tTamper = this.storage.getItem('topicTamper') || '';
-        const tOnline = this.storage.getItem('topicOnline') || '';
-        const subs = [tTarget, tCurrent, tTamper, tOnline].filter(Boolean);
+        const subs = this.collectAllSubscriptions();
         if (!subs.length && !this.storage.getItem('topicSetTarget')) {
             this.console.warn('Configura almeno un topic nelle impostazioni.');
         }
@@ -34213,6 +34427,11 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         this.console.log(`Connecting MQTT ${url} ...`);
         const client = mqtt_1.default.connect(url, opts);
         this.client = client;
+        // cache alarm topics for fast compare
+        const tTarget = this.storage.getItem('topicGetTarget') || '';
+        const tCurrent = this.storage.getItem('topicGetCurrent') || '';
+        const tTamper = this.storage.getItem('topicTamper') || '';
+        const tOnline = this.storage.getItem('topicOnline') || '';
         client.on('connect', () => {
             this.console.log('MQTT connected');
             this.online = true;
@@ -34229,29 +34448,27 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         client.on('message', (topic, payload) => {
             try {
                 const p = payload?.toString() ?? '';
-                // Online
+                const np = normalize(p);
+                // ---- Alarm handling ----
                 if (topic === tOnline) {
-                    if (truthy(p) || p.toLowerCase() === 'online')
+                    if (truthy(np) || np === 'online')
                         this.online = true;
-                    if (falsy(p) || p.toLowerCase() === 'offline')
+                    if (falsy(np) || np === 'offline')
                         this.online = false;
                     return;
                 }
-                // Tamper
                 if (topic === tTamper) {
-                    const np = normalize(p);
-                    if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
-                        this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np)) {
+                        this.tampered = ['cover', 'intrusion'].find(x => x === np) || true;
                     }
                     else if (falsy(np)) {
                         this.tampered = false;
                     }
                     return;
                 }
-                // CURRENT state → aggiorna il mode mostrato
                 if (topic === tCurrent) {
                     const mode = payloadToMode(payload);
-                    const isAlarm = ['alarm', 'triggered'].includes(normalize(p));
+                    const isAlarm = ['alarm', 'triggered'].includes(np);
                     const current = this.securitySystemState || { mode: sdk_1.SecuritySystemMode.Disarmed };
                     const newState = {
                         mode: mode ?? current.mode,
@@ -34266,19 +34483,22 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
                     this.securitySystemState = newState;
                     return;
                 }
-                // TARGET state → NON cambia il mode; lo memorizziamo solo come pending
                 if (topic === tTarget) {
                     this.pendingTarget = payloadToMode(payload);
                     this.console.log('Target state reported:', p, '->', this.pendingTarget);
                     return;
                 }
+                // ---- Sensor dispatch ----
+                for (const dev of this.devices.values()) {
+                    dev.handleMqtt(topic, payload);
+                }
             }
             catch (e) {
                 this.console.error('MQTT message handler error', e);
             }
         });
     }
-    // --- SecuritySystem commands ---
+    /** ---- SecuritySystem commands ---- */
     publishSetTarget(payload) {
         const topic = this.storage.getItem('topicSetTarget');
         if (!topic || !this.client) {
@@ -34298,14 +34518,12 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         this.console.log('armSecuritySystem', mode, '->', payload);
         this.pendingTarget = mode; // memorizza target, ma NON cambiare il current
         this.publishSetTarget(payload);
-        // niente update ottimistico: HomeKit vedrà Target ≠ Current e mostrerà "Arming..."
     }
     async disarmSecuritySystem() {
         const payload = this.getOutgoing(sdk_1.SecuritySystemMode.Disarmed);
         this.console.log('disarmSecuritySystem ->', payload);
         this.pendingTarget = sdk_1.SecuritySystemMode.Disarmed;
         this.publishSetTarget(payload);
-        // niente update ottimistico: aspetta il feedback CURRENT
     }
     getOutgoing(mode) {
         const map = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfranzoi/scrypted-mqtt-securitysystem",
-  "version": "1.0.15",
+  "version": "1.0.18",
   "description": "Scrypted plugin: Paradox Security System via MQTT (PAI/PAI-MQTT style).",
   "license": "MIT",
   "main": "dist/main.nodejs.js",