node-red-contrib-3dm-space 1.0.2 → 1.0.3

package/3dm-cloud-config.js

@@ -1,171 +1,887 @@
 module.exports = function (RED) {
     "use strict";
 
-    var mqtt = require("mqtt");
+    var fs = require("fs");
+    var path = require("path");
 
-    /*
-     * Hidden 3DM.space Cloud connection settings.
-     */
-    var CLOUD_HOST = "3dm.space";
-    var CLOUD_PORT = 1883;
-    var CLOUD_URL = "mqtt://" + CLOUD_HOST + ":" + CLOUD_PORT;
+    function asBool(value) {
+        return value === true || value === "true" || value === 1 || value === "1";
+    }
 
-    var MQTT_KEEPALIVE = 60;
-    var MQTT_CLEAN_SESSION = true;
-    var MQTT_RECONNECT_MS = 5000;
-    var MQTT_CONNECT_TIMEOUT_MS = 15000;
+    function asNumber(value) {
+        var n = parseFloat(value);
+        return Number.isNaN(n) ? NaN : n;
+    }
 
-    /*
-     * Prevent the same connection error being logged every few seconds.
-     */
-    var REPEAT_ERROR_LOG_MS = 60000;
+    function clampNumber(value, min, max, fallback) {
+        var n = parseInt(value, 10);
 
-    function cleanText(value) {
-        if (value === null || value === undefined) {
-            return "";
+        if (Number.isNaN(n)) {
+            return fallback;
         }
 
-        return String(value).trim();
+        return Math.max(min, Math.min(n, max));
     }
 
-    function ThreeDMCloudConfigNode(config) {
-        RED.nodes.createNode(this, config);
+    function safeParseJson(value) {
+        if (typeof value !== "string") {
+            return value;
+        }
 
-        var node = this;
+        try {
+            return JSON.parse(value);
+        } catch (err) {
+            return value;
+        }
+    }
+
+    function hasOwn(obj, key) {
+        return Object.prototype.hasOwnProperty.call(obj, key);
+    }
+
+    function getNestedValue(obj, key) {
+        if (!obj || key === null || key === undefined || key === "") {
+            return undefined;
+        }
 
-        node.name = cleanText(config.name);
-        node.clientid = cleanText(config.clientid);
+        if (typeof obj !== "object") {
+            return undefined;
+        }
 
-        node.username = node.credentials && node.credentials.username
-            ? cleanText(node.credentials.username)
-            : "";
+        if (hasOwn(obj, key)) {
+            return obj[key];
+        }
 
-        node.password = node.credentials && node.credentials.password
-            ? cleanText(node.credentials.password)
-            : "";
+        var current = obj;
+        var parts = String(key).split(".");
 
-        node.connected = false;
-        node.client = null;
-        node.subscriptions = {};
+        for (var i = 0; i < parts.length; i += 1) {
+            var part = parts[i];
+
+            if (!current || typeof current !== "object" || !hasOwn(current, part)) {
+                return undefined;
+            }
 
-        node.lastErrorText = "";
-        node.lastErrorTime = 0;
+            current = current[part];
+        }
 
-        node.setMaxListeners(0);
+        return current;
+    }
+
+    function makeDir(dir) {
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        } catch (err) {
+            try {
+                fs.mkdirSync(dir);
+            } catch (err2) {
+                throw err;
+            }
+        }
+    }
+
+    function dateKey(date) {
+        return (
+            date.getFullYear() + "-" +
+            (date.getMonth() + 1) + "-" +
+            date.getDate()
+        );
+    }
+
+    function outputNumberFromKey(outputKey, fallbackIndex, maxOutputs) {
+        maxOutputs = clampNumber(maxOutputs || 24, 1, 24, 24);
+
+        var match = String(outputKey || "").match(/output(\d+)/i);
+
+        if (match) {
+            var number = parseInt(match[1], 10);
+
+            if (number >= 1 && number <= maxOutputs) {
+                return number;
+            }
+
+            return null;
+        }
+
+        var fallbackNumber = fallbackIndex + 1;
+
+        if (fallbackNumber >= 1 && fallbackNumber <= maxOutputs) {
+            return fallbackNumber;
+        }
+
+        return null;
+    }
+
+    function normaliseMode(value, fallback) {
+        if (value === null || value === undefined || value === "") {
+            return fallback;
+        }
+
+        return String(value);
+    }
+
+    function isManualOn(mode) {
+        return String(mode).toUpperCase() === "ON";
+    }
+
+    function isManualOff(mode) {
+        return String(mode).toUpperCase() === "OFF";
+    }
+
+    function isAutoSchedule(mode) {
+        var text = String(mode || "").toLowerCase();
+        return text === "auto schedule" || text === "auto" || text === "schedule";
+    }
+
+    function isSchedulerType(type) {
+        var text = String(type || "").toLowerCase();
+        return text === "scheduler" || text === "schedule" || text === "consched" || text === "control-schedule";
+    }
+
+    function ThreeDMConfigStoreNode(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+
+        node.name = config.name;
+        node.configName = String(config.configName || "").trim();
+        node.outputCount = clampNumber(config.outputs || 24, 1, 24, 24);
+        node.tickSeconds = clampNumber(config.tickSeconds || 20, 1, 60, 20);
+        node.outputMode = config.outputMode || "change";
+        node.configOutput = clampNumber(config.configOutput || 0, 0, node.outputCount, 0);
+        node.emitConfigOnUpdate = asBool(config.emitConfigOnUpdate);
+
+        var userDir = RED.settings && RED.settings.userDir
+            ? RED.settings.userDir
+            : process.cwd();
+
+        var storeDir = path.join(userDir, "3dm-config-store");
+        var storeFile = path.join(storeDir, "3dm-config-store-" + node.id + ".json");
+
+        var closed = false;
+        var latestPayload = {};
+        var latestStore = {};
+        var outputStates = {};
+        var stoppedScheduleRuns = new Map();
+        var controlItemStates = new Map();
+        var lastStatusText = "";
+        var lastWarnText = "";
+        var lastWarnTime = 0;
 
         function warnOncePerMinute(text) {
             var now = Date.now();
 
-            if (text !== node.lastErrorText || (now - node.lastErrorTime) > REPEAT_ERROR_LOG_MS) {
-                node.lastErrorText = text;
-                node.lastErrorTime = now;
+            if (text !== lastWarnText || (now - lastWarnTime) > 60000) {
+                lastWarnText = text;
+                lastWarnTime = now;
                 node.warn(text);
             }
         }
 
-        node.connect = function () {
-            if (!node.username) {
-                node.connected = false;
-                node.emit("state", false);
-                warnOncePerMinute("3DM Cloud username is missing");
+        function setStatus(fill, shape, text) {
+            var shortText = String(text || "");
+
+            if (shortText.length > 90) {
+                shortText = shortText.slice(0, 87) + "...";
+            }
+
+            var key = fill + "|" + shape + "|" + shortText;
+
+            if (lastStatusText !== key) {
+                lastStatusText = key;
+                node.status({ fill: fill, shape: shape, text: shortText });
+            }
+        }
+
+        function saveToDisk() {
+            try {
+                makeDir(storeDir);
+
+                fs.writeFileSync(
+                    storeFile,
+                    JSON.stringify({
+                        version: 1,
+                        updatedAt: new Date().toISOString(),
+                        configStore: latestStore
+                    }, null, 2)
+                );
+            } catch (err) {
+                warnOncePerMinute("Failed to write 3DM config store to disk: " + (err.message || err));
+            }
+        }
+
+        function loadFromDisk() {
+            try {
+                if (!fs.existsSync(storeFile)) {
+                    latestStore = {};
+                    return;
+                }
+
+                var data = JSON.parse(fs.readFileSync(storeFile, "utf8"));
+
+                if (data && typeof data === "object" && data.configStore && typeof data.configStore === "object") {
+                    latestStore = data.configStore;
+                } else if (data && typeof data === "object") {
+                    latestStore = data;
+                } else {
+                    latestStore = {};
+                }
+            } catch (err) {
+                latestStore = {};
+                warnOncePerMinute("Failed to load saved 3DM config store: " + (err.message || err));
+            }
+        }
+
+        function shouldAcceptConfigName(configName) {
+            if (!node.configName) {
+                return true;
+            }
+
+            return String(configName) === node.configName;
+        }
+
+        function inferBlockType(configName, block) {
+            if (block && typeof block === "object" && !Array.isArray(block) && block.type) {
+                return String(block.type);
+            }
+
+            if (Array.isArray(block)) {
+                return "scheduler";
+            }
+
+            if (block && typeof block === "object" && Array.isArray(block.schedule)) {
+                return "scheduler";
+            }
+
+            if (String(configName || "").toLowerCase().indexOf("sched") !== -1) {
+                return "scheduler";
+            }
+
+            return "settings";
+        }
+
+        function normaliseConfigBlock(configName, block) {
+            var type = inferBlockType(configName, block);
+            var data = block;
+
+            if (block && typeof block === "object" && !Array.isArray(block) && hasOwn(block, "data")) {
+                data = block.data;
+            } else if (block && typeof block === "object" && !Array.isArray(block) && Array.isArray(block.schedule)) {
+                data = block.schedule;
+            }
+
+            return {
+                name: configName,
+                type: type,
+                data: data,
+                updatedAt: new Date().toISOString()
+            };
+        }
+
+        function extractConfigStore(msg) {
+            var payload = safeParseJson(msg.payload);
+
+            if (payload && typeof payload === "object" && hasOwn(payload, "configStore")) {
+                return payload.configStore;
+            }
+
+            if (msg.key === "configStore" || msg.topic === "configStore") {
+                return payload;
+            }
+
+            if (payload && typeof payload === "object" && payload.shared && hasOwn(payload.shared, "configStore")) {
+                return payload.shared.configStore;
+            }
+
+            if (payload && typeof payload === "object" && payload.client && hasOwn(payload.client, "configStore")) {
+                return payload.client.configStore;
+            }
+
+            return null;
+        }
+
+        function storeConfig(configStore) {
+            var savedNames = [];
+
+            if (!configStore || typeof configStore !== "object" || Array.isArray(configStore)) {
+                return savedNames;
+            }
+
+            Object.keys(configStore).forEach(function (configName) {
+                if (!shouldAcceptConfigName(configName)) {
+                    return;
+                }
+
+                latestStore[configName] = normaliseConfigBlock(configName, configStore[configName]);
+                savedNames.push(configName);
+            });
+
+            if (savedNames.length > 0) {
+                saveToDisk();
+            }
+
+            return savedNames;
+        }
+
+        function storedConfigValue(key) {
+            if (!key) {
+                return undefined;
+            }
+
+            var cleanKey = String(key);
+
+            var direct = getNestedValue({ configStore: latestStore }, cleanKey);
+
+            if (direct !== undefined) {
+                return direct;
+            }
+
+            direct = getNestedValue(latestStore, cleanKey);
+
+            if (direct !== undefined) {
+                return direct;
+            }
+
+            var names = Object.keys(latestStore);
+
+            for (var i = 0; i < names.length; i += 1) {
+                var block = latestStore[names[i]];
+
+                if (!block) {
+                    continue;
+                }
+
+                direct = getNestedValue(block, cleanKey);
+
+                if (direct !== undefined) {
+                    return direct;
+                }
+
+                direct = getNestedValue(block.data, cleanKey);
+
+                if (direct !== undefined) {
+                    return direct;
+                }
+            }
+
+            return undefined;
+        }
+
+        function resolveValue(key) {
+            var value = getNestedValue(latestPayload, key);
+
+            if (value !== undefined) {
+                return value;
+            }
+
+            return storedConfigValue(key);
+        }
+
+        function resolveSetpoint(item, valueKeys, fixedKeys) {
+            for (var i = 0; i < valueKeys.length; i += 1) {
+                var valueKeyName = valueKeys[i];
+
+                if (item[valueKeyName] !== undefined && item[valueKeyName] !== null && item[valueKeyName] !== "") {
+                    var resolved = resolveValue(item[valueKeyName]);
+
+                    if (resolved !== undefined) {
+                        return resolved;
+                    }
+                }
+            }
+
+            for (var j = 0; j < fixedKeys.length; j += 1) {
+                var fixedKeyName = fixedKeys[j];
+
+                if (item[fixedKeyName] !== undefined && item[fixedKeyName] !== null && item[fixedKeyName] !== "") {
+                    return item[fixedKeyName];
+                }
+            }
+
+            return undefined;
+        }
+
+        function itemMemoryKey(item, index, outputKey, configName) {
+            var explicitId = item.id || item.scheduleId || item.controlId || item.uid || item.uuid;
+
+            if (explicitId !== undefined && explicitId !== null && String(explicitId) !== "") {
+                return String(configName || "config") + "::" + String(item.controlType || "schedule") + "::" + String(explicitId);
+            }
+
+            var variableName = item.scheduleVariable || item.variable || item.key || item.keyName || "";
+
+            return JSON.stringify({
+                configName: configName || "",
+                type: item.controlType || "schedule",
+                output: outputKey,
+                name: item.name || "",
+                days: item.days || [],
+                startHour: item.startHour || "",
+                startMinute: item.startMinute || "",
+                runHour: item.runHour || "",
+                runMinute: item.runMinute || "",
+                variable: variableName,
+                direction: item.direction || "",
+                lowSetpoint: item.lowSetpoint || "",
+                highSetpoint: item.highSetpoint || "",
+                scheduleHighSetpoint: item.scheduleHighSetpoint || "",
+                index: index
+            });
+        }
+
+        function currentScheduleRun(item, now) {
+            var days = item.days || [];
+
+            if (typeof days === "string") {
+                days = days.split(",").map(function (day) {
+                    return day.trim().toLowerCase();
+                });
+            }
+
+            var startHour = parseInt(item.startHour || 0, 10);
+            var startMinute = parseInt(item.startMinute || 0, 10);
+            var runHour = parseInt(item.runHour || 0, 10);
+            var runMinute = parseInt(item.runMinute || 0, 10);
+
+            var startMinutes = startHour * 60 + startMinute;
+            var runMinutes = runHour * 60 + runMinute;
+
+            if (runMinutes <= 0) {
+                return null;
+            }
+
+            var dayNames = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+            var candidates = [new Date(now), new Date(now)];
+
+            candidates[1].setDate(candidates[1].getDate() - 1);
+
+            for (var i = 0; i < candidates.length; i += 1) {
+                var startDay = candidates[i];
+                var dayName = dayNames[startDay.getDay()];
+
+                if (days.length > 0 && days.indexOf(dayName) === -1) {
+                    continue;
+                }
+
+                var start = new Date(startDay);
+                start.setHours(Math.floor(startMinutes / 60), startMinutes % 60, 0, 0);
+
+                var end = new Date(start.getTime() + runMinutes * 60000);
+
+                if (now >= start && now < end) {
+                    return dateKey(start) + "@" + startMinutes;
+                }
+            }
+
+            return null;
+        }
+
+        function scheduleHighStopEnabled(item) {
+            return asBool(item.highStopEnabled);
+        }
+
+        function calculateScheduleState(item, itemKey) {
+            var mode = normaliseMode(item.mode, "Auto Schedule");
+
+            if (isManualOn(mode)) {
+                return 1;
+            }
+
+            if (isManualOff(mode)) {
+                return 0;
+            }
+
+            if (!isAutoSchedule(mode)) {
+                return null;
+            }
+
+            var runId = currentScheduleRun(item, new Date());
+
+            if (!runId) {
+                stoppedScheduleRuns.delete(itemKey);
+                return 0;
+            }
+
+            if (!scheduleHighStopEnabled(item)) {
+                return 1;
+            }
+
+            if (stoppedScheduleRuns.get(itemKey) === runId) {
+                return 0;
+            }
+
+            var keyName = item.scheduleVariable || item.variable || item.key || item.keyName;
+            var value = asNumber(resolveValue(keyName));
+
+            var highStopValue = resolveSetpoint(
+                item,
+                ["scheduleHighSetpointKey", "highStopKey", "highSetpointKey"],
+                ["scheduleHighSetpoint", "highStop", "highSetpoint"]
+            );
+
+            var highStop = asNumber(highStopValue);
+
+            if (Number.isNaN(value) || Number.isNaN(highStop)) {
+                return 1;
+            }
+
+            if (value >= highStop) {
+                stoppedScheduleRuns.set(itemKey, runId);
+                return 0;
+            }
+
+            return 1;
+        }
+
+        function calculateControlState(item, itemKey, outputKey) {
+            var mode = normaliseMode(item.mode, "AUTO");
+
+            if (isManualOn(mode)) {
+                controlItemStates.set(itemKey, 1);
+                return 1;
+            }
+
+            if (isManualOff(mode)) {
+                controlItemStates.set(itemKey, 0);
+                return 0;
+            }
+
+            var keyName = item.variable || item.key || item.keyName;
+            var value = asNumber(resolveValue(keyName));
+
+            var low = asNumber(resolveSetpoint(
+                item,
+                ["lowSetpointKey", "lowKey", "startSetpointKey"],
+                ["lowSetpoint", "low", "startSetpoint"]
+            ));
+
+            var high = asNumber(resolveSetpoint(
+                item,
+                ["highSetpointKey", "highKey", "stopSetpointKey"],
+                ["highSetpoint", "high", "stopSetpoint"]
+            ));
+
+            if (Number.isNaN(value) || Number.isNaN(low) || Number.isNaN(high)) {
+                return null;
+            }
+
+            var lastState = controlItemStates.has(itemKey)
+                ? controlItemStates.get(itemKey)
+                : (outputStates[outputKey] || 0);
+
+            var newState = lastState;
+            var direction = item.direction || "in";
+
+            if (direction === "in" || direction === "fill" || direction === "normal") {
+                if (value <= low) {
+                    newState = 1;
+                }
+
+                if (value >= high) {
+                    newState = 0;
+                }
+            } else {
+                if (value >= high) {
+                    newState = 1;
+                }
+
+                if (value <= low) {
+                    newState = 0;
+                }
+            }
+
+            controlItemStates.set(itemKey, newState);
+            return newState;
+        }
+
+        function getSchedulerItems() {
+            var items = [];
+            var configNames = Object.keys(latestStore);
+
+            configNames.forEach(function (configName) {
+                if (!shouldAcceptConfigName(configName)) {
+                    return;
+                }
+
+                var block = latestStore[configName];
+
+                if (!block || !isSchedulerType(block.type)) {
+                    return;
+                }
+
+                var list = [];
+
+                if (Array.isArray(block.data)) {
+                    list = block.data;
+                } else if (block.data && typeof block.data === "object" && Array.isArray(block.data.schedule)) {
+                    list = block.data.schedule;
+                }
+
+                list.forEach(function (item) {
+                    if (item && typeof item === "object") {
+                        items.push({
+                            configName: configName,
+                            item: item
+                        });
+                    }
+                });
+            });
+
+            return items;
+        }
+
+        function sendConfigSnapshot(eventName) {
+            if (node.configOutput < 1 || node.configOutput > node.outputCount) {
                 return;
             }
 
-            var options = {
-                username: node.username,
-                password: node.password,
-                clean: MQTT_CLEAN_SESSION,
-                keepalive: MQTT_KEEPALIVE,
-                reconnectPeriod: MQTT_RECONNECT_MS,
-                connectTimeout: MQTT_CONNECT_TIMEOUT_MS
+            var outputs = new Array(node.outputCount).fill(null);
+
+            outputs[node.configOutput - 1] = {
+                topic: "configStore",
+                event: eventName || "configStore",
+                payload: {
+                    configStore: latestStore
+                },
+                configStore: latestStore
             };
 
-            /*
-             * Only send Client ID if the user entered one.
-             */
-            if (node.clientid) {
-                options.clientId = node.clientid;
+            node.send(outputs);
+        }
+
+        function runConfigStore(isOffline, forceOutput) {
+            if (closed) {
+                return;
             }
 
-            node.client = mqtt.connect(CLOUD_URL, options);
+            var outputs = new Array(node.outputCount).fill(null);
+            var statusSummary = [];
+            var outputGroups = new Map();
+            var activeItemKeys = new Set();
+            var schedulerItems = getSchedulerItems();
+
+            schedulerItems.forEach(function (entry, index) {
+                var item = entry.item;
+                var configName = entry.configName;
+                var outputKey = item.output || ("output" + (index + 1));
+                var outputNumber = outputNumberFromKey(outputKey, index, node.outputCount);
+
+                if (outputNumber === null) {
+                    statusSummary.push(outputKey + ": " + (item.name || "item") + " skipped - output disabled");
+                    return;
+                }
 
-            node.client.on("connect", function () {
-                node.connected = true;
-                node.lastErrorText = "";
-                node.lastErrorTime = 0;
+                var itemKey = itemMemoryKey(item, index, outputKey, configName);
 
-                node.emit("state", true);
+                item.output = outputKey;
+                activeItemKeys.add(itemKey);
 
-                Object.keys(node.subscriptions).forEach(function (topic) {
-                    node.client.subscribe(topic, node.subscriptions[topic], function (err) {
-                        if (err) {
-                            warnOncePerMinute("3DM Cloud subscribe failed: " + (err.message || err));
-                        }
+                var newState = item.controlType === "control"
+                    ? calculateControlState(item, itemKey, outputKey)
+                    : calculateScheduleState(item, itemKey);
+
+                if (newState === null || newState === undefined) {
+                    statusSummary.push(outputKey + ": " + (item.name || "item") + " skipped");
+                    return;
+                }
+
+                if (!outputGroups.has(outputKey)) {
+                    outputGroups.set(outputKey, {
+                        outputKey: outputKey,
+                        outputNumber: outputNumber,
+                        states: [],
+                        names: [],
+                        controlTypes: new Set()
                     });
-                });
+                }
+
+                var group = outputGroups.get(outputKey);
+
+                group.states.push(Number(newState) === 1 ? 1 : 0);
+                group.names.push(item.name || outputKey);
+                group.controlTypes.add(item.controlType || "schedule");
             });
 
-            node.client.on("reconnect", function () {
-                node.emit("reconnect");
+            stoppedScheduleRuns.forEach(function (_value, key) {
+                if (!activeItemKeys.has(key)) {
+                    stoppedScheduleRuns.delete(key);
+                }
             });
 
-            node.client.on("offline", function () {
-                node.connected = false;
-                node.emit("state", false);
+            controlItemStates.forEach(function (_value, key) {
+                if (!activeItemKeys.has(key)) {
+                    controlItemStates.delete(key);
+                }
             });
 
-            node.client.on("close", function () {
-                node.connected = false;
-                node.emit("state", false);
+            outputGroups.forEach(function (group) {
+                var activeRequests = group.states.filter(function (state) {
+                    return state === 1;
+                }).length;
+
+                var combinedState = activeRequests > 0 ? 1 : 0;
+                var lastState = outputStates[group.outputKey];
+
+                if (node.outputMode === "always" || forceOutput || lastState !== combinedState) {
+                    outputStates[group.outputKey] = combinedState;
+
+                    var controlType = group.controlTypes.size === 1
+                        ? Array.from(group.controlTypes)[0]
+                        : "combined";
+
+                    outputs[group.outputNumber - 1] = {
+                        payload: Boolean(combinedState),
+                        topic: group.outputKey,
+                        output: group.outputKey,
+                        outputNumber: group.outputNumber,
+                        controlType: controlType,
+                        activeRequests: activeRequests,
+                        totalRequests: group.states.length,
+                        name: group.names.length === 1
+                            ? group.names[0]
+                            : group.outputKey + " (" + group.names.length + " commands)"
+                    };
+                }
+
+                statusSummary.push(
+                    group.outputKey + ": " +
+                    (combinedState ? "ON" : "OFF") +
+                    " (" + activeRequests + "/" + group.states.length + " active)"
+                );
             });
 
-            node.client.on("error", function (err) {
-                node.connected = false;
-                node.emit("state", false);
+            if (closed) {
+                return;
+            }
 
-                var text = err && err.message ? err.message : String(err);
+            if (statusSummary.length === 0) {
+                var names = Object.keys(latestStore);
 
-                if (text.indexOf("Not authorized") !== -1 || text.indexOf("not authorized") !== -1) {
-                    warnOncePerMinute("3DM Cloud login rejected. Check username, password, and Client ID.");
+                if (names.length === 0) {
+                    setStatus("yellow", "ring", "waiting for configStore");
                 } else {
-                    warnOncePerMinute("3DM Cloud connection error: " + text);
+                    setStatus("blue", "dot", "config stored: " + names.join(", "));
                 }
-            });
 
-            node.client.on("message", function (topic, payload) {
-                node.emit("cloud-message", topic, payload);
-            });
-        };
+                return;
+            }
+
+            node.send(outputs);
+
+            setStatus(
+                isOffline ? "yellow" : "blue",
+                "dot",
+                (isOffline ? "Offline: " : "") + statusSummary.join(" | ")
+            );
+        }
+
+        function storeLatestPayload(msg) {
+            var payload = safeParseJson(msg.payload);
+
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                latestPayload = payload;
+            } else {
+                latestPayload = {};
+            }
+        }
+
+        function handleGetRequest(msg) {
+            var payload = safeParseJson(msg.payload);
 
-        node.publish = function (topic, payload, options, callback) {
-            if (!node.client || !node.connected) {
-                var err = new Error("3DM Cloud is not connected");
+            if (msg.getConfigStore === true) {
+                sendConfigSnapshot("requested");
+                return true;
+            }
 
-                if (callback) {
-                    callback(err);
+            if (payload && typeof payload === "object") {
+                if (payload.getConfigStore === true || payload.configStoreGet === true) {
+                    sendConfigSnapshot("requested");
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        loadFromDisk();
+
+        if (Object.keys(latestStore).length > 0) {
+            setStatus("blue", "dot", "loaded saved config");
+        } else {
+            setStatus("yellow", "ring", "waiting for configStore");
+        }
+
+        var timer = setInterval(function () {
+            runConfigStore(false, false);
+        }, node.tickSeconds * 1000);
+
+        setTimeout(function () {
+            runConfigStore(false, true);
+        }, 500);
+
+        node.on("input", function (msg, send, done) {
+            send = send || function () {
+                node.send.apply(node, arguments);
+            };
+
+            if (closed) {
+                if (done) {
+                    done();
                 }
 
                 return;
             }
 
-            var data = payload;
+            try {
+                if (handleGetRequest(msg)) {
+                    if (done) {
+                        done();
+                    }
 
-            if (typeof data !== "string" && !Buffer.isBuffer(data)) {
-                data = JSON.stringify(data);
-            }
+                    return;
+                }
+
+                var configStore = extractConfigStore(msg);
 
-            node.client.publish(topic, data, options || {}, callback);
-        };
+                if (configStore) {
+                    var savedNames = storeConfig(configStore);
 
-        node.subscribe = function (topic, options, callback) {
-            node.subscriptions[topic] = options || {};
+                    if (savedNames.length > 0) {
+                        setStatus("blue", "dot", "saved: " + savedNames.join(", "));
 
-            if (node.client && node.connected) {
-                node.client.subscribe(topic, options || {}, callback);
-            } else if (callback) {
-                callback();
+                        if (node.emitConfigOnUpdate) {
+                            sendConfigSnapshot("updated");
+                        }
+
+                        runConfigStore(false, true);
+                    } else {
+                        setStatus("yellow", "ring", "configStore ignored");
+                    }
+
+                    if (done) {
+                        done();
+                    }
+
+                    return;
+                }
+
+                storeLatestPayload(msg);
+                runConfigStore(false, false);
+
+                if (done) {
+                    done();
+                }
+            } catch (err) {
+                setStatus("red", "ring", "config store error");
+                node.error("3DM Config Store error: " + (err.message || err), msg);
+
+                if (done) {
+                    done(err);
+                }
             }
-        };
+        });
 
         node.on("close", function (removed, done) {
             if (typeof removed === "function") {
@@ -174,24 +890,11 @@ module.exports = function (RED) {
 
             done = done || function () {};
 
-            node.connected = false;
-
-            if (node.client) {
-                node.client.end(true, function () {
-                    done();
-                });
-            } else {
-                done();
-            }
+            closed = true;
+            clearInterval(timer);
+            done();
         });
-
-        node.connect();
     }
 
-    RED.nodes.registerType("3dm-cloud-config", ThreeDMCloudConfigNode, {
-        credentials: {
-            username: { type: "text" },
-            password: { type: "password" }
-        }
-    });
+    RED.nodes.registerType("3dm-config-store", ThreeDMConfigStoreNode);
 };