homebridge-http-webhooks-plus 0.2.1

package/docs/COMPATIBILITY.md

@@ -0,0 +1,73 @@
+# Migrating to HTTP Webhooks Plus 0.2.1
+
+This release republishes the upstream 0.2.0 implementation under the independent
+package name `homebridge-http-webhooks-plus`. All `src/` files, the configuration
+schema, runtime dependencies and declared runtime requirements are unchanged.
+The package name passed to Homebridge registration is updated; the platform and
+accessory aliases are preserved. No new state modes or feedback API ship in 0.2.1.
+
+## Existing HomeKit accessories
+
+Keep the existing `"platform": "HttpWebHooks"` configuration and every configured
+accessory ID and name. Preserve the existing main/child bridge username, pairing,
+port, persistent storage, service types and accessory configuration. Do not remove
+the bridge or accessories in Apple Home, recreate the platform, clear cached
+accessories or reset pairing as part of this package replacement.
+
+Homebridge's static-platform UUID construction uses the configured platform
+identifier and the accessory UUID base/name. With the existing unqualified
+`HttpWebHooks` identifier and unchanged configuration, this release preserves
+those inputs and the complete accessory implementation. Package-registration
+tests and exact upstream runtime fingerprints protect this release boundary.
+The owner's actual HomeKit rooms, scenes and automations still need checking
+after a backed-up migration; source checks cannot verify a particular Home.
+
+A package-qualified identifier such as
+`homebridge-http-webhooks.HttpWebHooks` needs a separately reviewed migration:
+changing its prefix can change the UUID seed. The same caution applies to
+package-qualified standalone accessory identifiers. Do not blindly replace
+every occurrence of the old package name in configuration or persistent data.
+
+## Package replacement
+
+1. Record the installed version and location, Node/Homebridge versions and any
+   locally modified source files. Make a private backup of the package, full
+   Homebridge configuration, persistent storage and pairing data.
+2. Stop integrations that issue commands or publish state, then stop Homebridge
+   using the service manager appropriate to your installation.
+3. Replace the old package with the pinned Plus version in the same Homebridge
+   plugin installation location. Do not load both packages together: their
+   platform and accessory aliases intentionally overlap.
+4. If top-level plugin allowlists or disabled-plugin lists are used, migrate
+   the package entry deliberately. Retain the platform/accessory configuration
+   and bridge identity. Check external tools for saved package paths or integrity
+   receipts before restarting them.
+5. Start Homebridge, verify the loaded package, and check that all existing
+   accessories remain in the same rooms and automations. Then resume dependent
+   integrations after their read-only readiness checks pass.
+
+Installation directories vary between system packages, containers, global npm
+and development setups. Use the existing Homebridge installation method; a
+global npm command in an unrelated Node installation can affect the wrong copy.
+
+## Locally patched installations
+
+The public npm artifact contains generic upstream behavior. A locally patched
+installation needs its patches preserved separately during this first migration.
+Compare the exact original files and patched files, retain the installed hashes
+and backups, and adapt any deployment receipts or saved paths. Do not assume
+ordinary reinstalling retains changes made inside `node_modules`.
+
+The package has no dependency on any particular controller or deployment script.
+Future configurable features will allow integrations to stop patching installed
+source. Integration-specific migration logic belongs to those integrations.
+
+## State behavior retained from upstream
+
+`targetdoorstate` represents the requested final door state; `currentdoorstate`
+represents the reported state. Setting either through a webhook is a state update.
+An existing HomeKit command handler can also optimistically publish final state
+when its outgoing HTTP command succeeds. This first release preserves that
+behavior, including existing limitations; HTTP acceptance does not prove physical
+completion. Garage obstruction reporting is a separate characteristic and is
+not a lock feature. See the README for the existing webhook fields.

package/index.js

@@ -0,0 +1,35 @@
+var HttpWebHooksPlatform = require('./src/homekit/HttpWebHooksPlatform');
+var HttpWebHookSensorAccessory = require('./src/homekit/accessories/HttpWebHookSensorAccessory');
+var HttpWebHookSwitchAccessory = require('./src/homekit/accessories/HttpWebHookSwitchAccessory');
+var HttpWebHookPushButtonAccessory = require('./src/homekit/accessories/HttpWebHookPushButtonAccessory');
+var HttpWebHookDoorbellAccessory = require('./src/homekit/accessories/HttpWebHookDoorbellAccessory');
+var HttpWebHookLightBulbAccessory = require('./src/homekit/accessories/HttpWebHookLightBulbAccessory');
+var HttpWebHookThermostatAccessory = require('./src/homekit/accessories/HttpWebHookThermostatAccessory');
+var HttpWebHookOutletAccessory = require('./src/homekit/accessories/HttpWebHookOutletAccessory');
+var HttpWebHookSecurityAccessory = require('./src/homekit/accessories/HttpWebHookSecurityAccessory');
+var HttpWebHookGarageDoorOpenerAccessory = require('./src/homekit/accessories/HttpWebHookGarageDoorOpenerAccessory');
+var HttpWebHookStatelessSwitchAccessory = require('./src/homekit/accessories/HttpWebHookStatelessSwitchAccessory');
+var HttpWebHookLockMechanismAccessory = require('./src/homekit/accessories/HttpWebHookLockMechanismAccessory');
+var HttpWebHookWindowCoveringAccessory = require('./src/homekit/accessories/HttpWebHookWindowCoveringAccessory');
+var HttpWebHookFanv2Accessory = require('./src/homekit/accessories/HttpWebHookFanv2Accessory');
+var HttpWebHookCarbonDioxideSensoryAccessory = require('./src/homekit/accessories/HttpWebHookCarbonDioxideSensorAccessory');
+var HttpWebHookValveAccessory = require('./src/homekit/accessories/HttpWebHookValveAccessory');
+
+module.exports = function(homebridge) {
+  homebridge.registerPlatform("homebridge-http-webhooks-plus", "HttpWebHooks", HttpWebHooksPlatform);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookSensor", HttpWebHookSensorAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookSwitch", HttpWebHookSwitchAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookPushButton", HttpWebHookPushButtonAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookDoorbell", HttpWebHookDoorbellAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookLight", HttpWebHookLightBulbAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookThermostat", HttpWebHookThermostatAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookOutlet", HttpWebHookOutletAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookSecurity", HttpWebHookSecurityAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookGarageDoorOpener", HttpWebHookGarageDoorOpenerAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookStatelessSwitch", HttpWebHookStatelessSwitchAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookLockMechanism", HttpWebHookLockMechanismAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookWindowCovering", HttpWebHookWindowCoveringAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookFanv2", HttpWebHookFanv2Accessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookCarbonDioxideSensor", HttpWebHookCarbonDioxideSensoryAccessory);
+  homebridge.registerAccessory("homebridge-http-webhooks-plus", "HttpWebHookValve", HttpWebHookValveAccessory);
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "homebridge-http-webhooks-plus",
+  "version": "0.2.1",
+  "displayName": "Homebridge HTTP Webhooks Plus",
+  "description": "HTTP webhooks and virtual accessories for Homebridge; independently maintained fork of homebridge-http-webhooks.",
+  "license": "GPL-3.0",
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "plugin",
+    "http",
+    "webhook",
+    "httpwebhooks",
+    "http-webhooks",
+    "http webhooks",
+    "smart",
+    "homekit",
+    "siri"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pponce/homebridge-http-webhooks-plus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pponce/homebridge-http-webhooks-plus/issues"
+  },
+  "engines": {
+    "node": ">=9.11.2",
+    "homebridge": "^1.8.4||^2.0.0-beta"
+  },
+  "dependencies": {
+    "http-auth": "^4.2.0",
+    "node-persist": "^2.1.0",
+    "request": "^2.88.2",
+    "selfsigned": "^2.4.1"
+  },
+  "homepage": "https://github.com/pponce/homebridge-http-webhooks-plus#readme",
+  "author": "benzman81",
+  "files": [
+    "index.js",
+    "src/",
+    "config.schema.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "docs/COMPATIBILITY.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/Constants.js

@@ -0,0 +1,12 @@
+module.exports = {
+  DEFAULT_REQUEST_TIMEOUT : 10000,
+  DEFAULT_PORT : 51828,
+  DEFAULT_SENSOR_TIMEOUT : 5000,
+  DEFAULT_CACHE_DIR : "./.node-persist/storage",
+  DEFAULT_LISTEN_HOST : "0.0.0.0",
+  COVERS_REQUEST_TIMEOUT : 35000,
+  CONTEXT_FROM_WEBHOOK : "fromHTTPWebhooks",
+  CONTEXT_FROM_TIMEOUTCALL : "fromTimeoutCall",
+  CERT_VERSION : 2,
+  CERT_DAYS : 365
+};

package/src/Server.js

@@ -0,0 +1,192 @@
+const Constants = require('./Constants');
+
+var request = require("request");
+var http = require('http');
+var https = require('https');
+var url = require('url');
+var auth = require('http-auth');
+var fs = require('fs');
+var Service, Characteristic;
+
+function Server(ServiceParam, CharacteristicParam, platform, platformConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.webhookPort = platformConfig["webhook_port"] || Constants.DEFAULT_PORT;
+  this.webhookListenHost = platformConfig["webhook_listen_host"] || Constants.DEFAULT_LISTEN_HOST;
+  this.webhookEnableCORS = platformConfig["webhook_enable_cors"] || false;
+  this.httpAuthUser = platformConfig["http_auth_user"] || null;
+  this.httpAuthPass = platformConfig["http_auth_pass"] || null;
+  this.https = platformConfig["https"] === true;
+  this.httpsKeyFile = platformConfig["https_keyfile"];
+  this.httpsCertFile = platformConfig["https_certfile"];
+}
+
+Server.prototype.setAccessories = function(accessories) {
+  this.accessories = accessories;
+};
+
+Server.prototype.createSSLCertificate = function() {
+  this.log("Generating new ssl certificate.");
+  var selfsigned = require('selfsigned');
+  var certAttrs = [{ name: 'homebridgeHttpWebhooks', value: 'homebridgeHttpWebhooks.com' , type: 'homebridgeHttpWebhooks'}];
+  var certOpts = { days: Constants.CERT_DAYS};
+  certOpts.extensions = [{
+    name: 'subjectAltName',
+    altNames: [{
+            type: 2,
+            value: 'homebridgeHttpWebhooks.com'
+    }, {
+            type: 2,
+            value: 'localhost'
+    }]
+  }];
+  var pems = selfsigned.generate(certAttrs, certOpts);
+  var cachedSSLCert = pems;
+  cachedSSLCert.timestamp = Date.now();
+  cachedSSLCert.certVersion = Constants.CERT_VERSION;
+  return cachedSSLCert;
+};
+
+Server.prototype.getSSLServerOptions = function() {
+  var sslServerOptions = {};
+  if(this.https) {
+    if(!this.httpsKeyFile || !this.httpsCertFile) {
+      this.log("Using automatic created ssl certificate.");
+      var cachedSSLCert = this.storage.getItemSync("http-webhook-ssl-cert");
+      if(cachedSSLCert) {
+        var certVersion = cachedSSLCert.certVersion;
+        var timestamp = Date.now() - cachedSSLCert.timestamp;
+        var diffInDays = timestamp/1000/60/60/24;
+        if(diffInDays > Constants.CERT_DAYS - 1 || certVersion !== Constants.CERT_VERSION) {
+          cachedSSLCert = null;
+        }
+      }
+      if(!cachedSSLCert) {
+        cachedSSLCert = this.createSSLCertificate();
+        this.storage.setItemSync("http-webhook-ssl-cert", cachedSSLCert);
+      }
+
+      sslServerOptions = {
+          key: cachedSSLCert.private,
+          cert: cachedSSLCert.cert
+      };
+    }
+    else {
+      sslServerOptions = {
+          key: fs.readFileSync(this.httpsKeyFile),
+          cert: fs.readFileSync(this.httpsCertFile)
+      };
+    }
+  }
+  return sslServerOptions;
+};
+
+Server.prototype.createServerCallback = function() {
+  return (function(request, response) {
+    if(this.webhookEnableCORS) {
+      // Based on https://gist.github.com/balupton/3696140
+      response.setHeader('Access-Control-Allow-Origin', '*');
+      response.setHeader('Access-Control-Request-Method', '*');
+      response.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET, POST');
+      response.setHeader('Access-Control-Allow-Headers', '*');
+      if (request.method === 'OPTIONS') {
+        response.writeHead(200);
+        response.end();
+        return;
+      }
+    }
+    var theUrl = request.url;
+    var theUrlParts = url.parse(theUrl, true);
+    var theUrlParams = theUrlParts.query;
+    var body = [];
+    request.on('error', (function(err) {
+      this.log("[ERROR Http WebHook Server] Reason: %s.", err);
+    }).bind(this)).on('data', function(chunk) {
+      body.push(chunk);
+    }).on('end', (function() {
+      body = Buffer.concat(body).toString();
+
+      response.on('error', function(err) {
+        this.log("[ERROR Http WebHook Server] Reason: %s.", err);
+      });
+
+      response.statusCode = 200;
+      response.setHeader('Content-Type', 'application/json');
+
+      if (!theUrlParams.accessoryId) {
+        response.statusCode = 404;
+        response.setHeader("Content-Type", "text/plain");
+        var errorText = "[ERROR Http WebHook Server] No accessoryId in request.";
+        this.log(errorText);
+        response.write(errorText);
+        response.end();
+      }
+      else {
+        var responseBody = null;
+        var accessoryId = theUrlParams.accessoryId;
+        var found = false;
+        for (var i = 0; i < this.accessories.length; i++) {
+          var accessory = this.accessories[i];
+          if (accessory.id === accessoryId) {
+            responseBody = accessory.changeFromServer(theUrlParams);
+            found = true;
+            break;
+          }
+        }
+        if(responseBody) {
+          response.write(JSON.stringify(responseBody));
+          response.end();
+        }
+        else {
+          response.statusCode = 404;
+          response.setHeader("Content-Type", "text/plain");
+          var errorText = "[ERROR Http WebHook Server] AccessoryId '"+theUrlParams.accessoryId+"' did not return a response body from 'changeFromServer'.";
+          if(!found) {
+            errorText = "[ERROR Http WebHook Server] AccessoryId '"+theUrlParams.accessoryId+"' not found.";
+          }
+          this.log(errorText);
+          response.write(errorText);
+          response.end();
+        }
+      }
+    }).bind(this));
+  }).bind(this);
+};
+
+Server.prototype.start = function() {
+  var sslServerOptions = this.getSSLServerOptions();
+
+  var serverCallback = this.createServerCallback();
+
+  if (this.httpAuthUser && this.httpAuthPass) {
+    var httpAuthUser = this.httpAuthUser;
+    var httpAuthPass = this.httpAuthPass;
+    basicAuth = auth.basic({
+      realm : "Auth required"
+    }, function(username, password, callback) {
+      callback(username === httpAuthUser && password === httpAuthPass);
+    });
+    if(this.https) {
+      https.createServer(basicAuth, sslServerOptions, serverCallback).listen(this.webhookPort, this.webhookListenHost);
+    }
+    else {
+      http.createServer(basicAuth, serverCallback).listen(this.webhookPort, this.webhookListenHost);
+    }
+  }
+  else {
+    if(this.https) {
+      https.createServer(sslServerOptions, serverCallback).listen(this.webhookPort, this.webhookListenHost);
+    }
+    else {
+      http.createServer(serverCallback).listen(this.webhookPort, this.webhookListenHost);
+    }
+  }
+  this.log("Started server for webhooks on port '%s' listening for host '%s'.", this.webhookPort, this.webhookListenHost);
+};
+
+module.exports = Server;

package/src/Util.js

@@ -0,0 +1,51 @@
+const Constants = require('./Constants');
+
+var request = require("request");
+
+const callHttpApi = function(log, urlToCall, urlMethod, urlBody, urlForm, urlHeaders, rejectUnauthorized, homeKitCallback, context, onSuccessCallback, onFailureCallback, timeout) {
+  if (urlToCall !== "" && context !== Constants.CONTEXT_FROM_WEBHOOK) {
+    var theRequest = {
+      method : urlMethod,
+      url : urlToCall,
+      timeout : timeout || Constants.DEFAULT_REQUEST_TIMEOUT,
+      headers : JSON.parse(urlHeaders),
+      rejectUnauthorized: rejectUnauthorized
+    };
+    if (urlMethod === "POST" || urlMethod === "PUT" || urlMethod === "PATCH") {
+      if (urlForm) {
+        log("Adding Form " + urlForm);
+        theRequest.form = JSON.parse(urlForm);
+      }
+      else if (urlBody) {
+        log("Adding Body " + urlBody);
+        theRequest.body = urlBody;
+      }
+    }
+    request(theRequest, (function(err, response, body) {
+      var statusCode = response && response.statusCode ? response.statusCode : -1;
+      log("Request to '%s' finished with status code '%s' and body '%s'.", urlToCall, statusCode, body, err);
+      if (!err && statusCode >= 200 && statusCode < 300) {
+        if (onSuccessCallback) {
+          onSuccessCallback();
+        }
+        homeKitCallback(null);
+      }
+      else {
+        if (onFailureCallback) {
+          onFailureCallback();
+        }
+        homeKitCallback(err || new Error("Request to '" + urlToCall + "' was not succesful."));
+      }
+    }).bind(this));
+  }
+  else {
+    if (onSuccessCallback) {
+      onSuccessCallback();
+    }
+    homeKitCallback(null);
+  }
+};
+
+module.exports = {
+  callHttpApi : callHttpApi
+};

package/src/homekit/HttpWebHooksPlatform.js

@@ -0,0 +1,136 @@
+const Constants = require('../Constants');
+const Server = require('../Server');
+
+var HttpWebHookSensorAccessory = require('./accessories/HttpWebHookSensorAccessory');
+var HttpWebHookSwitchAccessory = require('./accessories/HttpWebHookSwitchAccessory');
+var HttpWebHookPushButtonAccessory = require('./accessories/HttpWebHookPushButtonAccessory');
+var HttpWebHookDoorbellAccessory = require('./accessories/HttpWebHookDoorbellAccessory');
+var HttpWebHookLightBulbAccessory = require('./accessories/HttpWebHookLightBulbAccessory');
+var HttpWebHookThermostatAccessory = require('./accessories/HttpWebHookThermostatAccessory');
+var HttpWebHookOutletAccessory = require('./accessories/HttpWebHookOutletAccessory');
+var HttpWebHookSecurityAccessory = require('./accessories/HttpWebHookSecurityAccessory');
+var HttpWebHookGarageDoorOpenerAccessory = require('./accessories/HttpWebHookGarageDoorOpenerAccessory');
+var HttpWebHookStatelessSwitchAccessory = require('./accessories/HttpWebHookStatelessSwitchAccessory');
+var HttpWebHookLockMechanismAccessory = require('./accessories/HttpWebHookLockMechanismAccessory');
+var HttpWebHookWindowCoveringAccessory = require('./accessories/HttpWebHookWindowCoveringAccessory');
+var HttpWebHookFanv2Accessory = require('./accessories/HttpWebHookFanv2Accessory');
+var HttpWebHookCarbonDioxideSensoryAccessory = require('./accessories/HttpWebHookCarbonDioxideSensorAccessory');
+var HttpWebHookValveAccessory = require('./accessories/HttpWebHookValveAccessory');
+
+var Service, Characteristic;
+
+function HttpWebHooksPlatform(log, config, homebridge) {
+  Service = homebridge.hap.Service;
+  Characteristic = homebridge.hap.Characteristic;
+
+  this.log = log;
+  this.cacheDirectory = config["cache_directory"] || Constants.DEFAULT_CACHE_DIR;
+  this.storage = require('node-persist');
+  this.storage.initSync({
+    dir : this.cacheDirectory
+  });
+
+  this.sensors = config["sensors"] || [];
+  this.switches = config["switches"] || [];
+  this.pushButtons = config["pushbuttons"] || [];
+  this.doorbells = config["doorbells"] || [];
+  this.lights = config["lights"] || [];
+  this.thermostats = config["thermostats"] || [];
+  this.outlets = config["outlets"] || [];
+  this.security = config["security"] || [];
+  this.garageDoorOpeners = config["garagedooropeners"] || [];
+  this.statelessSwitches = config["statelessswitches"] || [];
+  this.windowCoverings = config["windowcoverings"] || [];
+  this.lockMechanisms = config["lockmechanisms"] || [];
+  this.fanv2s = config["fanv2s"] || [];
+  this.co2sensors = config["co2sensors"] || [];
+  this.valves = config["valves"] || [];
+
+  this.server = new Server(Service, Characteristic, this, config);
+};
+
+HttpWebHooksPlatform.prototype.accessories = function(callback) {
+  var accessories = [];
+
+  for (var i = 0; i < this.sensors.length; i++) {
+    var sensor = new HttpWebHookSensorAccessory(Service, Characteristic, this, this.sensors[i]);
+    accessories.push(sensor);
+  }
+
+  for (var i = 0; i < this.switches.length; i++) {
+    var switchAccessory = new HttpWebHookSwitchAccessory(Service, Characteristic, this, this.switches[i]);
+    accessories.push(switchAccessory);
+  }
+
+  for (var i = 0; i < this.pushButtons.length; i++) {
+    var pushButtonsAccessory = new HttpWebHookPushButtonAccessory(Service, Characteristic, this, this.pushButtons[i]);
+    accessories.push(pushButtonsAccessory);
+  }
+
+  for (var i = 0; i < this.doorbells.length; i++) {
+    var doorbellAccessory = new HttpWebHookDoorbellAccessory(Service, Characteristic, this, this.doorbells[i]);
+    accessories.push(doorbellAccessory);
+  }
+
+  for (var i = 0; i < this.lights.length; i++) {
+    var lightAccessory = new HttpWebHookLightBulbAccessory(Service, Characteristic, this, this.lights[i]);
+    accessories.push(lightAccessory);
+  }
+
+  for (var i = 0; i < this.thermostats.length; i++) {
+    var thermostatAccessory = new HttpWebHookThermostatAccessory(Service, Characteristic, this, this.thermostats[i]);
+    accessories.push(thermostatAccessory);
+  }
+
+  for (var i = 0; i < this.outlets.length; i++) {
+    var outletAccessory = new HttpWebHookOutletAccessory(Service, Characteristic, this, this.outlets[i]);
+    accessories.push(outletAccessory);
+  }
+
+  for (var i = 0; i < this.security.length; i++) {
+    var securityAccessory = new HttpWebHookSecurityAccessory(Service, Characteristic, this, this.security[i]);
+    accessories.push(securityAccessory);
+  }
+
+  for (var i = 0; i < this.garageDoorOpeners.length; i++) {
+    var garageDoorOpenerAccessory = new HttpWebHookGarageDoorOpenerAccessory(Service, Characteristic, this, this.garageDoorOpeners[i]);
+    accessories.push(garageDoorOpenerAccessory);
+  }
+
+  for (var i = 0; i < this.windowCoverings.length; i++) {
+    var WindowCoveringAccessory = new HttpWebHookWindowCoveringAccessory(Service, Characteristic, this, this.windowCoverings[i]);
+    accessories.push(WindowCoveringAccessory);
+  }
+
+  for (var i = 0; i < this.statelessSwitches.length; i++) {
+    var statelessSwitchAccessory = new HttpWebHookStatelessSwitchAccessory(Service, Characteristic, this, this.statelessSwitches[i]);
+    accessories.push(statelessSwitchAccessory);
+  }
+
+  for (var i = 0; i < this.lockMechanisms.length; i++) {
+    var lockMechanismAccessory = new HttpWebHookLockMechanismAccessory(Service, Characteristic, this, this.lockMechanisms[i]);
+    accessories.push(lockMechanismAccessory);
+  }
+
+  for (var i = 0; i < this.fanv2s.length; i++) {
+    var fanv2Accessory = new HttpWebHookFanv2Accessory(Service, Characteristic, this, this.fanv2s[i]);
+    accessories.push(fanv2Accessory);
+  }
+
+  for (var i = 0; i < this.co2sensors.length; i++) {
+    var co2sensorAccessory = new HttpWebHookCarbonDioxideSensoryAccessory(Service, Characteristic, this, this.co2sensors[i]);
+    accessories.push(co2sensorAccessory);
+  }
+
+  for (var i = 0; i < this.valves.length; i++) {
+    var valveAccessory = new HttpWebHookValveAccessory(Service, Characteristic, this, this.valves[i]);
+    accessories.push(valveAccessory);
+  }
+
+  this.server.setAccessories(accessories);
+  this.server.start();
+
+  callback(accessories);
+};
+
+module.exports = HttpWebHooksPlatform;

package/src/homekit/accessories/HttpWebHookCarbonDioxideSensorAccessory.js

@@ -0,0 +1,75 @@
+const Constants = require('../../Constants');
+
+function HttpWebHookCarbonDioxideSensorAccessory(ServiceParam, CharacteristicParam, platform, sensorConfig) {
+  Service = ServiceParam;
+  Characteristic = CharacteristicParam;
+
+  this.platform = platform;
+  this.log = platform.log;
+  this.storage = platform.storage;
+
+  this.id = sensorConfig["id"];
+  this.name = sensorConfig["name"];
+  this.type = "co2";
+  this.co2PeakLevel = sensorConfig["co2_peak_level"] || 1200;
+
+  this.informationService = new Service.AccessoryInformation();
+  this.informationService.setCharacteristic(Characteristic.Manufacturer, "HttpWebHooksPlatform");
+  this.informationService.setCharacteristic(Characteristic.Model, "HttpWebHookCarbonDioxideSensorAccessory-" + this.name);
+  this.informationService.setCharacteristic(Characteristic.SerialNumber, "HttpWebHookCarbonDioxideSensorAccessory-" + this.id);
+
+  this.service = new Service.CarbonDioxideSensor(this.name);
+  this.service.getCharacteristic(Characteristic.CarbonDioxideLevel).on('get', this.getCarbonDioxideLevel.bind(this));
+  this.service.getCharacteristic(Characteristic.CarbonDioxideDetected).on('get', this.getCarbonDioxideDetected.bind(this));
+}
+
+HttpWebHookCarbonDioxideSensorAccessory.prototype.changeFromServer = function(urlParams) {
+  var cached = this.storage.getItemSync("http-webhook-" + this.id) || 0;
+  if (urlParams.value === undefined) {
+    this.log.debug(this.name + ": No urlValue");
+    return {
+      "success" : true,
+      "state" : cached
+    };
+  }
+  var urlValue = urlParams.value;
+  var co2Detected = urlValue > this.co2PeakLevel;
+  this.log.debug(this.name + ": urlValue: "+ urlValue);
+  this.log.debug(this.name + ": co2Detected: "+ co2Detected);
+  this.storage.setItemSync("http-webhook-carbon-dioxide-level-" + this.id, urlValue);
+  this.storage.setItemSync("http-webhook-carbon-dioxide-detected-" + this.id, co2Detected);
+  this.log.debug(this.name + ": cached: "+ cached);
+  this.log.debug(this.name + ": cached !== urlValue: "+ (cached !== urlValue));
+  if (cached !== urlValue) {
+    this.log(this.name + ": Change HomeKit value for " + this.type + " sensor to '%s'.", urlValue);
+    this.service.getCharacteristic(Characteristic.CarbonDioxideLevel).updateValue(urlValue, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+    this.service.getCharacteristic(Characteristic.CarbonDioxideDetected).updateValue(co2Detected ? Characteristic.CarbonDioxideDetected.CO2_LEVELS_ABNORMAL : Characteristic.CarbonDioxideDetected.CO2_LEVELS_NORMAL, undefined, Constants.CONTEXT_FROM_WEBHOOK);
+  }
+  return {
+    "success" : true
+  };
+}
+
+HttpWebHookCarbonDioxideSensorAccessory.prototype.getCarbonDioxideLevel = function(callback) {
+  this.log.debug(this.name + ": Getting carbon dioxide level for '%s'...", this.id);
+  var temp = this.storage.getItemSync("http-webhook-carbon-dioxide-level-" + this.id);
+  if (temp === undefined) {
+    temp = 0;
+  }
+  callback(null, temp);
+};
+
+HttpWebHookCarbonDioxideSensorAccessory.prototype.getCarbonDioxideDetected = function(callback) {
+    this.log.debug(this.name + ": Getting carbon dioxide detected state for '%s'...", this.id);
+    var state = this.storage.getItemSync("http-webhook-carbon-dioxide-detected-" + this.id);
+    if (state === undefined) {
+        state = false;
+    }
+    callback(null, state ? Characteristic.CarbonDioxideDetected.CO2_LEVELS_ABNORMAL : Characteristic.CarbonDioxideDetected.CO2_LEVELS_NORMAL);
+};
+
+HttpWebHookCarbonDioxideSensorAccessory.prototype.getServices = function() {
+  return [ this.service, this.informationService ];
+};
+
+module.exports = HttpWebHookCarbonDioxideSensorAccessory;