@apocaliss92/nodelink-js 0.2.5 → 0.3.5

package/dist/index.d.ts

@@ -300,27 +300,30 @@ export declare type AutoDetectResult = {
 };
 
 /**
- * Client per discovery continuato di telecamere Reolink sulla rete.
- * Supporta TCP/IPC (HTTP/HTTPS scanning) e/o UDP broadcast discovery.
+ * Continuous discovery client for Reolink cameras on the network.
+ * Runs periodic scans using all configured discovery methods and maintains
+ * an always-up-to-date list of discovered devices.
  *
- * Mantiene una lista aggiornata delle telecamere discoverate e offre
- * metodi per ottenere la lista corrente e controllare il processo di discovery.
+ * Supports callbacks for new/updated devices, making it ideal for plugins
+ * that want to be notified as cameras appear (e.g. battery cameras waking up).
  *
  * @example
  * ```typescript
  * const client = new AutodiscoveryClient({
- *   username: "admin",
- *   password: "password",
- *   scanIntervalMs: 30000, // 30 secondi
+ *   enableArpLookup: true,
+ *   enableOnvifDiscovery: true,
+ *   scanIntervalMs: 60_000,
  *   autoStart: true,
+ *   onDeviceDiscovered: (device) => {
+ *     console.log(`New device: ${device.host} (${device.model})`);
+ *   },
  * });
  *
- * // Ottieni la lista corrente
+ * // Get the current list
  * const devices = client.getDiscoveredDevices();
- * console.log(`Trovate ${devices.length} telecamere`);
  *
- * // Ferma il discovery
- * await client.stop();
+ * // Stop
+ * client.stop();
  * ```
  */
 export declare class AutodiscoveryClient {
@@ -329,96 +332,54 @@ export declare class AutodiscoveryClient {
     private scanTimer;
     private isRunning;
     private currentScanPromise;
-    /**
-     * Costruttore del client di autodiscovery.
-     *
-     * @param options - Opzioni di configurazione per il discovery
-     */
     constructor(options?: AutodiscoveryClientOptions);
     /**
-     * Avvia il discovery continuato.
-     * Se già in esecuzione, non fa nulla.
+     * Start continuous discovery. If already running, does nothing.
      */
     start(): void;
     /**
-     * Ferma il discovery continuato.
-     * Se non è in esecuzione, non fa nulla.
+     * Stop continuous discovery. If not running, does nothing.
      */
     stop(): void;
     /**
-     * Restituisce la lista corrente delle telecamere discoverate.
-     *
-     * @returns Array di dispositivi discoverati, ordinati per host
+     * Returns the current list of discovered devices, sorted by host IP.
      */
     getDiscoveredDevices(): DiscoveredDevice[];
     /**
-     * Restituisce il numero di telecamere attualmente discoverate.
-     *
-     * @returns Numero di dispositivi discoverati
+     * Returns the number of currently discovered devices.
      */
     getDeviceCount(): number;
     /**
-     * Verifica se il discovery è attualmente in esecuzione.
-     *
-     * @returns `true` se il discovery è in esecuzione, `false` altrimenti
+     * Returns whether continuous discovery is currently running.
      */
     isActive(): boolean;
     /**
-     * Forza un scan immediato (non aspetta l'intervallo programmato).
-     * Se uno scan è già in corso, attende il completamento prima di avviarne uno nuovo.
-     *
-     * @returns Promise che si risolve quando lo scan è completato
+     * Force an immediate scan (doesn't wait for the scheduled interval).
+     * If a scan is already in progress, waits for it to complete.
      */
     scanNow(): Promise<void>;
     /**
-     * Rimuove un dispositivo dalla lista (utile se si sa che non è più disponibile).
-     *
-     * @param host - Indirizzo IP del dispositivo da rimuovere
-     * @returns `true` se il dispositivo è stato rimosso, `false` se non era presente
+     * Remove a device from the discovered list.
      */
     removeDevice(host: string): boolean;
     /**
-     * Pulisce tutte le telecamere discoverate dalla lista.
+     * Clear all discovered devices.
      */
     clearDevices(): void;
-    /**
-     * Esegue un singolo scan della rete.
-     */
     private performScan;
-    /**
-     * Unisce le informazioni di un dispositivo esistente con quelle di un nuovo scan.
-     * Restituisce il dispositivo aggiornato se ci sono state modifiche, altrimenti `null`.
-     */
     private mergeDeviceInfo;
-    /**
-     * Programma il prossimo scan.
-     */
     private scheduleNextScan;
 }
 
-export declare interface AutodiscoveryClientOptions {
-    /** Network CIDR to scan (e.g., "192.168.1.0/24"). If not provided, auto-detects local network */
-    networkCidr?: string;
-    /** Username to use for authentication attempts (default: "admin") */
-    username?: string;
-    /** Password to use for authentication attempts (default: empty, will try unauthenticated) */
-    password?: string;
-    /** Timeout per HTTP probe in milliseconds (default: 2000) */
-    httpProbeTimeoutMs?: number;
-    /** Maximum number of concurrent HTTP probes (default: 50) */
-    maxConcurrentProbes?: number;
-    /** Logger instance for debug output */
-    logger?: Logger;
-    /** Ports to scan for HTTP (default: [80, 443]) */
-    httpPorts?: number[];
-    /** Interval between discovery scans in milliseconds (default: 60000 = 60 seconds) */
+export declare interface AutodiscoveryClientOptions extends DiscoveryOptions {
+    /** Interval between discovery scans in milliseconds (default: 120000 = 2 minutes) */
     scanIntervalMs?: number;
     /** Whether to start discovery automatically on construction (default: false) */
     autoStart?: boolean;
-    /** Discovery method to use: "http" (TCP/IPC), "udp" (broadcast), or "both" (default: "http") */
-    discoveryMethod?: "http" | "udp" | "both";
-    /** Timeout for UDP broadcast in milliseconds (default: 5000) */
-    udpBroadcastTimeoutMs?: number;
+    /** Called when new (previously unseen) devices are discovered */
+    onDeviceDiscovered?: (device: DiscoveredDevice) => void;
+    /** Called when an existing device's info is updated (e.g. model filled in) */
+    onDeviceUpdated?: (device: DiscoveredDevice) => void;
 }
 
 export declare type BaichuanCachedPush<T> = {
@@ -461,6 +422,22 @@ export declare class BaichuanClient extends EventEmitter<{
     private static readonly coverPreviewBackoffMs;
     private static readonly COVER_PREVIEW_INITIAL_BACKOFF_MS;
     private static readonly COVER_PREVIEW_MAX_BACKOFF_MS;
+    /**
+     * Per-client snapshot (cmd_id=109) serialization queue.
+     *
+     * WHY: On NVR/multi-camera devices sharing one socket, concurrent snapshot requests
+     * can cause JPEG data to mix (even with per-request msgNum filtering):
+     * - Camera A and B both send frames on same socket
+     * - Frame listener is global per socket
+     * - Timing quirks can cause chunk reordering or listener confusion
+     *
+     * FIX: Serialize all cmd_id=109 requests on THIS client instance.
+     * Each snapshot waits for previous one to complete before starting.
+     * This ensures clean frame sequences per request, zero data corruption.
+     *
+     * Impact: Snapshots are ~0–50ms slower per camera (negligible for users).
+     */
+    private snapshotQueueTail;
     private readonly opts;
     private readonly debugCfg;
     private readonly logger;
@@ -807,6 +784,7 @@ export declare class BaichuanClient extends EventEmitter<{
     private sendBinaryFileDownload6482;
     private sendBinaryFileInfoListReplay5;
     private sendBinarySnapshot109;
+    private sendBinarySnapshot109Impl;
     /**
      * Send CoverPreview command (cmd_id=298) to get an I-frame from a past recording.
      * Similar to sendBinarySnapshot109 but handles the stream header + frame format
@@ -3628,7 +3606,7 @@ export declare interface DiscoveredDevice {
     /** Firmware version (if available) */
     firmwareVersion?: string;
     /** Discovery method used to find this device */
-    discoveryMethod: "http_probe" | "udp_broadcast" | "udp_direct";
+    discoveryMethod: "http_probe" | "udp_broadcast" | "udp_direct" | "tcp_port_scan" | "arp" | "dhcp" | "onvif";
     /** Whether HTTPS is supported */
     supportsHttps?: boolean;
     /** Whether the device is accessible via HTTP */
@@ -3657,11 +3635,45 @@ export declare interface DiscoveredDevice {
  */
 export declare function discoverReolinkDevices(options?: DiscoveryOptions): Promise<DiscoveredDevice[]>;
 
+/**
+ * Discover Reolink devices by reading the system ARP table and filtering
+ * for Reolink MAC address prefixes (EC:71:DB). This mirrors the DHCP-based
+ * discovery used by Home Assistant but reads the already-populated ARP cache
+ * instead of sniffing live DHCP packets.
+ *
+ * Works on Linux, macOS, and Docker containers (reads /proc/net/arp or `arp -a`).
+ */
+export declare function discoverViaArpTable(options: DiscoveryOptions): Promise<DiscoveredDevice[]>;
+
+/**
+ * Discover Reolink devices by passively listening for DHCP traffic (port 67/68).
+ * Parses DHCP ACK/REQUEST packets and filters for Reolink MAC prefix or hostname.
+ * Requires root or CAP_NET_RAW (typical in Docker with --net=host).
+ *
+ * This mirrors Home Assistant's DHCP discovery: matches hostname "reolink*" or MAC "EC:71:DB".
+ */
+export declare function discoverViaDhcpListener(options: DiscoveryOptions): Promise<DiscoveredDevice[]>;
+
 /**
  * Discover devices via HTTP port scanning.
  */
 export declare function discoverViaHttpScan(options: DiscoveryOptions): Promise<DiscoveredDevice[]>;
 
+/**
+ * Discover devices via ONVIF WS-Discovery (multicast probe on 239.255.255.250:3702).
+ * Most Reolink cameras and NVRs support ONVIF and will respond with their service
+ * endpoint (XAddrs), model, and scopes. This is the standard IP camera discovery
+ * mechanism used by NVRs, VMS, and similar software.
+ */
+export declare function discoverViaOnvif(options: DiscoveryOptions): Promise<DiscoveredDevice[]>;
+
+/**
+ * Discover Reolink devices by scanning TCP port 9000 (Baichuan protocol).
+ * This is the most reliable method — every Reolink camera/NVR listens on port 9000.
+ * It only checks if the port is open; it does not authenticate or extract device info.
+ */
+export declare function discoverViaTcpPortScan(options: DiscoveryOptions): Promise<DiscoveredDevice[]>;
+
 /**
  * Discover devices via UDP broadcast (for battery cameras).
  */
@@ -3692,6 +3704,20 @@ export declare type DiscoveryOptions = {
     enableUdpDiscovery?: boolean;
     /** Whether to enable HTTP port scanning (default: true) */
     enableHttpScanning?: boolean;
+    /** Whether to enable TCP port 9000 scanning (Baichuan protocol). Works with all Reolink devices. (default: false) */
+    enableTcpPortScan?: boolean;
+    /** Timeout per TCP port probe in milliseconds (default: 1500) */
+    tcpProbeTimeoutMs?: number;
+    /** Whether to enable ARP table lookup for Reolink MAC prefix (ec:71:db). Similar to Home Assistant DHCP discovery. (default: false) */
+    enableArpLookup?: boolean;
+    /** Whether to enable passive DHCP listening for Reolink devices (requires root/NET_RAW). (default: false) */
+    enableDhcpListener?: boolean;
+    /** Timeout for DHCP listener in milliseconds (default: 10000) */
+    dhcpListenerTimeoutMs?: number;
+    /** Whether to enable ONVIF WS-Discovery (multicast probe on 239.255.255.250:3702). Most Reolink cameras support ONVIF. (default: false) */
+    enableOnvifDiscovery?: boolean;
+    /** Timeout for ONVIF WS-Discovery in milliseconds (default: 5000) */
+    onvifDiscoveryTimeoutMs?: number;
     /** Ports to scan for HTTP (default: [80, 443]) */
     httpPorts?: number[];
 };
@@ -4031,6 +4057,104 @@ export declare interface GetVodUrlParams {
  */
 export declare function getXmlText(xml: string, tagName: string): string | undefined;
 
+export declare class Go2rtcTcpServer extends EventEmitter<{
+    client: [string];
+    clientDisconnected: [string];
+    error: [Error];
+    close: [];
+    listening: [{
+        host: string;
+        port: number;
+    }];
+}> {
+    private readonly api;
+    private readonly channel;
+    private readonly profile;
+    private readonly variant;
+    private readonly listenHost;
+    private readonly listenPort;
+    private readonly logger;
+    private readonly deviceId;
+    private readonly gracePeriodMs;
+    private readonly prebufferMaxMs;
+    private readonly maxBufferBytes;
+    private readonly prestartStream;
+    private active;
+    private server;
+    private resolvedPort;
+    private nativeFanout;
+    private nativeStreamActive;
+    private dedicatedSessionRelease;
+    private detectedVideoType;
+    private connectedClients;
+    private clientSockets;
+    private stopGraceTimer;
+    private prebuffer;
+    constructor(options: Go2rtcTcpServerOptions);
+    /** Start listening. Resolves once the TCP server is bound. */
+    start(): Promise<void>;
+    /** Stop the server and all active streams. */
+    stop(): Promise<void>;
+    /** The actual port the server is listening on (available after start()). */
+    get port(): number | undefined;
+    /** The go2rtc-compatible source URL. */
+    get go2rtcSourceUrl(): string | undefined;
+    /** Number of currently connected clients. */
+    get clientCount(): number;
+    private handleClient;
+    private feedClient;
+    /**
+     * Convert a native frame to wire-ready Annex-B.
+     * Audio frames are skipped — raw TCP carries only video (Annex-B).
+     * go2rtc auto-detects the codec from SPS/PPS/VPS NALUs.
+     */
+    private convertFrame;
+    /** Check if an Annex-B buffer contains a keyframe (IDR for H.264, IRAP for H.265). */
+    private isAnnexBKeyframe;
+    /** Split Annex-B byte stream into individual NAL units. */
+    private static splitAnnexBNals;
+    private startNativeStream;
+    private stopNativeStream;
+    private removeClient;
+    private scheduleStop;
+}
+
+export declare interface Go2rtcTcpServerOptions {
+    /** API instance (required). */
+    api: ReolinkBaichuanApi;
+    /** Channel number (required). */
+    channel: number;
+    /** Stream profile (required). */
+    profile: StreamProfile;
+    /** TrackMix tele/autotrack variant. */
+    variant?: NativeVideoStreamVariant;
+    /** Host to listen on (default: "127.0.0.1"). */
+    listenHost?: string;
+    /** Port to listen on (default: 0 = OS picks). */
+    listenPort?: number;
+    /** Logger. */
+    logger?: Logger;
+    /**
+     * External identifier for dedicated socket session.
+     * When provided, a dedicated BaichuanClient is created for the stream,
+     * isolating it from other streams on the shared socket.
+     */
+    deviceId?: string;
+    /** Grace period in ms before stopping native stream after last client disconnects (default: 30 000). */
+    gracePeriodMs?: number;
+    /** Maximum prebuffer window in ms (default: 3 000). */
+    prebufferMs?: number;
+    /** Maximum write buffer per client before dropping the connection (default: 100 MB). */
+    maxBufferBytes?: number;
+    /**
+     * When true, the native camera stream is started immediately on start()
+     * rather than waiting for the first TCP client. This ensures frames are
+     * already flowing (and the prebuffer is warm) when go2rtc connects.
+     * Default: true.
+     */
+    prestartStream?: boolean;
+}
+
 /**
  * Depacketizer for H.264 "RTP-like" payloads (RFC 6184) when the camera sends single NAL units,
  * STAP/MTAP aggregation or FU-A/FU-B fragmentation inside a BcMedia frame payload.