@camstack/addon-provider-frigate 0.1.3 → 0.1.4

package/dist/addon.js

@@ -0,0 +1,1000 @@
+"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);
+
+// src/addon.ts
+var addon_exports = {};
+__export(addon_exports, {
+  FrigateProviderAddon: () => FrigateProviderAddon
+});
+module.exports = __toCommonJS(addon_exports);
+
+// src/frigate-api.ts
+var FrigateApiClient = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = (config.baseUrl ?? "").replace(/\/+$/, "");
+  }
+  baseUrl;
+  authToken = null;
+  authHeader = null;
+  async authenticate() {
+    const { username, password } = this.config;
+    if (!username || !password) {
+      return;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/api/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ user: username, password })
+      });
+      if (response.ok) {
+        const cookies = response.headers.get("set-cookie");
+        if (cookies) {
+          this.authToken = cookies;
+          return;
+        }
+      }
+    } catch {
+    }
+    this.authHeader = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+  }
+  buildHeaders() {
+    const headers = {};
+    if (this.authToken) {
+      headers["Cookie"] = this.authToken;
+    } else if (this.authHeader) {
+      headers["Authorization"] = this.authHeader;
+    }
+    return headers;
+  }
+  async request(path, options) {
+    if ((this.config.username || this.config.password) && !this.authToken && !this.authHeader) {
+      await this.authenticate();
+    }
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.buildHeaders(),
+        ...options?.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Frigate API error: ${response.status} ${response.statusText} for ${path}`);
+    }
+    return response.json();
+  }
+  async requestBuffer(path) {
+    if ((this.config.username || this.config.password) && !this.authToken && !this.authHeader) {
+      await this.authenticate();
+    }
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      headers: this.buildHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Frigate API error: ${response.status} ${response.statusText} for ${path}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  async requestText(path, options) {
+    if ((this.config.username || this.config.password) && !this.authToken && !this.authHeader) {
+      await this.authenticate();
+    }
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.buildHeaders(),
+        ...options?.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Frigate API error: ${response.status} ${response.statusText} for ${path}`);
+    }
+    return response.text();
+  }
+  // --- Config & Discovery ---
+  async getConfig() {
+    return this.request("/api/config");
+  }
+  async getGo2rtcStreams() {
+    return this.request("/api/go2rtc/streams");
+  }
+  // --- Events ---
+  async getEvents(params) {
+    const query = buildQueryString(params);
+    return this.request(`/api/events${query}`);
+  }
+  async getReviewItems(params) {
+    const query = buildQueryString(params);
+    return this.request(`/api/review${query}`);
+  }
+  // --- Recordings ---
+  async getRecordings(camera, after, before) {
+    const query = buildQueryString({ after, before });
+    return this.request(`/api/${encodeURIComponent(camera)}/recordings${query}`);
+  }
+  async getMotionActivity(params) {
+    const query = buildQueryString(params);
+    return this.request(`/api/motion_activity${query}`);
+  }
+  // --- Media ---
+  async getLatestSnapshot(camera) {
+    return this.requestBuffer(`/api/${encodeURIComponent(camera)}/latest.jpg`);
+  }
+  async getEventThumbnail(eventId) {
+    return this.requestBuffer(`/api/events/${encodeURIComponent(eventId)}/thumbnail.jpg`);
+  }
+  async getEventSnapshot(eventId) {
+    return this.requestBuffer(`/api/events/${encodeURIComponent(eventId)}/snapshot.jpg`);
+  }
+  async getEventClip(eventId) {
+    return this.requestBuffer(`/api/events/${encodeURIComponent(eventId)}/clip.mp4`);
+  }
+  async getRecordingThumbnail(camera, timestampSec) {
+    return this.requestBuffer(
+      `/api/${encodeURIComponent(camera)}/recordings/thumbnail-${timestampSec}.jpg`
+    );
+  }
+  // --- WebRTC ---
+  async proxyWhepSdp(streamName, sdpOffer) {
+    return this.requestText(`/api/go2rtc/webrtc?src=${encodeURIComponent(streamName)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/sdp" },
+      body: sdpOffer
+    });
+  }
+  // --- PTZ ---
+  async getPtzInfo(camera) {
+    try {
+      return await this.request(
+        `/api/${encodeURIComponent(camera)}/ptz/info`
+      );
+    } catch {
+      return null;
+    }
+  }
+  async ptzCommand(camera, command, params) {
+    const query = buildQueryString({ ...params, command });
+    await this.request(`/api/${encodeURIComponent(camera)}/ptz${query}`);
+  }
+  // --- Test Connection ---
+  async testConnection() {
+    try {
+      const config = await this.getConfig();
+      const cameraNames = Object.keys(config.cameras ?? {});
+      return {
+        success: true,
+        version: config.version,
+        cameraCount: cameraNames.length
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+function buildQueryString(params) {
+  const entries = Object.entries(params).filter(
+    ([, v]) => v !== void 0 && v !== null
+  );
+  if (entries.length === 0) {
+    return "";
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of entries) {
+    searchParams.set(key, String(value));
+  }
+  return `?${searchParams.toString()}`;
+}
+
+// src/frigate-mqtt.ts
+var import_mqtt = require("mqtt");
+var FrigateMqttClient = class {
+  constructor(config, cameraResolutions) {
+    this.config = config;
+    this.cameraResolutions = cameraResolutions;
+  }
+  client = null;
+  listeners = /* @__PURE__ */ new Set();
+  eventCount = 0;
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const { brokerUrl, username, password, topicPrefix } = this.config;
+      this.client = (0, import_mqtt.connect)(brokerUrl, {
+        username,
+        password,
+        reconnectPeriod: 5e3,
+        connectTimeout: 1e4
+      });
+      this.client.on("connect", () => {
+        const prefix = topicPrefix;
+        this.client.subscribe([
+          `${prefix}/events`,
+          `${prefix}/reviews`,
+          `${prefix}/+/motion/state`,
+          `${prefix}/+/audio/+`
+        ]);
+        resolve();
+      });
+      this.client.on("error", (err) => {
+        reject(err);
+      });
+      this.client.on("message", (topic, payload) => {
+        const event = parseMqttMessage(
+          topic,
+          payload,
+          topicPrefix,
+          this.cameraResolutions
+        );
+        if (event) {
+          this.eventCount++;
+          for (const listener of this.listeners) {
+            listener(event);
+          }
+        }
+      });
+    });
+  }
+  async disconnect() {
+    if (this.client) {
+      await this.client.endAsync();
+      this.client = null;
+    }
+    this.listeners.clear();
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  get status() {
+    return {
+      connected: this.client?.connected ?? false,
+      eventCount: this.eventCount
+    };
+  }
+};
+function parseMqttMessage(topic, payload, prefix, resolutions) {
+  const topicParts = topic.split("/");
+  const prefixParts = prefix.split("/");
+  const relative = topicParts.slice(prefixParts.length);
+  if (relative.length === 1 && relative[0] === "events") {
+    return parseDetectionEvent(payload, resolutions);
+  }
+  if (relative.length === 1 && relative[0] === "reviews") {
+    return parseReviewEvent(payload);
+  }
+  if (relative.length === 3 && relative[1] === "motion" && relative[2] === "state") {
+    const camera = relative[0];
+    return parseMotionEvent(camera, payload);
+  }
+  if (relative.length === 3 && relative[1] === "audio") {
+    const camera = relative[0];
+    const metric = relative[2];
+    return parseAudioEvent(camera, metric, payload);
+  }
+  return null;
+}
+function parseDetectionEvent(payload, resolutions) {
+  try {
+    const parsed = JSON.parse(payload.toString());
+    const state = parsed.after ?? parsed.before;
+    if (!state?.camera || !state?.label) {
+      return null;
+    }
+    const data = {
+      eventType: parsed.type ?? "update",
+      id: state.id,
+      label: state.label,
+      subLabel: state.sub_label,
+      score: state.top_score,
+      startTime: state.start_time,
+      endTime: state.end_time,
+      zones: state.current_zones,
+      hasSnapshot: state.has_snapshot,
+      hasClip: state.has_clip
+    };
+    if (state.box) {
+      const resolution = resolutions.get(state.camera);
+      if (resolution) {
+        data.boundingBox = normalizeBoundingBox(state.box, resolution.width, resolution.height);
+      } else {
+        data.rawBox = state.box;
+      }
+    }
+    return {
+      type: "detection",
+      camera: state.camera,
+      timestamp: Date.now(),
+      data
+    };
+  } catch {
+    return null;
+  }
+}
+function parseReviewEvent(payload) {
+  try {
+    const parsed = JSON.parse(payload.toString());
+    const state = parsed.after ?? parsed.before;
+    if (!state?.camera) {
+      return null;
+    }
+    return {
+      type: "review",
+      camera: state.camera,
+      timestamp: Date.now(),
+      data: {
+        eventType: parsed.type ?? "update",
+        id: state.id,
+        severity: state.severity,
+        startTime: state.start_time,
+        endTime: state.end_time,
+        objects: state.data?.objects,
+        zones: state.data?.zones,
+        subLabels: state.data?.sub_labels
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function parseMotionEvent(camera, payload) {
+  const value = payload.toString().trim();
+  const active = value === "ON";
+  return {
+    type: "motion",
+    camera,
+    timestamp: Date.now(),
+    data: { active }
+  };
+}
+function parseAudioEvent(camera, metric, payload) {
+  const raw = payload.toString().trim();
+  const value = parseFloat(raw);
+  if (isNaN(value)) {
+    return null;
+  }
+  return {
+    type: "audio",
+    camera,
+    timestamp: Date.now(),
+    data: { metric, value }
+  };
+}
+function normalizeBoundingBox(box, width, height) {
+  const [yMin, xMin, yMax, xMax] = box;
+  return {
+    x: xMin / width,
+    y: yMin / height,
+    w: (xMax - xMin) / width,
+    h: (yMax - yMin) / height
+  };
+}
+
+// src/frigate-device.ts
+var import_types = require("@camstack/types");
+var FrigateDevice = class {
+  constructor(config, api, ctx) {
+    this.config = config;
+    this.api = api;
+    this.id = `${config.providerId}/${config.cameraName}`;
+    this.name = config.cameraName;
+    this.providerId = config.providerId;
+    this.ctx = ctx;
+    const caps = ["camera", "events", "recording", "motionSensor", "objectDetector"];
+    if (config.audioEnabled) caps.push("audioDetector");
+    this.capabilities = caps;
+    this.capabilityMap.set("camera", this.createCamera());
+    this.capabilityMap.set("motionSensor", this.createMotionSensor());
+    this.capabilityMap.set("objectDetector", this.createObjectDetector());
+    this.capabilityMap.set("events", this.createEvents());
+    this.capabilityMap.set("recording", this.createRecording());
+    if (config.audioEnabled) {
+      this.capabilityMap.set("audioDetector", this.createAudioDetector());
+    }
+  }
+  id;
+  name;
+  providerId;
+  type = import_types.DeviceType.Camera;
+  capabilities;
+  capabilityMap = /* @__PURE__ */ new Map();
+  ctx;
+  getCapability(cap) {
+    return this.capabilityMap.get(cap) ?? null;
+  }
+  hasCapability(cap) {
+    return this.capabilityMap.has(cap);
+  }
+  getState() {
+    return { online: true };
+  }
+  getMetadata() {
+    return { manufacturer: "Frigate NVR" };
+  }
+  // --- Capability Factories ---
+  createCamera() {
+    const { api, config } = this;
+    return {
+      kind: "camera",
+      async getSnapshot() {
+        return api.getLatestSnapshot(config.cameraName);
+      },
+      async getStreamOptions() {
+        return config.streams.map((s) => ({
+          ...s,
+          url: s.url ?? `rtsp://${config.frigateHost}:8554/${s.id}`
+        }));
+      },
+      async getStreamUrl(option) {
+        return `/api/go2rtc/webrtc?src=${encodeURIComponent(option.id)}`;
+      },
+      getConnectionMode() {
+        return "on-demand";
+      },
+      async setConnectionMode() {
+      }
+    };
+  }
+  createMotionSensor() {
+    let motionActive = false;
+    return {
+      kind: "motionSensor",
+      isMotionDetected() {
+        return motionActive;
+      },
+      subscribe() {
+        return () => {
+        };
+      }
+      // real-time via MQTT through provider
+    };
+  }
+  createObjectDetector() {
+    const zones = [];
+    const lines = [];
+    return {
+      kind: "objectDetector",
+      getLabels() {
+        return [];
+      },
+      onDetections() {
+        return () => {
+        };
+      },
+      // Zone management
+      async getZones() {
+        return zones;
+      },
+      async addZone(zone) {
+        zones.push(zone);
+      },
+      async removeZone(id) {
+        const i = zones.findIndex((z) => z.id === id);
+        if (i >= 0) zones.splice(i, 1);
+      },
+      async updateZone(id, partial) {
+        const z = zones.find((z2) => z2.id === id);
+        if (z) Object.assign(z, partial);
+      },
+      // Line management
+      async getLines() {
+        return lines;
+      },
+      async addLine(line) {
+        lines.push(line);
+      },
+      async removeLine(id) {
+        const i = lines.findIndex((l) => l.id === id);
+        if (i >= 0) lines.splice(i, 1);
+      },
+      // Active tracking (populated by MQTT events in real-time)
+      getActiveDetections() {
+        return [];
+      },
+      getZoneDetections() {
+        return [];
+      },
+      getStationaryDetections() {
+        return [];
+      },
+      getMovingDetections() {
+        return [];
+      }
+    };
+  }
+  createEvents() {
+    const { api, config } = this;
+    return {
+      kind: "events",
+      async getEvents(query) {
+        const raw = await api.getEvents({
+          cameras: config.cameraName,
+          after: query.since,
+          before: query.until,
+          limit: query.limit,
+          labels: query.detectionClasses?.join(",")
+        });
+        const events = raw.map((e) => ({
+          id: e.id,
+          type: "detection",
+          timestamp: e.start_time * 1e3,
+          // Frigate uses seconds, we use ms
+          endTimestamp: e.end_time ? e.end_time * 1e3 : void 0,
+          label: e.label,
+          score: e.top_score,
+          hasClip: e.has_clip,
+          hasSnapshot: e.has_snapshot,
+          thumbnailUrl: `/api/events/${e.id}/thumbnail.jpg`
+        }));
+        return { events, total: events.length };
+      },
+      async getEventThumbnail(eventId) {
+        try {
+          return await api.getEventThumbnail(eventId);
+        } catch {
+          return null;
+        }
+      },
+      async getEventSnapshot(eventId) {
+        try {
+          return await api.getEventSnapshot(eventId);
+        } catch {
+          return null;
+        }
+      },
+      async getEventClipUrl(eventId) {
+        return `/api/events/${encodeURIComponent(eventId)}/clip.mp4`;
+      }
+    };
+  }
+  createRecording() {
+    const { api, config } = this;
+    return {
+      kind: "recording",
+      async getSegments(range) {
+        const recs = await api.getRecordings(config.cameraName, range.since, range.until);
+        return recs.map((r) => ({
+          id: r.id ?? `${config.cameraName}-${r.start_time}`,
+          startTime: r.start_time * 1e3,
+          endTime: r.end_time * 1e3,
+          duration: r.duration
+        }));
+      },
+      async getPlaybackUrl(startTime, endTime) {
+        const startSec = Math.floor(startTime / 1e3);
+        const endSec = Math.floor(endTime / 1e3);
+        return `/api/${encodeURIComponent(config.cameraName)}/start/${startSec}/end/${endSec}/clip.mp4`;
+      },
+      async getThumbnailAt(timestampMs) {
+        try {
+          return await api.getRecordingThumbnail(config.cameraName, Math.floor(timestampMs / 1e3));
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+  createAudioDetector() {
+    return {
+      kind: "audioDetector",
+      getAudioLevel() {
+        return 0;
+      },
+      subscribe() {
+        return () => {
+        };
+      }
+      // real-time via MQTT through provider
+    };
+  }
+};
+
+// src/element-config-store.ts
+var ElementConfigStore = class {
+  constructor(elementId, storage) {
+    this.elementId = elementId;
+    this.storage = storage;
+  }
+  cache = {};
+  listeners = /* @__PURE__ */ new Set();
+  loaded = false;
+  /** Load config from storage into cache. Called once on first access. */
+  async ensureLoaded() {
+    if (this.loaded) return;
+    if (!this.storage.structured) {
+      this.loaded = true;
+      return;
+    }
+    try {
+      const records = await this.storage.structured.query("config", {
+        where: { id: this.elementId },
+        limit: 1
+      });
+      if (records.length > 0) {
+        this.cache = records[0].data ?? {};
+      }
+    } catch {
+    }
+    this.loaded = true;
+  }
+  getAll() {
+    return { ...this.cache };
+  }
+  get(key) {
+    const parts = key.split(".");
+    let current = this.cache;
+    for (const part of parts) {
+      if (current == null || typeof current !== "object") return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+  async set(key, value) {
+    await this.ensureLoaded();
+    setNestedValue(this.cache, key, value);
+    await this.persist();
+    this.notifyListeners();
+  }
+  async setAll(config) {
+    await this.ensureLoaded();
+    this.cache = { ...config };
+    await this.persist();
+    this.notifyListeners();
+  }
+  onChange(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /** Initialize from storage — called by ContextFactory after creation */
+  async load() {
+    await this.ensureLoaded();
+  }
+  /** Initialize with default values (doesn't overwrite existing) */
+  async loadDefaults(defaults) {
+    await this.ensureLoaded();
+    if (Object.keys(this.cache).length === 0) {
+      this.cache = { ...defaults };
+      await this.persist();
+    }
+  }
+  async persist() {
+    if (!this.storage.structured) return;
+    try {
+      const existing = await this.storage.structured.query("config", {
+        where: { id: this.elementId },
+        limit: 1
+      });
+      if (existing.length > 0) {
+        await this.storage.structured.update("config", this.elementId, this.cache);
+      } else {
+        await this.storage.structured.insert({
+          collection: "config",
+          id: this.elementId,
+          data: this.cache
+        });
+      }
+    } catch {
+    }
+  }
+  notifyListeners() {
+    const snapshot = this.getAll();
+    for (const listener of this.listeners) {
+      try {
+        listener(snapshot);
+      } catch {
+      }
+    }
+  }
+};
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+// src/frigate-provider.ts
+var ADOPTED_DEVICES_KEY = "adoptedDevices";
+var FrigateProvider = class {
+  constructor(config, ctx) {
+    this.config = config;
+    this.id = config.id;
+    this.name = config.name;
+    this.ctx = ctx;
+    this.api = new FrigateApiClient({
+      baseUrl: config.url,
+      username: config.username,
+      password: config.password
+    });
+    this.frigateHost = new URL(config.url).hostname;
+  }
+  id;
+  type = "frigate";
+  name;
+  discoveryMode = "auto";
+  ctx;
+  api;
+  mqtt = null;
+  devices = [];
+  liveEventListeners = /* @__PURE__ */ new Set();
+  mqttUnsubscribe;
+  /** Cached Frigate config, refreshed on start() and discoverDevices() */
+  frigateConfig = null;
+  go2rtcStreams = {};
+  frigateHost;
+  async start() {
+    this.ctx.logger.info(`Starting Frigate provider: ${this.config.url}`);
+    this.frigateConfig = await this.api.getConfig();
+    this.go2rtcStreams = await this.api.getGo2rtcStreams();
+    const resolutions = /* @__PURE__ */ new Map();
+    for (const [name, cam] of Object.entries(this.frigateConfig.cameras)) {
+      if (cam.detect) {
+        resolutions.set(name, { width: cam.detect.width, height: cam.detect.height });
+      }
+    }
+    const adoptedIds = this.getAdoptedDeviceIds();
+    if (adoptedIds.length > 0) {
+      const devices = [];
+      for (const cameraName of adoptedIds) {
+        const cam = this.frigateConfig.cameras[cameraName];
+        if (!cam || cam.enabled === false) {
+          this.ctx.logger.warn(`Adopted camera "${cameraName}" no longer available in Frigate config, skipping`);
+          continue;
+        }
+        devices.push(this.createDeviceFromCamera(cameraName, cam));
+      }
+      this.devices = devices;
+      this.ctx.logger.info(`Loaded ${devices.length} adopted cameras`);
+    } else {
+      this.ctx.logger.info("No adopted cameras yet \u2014 use discoverDevices() + adoptDevice() to import cameras");
+    }
+    if (this.config.mqtt?.brokerUrl) {
+      this.mqtt = new FrigateMqttClient(
+        {
+          brokerUrl: this.config.mqtt.brokerUrl,
+          username: this.config.mqtt.username,
+          password: this.config.mqtt.password,
+          topicPrefix: this.config.mqtt.topicPrefix ?? "frigate"
+        },
+        resolutions
+      );
+      await this.mqtt.connect();
+      this.mqttUnsubscribe = this.mqtt.subscribe((event) => {
+        for (const listener of this.liveEventListeners) {
+          listener(event);
+        }
+      });
+      this.ctx.logger.info("MQTT connected");
+    }
+  }
+  async stop() {
+    this.ctx.logger.info("Stopping Frigate provider");
+    this.mqttUnsubscribe?.();
+    this.mqttUnsubscribe = void 0;
+    await this.mqtt?.disconnect();
+    this.mqtt = null;
+    this.devices = [];
+    this.frigateConfig = null;
+    this.go2rtcStreams = {};
+  }
+  getStatus() {
+    return {
+      connected: this.mqtt?.status.connected ?? false,
+      deviceCount: this.devices.length
+    };
+  }
+  async discoverDevices() {
+    this.frigateConfig = await this.api.getConfig();
+    this.go2rtcStreams = await this.api.getGo2rtcStreams();
+    const adoptedIds = this.getAdoptedDeviceIds();
+    const discovered = [];
+    for (const [name, cam] of Object.entries(this.frigateConfig.cameras)) {
+      if (cam.enabled === false) continue;
+      const caps = ["camera", "events", "recording", "motionSensor", "objectDetector"];
+      if (cam.audio?.enabled) caps.push("audioDetector");
+      discovered.push({
+        externalId: name,
+        name,
+        type: "camera",
+        capabilities: caps,
+        metadata: { manufacturer: "Frigate NVR" }
+      });
+    }
+    return discovered;
+  }
+  async adoptDevice(externalId, _config) {
+    if (!this.frigateConfig) {
+      this.frigateConfig = await this.api.getConfig();
+      this.go2rtcStreams = await this.api.getGo2rtcStreams();
+    }
+    const cam = this.frigateConfig.cameras[externalId];
+    if (!cam) {
+      throw new Error(`Camera "${externalId}" not found in Frigate config`);
+    }
+    if (cam.enabled === false) {
+      throw new Error(`Camera "${externalId}" is disabled in Frigate config`);
+    }
+    const existing = this.devices.find((d) => d.name === externalId);
+    if (existing) {
+      this.ctx.logger.info(`Camera "${externalId}" is already adopted`);
+      return existing;
+    }
+    const device = this.createDeviceFromCamera(externalId, cam);
+    this.devices = [...this.devices, device];
+    await this.persistAdoptedDeviceId(externalId);
+    this.ctx.logger.info(`Adopted camera "${externalId}" (total: ${this.devices.length})`);
+    return device;
+  }
+  getDevices() {
+    return [...this.devices];
+  }
+  subscribeLiveEvents(callback) {
+    this.liveEventListeners.add(callback);
+    return () => {
+      this.liveEventListeners.delete(callback);
+    };
+  }
+  // --- Private helpers ---
+  createDeviceFromCamera(cameraName, cam) {
+    const streams = buildStreamOptions(cameraName, this.go2rtcStreams);
+    const deviceId = `${this.id}/${cameraName}`;
+    const deviceCtx = {
+      id: `device:${deviceId}`,
+      logger: this.ctx.logger.child(cameraName),
+      eventBus: this.ctx.eventBus,
+      storage: this.ctx.storage,
+      config: new ElementConfigStore(`device:${deviceId}`, this.ctx.storage)
+    };
+    return new FrigateDevice(
+      {
+        cameraName,
+        providerId: this.id,
+        detectWidth: cam.detect?.width ?? 1920,
+        detectHeight: cam.detect?.height ?? 1080,
+        audioEnabled: cam.audio?.enabled ?? false,
+        recordEnabled: cam.record?.enabled ?? false,
+        ptzEnabled: false,
+        streams,
+        frigateHost: this.frigateHost
+      },
+      this.api,
+      deviceCtx
+    );
+  }
+  getAdoptedDeviceIds() {
+    return this.ctx.config.get(ADOPTED_DEVICES_KEY) ?? [];
+  }
+  async persistAdoptedDeviceId(cameraName) {
+    const current = this.getAdoptedDeviceIds();
+    if (current.includes(cameraName)) return;
+    await this.ctx.config.set(ADOPTED_DEVICES_KEY, [...current, cameraName]);
+  }
+};
+function buildStreamOptions(cameraName, go2rtcStreams) {
+  const streams = [];
+  for (const streamName of Object.keys(go2rtcStreams)) {
+    if (!streamName.startsWith(cameraName)) continue;
+    const isSub = streamName.includes("sub") || streamName.includes("ext") || streamName.includes("medium");
+    streams.push({ id: streamName, label: streamName, protocol: "rtsp", quality: isSub ? "sub" : "main" });
+  }
+  return streams;
+}
+
+// src/addon.ts
+var FrigateProviderAddon = class {
+  manifest = {
+    id: "provider-frigate",
+    name: "Frigate NVR Provider",
+    version: "0.1.0",
+    description: "Integrazione con Frigate NVR per camere e detection",
+    capabilities: ["device-provider"]
+  };
+  provider = null;
+  async initialize(context) {
+    const config = context.addonConfig;
+    if (!config.url) {
+      context.logger.warn("Frigate provider: no URL configured, skipping initialization");
+      return;
+    }
+    const providerConfig = {
+      id: config.id ?? "frigate-default",
+      name: config.name ?? "Frigate NVR",
+      url: config.url,
+      username: config.username,
+      password: config.password,
+      mqtt: config.mqtt
+    };
+    this.provider = new FrigateProvider(providerConfig, {
+      id: context.id,
+      logger: context.logger,
+      eventBus: context.eventBus,
+      storage: context.storage,
+      config: context.config
+    });
+    context.logger.info("Frigate provider addon initialized");
+  }
+  async shutdown() {
+    await this.provider?.stop();
+    this.provider = null;
+  }
+  getCapabilityProvider(name) {
+    if (name === "device-provider" && this.provider) {
+      return this.provider;
+    }
+    return null;
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "connection",
+          title: "Frigate Connection",
+          description: "Configure the connection to your Frigate NVR instance",
+          columns: 2,
+          fields: [
+            { type: "text", key: "url", label: "Frigate URL", required: true, placeholder: "http://frigate:5000" },
+            { type: "text", key: "name", label: "Display Name", placeholder: "Frigate NVR" },
+            { type: "text", key: "username", label: "Username" },
+            { type: "password", key: "password", label: "Password", showToggle: true }
+          ]
+        },
+        {
+          id: "mqtt",
+          title: "MQTT Settings",
+          description: "Optional: Connect to Frigate MQTT for real-time events",
+          style: "accordion",
+          defaultCollapsed: true,
+          columns: 2,
+          fields: [
+            { type: "text", key: "mqtt.brokerUrl", label: "MQTT Broker URL", placeholder: "mqtt://broker:1883" },
+            { type: "text", key: "mqtt.topicPrefix", label: "Topic Prefix", placeholder: "frigate" },
+            { type: "text", key: "mqtt.username", label: "MQTT Username" },
+            { type: "password", key: "mqtt.password", label: "MQTT Password", showToggle: true }
+          ]
+        }
+      ]
+    };
+  }
+  getConfig() {
+    return {};
+  }
+  async onConfigChange(_config) {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FrigateProviderAddon
+});
+//# sourceMappingURL=addon.js.map