@apocaliss92/nodelink-js 0.5.0 → 0.5.1-beta.0

package/README.md

@@ -8,7 +8,7 @@
 
 ### [Manager UI (Web Dashboard)](./app/README.md)
 
-A complete web-based management interface for camera configuration and live streaming — no code required. Docker deployment, go2rtc restreamer, real-time events, MQTT, Home Assistant integration.
+A complete web-based management interface for camera configuration and live streaming — no code required. Docker deployment, native RTSP + WebRTC, real-time events, MQTT, Home Assistant integration.
 
 ### [Library (`@apocaliss92/nodelink-js`)](./documentation/baichuan-api/README.md)
 

package/dist/index.cjs

@@ -41646,17 +41646,47 @@ var import_node_events15 = require("events");
 var net6 = __toESM(require("net"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
 var md5Hex = (s) => crypto3.createHash("md5").update(s).digest("hex");
+function normalizePath(path7) {
+  if (!path7) return "/";
+  let p = path7;
+  if (!p.startsWith("/")) p = "/" + p;
+  while (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p;
+}
+function extractBasePath(url) {
+  if (!url || url === "*") return null;
+  let pathPart;
+  if (url.startsWith("rtsp://") || url.startsWith("rtsps://")) {
+    try {
+      const u = new URL(url.replace(/^rtsps?:/, "http:"));
+      pathPart = u.pathname || "/";
+    } catch {
+      return null;
+    }
+  } else {
+    const q = url.indexOf("?");
+    pathPart = q >= 0 ? url.slice(0, q) : url;
+  }
+  if (pathPart.endsWith("/audiobackchannel")) {
+    pathPart = pathPart.slice(0, -"/audiobackchannel".length);
+  }
+  return normalizePath(pathPart);
+}
 var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events15.EventEmitter {
-  api;
-  channel;
   listenHost;
   listenPort;
-  path;
   logger;
   authCredentials;
   requireAuth;
   authRealm;
-  deviceId;
+  /**
+   * Path → route table. Single-camera mode stores one entry; multi-tenant
+   * mode can have many. The internal `singleCameraFallback` flag (below)
+   * controls whether an unmatched request falls through to the sole
+   * registered route (legacy behavior) or returns 404 (strict).
+   */
+  routes = /* @__PURE__ */ new Map();
+  singleCameraFallback;
   server = void 0;
   /** Active backchannel sessions keyed by their per-client unique id. */
   sessionByClient = /* @__PURE__ */ new Map();
@@ -41664,11 +41694,8 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
   static NONCE_TTL_MS = 5 * 60 * 1e3;
   constructor(options) {
     super();
-    this.api = options.api;
-    this.channel = options.channel;
     this.listenHost = options.listenHost ?? "127.0.0.1";
     this.listenPort = options.listenPort ?? 8555;
-    this.path = options.path ?? "/talk";
     this.logger = options.logger ?? console;
     this.authCredentials = (options.credentials ?? []).map((c) => ({
       username: c.username,
@@ -41677,11 +41704,88 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
     }));
     this.requireAuth = options.requireAuth ?? this.authCredentials.length > 0;
     this.authRealm = options.authRealm ?? "BaichuanRtspBackchannelServer";
-    this.deviceId = options.deviceId;
+    const singleCamera = options.api !== void 0 && options.channel !== void 0;
+    const hasRoutes = options.routes !== void 0 && Object.keys(options.routes).length > 0;
+    if (singleCamera && hasRoutes) {
+      throw new Error(
+        "BaichuanRtspBackchannelServer: pass either { api, channel } (single camera) or { routes } (multi tenant), not both"
+      );
+    }
+    if (!singleCamera && options.routes === void 0) {
+      throw new Error(
+        "BaichuanRtspBackchannelServer: provide { api, channel } or { routes } (or both via constructor; addRoute() works too)"
+      );
+    }
+    if (singleCamera) {
+      const path7 = normalizePath(options.path ?? "/talk");
+      this.routes.set(path7, {
+        api: options.api,
+        channel: options.channel,
+        ...options.deviceId !== void 0 ? { deviceId: options.deviceId } : {}
+      });
+      this.singleCameraFallback = true;
+    } else {
+      this.singleCameraFallback = false;
+      if (options.routes) {
+        for (const [path7, route] of Object.entries(options.routes)) {
+          this.routes.set(normalizePath(path7), { ...route });
+        }
+      }
+    }
   }
   get listening() {
     return this.server !== void 0 && this.server.listening;
   }
+  /**
+   * Register (or replace) a camera route at runtime. The path is normalized
+   * (leading slash, no trailing slash). The manager uses this to wire a
+   * single shared port to N cameras as they come online.
+   */
+  addRoute(path7, route) {
+    const normalized = normalizePath(path7);
+    this.routes.set(normalized, { ...route });
+    this.logger.info?.(
+      `[BaichuanRtspBackchannelServer] route registered path=${normalized} channel=${route.channel}${route.deviceId ? ` deviceId="${route.deviceId}"` : ""} totalRoutes=${this.routes.size}`
+    );
+  }
+  /** Remove a route. Returns true if a route was actually removed. */
+  removeRoute(path7) {
+    const normalized = normalizePath(path7);
+    const had = this.routes.delete(normalized);
+    if (had) {
+      this.logger.info?.(
+        `[BaichuanRtspBackchannelServer] route unregistered path=${normalized} totalRoutes=${this.routes.size}`
+      );
+    }
+    return had;
+  }
+  /** Cheap presence check. */
+  hasRoute(path7) {
+    return this.routes.has(normalizePath(path7));
+  }
+  /** Snapshot of currently registered route paths. */
+  listRoutes() {
+    return Array.from(this.routes.keys());
+  }
+  /**
+   * Resolve the {@link BackchannelRoute} for an incoming RTSP request URL.
+   * In single-camera mode this falls back to the only registered route to
+   * preserve permissive legacy behavior; in multi-tenant mode unmatched
+   * paths return undefined so the caller can reply 404.
+   */
+  resolveRouteForRequest(url) {
+    const base = extractBasePath(url);
+    if (base !== null) {
+      const exact = this.routes.get(base);
+      if (exact) return { route: exact, path: base };
+    }
+    if (this.singleCameraFallback && this.routes.size === 1) {
+      const path7 = this.routes.keys().next().value;
+      const route = this.routes.get(path7);
+      return { route, path: path7 };
+    }
+    return void 0;
+  }
   async start() {
     if (this.server) return;
     await new Promise((resolve, reject) => {
@@ -41694,13 +41798,33 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
       server.listen(this.listenPort, this.listenHost, () => {
         server.removeListener("error", onError);
         this.server = server;
+        const routeList = Array.from(this.routes.keys()).join(", ") || "(none)";
         this.logger.info?.(
-          `[BaichuanRtspBackchannelServer] listening on ${this.listenHost}:${this.listenPort} path=${this.path}`
+          `[BaichuanRtspBackchannelServer] listening on ${this.listenHost}:${this.listenPort} routes=[${routeList}]`
         );
         resolve();
       });
     });
   }
+  /**
+   * Inject an already-accepted client socket from a multiplexer (e.g.
+   * `LocalRtspMux`) that owns the listening port. The mux reads the first
+   * RTSP request line to dispatch on path, then hands the socket over;
+   * any bytes already consumed during routing are replayed via
+   * `socket.unshift()` so the RTSP parser in `handleConnection` sees the
+   * full original request.
+   *
+   * This lets the same backchannel server share a TCP port with the
+   * per-profile video servers when the manager runs in local restreamer
+   * mode. The server doesn't need to be `start()`ed in that mode — `stop()`
+   * still tears down any in-flight talk sessions correctly.
+   */
+  injectSocket(socket, preReadData) {
+    if (preReadData && preReadData.length > 0) {
+      socket.unshift(preReadData);
+    }
+    this.handleConnection(socket);
+  }
   async stop() {
     const server = this.server;
     this.server = void 0;
@@ -41724,7 +41848,7 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
     const connectedAt = Date.now();
     let buffer = Buffer.alloc(0);
     this.logger.info?.(
-      `[BaichuanRtspBackchannelServer] client connected client=${clientId} path=${this.path}`
+      `[BaichuanRtspBackchannelServer] client connected client=${clientId}`
     );
     this.emit("client", clientId);
     const cleanup = () => {
@@ -41892,9 +42016,17 @@ CSeq: ${cseq}\r
         });
         return;
       case "DESCRIBE": {
+        const resolved = this.resolveRouteForRequest(url);
+        if (!resolved) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] DESCRIBE no route matches url="${url}" client=${clientId} known=[${Array.from(this.routes.keys()).join(", ")}]`
+          );
+          send(404, "Not Found");
+          return;
+        }
         const sdp = this.buildSdp();
         this.logger.debug?.(
-          `[BaichuanRtspBackchannelServer] DESCRIBE sdp for ${clientId}:
+          `[BaichuanRtspBackchannelServer] DESCRIBE sdp for ${clientId} path=${resolved.path}:
 ${sdp.trimEnd()}`
         );
         send(
@@ -41902,7 +42034,7 @@ ${sdp.trimEnd()}`
           "OK",
           {
             "Content-Type": "application/sdp",
-            "Content-Base": `rtsp://${this.listenHost}:${this.listenPort}${this.path}/`
+            "Content-Base": `rtsp://${this.listenHost}:${this.listenPort}${resolved.path}/`
           },
           sdp
         );
@@ -41916,9 +42048,17 @@ ${sdp.trimEnd()}`
           send(404, "Not Found");
           return;
         }
+        const resolved = this.resolveRouteForRequest(url);
+        if (!resolved) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] SETUP no route matches url="${url}" client=${clientId} known=[${Array.from(this.routes.keys()).join(", ")}]`
+          );
+          send(404, "Not Found");
+          return;
+        }
         const transportLine = requestText.match(/Transport:\s*([^\r\n]+)/i)?.[1] ?? "";
         this.logger.info?.(
-          `[BaichuanRtspBackchannelServer] SETUP transport="${transportLine}" client=${clientId}`
+          `[BaichuanRtspBackchannelServer] SETUP transport="${transportLine}" client=${clientId} path=${resolved.path}`
         );
         if (!transportLine.toUpperCase().includes("RTP/AVP/TCP") && !transportLine.toLowerCase().includes("interleaved")) {
           this.logger.warn?.(
@@ -41939,10 +42079,12 @@ ${sdp.trimEnd()}`
           clientId,
           socket,
           rtpChannel: interleaved.rtp,
-          rtcpChannel: interleaved.rtcp
+          rtcpChannel: interleaved.rtcp,
+          route: resolved.route,
+          routePath: resolved.path
         });
         this.logger.info?.(
-          `[BaichuanRtspBackchannelServer] SETUP ok client=${clientId} session=${sessionId} interleaved=${interleaved.rtp}-${interleaved.rtcp}`
+          `[BaichuanRtspBackchannelServer] SETUP ok client=${clientId} session=${sessionId} interleaved=${interleaved.rtp}-${interleaved.rtcp} path=${resolved.path}`
         );
         send(200, "OK", {
           Transport: `RTP/AVP/TCP;unicast;interleaved=${interleaved.rtp}-${interleaved.rtcp};mode=record`,
@@ -41968,10 +42110,10 @@ ${sdp.trimEnd()}`
           send(200, "OK", { Session: session.sessionId });
           return;
         }
-        const apiRef = this.api;
-        const channelForCamera = this.channel;
+        const apiRef = session.route.api;
+        const channelForCamera = session.route.channel;
         const loggerRef = this.logger;
-        const deviceIdRef = this.deviceId ?? `rtsp-backchannel-${clientId}`;
+        const deviceIdRef = session.route.deviceId ?? `rtsp-backchannel-${clientId}`;
         const handler = new RtspBackchannel({
           openTalkSession: () => apiRef.createDedicatedTalkSession(channelForCamera, {
             deviceId: deviceIdRef,
@@ -41981,7 +42123,7 @@ ${sdp.trimEnd()}`
         });
         const recordStart = Date.now();
         this.logger.info?.(
-          `[BaichuanRtspBackchannelServer] RECORD opening TalkSession client=${clientId} session=${session.sessionId} channel=${channelForCamera} deviceId="${deviceIdRef}"`
+          `[BaichuanRtspBackchannelServer] RECORD opening TalkSession client=${clientId} session=${session.sessionId} path=${session.routePath} channel=${channelForCamera} deviceId="${deviceIdRef}"`
         );
         try {
           const talk = await handler.start();