@camstack/addon-provider-rtsp 0.1.14 → 0.1.16

package/dist/index.js

@@ -1,588 +1,7 @@
 "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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  RtspCamera: () => RtspCamera,
-  RtspProviderAddon: () => RtspProviderAddon,
-  rtspCameraSchema: () => rtspCameraSchema
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/addon.ts
-var import_types2 = require("@camstack/types");
-
-// src/rtsp-camera.ts
-var import_zod = require("zod");
-var import_types = require("@camstack/types");
-var streamEntrySchema = import_zod.z.object({
-  id: import_zod.z.string().regex(/^stream-\d+$/).describe("Stable slot id (stream-1/2/3)"),
-  url: import_zod.z.string().describe("RTSP stream URL"),
-  profileHint: import_zod.z.enum(["high", "mid", "low"]).optional().describe("Provider-suggested profile \u2014 advisory only"),
-  resolution: import_zod.z.object({ width: import_zod.z.number().int().positive(), height: import_zod.z.number().int().positive() }).optional().describe("Probed resolution, if known")
-});
-var streamsField = import_zod.z.preprocess(
-  (raw) => {
-    if (!Array.isArray(raw)) return raw;
-    return raw.map((entry, i) => {
-      if (!entry || typeof entry !== "object") return entry;
-      const o = entry;
-      if (typeof o["id"] === "string") return entry;
-      if (typeof o["label"] === "string" && typeof o["url"] === "string") {
-        return {
-          id: `stream-${i + 1}`,
-          url: o["url"],
-          profileHint: o["label"]
-        };
-      }
-      return entry;
-    });
-  },
-  import_zod.z.array(streamEntrySchema).min(1)
-);
-var rtspCameraSchema = import_zod.z.object({
-  // `name` is now base meta (DB column on `device-meta`, not in this
-  // hardware-config schema). Read via `this.name` (resolved by
-  // `BaseDevice` from `ctx.deviceMeta.name`); mutated via
-  // `kernel.devices.setName(id, name)`.
-  streams: streamsField.describe("Published RTSP streams"),
-  snapshotUrl: import_zod.z.string().default("").describe("Snapshot URL (optional)"),
-  username: import_zod.z.string().default("").describe("Username"),
-  password: import_zod.z.string().default("").describe("Password")
-});
-var legacyStreamSchema = import_zod.z.object({
-  label: import_zod.z.enum(["high", "mid", "low"]),
-  url: import_zod.z.string()
-});
-var RtspCamera = class extends import_types.BaseDevice {
-  type = import_types.DeviceType.Camera;
-  features = [];
-  constructor(ctx) {
-    super(
-      ctx,
-      rtspCameraSchema,
-      { type: import_types.DeviceType.Camera }
-    );
-    this.migrateLegacyStreamsIfNeeded(ctx.persistedConfig ?? {});
-    this.registerSnapshotProvider();
-  }
-  /**
-   * Detect legacy `{label, url}` stream shapes and reshape to
-   * `{id, url, profileHint}`. Persists via `config.setAll` once, so
-   * subsequent boots find the new shape and this branch is inert.
-   *
-   * Runs fire-and-forget — the constructor can't await. The reshape is
-   * additive (ids are newly minted) so a failed persist is recoverable
-   * on next boot.
-   */
-  migrateLegacyStreamsIfNeeded(initialData) {
-    const raw = initialData["streams"];
-    if (!Array.isArray(raw)) return;
-    if (raw.every((s) => s && typeof s === "object" && typeof s["id"] === "string")) {
-      return;
-    }
-    const migrated = [];
-    let nextIdx = 1;
-    for (const entry of raw) {
-      const parsed = legacyStreamSchema.safeParse(entry);
-      if (!parsed.success) continue;
-      migrated.push({
-        id: `stream-${nextIdx++}`,
-        url: parsed.data.url,
-        profileHint: parsed.data.label
-      });
-    }
-    if (migrated.length === 0) return;
-    const snapshotUrl = this.config.get("snapshotUrl") ?? "";
-    const username = this.config.get("username") ?? "";
-    const password = this.config.get("password") ?? "";
-    this.ctx.logger.info("Migrating legacy {label,url} streams to {id,url,profileHint}", {
-      tags: { stableId: this.stableId },
-      meta: { streamCount: migrated.length }
-    });
-    void this.config.setAll({ streams: migrated, snapshotUrl, username, password }).catch((err) => {
-      this.ctx.logger.warn("Legacy stream migration failed", {
-        tags: { stableId: this.stableId },
-        meta: { error: err instanceof Error ? err.message : String(err) }
-      });
-    });
-  }
-  /**
-   * Publish every configured stream to the system stream-broker as a
-   * `pull-rtsp` cam stream. Idempotent — the broker's publishCameraStream
-   * entry is keyed by `(deviceId, camStreamId)` so callers may invoke
-   * this at will (e.g. on stream-broker restart). Fire-and-forget safe.
-   */
-  /**
-   * Lifecycle hook fired by the kernel after registration. Publishes
-   * the camera's streams to the broker — the kernel doesn't know
-   * about the broker, but the camera does. Best-effort: if the
-   * broker isn't ready, the provider's `system.ready-state`
-   * subscription re-publishes on the next ready fire.
-   */
-  async onActivate() {
-    await this.publishToBroker().catch((err) => {
-      this.ctx.logger.warn("publishToBroker on activate failed \u2014 will retry on broker ready", {
-        meta: { error: err instanceof Error ? err.message : String(err) }
-      });
-    });
-  }
-  async publishToBroker() {
-    const streams = this.config.get("streams");
-    for (const [i, s] of streams.entries()) {
-      try {
-        await this.ctx.api.streamBroker.publishCameraStream.mutate({
-          deviceId: this.id,
-          camStreamId: s.id,
-          kind: "pull-rtsp",
-          url: s.url,
-          ...s.resolution ? { resolution: s.resolution } : {},
-          label: `Stream ${i + 1}`
-        });
-      } catch (err) {
-        this.ctx.logger.warn("publishCameraStream failed", {
-          tags: { deviceId: this.id, camStreamId: s.id },
-          meta: { error: err instanceof Error ? err.message : String(err) }
-        });
-      }
-    }
-  }
-  /**
-   * Thin compat shim: reflects the stored `{id, url, profileHint?}`
-   * streams into the legacy `StreamSourceEntry` shape so
-   * `ICameraDevice`-aware consumers (device-manager legacy paths,
-   * device-cap-proxy fallback) still find data. The broker itself does
-   * NOT read this anymore — it consumes `publishCameraStream`. This
-   * shim goes away when every consumer migrates (C5/C7).
-   */
-  async getStreamSources() {
-    const streams = this.config.get("streams");
-    return streams.map((s) => ({
-      id: s.id,
-      label: s.profileHint ?? s.id,
-      protocol: "rtsp",
-      url: s.url,
-      ...s.profileHint ? { profileHint: s.profileHint } : {},
-      ...s.resolution ? { resolution: s.resolution } : {}
-    }));
-  }
-  async removeDevice() {
-    this.ctx.logger.info("Removing RTSP camera", { meta: { stableId: this.stableId } });
-    const streams = this.config.get("streams");
-    await Promise.all(
-      streams.map(
-        (s) => this.ctx.api.streamBroker.retractCameraStream.mutate({ deviceId: this.id, camStreamId: s.id }).catch((err) => {
-          this.ctx.logger.warn("retractCameraStream failed", {
-            tags: { deviceId: this.id, camStreamId: s.id },
-            meta: { error: err instanceof Error ? err.message : String(err) }
-          });
-        })
-      )
-    );
-  }
-  // ── Driver-authored settings UI ────────────────────────────────────────
-  //
-  // Streams are stored as `Array<{id, url, profileHint?, resolution?}>`
-  // but the settings UI exposes them as a `multiple` probe field of raw
-  // URLs — the form only cares about the ordered list of URLs, the ids
-  // and classification live in storage. Values are projected from
-  // storage into the flat form keys referenced by the schema.
-  getSettingsUISchema() {
-    const schema = {
-      sections: [
-        // The `name` field is now base meta — rendered by the
-        // device-manager's own settings contribution (with the
-        // location field), NOT by the driver's hardware-config
-        // schema. Driver UIs only carry technical knobs.
-        {
-          id: "streams",
-          title: "RTSP Streams",
-          description: "Provide 1\u20133 RTSP URLs for this camera. After save, each URL is probed and the stream-broker assigns the (high / mid / low) profiles by resolution (highest pixel count \u2192 high). Input slot order in this form does not affect the broker profile mapping.",
-          columns: 1,
-          fields: [
-            {
-              type: "probe",
-              key: "streams",
-              label: "RTSP stream URL",
-              required: true,
-              placeholder: "rtsp://user:pass@host:554/Streaming/Channels/101",
-              inputType: "url",
-              multiple: {
-                min: 1,
-                max: 3,
-                addLabel: "Add stream",
-                itemLabel: "Stream ${n}",
-                itemDefault: ""
-              }
-            }
-          ]
-        },
-        {
-          id: "snapshot",
-          title: "Snapshot",
-          columns: 1,
-          fields: [
-            { type: "probe", key: "snapshotUrl", label: "Snapshot URL", description: "Optional HTTP(S) endpoint that returns a JPEG still.", placeholder: "http://host/ISAPI/Streaming/channels/101/picture", inputType: "url" }
-          ]
-        },
-        {
-          id: "credentials",
-          title: "Credentials",
-          description: "Optional. If the RTSP URL already contains user:pass@ you can leave these empty.",
-          columns: 2,
-          fields: [
-            { type: "text", key: "username", label: "Username" },
-            { type: "password", key: "password", label: "Password", showToggle: true }
-          ]
-        }
-      ]
-    };
-    return (0, import_types.hydrateSchema)(schema, this.collectFormValues());
-  }
-  /**
-   * Project stored config into the flat UI keys referenced by the schema.
-   * Form only sees URLs — the internal id/profileHint/resolution stay
-   * invisible to the operator (the broker decides profiles from probed
-   * metadata at save time).
-   */
-  collectFormValues() {
-    const stored = this.config.get("streams");
-    const sorted = [...stored].sort((a, b) => a.id.localeCompare(b.id, "en", { numeric: true }));
-    const urls = sorted.map((s) => s.url).filter((u) => u.length > 0);
-    return {
-      streams: urls,
-      snapshotUrl: this.config.get("snapshotUrl"),
-      username: this.config.get("username"),
-      password: this.config.get("password")
-    };
-  }
-  async applySettingsPatch(patch) {
-    const current = this.collectFormValues();
-    const merged = { ...current, ...patch };
-    const pickStr = (k) => typeof merged[k] === "string" ? merged[k].trim() : "";
-    const next = {};
-    const rawStreams = merged["streams"];
-    const incomingUrls = Array.isArray(rawStreams) ? rawStreams.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0) : [];
-    if (incomingUrls.length === 0) {
-      next.streams = this.config.get("streams");
-    } else {
-      const probed = await this.probeAndClassify(incomingUrls.slice(0, 3));
-      next.streams = probed;
-    }
-    next.snapshotUrl = pickStr("snapshotUrl");
-    next.username = pickStr("username");
-    next.password = typeof merged["password"] === "string" ? merged["password"] : this.config.get("password");
-    await this.config.setAll(next);
-    await this.publishToBroker();
-  }
-  /**
-   * Probe a list of RTSP URLs through the kernel stream-probe and return
-   * the new `{id, url, profileHint?, resolution?}` entries. Ids are
-   * assigned `stream-1/2/3` in input order so the UI's slot ordering is
-   * preserved across edits. The broker is in charge of the actual
-   * (high/mid/low) profile assignment via `computeInitialAssignment`.
-   */
-  async probeAndClassify(urls) {
-    const streamProbe = this.ctx.streamProbe;
-    if (!streamProbe) {
-      this.ctx.logger.warn(
-        "[rtsp-edit] ctx.streamProbe unavailable \u2014 falling back to input-order profile assignment",
-        { meta: { streamCount: urls.length } }
-      );
-      const sequence = urls.length === 1 ? ["high"] : urls.length === 2 ? ["high", "low"] : ["high", "mid", "low"];
-      return urls.map((url, i) => ({
-        id: `stream-${i + 1}`,
-        url,
-        profileHint: sequence[i]
-      }));
-    }
-    const probed = await Promise.all(
-      urls.map(async (url) => {
-        try {
-          const metadata = await streamProbe.probe(url, { force: false });
-          return { url, metadata };
-        } catch (err) {
-          this.ctx.logger.warn(
-            "[rtsp-edit] probe failed \u2014 landing in the lowest tier via classifyStreams",
-            { meta: { url: (0, import_types.maskUrlCredentials)(url), error: err instanceof Error ? err.message : String(err) } }
-          );
-          const emptyMetadata = {};
-          return { url, metadata: emptyMetadata };
-        }
-      })
-    );
-    const classified = (0, import_types.classifyStreams)(probed);
-    const metadataByUrl = new Map(probed.map((p) => [p.url, p.metadata]));
-    const classifiedByUrl = new Map(classified.map((c) => [c.url, c]));
-    return urls.map((url, i) => {
-      const tag = classifiedByUrl.get(url);
-      const meta = metadataByUrl.get(url);
-      const entry = { id: `stream-${i + 1}`, url };
-      if (tag) entry.profileHint = tag.quality;
-      if (meta?.width && meta?.height) entry.resolution = { width: meta.width, height: meta.height };
-      return entry;
-    });
-  }
-  // ── Native capabilities ────────────────────────────────────────────────
-  registerSnapshotProvider() {
-    const snapshotUrl = (this.config.get("snapshotUrl") ?? "").trim();
-    if (!snapshotUrl) return;
-    const provider = {
-      getSnapshot: async ({ deviceId }) => {
-        if (deviceId !== this.id) {
-          throw new Error(`RtspCamera: deviceId mismatch, expected ${this.id}, got ${deviceId}`);
-        }
-        const buf = await this.fetchHttpSnapshot(snapshotUrl);
-        if (buf.length === 0) return null;
-        return { base64: buf.toString("base64"), contentType: "image/jpeg" };
-      },
-      invalidateCache: async () => {
-      }
-    };
-    this.ctx.registerNativeCap(import_types.snapshotCapability, provider);
-  }
-  async fetchHttpSnapshot(url) {
-    const username = (this.config.get("username") ?? "").trim();
-    const password = (this.config.get("password") ?? "").trim();
-    const headers = {};
-    if (username || password) {
-      const creds = Buffer.from(`${username}:${password}`).toString("base64");
-      headers["authorization"] = `Basic ${creds}`;
-    }
-    const res = await fetch(url, { headers });
-    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
-    const ab = await res.arrayBuffer();
-    return Buffer.from(ab);
-  }
-};
-
-// src/addon.ts
-function getString(obj, key) {
-  const v = obj[key];
-  return typeof v === "string" ? v : "";
-}
-function getStringArray(obj, key) {
-  const v = obj[key];
-  if (!Array.isArray(v)) return [];
-  return v.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function buildCreationFormSchema() {
-  return {
-    sections: [
-      {
-        id: "identity",
-        title: "Camera",
-        columns: 1,
-        fields: [
-          { type: "text", key: "name", label: "Name", required: true, placeholder: "Living room" }
-        ]
-      },
-      {
-        id: "streams",
-        title: "RTSP Streams",
-        description: "Provide 1\u20133 RTSP URLs for this camera. Each URL is probed and published to the stream-broker; the broker assigns the (high / mid / low) profiles by resolution \u2014 you do not need to label the streams manually.",
-        columns: 1,
-        fields: [
-          {
-            type: "probe",
-            key: "streams",
-            label: "RTSP stream URL",
-            required: true,
-            placeholder: "rtsp://user:pass@host:554/Streaming/Channels/101",
-            inputType: "url",
-            multiple: {
-              min: 1,
-              max: 3,
-              addLabel: "Add stream",
-              itemLabel: "Stream ${n}",
-              itemDefault: ""
-            }
-          }
-        ]
-      },
-      {
-        id: "snapshot",
-        title: "Snapshot",
-        columns: 1,
-        fields: [
-          { type: "probe", key: "snapshotUrl", label: "Snapshot URL", description: "Optional HTTP(S) endpoint that returns a JPEG still.", placeholder: "http://host/ISAPI/Streaming/channels/101/picture", inputType: "url" }
-        ]
-      },
-      {
-        id: "credentials",
-        title: "Credentials",
-        description: "Optional. If the RTSP URL already contains user:pass@ you can leave these empty.",
-        columns: 2,
-        fields: [
-          { type: "text", key: "username", label: "Username" },
-          { type: "password", key: "password", label: "Password", showToggle: true }
-        ]
-      }
-    ]
-  };
-}
-function isStreamBrokerReady(event) {
-  if (event.category !== "system.ready-state") return false;
-  const data = event.data;
-  return data["capName"] === "stream-broker" && data["state"] === "ready";
-}
-var RtspProviderAddon = class extends import_types2.BaseDeviceProvider {
-  addonId = "provider-rtsp";
-  providerName = "RTSP";
-  deviceClasses = {
-    [import_types2.DeviceType.Camera]: RtspCamera
-  };
-  constructor() {
-    super({});
-  }
-  async onInitialize() {
-    const regs = await super.onInitialize();
-    this.subscribe(
-      { category: import_types2.EventCategory.DeviceStateChanged },
-      (event) => {
-        const data = event.data;
-        if (data.capName !== "camera-streams") return;
-        const deviceId = data.deviceId;
-        if (typeof deviceId !== "number") return;
-        const registry = this.ctx.kernel.deviceRegistry;
-        if (!registry) return;
-        if (registry.getAddonId(deviceId) !== this.addonId) return;
-        const device = registry.getById(deviceId);
-        if (!device) return;
-        const online = data.slice?.online === true;
-        if (device.online !== online) device.online = online;
-      }
-    );
-    this.subscribe(
-      { category: import_types2.EventCategory.SystemReadyState },
-      (event) => {
-        if (!isStreamBrokerReady(event)) return;
-        void this.republishAll().catch((err) => {
-          this.ctx.logger.warn("Failed to re-publish RTSP streams after broker ready", {
-            meta: { error: err instanceof Error ? err.message : String(err) }
-          });
-        });
-      }
-    );
-    return regs;
-  }
-  // ── Creation ─────────────────────────────────────────────────────────
-  async onGetCreationSchema(type) {
-    if (type !== import_types2.DeviceType.Camera) return null;
-    return buildCreationFormSchema();
-  }
-  async onCreateDevice(type, config) {
-    if (type !== import_types2.DeviceType.Camera) {
-      throw new Error(`RTSP provider does not support device type: ${type}`);
-    }
-    const name = getString(config, "name").trim();
-    if (!name) throw new Error("Camera name is required");
-    const rawStreams = getStringArray(config, "streams");
-    if (rawStreams.length === 0) throw new Error("At least one RTSP stream URL is required");
-    if (rawStreams.length > 3) throw new Error("At most 3 RTSP stream URLs are supported");
-    const streamProbe = this.ctx.kernel.streamProbe;
-    if (!streamProbe) throw new Error("ctx.kernel.streamProbe unavailable \u2014 cannot probe streams");
-    const probed = await Promise.all(
-      rawStreams.map(async (url) => {
-        try {
-          const metadata = await streamProbe.probe(url, { force: false });
-          return { url, metadata, ok: true };
-        } catch (err) {
-          this.ctx.logger.warn(
-            "[rtsp-create] probe failed \u2014 publishing without probed metadata",
-            { meta: { url: (0, import_types2.maskUrlCredentials)(url), error: err instanceof Error ? err.message : String(err) } }
-          );
-          return { url, metadata: void 0, ok: false };
-        }
-      })
-    );
-    const classified = (0, import_types2.classifyStreams)(
-      probed.map((p) => ({ url: p.url, metadata: p.metadata ?? {} }))
-    );
-    const hintByUrl = new Map(classified.map((c) => [c.url, c.quality]));
-    const streams = probed.map((p, i) => {
-      const entry = { id: `stream-${i + 1}`, url: p.url };
-      const hint = hintByUrl.get(p.url);
-      if (hint) entry.profileHint = hint;
-      if (p.metadata?.width && p.metadata?.height) {
-        entry.resolution = { width: p.metadata.width, height: p.metadata.height };
-      }
-      return entry;
-    });
-    const parsed = rtspCameraSchema.parse({
-      streams,
-      snapshotUrl: getString(config, "snapshotUrl"),
-      username: getString(config, "username"),
-      password: getString(config, "password")
-    });
-    return {
-      meta: { type: import_types2.DeviceType.Camera, name },
-      config: parsed
-    };
-  }
-  // ── Field probing ────────────────────────────────────────────────────
-  async testCreationField(input) {
-    if (input.type !== import_types2.DeviceType.Camera) {
-      return { status: "error", error: `Unsupported device type: ${input.type}` };
-    }
-    const streamProbe = this.ctx.kernel.streamProbe;
-    if (!streamProbe) {
-      return { status: "error", error: "ctx.kernel.streamProbe unavailable \u2014 cannot reach kernel probe" };
-    }
-    return streamProbe.probeField(input.key, input.value);
-  }
-  // ── Restore ──────────────────────────────────────────────────────────
-  //
-  // `BaseDeviceProvider.onRestoreDevices` default impl iterates
-  // `savedDevices`, looks up the right class via `deviceClasses`,
-  // and calls `kernel.devices.create()`. Each created device fires
-  // its `onCreated` lifecycle hook (see `RtspCamera.onCreated()`)
-  // which publishes streams to the broker — no per-provider override
-  // needed here.
-  // ── Internal — re-publish every RtspCamera to the broker ────────────
-  async republishAll() {
-    const all = await this.ctx.kernel.devices?.getAll() ?? [];
-    let published = 0;
-    for (const dev of all) {
-      if (!(dev instanceof RtspCamera)) continue;
-      try {
-        await dev.publishToBroker();
-        published++;
-      } catch (err) {
-        this.ctx.logger.debug("publishToBroker threw during republish", {
-          tags: { deviceId: dev.id },
-          meta: { error: err instanceof Error ? err.message : String(err) }
-        });
-      }
-    }
-    if (published > 0) {
-      this.ctx.logger.info("Re-published RTSP streams to stream-broker", {
-        meta: { published, total: all.length }
-      });
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RtspCamera,
-  RtspProviderAddon,
-  rtspCameraSchema
-});
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const addon = require("./addon.js");
+exports.RtspCamera = addon.RtspCamera;
+exports.RtspProviderAddon = addon.RtspProviderAddon;
+exports.rtspCameraSchema = addon.rtspCameraSchema;
+//# sourceMappingURL=index.js.map