@camstack/addon-provider-frigate 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -1,972 +1,10 @@
-// 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
-import { connect } from "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 = 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
-import { DeviceType } from "@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 = 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) {
-  }
-};
+import {
+  FrigateApiClient,
+  FrigateDevice,
+  FrigateMqttClient,
+  FrigateProvider,
+  FrigateProviderAddon
+} from "./chunk-4YBCO3RD.mjs";
 export {
   FrigateApiClient,
   FrigateDevice,