@7365admin1/core 3.75.1 → 3.76.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7365admin1/core",
   "license": "MIT",
-  "version": "3.75.1",
+  "version": "3.76.0",
   "author": "7365admin1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/test/camera-live-link.test.mjs

@@ -0,0 +1,163 @@
+/**
+ * The server signs the LIVE view link, the same way it already signs recorded
+ * footage — and hands it out WITHOUT touching `camera.host`.
+ *
+ * Both halves are asserted here, and they are different claims:
+ *
+ *  1. `signLiveLink` produces exactly the string the relay's `playback.js`
+ *     verifies (the expected signature is recomputed here by hand, not taken
+ *     from the function under test).
+ *  2. The camera payloads this estate actually returns CARRY it — proved
+ *     through `withLiveLink(publicCameraFields(...))`, the wrapper the wall,
+ *     the health sweep and the single-camera view all go through.
+ */
+import assert from "node:assert/strict";
+import { createHmac } from "node:crypto";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import {
+  PLAYBACK_LINK_SECONDS,
+  signLiveLink,
+  signPlaybackLink,
+  withLiveLink,
+} from "./.build/utils/camera-playback.util.mjs";
+import {
+  isRelayPlayerUrl,
+} from "./.build/utils/camera-capability.util.mjs";
+import { publicCameraFields } from "./.build/utils/camera-view.util.mjs";
+
+const KEY = "k".repeat(40);
+const RELAY = "the-loft.example.net";
+const RELAYS = { [RELAY]: KEY };
+const NOW = new Date("2026-09-16T08:00:00Z");
+const EXP = Math.floor(NOW.getTime() / 1000) + PLAYBACK_LINK_SECONDS;
+
+/** What the relay computes. Written out here so the test is not the code twice. */
+const expectedSig = (channel, exp = EXP, key = KEY) =>
+  createHmac("sha256", key).update(`${channel}|${exp}`).digest("hex");
+
+test("a live link is signed over channel|exp with the relay's key", () => {
+  const link = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+
+  assert.equal(link.liveAuth, `exp=${EXP}&sig=${expectedSig("7")}`);
+  assert.equal(link.liveUrl, `https://${RELAY}/7?${link.liveAuth}`);
+  assert.equal(link.liveExpiresAt, new Date(EXP * 1000).toISOString());
+});
+
+test("the live link and the recorded-footage link sign DIFFERENT messages", () => {
+  const start = new Date("2026-09-16T07:00:00Z");
+  const end = new Date("2026-09-16T07:10:00Z");
+  const recorded = signPlaybackLink({
+    host: `https://${RELAY}/7`,
+    key: KEY,
+    start,
+    end,
+    now: NOW,
+  });
+  const live = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+
+  // Same key, same expiry, different signature - so a recording link cannot be
+  // replayed as a live link, which is what the relay's tests assert from the
+  // other side.
+  assert.equal(new URL(recorded.playerUrl).searchParams.get("exp"), String(EXP));
+  assert.notEqual(
+    new URL(recorded.playerUrl).searchParams.get("sig"),
+    new URL(live.liveUrl).searchParams.get("sig"),
+  );
+});
+
+test("the link lives as long as a recorded-footage link, and no longer", () => {
+  assert.equal(PLAYBACK_LINK_SECONDS, 120);
+  const link = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+  const exp = Number(new URLSearchParams(link.liveAuth).get("exp"));
+  assert.equal(exp - Math.floor(NOW.getTime() / 1000), PLAYBACK_LINK_SECONDS);
+});
+
+test("no relay configured for that address means NOTHING changes", () => {
+  // The estate has cameras on hosts nobody has configured. They must keep their
+  // plain link rather than get a signature no relay can check.
+  assert.equal(signLiveLink(`https://other.example.net/7`, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink(`https://${RELAY}/7`, { relays: {}, now: NOW }), null);
+  // A host with no channel is genuinely unresolvable, not channel 1.
+  assert.equal(signLiveLink(`https://${RELAY}/lobby`, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink(undefined, { relays: RELAYS, now: NOW }), null);
+  assert.equal(signLiveLink("", { relays: RELAYS, now: NOW }), null);
+});
+
+test("one signature serves the page, the socket, the still and the clip", () => {
+  // It covers the CHANNEL, not the path - which is why appending it to
+  // /screenshot/<ch> and /record/<ch>/duration/<n> works, and why the clients
+  // that splice `screenshot` into the path are unaffected.
+  const { liveAuth } = signLiveLink(`https://${RELAY}/7`, { relays: RELAYS, now: NOW });
+  for (const path of ["/7", "/api/stream/7", "/screenshot/7", "/record/7/duration/10"]) {
+    const url = new URL(`https://${RELAY}${path}?${liveAuth}`);
+    assert.equal(url.searchParams.get("sig"), expectedSig("7"));
+  }
+});
+
+test("the camera payloads the estate returns carry the signed link", () => {
+  const camera = { _id: "c1", name: "Lobby", type: "ip", status: "active", host: `https://${RELAY}/7` };
+  const fields = withLiveLink(publicCameraFields(camera), { relays: RELAYS, now: NOW });
+
+  assert.equal(fields.liveUrl, `https://${RELAY}/7?exp=${EXP}&sig=${expectedSig("7")}`);
+  assert.equal(fields.liveAuth, `exp=${EXP}&sig=${expectedSig("7")}`);
+});
+
+test("the stored host is handed back UNCHANGED, and stays a relay player URL", () => {
+  const host = `https://${RELAY}/7`;
+  const fields = withLiveLink(publicCameraFields({ _id: "c1", type: "ip", status: "active", host }), {
+    relays: RELAYS,
+    now: NOW,
+  });
+
+  // If `host` ever carried the signature, `isRelayPlayerUrl` would refuse it
+  // (it rejects any query), the liveVideo capability would switch off for both
+  // mobile apps and the web wall, and the patrol-route form would freeze an
+  // expiring signature into the route document. So this is load-bearing.
+  assert.equal(fields.host, host);
+  assert.equal(isRelayPlayerUrl(fields.host), true);
+});
+
+/**
+ * The WIRING, asserted on the service source — the same reason and the same
+ * method as `camera-entitlement-wiring.test.mjs`: constructing the service needs
+ * a live Atlas connection, so the only way to prove the service actually calls
+ * this is to assert the source.
+ *
+ * Without this, every assertion above could pass while the wall still handed out
+ * unsigned links — a helper nobody called.
+ */
+test("EVERY camera payload the service returns goes through withLiveLink", () => {
+  const source = readFileSync(
+    fileURLToPath(new URL("../src/services/camera-view.service.ts", import.meta.url)),
+    "utf8",
+  );
+
+  const uses = [...source.matchAll(/publicCameraFields\(/g)];
+  // The import line names it too; the call sites are what matter.
+  const callSites = uses.filter((m) => !/import|from/.test(source.slice(Math.max(0, m.index - 80), m.index)));
+  assert.ok(callSites.length >= 3, `expected the wall, the health sweep and the single view, found ${callSites.length}`);
+
+  for (const match of callSites) {
+    const before = source.slice(Math.max(0, match.index - 60), match.index);
+    assert.match(
+      before,
+      /withLiveLink\(\s*$/,
+      `a camera payload at offset ${match.index} is handed out without a signed live link`,
+    );
+  }
+});
+
+test("an ANPR camera gets no host and therefore no live link", () => {
+  // `publicCameraFields` already withholds `host` for ANPR; nothing may put one
+  // back. ANPR belongs to visitor and vehicle management, not to CCTV.
+  const fields = withLiveLink(
+    publicCameraFields({ _id: "c2", type: "anpr", status: "active", host: `https://${RELAY}/7` }),
+    { relays: RELAYS, now: NOW },
+  );
+  assert.equal(fields.host, undefined);
+  assert.equal(fields.liveUrl, undefined);
+  assert.equal(fields.liveAuth, undefined);
+});