@apocaliss92/nodelink-js 0.4.5 → 0.4.7

package/dist/cli/rtsp-server.js

@@ -3,10 +3,10 @@ import {
   BaichuanRtspServer,
   ReolinkBaichuanApi,
   autoDetectDeviceType
-} from "../chunk-WDFKIHM5.js";
+} from "../chunk-GKLOJJ34.js";
 import {
   __require
-} from "../chunk-DEOMUWBN.js";
+} from "../chunk-TR3V5FTO.js";
 
 // src/cli/rtsp-server.ts
 function parseArgs() {

package/dist/index.cjs

@@ -2178,6 +2178,19 @@ var init_BaichuanVideoStream = __esm({
       // Stateful AES decryptor for fragmented BcMedia packets (full_aes mode)
       // In CFB mode, continuation frames must use the cipher state from previous frames.
       aesStreamDecryptor = null;
+      /**
+       * Pending startup error stashed when emitSafeError is called before any
+       * "error" listener is registered (e.g. camera returns 400 during start()).
+       * The rfc4571-server's waitForKeyframe can consume this immediately instead
+       * of waiting for the full keyframe timeout.
+       */
+      _pendingStartupError;
+      /** Consume and clear any pending startup error. */
+      consumePendingStartupError() {
+        const err = this._pendingStartupError;
+        this._pendingStartupError = void 0;
+        return err;
+      }
       emitSafeError(err) {
         if (!this.active) {
           this.logger?.warn?.(
@@ -2189,6 +2202,7 @@ var init_BaichuanVideoStream = __esm({
           this.logger?.warn?.(
             `[BaichuanVideoStream] Unhandled stream error: ${err.message}`
           );
+          this._pendingStartupError = err;
           return;
         }
         this.emit("error", err);
@@ -8527,6 +8541,9 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
   resendTimer;
   hbTimer;
   discoveryTid;
+  // Track discovery-phase timers so close() can cancel them even if
+  // discovery is still in progress (prevents ERR_SOCKET_DGRAM_NOT_RUNNING).
+  discoveryTimers = [];
   acceptSent = false;
   lastAcceptAtMs;
   ackScheduled = false;
@@ -8575,9 +8592,31 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    await new Promise(
-      (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
-    );
+    const portRange = Array.from({ length: 500 }, (_, i) => 53500 + i);
+    for (let i = portRange.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [portRange[i], portRange[j]] = [portRange[j], portRange[i]];
+    }
+    let bound = false;
+    for (const port of portRange) {
+      try {
+        await new Promise((resolve, reject) => {
+          sock.once("error", reject);
+          sock.bind(port, "0.0.0.0", () => {
+            sock.removeListener("error", reject);
+            resolve();
+          });
+        });
+        bound = true;
+        break;
+      } catch {
+      }
+    }
+    if (!bound) {
+      await new Promise(
+        (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
+      );
+    }
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -8997,7 +9036,24 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
       BCUDP_DISCOVERY_PORT_LOCAL_ANY,
       BCUDP_DISCOVERY_PORT_LOCAL_UID
     ];
-    const broadcastHost = "255.255.255.255";
+    const broadcastHosts = ["255.255.255.255"];
+    const ifaces = (0, import_node_os.networkInterfaces)();
+    for (const name of Object.keys(ifaces)) {
+      const entries = ifaces[name];
+      if (!entries) continue;
+      for (const addr2 of entries) {
+        if (addr2.family === "IPv4" && !addr2.internal && addr2.cidr) {
+          const ipParts = addr2.address.split(".").map(Number);
+          const maskParts = addr2.netmask.split(".").map(Number);
+          if (ipParts.length === 4 && maskParts.length === 4) {
+            const bcast = ipParts.map((octet, i) => octet | ~maskParts[i] & 255).join(".");
+            if (!broadcastHosts.includes(bcast)) {
+              broadcastHosts.push(bcast);
+            }
+          }
+        }
+      }
+    }
     const directHost = (this.opts.directHost ?? "").trim();
     const localMode = opts?.localMode ?? "local-broadcast";
     const directFirstWindowMs = localMode === "local-direct" && directHost ? 3e3 : 0;
@@ -9024,6 +9080,7 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
           )
         );
       }, discoveryTimeout);
+      this.discoveryTimers.push(timeout);
       let retryTimer;
       let retryCount = 0;
       let discoveredSid;
@@ -9200,11 +9257,11 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
             if (directHost) {
               if (directFirstWindowMs > 0 && elapsedMs < directFirstWindowMs)
                 return [directHost];
-              return [directHost, broadcastHost];
+              return [directHost, ...broadcastHosts];
             }
-            return [broadcastHost];
+            return broadcastHosts;
           }
-          return [broadcastHost];
+          return broadcastHosts;
         })();
         for (const host of Array.from(new Set(hosts))) {
           for (const port of ports) {
@@ -9212,8 +9269,7 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
               sock.send(packet, port, host);
               retryCount++;
               this.emit("debug", "discovery_send", { retryCount, host, port });
-            } catch (e) {
-              this.emit("error", e instanceof Error ? e : new Error(String(e)));
+            } catch {
             }
           }
         }
@@ -9222,6 +9278,7 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
       retryTimer = (0, import_node_timers.setInterval)(() => {
         sendDiscovery();
       }, retryInterval);
+      this.discoveryTimers.push(retryTimer);
     });
     this.clientId = reply.cid;
     this.cameraId = reply.did;
@@ -9538,6 +9595,10 @@ var BcUdpStream = class extends import_node_events.EventEmitter {
     this.ackTimer = void 0;
     this.resendTimer = void 0;
     this.hbTimer = void 0;
+    for (const t of this.discoveryTimers) {
+      clearInterval(t);
+    }
+    this.discoveryTimers = [];
     const s = this.sock;
     this.sock = void 0;
     if (!s) return;
@@ -18011,6 +18072,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * - "replay:XXX" - dedicated per replay session
    */
   socketPool = /* @__PURE__ */ new Map();
+  /**
+   * Consecutive stream-start (cmdId=3) timeout counter per socket tag.
+   * When a streaming socket has N consecutive timeouts, the socket is force-closed
+   * so the next attempt creates a fresh connection. Resets on success.
+   */
+  consecutiveStreamTimeouts = /* @__PURE__ */ new Map();
+  static MAX_CONSECUTIVE_STREAM_TIMEOUTS = 3;
   /** BaichuanClientOptions to use when creating new sockets */
   clientOptions;
   /**
@@ -18165,14 +18233,20 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         if (!xml) return;
         const channel = frame.header.channelId;
         const battery = this.parseBatteryInfoXml(xml, channel);
-        if (battery.batteryPercent !== void 0 || battery.chargeStatus !== void 0 || battery.adapterStatus !== void 0) {
-          this.dispatchSimpleEvent({
-            type: "battery",
-            channel,
-            timestamp: Date.now(),
-            battery
-          });
+        if (battery.batteryPercent === void 0 && battery.chargeStatus === void 0 && battery.adapterStatus === void 0) {
+          return;
         }
+        const key = `${battery.batteryPercent ?? ""}|${battery.chargeStatus ?? ""}|${battery.adapterStatus ?? ""}`;
+        if (this.lastBatteryPushKey.get(channel) === key) {
+          return;
+        }
+        this.lastBatteryPushKey.set(channel, key);
+        this.dispatchSimpleEvent({
+          type: "battery",
+          channel,
+          timestamp: Date.now(),
+          battery
+        });
       } catch (e) {
         this.logger.debug?.(
           "[ReolinkBaichuanApi] Error parsing battery push",
@@ -18338,6 +18412,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   deviceCapabilitiesCache = /* @__PURE__ */ new Map();
   static CAPABILITIES_CACHE_TTL_MS = 5 * 60 * 1e3;
   // 5 minutes
+  /**
+   * Dedupe key for battery push events (cmd_id 252), per channel.
+   * Cameras emit BatteryInfoList frequently while streaming (every few
+   * seconds). We only forward an event when the meaningful fields change
+   * (percent, chargeStatus, adapterStatus) to avoid flooding SSE/MQTT
+   * consumers and the UI event log.
+   */
+  lastBatteryPushKey = /* @__PURE__ */ new Map();
   // ─────────────────────────────────────────────────────────────────────────────
   // SOCKET POOL CONSTANTS
   // ─────────────────────────────────────────────────────────────────────────────
@@ -18654,6 +18736,20 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const prefix = basename.substring(0, 10).toUpperCase();
     return prefix.includes("S") ? "subStream" : "mainStream";
   }
+  /**
+   * Stream profiles that the device explicitly rejected (response_code 400).
+   * Keyed by `"ch:profile"` (e.g. `"0:ext"`). Once a profile is in this set
+   * it is excluded from `buildVideoStreamOptions()` results and no further
+   * start attempts are made until the API instance is recreated.
+   */
+  _rejectedStreamProfiles = /* @__PURE__ */ new Set();
+  /**
+   * Check whether a stream profile was rejected by the device at runtime
+   * (e.g. ext returned response_code 400).
+   */
+  isStreamProfileRejected(channel, profile) {
+    return this._rejectedStreamProfiles.has(`${channel}:${profile}`);
+  }
   /**
    * Cache for buildVideoStreamOptions.
    *
@@ -23778,6 +23874,16 @@ ${stderr}`)
         }
         if (!frame) frame = await targetClient.sendFrame(baseParams);
         if (frame.header.responseCode !== 200) {
+          if (frame.header.responseCode === 400) {
+            const rejKey = `${ch}:${profile}`;
+            if (!this._rejectedStreamProfiles.has(rejKey)) {
+              this._rejectedStreamProfiles.add(rejKey);
+              this.videoStreamOptionsCache.clear();
+              this.logger?.warn?.(
+                `[ReolinkBaichuanApi] Stream profile rejected by device: channel=${ch} profile=${profile} (response_code 400). This profile will be excluded from available streams. The camera may not support this stream profile with the current firmware.`
+              );
+            }
+          }
           throw new Error(
             `Video stream request rejected (response_code ${frame.header.responseCode}). Expected response_code 200, camera returned ${frame.header.responseCode}`
           );
@@ -23786,6 +23892,7 @@ ${stderr}`)
           `${ch}:${profile}:${variant}`,
           frame.header.msgNum
         );
+        this.resetStreamTimeoutCounter(targetClient);
         return;
       } catch (error) {
         lastError = error;
@@ -23800,6 +23907,10 @@ ${stderr}`)
         }
       }
     }
+    const isTimeout = lastError instanceof Error && lastError.message?.includes("timeout");
+    if (isTimeout) {
+      this.trackStreamTimeout(targetClient);
+    }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
   /**
@@ -24259,6 +24370,18 @@ ${stderr}`)
   notifyD2cDisc() {
     const now = Date.now();
     this.lastD2cDiscAtMs = now;
+    const streamingTags = Array.from(this.socketPool.keys()).filter(
+      (tag) => tag.startsWith("streaming:")
+    );
+    if (streamingTags.length > 0) {
+      this.logger?.log?.(
+        `[D2C_DISC] Force-closing ${streamingTags.length} streaming socket(s): ${streamingTags.join(", ")}`
+      );
+      for (const tag of streamingTags) {
+        this.forceClosePooledSocket(tag, this.logger).catch(() => {
+        });
+      }
+    }
     const immediateCooldownUntil = now + _ReolinkBaichuanApi.D2C_DISC_IMMEDIATE_COOLDOWN_MS;
     const existing = this.socketPoolCooldowns.get(this.host);
     if (!existing || existing.cooldownUntil < immediateCooldownUntil) {
@@ -24291,6 +24414,43 @@ ${stderr}`)
       }
     }
   }
+  /**
+   * Find the socket pool tag for a given BaichuanClient instance.
+   * Returns undefined if the client is not in the pool (e.g. it's the general socket used directly).
+   */
+  findSocketTagForClient(client) {
+    for (const [tag, entry] of this.socketPool) {
+      if (entry.client === client) return tag;
+    }
+    return void 0;
+  }
+  /**
+   * Reset the consecutive stream-start timeout counter for a streaming socket.
+   * Called on successful stream start.
+   */
+  resetStreamTimeoutCounter(client) {
+    const tag = this.findSocketTagForClient(client);
+    if (tag) this.consecutiveStreamTimeouts.delete(tag);
+  }
+  /**
+   * Track a stream-start timeout on a streaming socket.
+   * After MAX_CONSECUTIVE_STREAM_TIMEOUTS consecutive timeouts, force-close the
+   * socket so the next attempt creates a fresh connection.
+   */
+  trackStreamTimeout(client) {
+    const tag = this.findSocketTagForClient(client);
+    if (!tag || !tag.startsWith("streaming:")) return;
+    const count = (this.consecutiveStreamTimeouts.get(tag) ?? 0) + 1;
+    this.consecutiveStreamTimeouts.set(tag, count);
+    if (count >= _ReolinkBaichuanApi.MAX_CONSECUTIVE_STREAM_TIMEOUTS) {
+      this.logger?.warn?.(
+        `[SocketPool] ${count} consecutive stream timeouts on tag=${tag}, force-closing socket`
+      );
+      this.consecutiveStreamTimeouts.delete(tag);
+      this.forceClosePooledSocket(tag, this.logger).catch(() => {
+      });
+    }
+  }
   /**
    * Best-effort sleeping inference for battery/BCUDP cameras.
    *
@@ -25799,6 +25959,8 @@ ${xml}`
       for (const metadata of params.metadatas) {
         const profile = metadata.profile;
         if (isMultiFocal && profile === "ext") continue;
+        if (this._rejectedStreamProfiles.has(`${params.channel}:${profile}`))
+          continue;
         if (params.includeRtsp && profile !== "ext") {
           const streamName = profile === "main" ? "main" : "sub";
           pushRtsp({
@@ -32289,6 +32451,11 @@ async function createRfc4571TcpServerInternal(options) {
           "videoAccessUnit",
           onAu
         );
+        const pendingErr = videoStream.consumePendingStartupError?.();
+        if (pendingErr) {
+          cleanup();
+          reject(pendingErr);
+        }
       });
     }
   };
@@ -32300,24 +32467,32 @@ async function createRfc4571TcpServerInternal(options) {
       await videoStream.stop();
     } catch {
     }
-    if (closeApiOnTeardown) {
-      await Promise.allSettled(
-        Array.from(apisToClose).map(async (a) => {
+    if (dedicatedSession) {
+      try {
+        await dedicatedSession.release();
+      } catch {
+      }
+    }
+    if (!dedicatedSession) {
+      if (closeApiOnTeardown) {
+        await Promise.allSettled(
+          Array.from(apisToClose).map(async (a) => {
+            try {
+              await a.close();
+            } catch {
+            }
+          })
+        );
+      } else {
+        const graceMs = isComposite ? 5e3 : 0;
+        for (const a of Array.from(apisToClose)) {
           try {
-            await a.close();
+            a?.client?.requestIdleDisconnectSoon?.(
+              "rfc4571_teardown",
+              graceMs
+            );
           } catch {
           }
-        })
-      );
-    } else {
-      const graceMs = isComposite ? 5e3 : 0;
-      for (const a of Array.from(apisToClose)) {
-        try {
-          a?.client?.requestIdleDisconnectSoon?.(
-            "rfc4571_teardown",
-            graceMs
-          );
-        } catch {
         }
       }
     }
@@ -32573,7 +32748,7 @@ async function createRfc4571TcpServerInternal(options) {
       } catch {
       }
     }
-    if (closeApiOnTeardown) {
+    if (closeApiOnTeardown && !dedicatedSession) {
       await Promise.allSettled(
         Array.from(apisToClose).map(async (a) => {
           try {
@@ -33540,6 +33715,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   gracePeriodMs;
   prebufferMaxMs;
   maxBufferBytes;
+  streamTimeoutMs;
   prestartStream;
   active = false;
   server;
@@ -33553,6 +33729,11 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   connectedClients = /* @__PURE__ */ new Set();
   clientSockets = /* @__PURE__ */ new Map();
   stopGraceTimer;
+  // Stream health monitoring
+  lastFrameAt = 0;
+  streamHealthTimer;
+  totalFramesReceived = 0;
+  totalVideoFramesWritten = 0;
   // Prebuffer
   prebuffer = [];
   constructor(options) {
@@ -33568,6 +33749,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     this.gracePeriodMs = options.gracePeriodMs ?? 3e4;
     this.prebufferMaxMs = options.prebufferMs ?? 3e3;
     this.maxBufferBytes = options.maxBufferBytes ?? 1e8;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 15e3;
     this.prestartStream = options.prestartStream ?? true;
   }
   // -----------------------------------------------------------------------
@@ -33606,6 +33788,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     if (!this.active) return;
     this.active = false;
     clearTimeout(this.stopGraceTimer);
+    this.stopStreamHealthMonitor();
     for (const [id, sock] of this.clientSockets) {
       sock.destroy();
       this.connectedClients.delete(id);
@@ -33659,12 +33842,12 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         `[Go2rtcTcpServer] feedClient error  id=${clientId}: ${err}`
       );
     });
-    const cleanup = () => {
-      this.removeClient(clientId);
+    const cleanup = (reason) => {
+      this.removeClient(clientId, reason);
       socket.destroy();
     };
-    socket.on("error", cleanup);
-    socket.on("close", cleanup);
+    socket.on("error", (err) => cleanup(`error: ${err.message}`));
+    socket.on("close", (hadError) => cleanup(hadError ? "close (with error)" : "close (clean)"));
   }
   async feedClient(clientId, socket) {
     const fanoutDeadline = Date.now() + 3e4;
@@ -33725,6 +33908,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         }
         socket.write(annexB);
         liveVideoWritten++;
+        this.totalVideoFramesWritten++;
         if (Date.now() - lastLogAt > 1e4) {
           this.logger.info?.(
             `[Go2rtcTcpServer] live stats  client=${clientId} received=${liveFrameCount} written=${liveVideoWritten} bufLen=${socket.writableLength}`
@@ -33851,6 +34035,8 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         ...dedicatedClient ? { client: dedicatedClient } : {}
       }),
       onFrame: (frame) => {
+        this.lastFrameAt = Date.now();
+        this.totalFramesReceived++;
         if (!frame.audio && (frame.videoType === "H264" || frame.videoType === "H265")) {
           this.detectedVideoType = frame.videoType;
         }
@@ -33877,6 +34063,12 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
         this.nativeFanout = null;
+        this.stopStreamHealthMonitor();
+        const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+        const diagnosis = silenceMs > this.streamTimeoutMs ? "camera stopped sending frames" : silenceMs >= 0 ? "stream source closed" : "no frames were ever received";
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] native stream ended  diagnosis="${diagnosis}" lastFrame=${silenceMs >= 0 ? `${(silenceMs / 1e3).toFixed(1)}s ago` : "never"} totalRx=${this.totalFramesReceived} clients=${this.connectedClients.size}`
+        );
         if (this.dedicatedSessionRelease) {
           this.dedicatedSessionRelease().catch(() => {
           });
@@ -33884,16 +34076,18 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         }
         if (this.active && (this.connectedClients.size > 0 || this.prestartStream)) {
           this.logger.info?.(
-            `[Go2rtcTcpServer] native stream ended, restarting (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
+            `[Go2rtcTcpServer] restarting native stream (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
           );
           this.startNativeStream();
         }
       }
     });
     this.nativeFanout.start();
+    this.startStreamHealthMonitor();
   }
   async stopNativeStream() {
     this.nativeStreamActive = false;
+    this.stopStreamHealthMonitor();
     const fanout = this.nativeFanout;
     this.nativeFanout = null;
     if (fanout) {
@@ -33907,14 +34101,50 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     }
   }
   // -----------------------------------------------------------------------
+  // Stream health monitoring
+  // -----------------------------------------------------------------------
+  startStreamHealthMonitor() {
+    this.stopStreamHealthMonitor();
+    if (this.streamTimeoutMs <= 0) return;
+    this.lastFrameAt = Date.now();
+    this.streamHealthTimer = setInterval(() => {
+      if (!this.nativeStreamActive || !this.active) {
+        this.stopStreamHealthMonitor();
+        return;
+      }
+      const silenceMs = Date.now() - this.lastFrameAt;
+      if (silenceMs > this.streamTimeoutMs) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] stream inactivity timeout: no frames for ${(silenceMs / 1e3).toFixed(1)}s (threshold=${this.streamTimeoutMs}ms), totalReceived=${this.totalFramesReceived} clients=${this.connectedClients.size} \u2014 forcing stream restart`
+        );
+        this.stopStreamHealthMonitor();
+        const fanout = this.nativeFanout;
+        if (fanout) {
+          this.nativeStreamActive = false;
+          this.nativeFanout = null;
+          fanout.stop().catch(() => {
+          });
+        }
+      }
+    }, Math.min(this.streamTimeoutMs / 2, 5e3));
+  }
+  stopStreamHealthMonitor() {
+    if (this.streamHealthTimer) {
+      clearInterval(this.streamHealthTimer);
+      this.streamHealthTimer = void 0;
+    }
+  }
+  // -----------------------------------------------------------------------
   // Client lifecycle
   // -----------------------------------------------------------------------
-  removeClient(clientId) {
+  removeClient(clientId, reason) {
     if (!this.connectedClients.has(clientId)) return;
     this.connectedClients.delete(clientId);
     this.clientSockets.delete(clientId);
+    const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+    const silenceInfo = silenceMs >= 0 ? ` lastFrame=${(silenceMs / 1e3).toFixed(1)}s ago` : "";
     this.logger.info?.(
-      `[Go2rtcTcpServer] client disconnected  id=${clientId} remaining=${this.connectedClients.size}`
+      `[Go2rtcTcpServer] client disconnected  id=${clientId} reason=${reason ?? "unknown"}  remaining=${this.connectedClients.size}  totalRx=${this.totalFramesReceived} totalTx=${this.totalVideoFramesWritten}${silenceInfo}`
     );
     this.emit("clientDisconnected", clientId);
     if (this.connectedClients.size === 0 && !this.prestartStream) {
@@ -36249,16 +36479,16 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
   return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("socket hang up") || message.includes("TCP connection timeout") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
 }
 async function pingHost(host, timeoutMs = 3e3) {
+  const { exec } = await import("child_process");
+  const platform2 = process.platform;
+  const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "darwin" ? (
+    // macOS: -W is in milliseconds (Linux: seconds)
+    `ping -c 1 -W ${timeoutMs} ${host}`
+  ) : (
+    // Linux/BSD-ish: -W is in seconds on most distros
+    `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
+  );
   return new Promise((resolve) => {
-    const { exec } = require("child_process");
-    const platform2 = process.platform;
-    const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "darwin" ? (
-      // macOS: -W is in milliseconds (Linux: seconds)
-      `ping -c 1 -W ${timeoutMs} ${host}`
-    ) : (
-      // Linux/BSD-ish: -W is in seconds on most distros
-      `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
-    );
     exec(pingCmd, (error) => {
       resolve(!error);
     });