node-red-contrib-homekit-bridged 2.0.0-dev.1 → 2.0.0-dev.10

package/build/plugins/embedded/homebridge-unifi-protect/index.js

@@ -0,0 +1,521 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var homebridge_unifi_protect_exports = {};
+__export(homebridge_unifi_protect_exports, {
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID: () => HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME: () => HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME,
+  attachHomebridgeUniFiProtectPlugin: () => attachHomebridgeUniFiProtectPlugin,
+  createHomebridgeUniFiProtectCleanup: () => createHomebridgeUniFiProtectCleanup,
+  createHomebridgeUniFiProtectPluginEntry: () => createHomebridgeUniFiProtectPluginEntry,
+  ensureHomebridgePlatformAccessoryShape: () => ensureHomebridgePlatformAccessoryShape,
+  homebridgeUniFiProtectPluginFactory: () => homebridgeUniFiProtectPluginFactory,
+  homebridgeUniFiProtectPluginMetadata: () => homebridgeUniFiProtectPluginMetadata,
+  registerHomebridgeUniFiProtectPlugin: () => registerHomebridgeUniFiProtectPlugin
+});
+module.exports = __toCommonJS(homebridge_unifi_protect_exports);
+var import_hap_nodejs = require("@homebridge/hap-nodejs");
+var import_logger = require("@nrchkb/logger");
+var import_registry = require("../../registry");
+const HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME = "homebridge-unifi-protect";
+const HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID = (0, import_registry.normalizePluginId)(
+  "node-red-contrib-homekit-bridged",
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME
+);
+const requirePackageJson = (packageName) => {
+  try {
+    return require(`${packageName}/package.json`);
+  } catch (_) {
+    return {};
+  }
+};
+const upstreamPackage = requirePackageJson("homebridge-unifi-protect");
+const toName = (value) => typeof value === "string" ? value : value?.name ?? "";
+const upstreamAuthor = toName(upstreamPackage.author);
+const upstreamContributors = upstreamPackage.contributors?.map(toName).filter(Boolean) ?? [];
+const importEsm = (specifier) => {
+  const importer = new Function("specifier", "return import(specifier)");
+  return importer(specifier);
+};
+const ensureHomebridgePlatformAccessoryShape = (accessory, bridged) => {
+  const platformAccessory = accessory;
+  platformAccessory._associatedHAPAccessory ??= {};
+  platformAccessory._associatedHAPAccessory.bridged = bridged;
+};
+const createHomebridgeLogger = () => {
+  const log = (0, import_logger.logger)("NRCHKB", "HomebridgeUniFiProtect");
+  const write = (level) => (message, ...parameters) => {
+    const suffix = parameters.length ? ` ${parameters.join(" ")}` : "";
+    const text = `${message}${suffix}`;
+    if (level === "error") {
+      log.error(text);
+    } else {
+      log.debug(text);
+    }
+  };
+  return {
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error"),
+    success: write("info"),
+    log: write("info")
+  };
+};
+const getControllerNode = (context) => {
+  const controllerId = context.config.controller;
+  if (!controllerId || !context.RED) {
+    throw new Error("UniFi Protect controller is not configured.");
+  }
+  const controller = context.RED.nodes.getNode(controllerId);
+  if (!controller) {
+    throw new Error(`UniFi controller "${controllerId}" was not found.`);
+  }
+  if ((controller.application ?? "protect") !== "protect") {
+    throw new Error(
+      "Selected UniFi controller is not a Protect controller."
+    );
+  }
+  if (!controller.address || !controller.credentials?.username || !controller.credentials.password) {
+    throw new Error(
+      "UniFi Protect controller address, username, and password are required."
+    );
+  }
+  return controller;
+};
+const getSelectedCamera = (context) => {
+  const camera = context.config.camera?.trim();
+  if (!camera) {
+    throw new Error("Select a UniFi Protect camera before deploying.");
+  }
+  return camera;
+};
+const splitFeatureOptions = (value) => (value ?? "").split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean);
+const buildFeatureOptions = (config) => {
+  const options = splitFeatureOptions(config.featureOptions);
+  if (config.audio === false) {
+    options.push("Disable.Audio");
+  }
+  if (config.twoWayAudio === false) {
+    options.push("Disable.Audio.TwoWay");
+  }
+  if (config.twoWayAudioDirect === true) {
+    options.push("Enable.Audio.TwoWay.Direct");
+  }
+  if (config.hksv === false) {
+    options.push("Disable.Video.HKSV");
+  }
+  if (config.hksvRecordingSwitch === true) {
+    options.push("Enable.Video.HKSV.Recording.Switch");
+  }
+  if (config.motionSwitch === true) {
+    options.push("Enable.Motion.Switch");
+  }
+  if (config.motionTrigger === true) {
+    options.push("Enable.Motion.Trigger");
+  }
+  if (config.occupancySensor === true) {
+    options.push("Enable.Motion.OccupancySensor");
+  }
+  if (config.doorbellTrigger === true) {
+    options.push("Enable.Doorbell.Trigger");
+  }
+  return options;
+};
+const createHomebridgeApiShim = async (context) => {
+  const hap = await import("@homebridge/hap-nodejs");
+  const handlers = /* @__PURE__ */ new Map();
+  const PlatformAccessoryShim = class extends hap.Accessory {
+    constructor(displayName, uuid) {
+      super(displayName, uuid);
+      this.context ??= {};
+      ensureHomebridgePlatformAccessoryShape(this, true);
+    }
+  };
+  const api = {
+    hap,
+    platformAccessory: PlatformAccessoryShim,
+    on: (event, handler) => {
+      const eventHandlers = handlers.get(event) ?? [];
+      eventHandlers.push(handler);
+      handlers.set(event, eventHandlers);
+    },
+    registerPlatformAccessories: (_pluginName, _platformName, accessories) => {
+      accessories.forEach((accessory) => {
+        ensureHomebridgePlatformAccessoryShape(accessory, true);
+        if (!context.accessory.services.includes(accessory)) {
+        }
+      });
+    },
+    unregisterPlatformAccessories: () => void 0,
+    updatePlatformAccessories: () => void 0,
+    publishExternalAccessories: (_pluginName, accessories) => {
+      accessories.forEach((accessory) => {
+        ensureHomebridgePlatformAccessoryShape(accessory, false);
+      });
+    }
+  };
+  return {
+    api,
+    emit: (event) => {
+      ;
+      (handlers.get(event) ?? []).forEach((handler) => handler());
+    }
+  };
+};
+const configureSelectedCameraOnly = (context, platform) => {
+  const selectedCamera = getSelectedCamera(context).toLowerCase();
+  context.accessory.context ??= {};
+  ensureHomebridgePlatformAccessoryShape(context.accessory, true);
+  platform.accessories = [context.accessory];
+  platform.controllers.forEach((controller) => {
+    controller.addHomeKitDevice = (device) => {
+      const deviceMac = device.mac?.toLowerCase();
+      const deviceId = device.id?.toLowerCase();
+      if (!selectedCamera || selectedCamera !== deviceMac && selectedCamera !== deviceId) {
+        return false;
+      }
+      context.accessory.context ??= {};
+      context.accessory.context.mac = device.mac;
+      if (controller.ufp?.mac) {
+        context.accessory.context.nvr = controller.ufp.mac;
+      }
+      const accessoryUuid = context.accessory.UUID;
+      if (!controller.configuredDevices.has(accessoryUuid)) {
+        controller.addProtectDevice(context.accessory, device);
+        return true;
+      }
+      controller.events?.emit("updateEvent", {
+        header: {
+          action: "update",
+          hbupBootstrap: true,
+          id: device.id,
+          modelKey: device.modelKey
+        },
+        payload: device
+      });
+      return true;
+    };
+  });
+};
+const guardPlatformLaunch = (platform) => {
+  platform.launchControllers = async () => {
+    try {
+      if (platform.codecSupport && !await platform.codecSupport.probe()) {
+        platform.log?.error(
+          "Homebridge UniFi Protect requires a working FFmpeg executable."
+        );
+        return;
+      }
+      await Promise.all(
+        platform.controllers.map(async (controller) => {
+          try {
+            const login = controller.login;
+            await login?.call(controller);
+          } catch (error) {
+            platform.log?.error(
+              "Unable to start UniFi Protect controller: %s",
+              error
+            );
+          }
+        })
+      );
+    } catch (error) {
+      platform.log?.error("Unable to launch UniFi Protect: %s", error);
+    }
+  };
+};
+const createHomebridgeUniFiProtectCleanup = (platform, emit) => {
+  let closed = false;
+  return () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    emit("shutdown");
+    platform.controllers.forEach((controller) => {
+      controller.configuredDevices.forEach((device) => {
+        try {
+          device.cleanup?.();
+        } catch (_) {
+        }
+      });
+      try {
+        controller.disconnect();
+      } catch (_) {
+      }
+      try {
+        controller.ufpApi?.logout?.();
+      } catch (_) {
+      }
+    });
+  };
+};
+const homebridgeUniFiProtectPluginMetadata = {
+  id: HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  packageName: "node-red-contrib-homekit-bridged",
+  pluginName: HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME,
+  displayName: "Homebridge UniFi Protect",
+  author: "NRCHKB",
+  version: "1.0.0",
+  description: "Adds a selected UniFi Protect camera using Homebridge UniFi Protect runtime behavior.",
+  attachment: "config-node",
+  license: "Apache-2.0",
+  capabilities: {
+    camera: true,
+    snapshots: true,
+    liveVideo: true,
+    audio: true,
+    twoWayAudio: true,
+    secureVideo: true,
+    experimental: ["twoWayAudio", "secureVideo"]
+  },
+  prerequisites: {
+    serviceNames: ["Camera"]
+  },
+  serviceNames: ["Camera"],
+  multipleInstances: false,
+  upstream: {
+    packageName: "homebridge-unifi-protect",
+    packageVersion: upstreamPackage.version,
+    projectName: "Homebridge UniFi Protect",
+    repoUrl: "https://github.com/hjdhjd/homebridge-unifi-protect",
+    license: upstreamPackage.license,
+    authors: upstreamAuthor ? [upstreamAuthor] : [],
+    contributors: upstreamContributors,
+    disclaimer: "Original authors and contributors are credited for the upstream Homebridge plugin. NRCHKB owns and supports this embedded integration."
+  },
+  editor: {
+    defaultConfig: {
+      controller: "",
+      camera: "",
+      videoProcessor: "",
+      verboseFfmpeg: false,
+      audio: true,
+      twoWayAudio: true,
+      twoWayAudioDirect: false,
+      hksv: true,
+      hksvRecordingSwitch: false,
+      motionSwitch: false,
+      motionTrigger: false,
+      occupancySensor: false,
+      doorbellTrigger: false,
+      featureOptions: ""
+    },
+    sections: [
+      {
+        title: "Controller",
+        fields: [
+          {
+            path: "controller",
+            label: "UniFi Controller",
+            type: "config-node",
+            icon: "fa-server",
+            configNodeType: "homekit-unifi-controller"
+          }
+        ]
+      },
+      {
+        title: "Camera",
+        fields: [
+          {
+            path: "camera",
+            label: "Camera",
+            type: "dynamic-select",
+            icon: "fa-video-camera",
+            optionsUrl: "nrchkb/unifi/controllers/{controller}/protect/cameras",
+            optionsDependsOn: "controller"
+          }
+        ]
+      },
+      {
+        title: "Streaming & Audio",
+        fields: [
+          {
+            path: "videoProcessor",
+            label: "FFmpeg Location",
+            type: "text",
+            icon: "fa-terminal"
+          },
+          {
+            path: "verboseFfmpeg",
+            label: "Verbose FFmpeg",
+            type: "checkbox",
+            icon: "fa-bug",
+            default: false
+          },
+          {
+            path: "audio",
+            label: "Audio",
+            type: "checkbox",
+            icon: "fa-headphones",
+            default: true
+          },
+          {
+            path: "twoWayAudio",
+            label: "Two-Way Audio",
+            type: "checkbox",
+            icon: "fa-microphone",
+            default: true
+          },
+          {
+            path: "twoWayAudioDirect",
+            label: "Direct Two-Way Audio",
+            type: "checkbox",
+            icon: "fa-microphone",
+            default: false
+          }
+        ]
+      },
+      {
+        title: "Recording / HKSV",
+        fields: [
+          {
+            path: "hksv",
+            label: "HomeKit Secure Video",
+            type: "checkbox",
+            icon: "fa-video-camera",
+            default: true
+          },
+          {
+            path: "hksvRecordingSwitch",
+            label: "Recording Switch",
+            type: "checkbox",
+            icon: "fa-toggle-on",
+            default: false
+          }
+        ]
+      },
+      {
+        title: "Advanced",
+        fields: [
+          {
+            path: "motionSwitch",
+            label: "Motion Switch",
+            type: "checkbox",
+            icon: "fa-toggle-on",
+            default: false
+          },
+          {
+            path: "motionTrigger",
+            label: "Motion Trigger",
+            type: "checkbox",
+            icon: "fa-bell",
+            default: false
+          },
+          {
+            path: "occupancySensor",
+            label: "Occupancy Sensor",
+            type: "checkbox",
+            icon: "fa-street-view",
+            default: false
+          },
+          {
+            path: "doorbellTrigger",
+            label: "Doorbell Trigger",
+            type: "checkbox",
+            icon: "fa-bell-o",
+            default: false
+          },
+          {
+            path: "featureOptions",
+            label: "Feature Options",
+            type: "textarea",
+            icon: "fa-list",
+            placeholder: "One Homebridge UniFi Protect feature option per line"
+          }
+        ]
+      }
+    ]
+  }
+};
+const attachHomebridgeUniFiProtectPlugin = async (context) => {
+  getSelectedCamera(context);
+  const controller = getControllerNode(context);
+  const module2 = await importEsm(
+    "homebridge-unifi-protect/dist/protect-platform.js"
+  );
+  const { api, emit } = await createHomebridgeApiShim(context);
+  const hbupConfig = {
+    controllers: [
+      {
+        address: controller.address,
+        username: controller.credentials?.username,
+        password: controller.credentials?.password,
+        name: controller.name,
+        overrideAddress: controller.overrideAddress
+      }
+    ],
+    options: buildFeatureOptions(context.config),
+    verboseFfmpeg: context.config.verboseFfmpeg === true,
+    videoProcessor: context.config.videoProcessor || void 0
+  };
+  const platform = new module2.ProtectPlatform(
+    createHomebridgeLogger(),
+    hbupConfig,
+    api
+  );
+  configureSelectedCameraOnly(context, platform);
+  guardPlatformLaunch(platform);
+  emit("didFinishLaunching");
+  context.node?.on(
+    "close",
+    createHomebridgeUniFiProtectCleanup(platform, emit)
+  );
+  return context.accessory.getService(import_hap_nodejs.Service.CameraRTPStreamManagement) ?? context.accessory.addService(
+    import_hap_nodejs.Service.CameraRTPStreamManagement,
+    context.serviceInformation.name
+  );
+};
+const homebridgeUniFiProtectPluginFactory = {
+  attach: attachHomebridgeUniFiProtectPlugin
+};
+const registerHomebridgeUniFiProtectPlugin = () => (0, import_registry.registerPlugin)(
+  homebridgeUniFiProtectPluginMetadata,
+  homebridgeUniFiProtectPluginFactory
+);
+const createHomebridgeUniFiProtectPluginEntry = (config) => ({
+  id: HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  automatic: false,
+  modified: true,
+  config: {
+    ...config
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME,
+  attachHomebridgeUniFiProtectPlugin,
+  createHomebridgeUniFiProtectCleanup,
+  createHomebridgeUniFiProtectPluginEntry,
+  ensureHomebridgePlatformAccessoryShape,
+  homebridgeUniFiProtectPluginFactory,
+  homebridgeUniFiProtectPluginMetadata,
+  registerHomebridgeUniFiProtectPlugin
+});

package/build/plugins/embedded/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var embedded_exports = {};
+__export(embedded_exports, {
+  HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_ID: () => import_homebridge_camera_ffmpeg2.HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_ID,
+  HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_NAME: () => import_homebridge_camera_ffmpeg2.HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_NAME,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID: () => import_homebridge_unifi_protect2.HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME: () => import_homebridge_unifi_protect2.HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME,
+  createAutomaticHomebridgeCameraFfmpegPluginEntry: () => import_homebridge_camera_ffmpeg2.createAutomaticHomebridgeCameraFfmpegPluginEntry,
+  createHomebridgeUniFiProtectCleanup: () => import_homebridge_unifi_protect2.createHomebridgeUniFiProtectCleanup,
+  createHomebridgeUniFiProtectPluginEntry: () => import_homebridge_unifi_protect2.createHomebridgeUniFiProtectPluginEntry,
+  ensureHomebridgePlatformAccessoryShape: () => import_homebridge_unifi_protect2.ensureHomebridgePlatformAccessoryShape,
+  mapLegacyCameraConfigToPluginConfig: () => import_homebridge_camera_ffmpeg2.mapLegacyCameraConfigToPluginConfig,
+  registerEmbeddedPlugins: () => registerEmbeddedPlugins
+});
+module.exports = __toCommonJS(embedded_exports);
+var import_registry = require("../registry");
+var import_homebridge_camera_ffmpeg = require("./homebridge-camera-ffmpeg");
+var import_homebridge_unifi_protect = require("./homebridge-unifi-protect");
+var import_homebridge_camera_ffmpeg2 = require("./homebridge-camera-ffmpeg");
+var import_homebridge_unifi_protect2 = require("./homebridge-unifi-protect");
+const registerEmbeddedPlugins = () => {
+  if (!(0, import_registry.getPlugin)(import_homebridge_camera_ffmpeg.HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_ID)) {
+    (0, import_homebridge_camera_ffmpeg.registerHomebridgeCameraFfmpegPlugin)();
+  }
+  if (!(0, import_registry.getPlugin)(import_homebridge_unifi_protect.HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID)) {
+    (0, import_homebridge_unifi_protect.registerHomebridgeUniFiProtectPlugin)();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_ID,
+  HOMEBRIDGE_CAMERA_FFMPEG_PLUGIN_NAME,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_ID,
+  HOMEBRIDGE_UNIFI_PROTECT_PLUGIN_NAME,
+  createAutomaticHomebridgeCameraFfmpegPluginEntry,
+  createHomebridgeUniFiProtectCleanup,
+  createHomebridgeUniFiProtectPluginEntry,
+  ensureHomebridgePlatformAccessoryShape,
+  mapLegacyCameraConfigToPluginConfig,
+  registerEmbeddedPlugins
+});

package/build/plugins/nrchkb-homekit-plugins.js

@@ -0,0 +1,17 @@
+"use strict";
+var import_homebridge_camera_ffmpeg = require("./embedded/homebridge-camera-ffmpeg");
+var import_homebridge_unifi_protect = require("./embedded/homebridge-unifi-protect");
+var import_registry = require("./registry");
+module.exports = (RED) => {
+  const plugins = RED.plugins;
+  plugins?.registerPlugin?.(import_homebridge_camera_ffmpeg.homebridgeCameraFfmpegPluginMetadata.id, {
+    type: import_registry.NRCHKB_NODE_RED_PLUGIN_TYPE,
+    metadata: import_homebridge_camera_ffmpeg.homebridgeCameraFfmpegPluginMetadata,
+    factory: import_homebridge_camera_ffmpeg.homebridgeCameraFfmpegPluginFactory
+  });
+  plugins?.registerPlugin?.(import_homebridge_unifi_protect.homebridgeUniFiProtectPluginMetadata.id, {
+    type: import_registry.NRCHKB_NODE_RED_PLUGIN_TYPE,
+    metadata: import_homebridge_unifi_protect.homebridgeUniFiProtectPluginMetadata,
+    factory: import_homebridge_unifi_protect.homebridgeUniFiProtectPluginFactory
+  });
+};