@camstack/addon-provider-onvif 0.1.0

package/dist/index.mjs

@@ -0,0 +1,624 @@
+// src/onvif-client.ts
+import { Cam } from "onvif";
+var OnvifClient = class {
+  constructor(host, port, username, password, logger) {
+    this.host = host;
+    this.port = port;
+    this.username = username;
+    this.password = password;
+    this.logger = logger;
+  }
+  cam = null;
+  /** Connect to the camera */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.cam = new Cam(
+        {
+          hostname: this.host,
+          port: this.port,
+          username: this.username,
+          password: this.password
+        },
+        (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            this.logger.info(`Connected to ONVIF camera at ${this.host}:${this.port}`);
+            resolve();
+          }
+        }
+      );
+    });
+  }
+  /** Get device info */
+  async getDeviceInfo() {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.getDeviceInformation((err, info) => {
+        if (err) reject(err);
+        else resolve(info);
+      });
+    });
+  }
+  /** Get RTSP stream URI */
+  async getStreamUri(profileToken) {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      const options = { protocol: "RTSP" };
+      if (profileToken) options.profileToken = profileToken;
+      this.cam.getStreamUri(options, (err, stream) => {
+        if (err) reject(err);
+        else resolve(stream.uri);
+      });
+    });
+  }
+  /** Get available media profiles */
+  async getProfiles() {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.getProfiles((err, profiles) => {
+        if (err) reject(err);
+        else
+          resolve(
+            profiles.map((p) => ({
+              token: p.$.token ?? p.token,
+              name: p.name,
+              videoWidth: p.videoEncoderConfiguration?.resolution?.width,
+              videoHeight: p.videoEncoderConfiguration?.resolution?.height
+            }))
+          );
+      });
+    });
+  }
+  /** Get snapshot URI */
+  async getSnapshotUri(profileToken) {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      const options = {};
+      if (profileToken) options.profileToken = profileToken;
+      this.cam.getSnapshotUri(options, (err, res) => {
+        if (err) reject(err);
+        else resolve(res.uri);
+      });
+    });
+  }
+  /** Check if PTZ is supported */
+  hasPtz() {
+    return this.cam?.ptzUri != null;
+  }
+  /** PTZ move (continuous) */
+  async ptzMove(options) {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.continuousMove(
+        {
+          x: options.x ?? 0,
+          y: options.y ?? 0,
+          zoom: options.zoom ?? 0,
+          timeout: 1e3
+        },
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+    });
+  }
+  /** PTZ stop */
+  async ptzStop() {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.stop({}, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  /** PTZ absolute move */
+  async ptzAbsoluteMove(options) {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.absoluteMove(
+        {
+          x: options.x,
+          y: options.y,
+          zoom: options.zoom
+        },
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+    });
+  }
+  /** Get PTZ presets */
+  async getPtzPresets() {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.getPresets({}, (err, presets) => {
+        if (err) reject(err);
+        else {
+          const list = Array.isArray(presets) ? presets : [presets];
+          resolve(
+            list.filter(Boolean).map((p) => ({
+              token: p.$.token ?? String(p.token),
+              name: p.name ?? p.$.token ?? "Preset"
+            }))
+          );
+        }
+      });
+    });
+  }
+  /** Go to PTZ preset */
+  async gotoPreset(presetToken) {
+    return new Promise((resolve, reject) => {
+      if (!this.cam) return reject(new Error("Not connected"));
+      this.cam.gotoPreset({ preset: presetToken }, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  disconnect() {
+    this.cam = null;
+  }
+};
+
+// src/onvif-device.ts
+var OnvifDevice = class {
+  constructor(client, config, ctx) {
+    this.client = client;
+    this.config = config;
+    this.id = `${config.providerId}/${config.cameraId}`;
+    this.name = config.cameraName;
+    this.providerId = config.providerId;
+    this.ctx = ctx;
+    const caps = ["camera"];
+    if (config.hasPtz) caps.push("panTiltZoom");
+    this.capabilities = caps;
+    this.capabilityMap.set("camera", this.createCamera());
+    if (config.hasPtz) this.capabilityMap.set("panTiltZoom", this.createPtz());
+  }
+  id;
+  name;
+  providerId;
+  type = "camera";
+  capabilities;
+  ctx;
+  capabilityMap = /* @__PURE__ */ new Map();
+  getCapability(cap) {
+    return this.capabilityMap.get(cap) ?? null;
+  }
+  hasCapability(cap) {
+    return this.capabilityMap.has(cap);
+  }
+  getState() {
+    return { online: true };
+  }
+  getMetadata() {
+    return {
+      manufacturer: this.config.manufacturer ?? "ONVIF",
+      model: this.config.model,
+      firmware: this.config.firmware
+    };
+  }
+  createCamera() {
+    const { config } = this;
+    return {
+      kind: "camera",
+      async getSnapshot() {
+        if (config.snapshotUrl) {
+          const res = await fetch(config.snapshotUrl);
+          return Buffer.from(await res.arrayBuffer());
+        }
+        return Buffer.alloc(0);
+      },
+      async getStreamOptions() {
+        const options = [
+          {
+            id: `${config.cameraId}_main`,
+            label: "Main",
+            protocol: "rtsp",
+            quality: "main",
+            url: config.rtspUrl
+          }
+        ];
+        if (config.subStreamUrl) {
+          options.push({
+            id: `${config.cameraId}_sub`,
+            label: "Sub",
+            protocol: "rtsp",
+            quality: "sub",
+            url: config.subStreamUrl
+          });
+        }
+        return options;
+      },
+      async getStreamUrl(option) {
+        return option.url ?? config.rtspUrl;
+      },
+      getConnectionMode() {
+        return "on-demand";
+      },
+      async setConnectionMode() {
+      }
+    };
+  }
+  createPtz() {
+    const { client } = this;
+    return {
+      kind: "panTiltZoom",
+      async move(cmd) {
+        await client.ptzMove({ x: cmd.pan, y: cmd.tilt, zoom: cmd.zoom, speed: cmd.speed });
+      },
+      async continuousMove(cmd) {
+        await client.ptzMove({ x: cmd.pan, y: cmd.tilt, zoom: cmd.zoom });
+      },
+      async stop() {
+        await client.ptzStop();
+      },
+      async getPresets() {
+        const presets = await client.getPtzPresets();
+        return presets.map((p) => ({ id: p.token, name: p.name }));
+      },
+      async goToPreset(presetId) {
+        await client.gotoPreset(presetId);
+      },
+      async goHome() {
+        await client.ptzAbsoluteMove({ x: 0, y: 0, zoom: 0 });
+      },
+      async getPosition() {
+        return { pan: 0, tilt: 0, zoom: 0 };
+      }
+    };
+  }
+};
+
+// src/onvif-discovery.ts
+import { Discovery } from "onvif";
+async function discoverOnvifCameras(timeout = 5e3) {
+  return new Promise((resolve) => {
+    const cameras = [];
+    Discovery.on("device", (cam) => {
+      cameras.push({
+        host: cam.hostname,
+        port: cam.port ?? 80,
+        name: cam.name,
+        manufacturer: cam.manufacturer,
+        model: cam.model,
+        scopes: cam.scopes
+      });
+    });
+    Discovery.probe({ timeout });
+    setTimeout(() => {
+      Discovery.removeAllListeners("device");
+      resolve(cameras);
+    }, timeout + 500);
+  });
+}
+
+// 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/onvif-provider.ts
+var OnvifProvider = class {
+  constructor(config, ctx) {
+    this.config = config;
+    this.id = config.id;
+    this.name = config.name;
+    this.ctx = ctx;
+  }
+  id;
+  type = "onvif";
+  name;
+  discoveryMode = "both";
+  ctx;
+  devices = [];
+  clients = /* @__PURE__ */ new Map();
+  async start() {
+    if (this.config.discovery?.enabled !== false) {
+      const timeout = this.config.discovery?.timeout ?? 5e3;
+      this.ctx.logger.info(`Starting ONVIF discovery (timeout: ${timeout}ms)`);
+      const discovered = await discoverOnvifCameras(timeout);
+      this.ctx.logger.info(`Discovered ${discovered.length} ONVIF camera(s)`);
+      for (const cam of discovered) {
+        await this.addCamera({
+          id: cam.host.replace(/\./g, "-"),
+          name: cam.name ?? cam.host,
+          host: cam.host,
+          port: cam.port,
+          username: this.config.defaultUsername,
+          password: this.config.defaultPassword
+        });
+      }
+    }
+    for (const cam of this.config.cameras ?? []) {
+      await this.addCamera(cam);
+    }
+    this.ctx.logger.info(
+      `ONVIF provider started with ${this.devices.length} camera(s)`
+    );
+  }
+  async addCamera(cam) {
+    try {
+      const client = new OnvifClient(
+        cam.host,
+        cam.port ?? 80,
+        cam.username ?? "",
+        cam.password ?? "",
+        this.ctx.logger.child(cam.name)
+      );
+      await client.connect();
+      const info = await client.getDeviceInfo();
+      const profiles = await client.getProfiles();
+      const mainProfile = profiles[0];
+      const subProfile = profiles.length > 1 ? profiles[1] : void 0;
+      const rtspUrl = cam.rtspUrl ?? await client.getStreamUri(mainProfile?.token);
+      const subStreamUrl = subProfile ? await client.getStreamUri(subProfile.token) : void 0;
+      let snapshotUrl;
+      try {
+        snapshotUrl = await client.getSnapshotUri(mainProfile?.token);
+      } catch {
+      }
+      const deviceCtx = {
+        id: `device:${this.id}/${cam.id}`,
+        logger: this.ctx.logger.child(cam.name),
+        eventBus: this.ctx.eventBus,
+        storage: this.ctx.storage,
+        config: new ElementConfigStore(`device:${this.id}/${cam.id}`, this.ctx.storage)
+      };
+      const device = new OnvifDevice(
+        client,
+        {
+          cameraId: cam.id,
+          cameraName: cam.name,
+          providerId: this.id,
+          rtspUrl,
+          subStreamUrl,
+          snapshotUrl,
+          hasPtz: client.hasPtz(),
+          profiles,
+          manufacturer: info.manufacturer,
+          model: info.model,
+          firmware: info.firmwareVersion
+        },
+        deviceCtx
+      );
+      this.devices = [...this.devices, device];
+      this.clients.set(cam.id, client);
+      this.ctx.logger.info(
+        `Camera ${cam.name} (${cam.host}) connected \u2014 PTZ: ${client.hasPtz()}, profiles: ${profiles.length}`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.ctx.logger.warn(`Failed to connect to ${cam.host}: ${message}`);
+    }
+  }
+  async stop() {
+    for (const client of this.clients.values()) {
+      client.disconnect();
+    }
+    this.devices = [];
+    this.clients.clear();
+    this.ctx.logger.info("ONVIF provider stopped");
+  }
+  getStatus() {
+    return { connected: true, deviceCount: this.devices.length };
+  }
+  async discoverDevices() {
+    const cameras = await discoverOnvifCameras();
+    return cameras.map((c) => ({
+      externalId: c.host,
+      name: c.name ?? c.host,
+      type: "camera",
+      capabilities: ["camera"],
+      metadata: { manufacturer: c.manufacturer, model: c.model }
+    }));
+  }
+  getDevices() {
+    return [...this.devices];
+  }
+  getDeviceConfigSchema() {
+    return {
+      id: "string",
+      name: "string",
+      host: "string (IP or hostname)",
+      port: "number (default: 80)",
+      username: "string (optional)",
+      password: "string (optional)",
+      rtspUrl: "string (optional, override ONVIF stream URI)"
+    };
+  }
+  subscribeLiveEvents(_callback) {
+    return () => {
+    };
+  }
+};
+
+// src/addon.ts
+var OnvifProviderAddon = class {
+  manifest = {
+    id: "provider-onvif",
+    name: "ONVIF Camera Provider",
+    version: "0.1.0",
+    capabilities: ["device-provider"]
+  };
+  provider = null;
+  async initialize(context) {
+    const config = context.addonConfig;
+    const providerConfig = {
+      id: config.id ?? "onvif-default",
+      name: config.name ?? "ONVIF Cameras",
+      discovery: config.discovery,
+      cameras: config.cameras,
+      defaultUsername: config.defaultUsername,
+      defaultPassword: config.defaultPassword
+    };
+    this.provider = new OnvifProvider(providerConfig, {
+      id: context.id,
+      logger: context.logger,
+      eventBus: context.eventBus,
+      storage: context.storage,
+      config: context.config
+    });
+    context.logger.info("ONVIF 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: "discovery",
+          title: "ONVIF Discovery",
+          description: "Auto-discover ONVIF cameras on the local network",
+          columns: 2,
+          fields: [
+            { type: "boolean", key: "discovery.enabled", label: "Enable Auto-Discovery" },
+            { type: "number", key: "discovery.timeout", label: "Discovery Timeout", unit: "ms", min: 1e3, max: 3e4, step: 1e3 }
+          ]
+        },
+        {
+          id: "credentials",
+          title: "Default Credentials",
+          description: "Default credentials for discovered cameras",
+          columns: 2,
+          fields: [
+            { type: "text", key: "defaultUsername", label: "Default Username" },
+            { type: "password", key: "defaultPassword", label: "Default Password", showToggle: true }
+          ]
+        }
+      ]
+    };
+  }
+  getConfig() {
+    return {};
+  }
+  async onConfigChange(_config) {
+  }
+};
+export {
+  OnvifClient,
+  OnvifDevice,
+  OnvifProvider,
+  OnvifProviderAddon,
+  discoverOnvifCameras
+};
+//# sourceMappingURL=index.mjs.map