@apocaliss92/nodelink-js 0.3.5 → 0.4.1

package/dist/cli/rtsp-server.cjs

@@ -4912,15 +4912,18 @@ var init_zip = __esm({
 // src/debug/DiagnosticsTools.ts
 var DiagnosticsTools_exports = {};
 __export(DiagnosticsTools_exports, {
+  captureModelFixtures: () => captureModelFixtures,
   collectCgiDiagnostics: () => collectCgiDiagnostics,
   collectMultifocalDiagnostics: () => collectMultifocalDiagnostics,
   collectNativeDiagnostics: () => collectNativeDiagnostics,
   collectNvrDiagnostics: () => collectNvrDiagnostics,
+  computeExpectedStreamCompatibility: () => computeExpectedStreamCompatibility,
   createDiagnosticsBundle: () => createDiagnosticsBundle,
   printNvrDiagnostics: () => printNvrDiagnostics,
   runAllDiagnosticsConsecutively: () => runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively: () => runMultifocalDiagnosticsConsecutively,
   sampleStreams: () => sampleStreams,
+  sanitizeFixtureData: () => sanitizeFixtureData,
   testChannelStreams: () => testChannelStreams
 });
 function safeStringifyError(error) {
@@ -4945,6 +4948,10 @@ function writeJson(filePath, obj) {
   mkdirp(path4.dirname(filePath));
   fs4.writeFileSync(filePath, JSON.stringify(obj, null, 2));
 }
+function writeText(filePath, text) {
+  mkdirp(path4.dirname(filePath));
+  fs4.writeFileSync(filePath, text);
+}
 function appendNdjson(filePath, obj) {
   mkdirp(path4.dirname(filePath));
   fs4.appendFileSync(filePath, JSON.stringify(obj) + "\n");
@@ -7208,7 +7215,411 @@ async function runAllDiagnosticsConsecutively(params) {
     streamsDir
   };
 }
-var fs4, path4, import_node_child_process2, import_node_path;
+function maskIp(ip) {
+  const parts = ip.split(".");
+  return `${parts[0]}.***.***.***`;
+}
+function maskMac(mac) {
+  const sep = mac.includes("-") ? "-" : ":";
+  const parts = mac.split(/[:-]/);
+  return `${parts[0]}${sep}${parts[1]}${sep}**${sep}**${sep}**${sep}**`;
+}
+function maskSerial(val) {
+  if (val.length <= 4) return "****";
+  return val.slice(0, 2) + "*".repeat(val.length - 4) + val.slice(-2);
+}
+function sanitizeString(s) {
+  let out = s;
+  out = out.replace(/:\/\/([^:@]+):([^@]+)@/g, "://***:***@");
+  out = out.replace(/(password=)[^&\s]*/gi, "$1***");
+  out = out.replace(/(user=)[^&\s]*/gi, "$1***");
+  out = out.replace(IPV4_RE, (match) => maskIp(match));
+  out = out.replace(MAC_RE, (match) => maskMac(match));
+  return out;
+}
+function sanitizeFixtureData(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    return sanitizeString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(sanitizeFixtureData);
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const kLower = k.toLowerCase();
+      if (REDACT_KEYS.has(kLower)) {
+        out[k] = "***";
+      } else if (MASK_KEYS.has(kLower) || kLower === "serialnumber") {
+        out[k] = typeof v === "string" ? maskSerial(v) : "***";
+      } else if (kLower === "mac") {
+        out[k] = typeof v === "string" ? maskMac(v) : "***";
+      } else if (kLower === "ip" || kLower === "ipaddress" || kLower === "host") {
+        out[k] = typeof v === "string" ? maskIp(v) : v;
+      } else if (kLower === "name" && typeof v === "string" && k !== "name") {
+        out[k] = v;
+      } else {
+        out[k] = sanitizeFixtureData(v);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function computeExpectedStreamCompatibility(params) {
+  const { channelCount } = params;
+  const profiles = params.profiles ?? ["main", "sub", "ext"];
+  const expectedStreamType = { main: 0, sub: 1, ext: 0 };
+  const allStreams = [];
+  for (let ch = 0; ch < channelCount; ch++) {
+    for (const p of profiles) {
+      allStreams.push({ ch, profile: p, label: channelCount > 1 ? `ch${ch}_${p}` : p });
+    }
+  }
+  const results = [];
+  for (let i = 0; i < allStreams.length; i++) {
+    for (let j = i + 1; j < allStreams.length; j++) {
+      const a = allStreams[i];
+      const b = allStreams[j];
+      const stA = expectedStreamType[a.profile] ?? 0;
+      const stB = expectedStreamType[b.profile] ?? 0;
+      const sameChannel = a.ch === b.ch;
+      let expectedOk;
+      let reason;
+      if (sameChannel && stA === stB) {
+        expectedOk = false;
+        reason = `same streamType (${stA}) on same channel`;
+      } else if (!sameChannel && a.profile === b.profile) {
+        expectedOk = false;
+        reason = `multifocal rejects same profile (${a.profile}) across channels`;
+      } else if (!sameChannel && stA === stB) {
+        expectedOk = false;
+        reason = `same streamType (${stA}) across channels`;
+      } else {
+        expectedOk = true;
+        reason = `different streamTypes (${stA} vs ${stB})`;
+      }
+      results.push({ pair: [a.label, b.label], expectedOk, reason });
+    }
+  }
+  return results;
+}
+async function captureModelFixtures(params) {
+  const { api, channel, outDir } = params;
+  const log = params.log ?? console.log;
+  mkdirp(outDir);
+  const writeJsonSafe = (filePath, data) => writeJson(filePath, sanitizeFixtureData(data));
+  const writeTextSafe = (filePath, text) => writeText(filePath, sanitizeString(text));
+  const calls = {};
+  const errors = [];
+  async function capture(name, fn, writer) {
+    try {
+      const value = await fn();
+      calls[name] = { ok: true, value };
+      if (writer && value !== void 0 && value !== null) {
+        writer(value);
+      }
+      log(`  \u2713 ${name}`);
+      return value;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      calls[name] = { ok: false, error: msg };
+      errors.push(`${name}: ${msg}`);
+      log(`  \u2717 ${name}: ${msg}`);
+      return void 0;
+    }
+  }
+  const info = await capture(
+    "getInfo",
+    () => api.getInfo(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "device-info.json"), v)
+  );
+  const support = await capture(
+    "getSupportInfo",
+    () => api.getSupportInfo(),
+    (v) => writeJsonSafe(path4.join(outDir, "support-info.json"), v)
+  );
+  const abilities = await capture(
+    "getAbilityInfo",
+    () => api.getAbilityInfo(),
+    (v) => writeJsonSafe(path4.join(outDir, "ability-info.json"), v)
+  );
+  await capture(
+    "getDeviceCapabilities",
+    () => api.getDeviceCapabilities(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "capabilities.json"), v)
+  );
+  await capture("cmd289-WhiteLed", () => api.sendXml({
+    cmdId: BC_CMD_ID_GET_WHITE_LED,
+    channel,
+    timeoutMs: 3e3
+  }), (v) => writeTextSafe(path4.join(outDir, "cmd289-white-led.xml"), v));
+  await capture(
+    "getStreamMetadata",
+    () => api.getStreamMetadata(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "stream-metadata.json"), v)
+  );
+  await capture(
+    "getEncXml",
+    () => api.getEncXml(channel),
+    (v) => writeTextSafe(path4.join(outDir, "enc-config.xml"), v)
+  );
+  await capture(
+    "getPorts",
+    () => api.getPorts(),
+    (v) => writeJsonSafe(path4.join(outDir, "ports.json"), v)
+  );
+  await capture(
+    "getTalkAbility",
+    () => api.getTalkAbility(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "talk-ability.json"), v)
+  );
+  await capture(
+    "getTwoWayAudioConfig",
+    () => api.getTwoWayAudioConfig(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "two-way-audio-config.json"), v)
+  );
+  await capture(
+    "getAiState",
+    () => api.getAiState(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "ai-state.json"), v)
+  );
+  await capture(
+    "getAiCfg",
+    () => api.getAiCfg(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "ai-cfg.json"), v)
+  );
+  await capture(
+    "getOsd",
+    () => api.getOsd(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "osd.json"), v)
+  );
+  await capture(
+    "getMotionAlarm",
+    () => api.getMotionAlarm(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "motion-alarm.json"), v)
+  );
+  await capture(
+    "getRecordCfg",
+    () => api.getRecordCfg(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "record-cfg.json"), v)
+  );
+  await capture(
+    "getVideoInput",
+    () => api.getVideoInput(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "video-input.json"), v)
+  );
+  await capture(
+    "getPtzPresets",
+    () => api.getPtzPresets(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "ptz-presets.json"), v)
+  );
+  await capture(
+    "getNetworkInfo",
+    () => api.getNetworkInfo(),
+    (v) => writeJsonSafe(path4.join(outDir, "network-info.json"), v)
+  );
+  await capture(
+    "getSystemGeneral",
+    () => api.getSystemGeneral(),
+    (v) => writeJsonSafe(path4.join(outDir, "system-general.json"), v)
+  );
+  await capture(
+    "getWifiSignal",
+    () => api.getWifiSignal(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "wifi-signal.json"), v)
+  );
+  await capture(
+    "getWhiteLedState",
+    () => api.getWhiteLedState(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "white-led-state.json"), v)
+  );
+  await capture(
+    "getFloodlightOnMotion",
+    () => api.getFloodlightOnMotion(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "floodlight-on-motion.json"), v)
+  );
+  await capture(
+    "buildVideoStreamOptions",
+    () => api.buildVideoStreamOptions({ channel }),
+    (v) => writeJsonSafe(path4.join(outDir, "video-stream-options.json"), v)
+  );
+  await capture(
+    "getDualLensChannelInfo",
+    () => api.getDualLensChannelInfo(channel),
+    (v) => writeJsonSafe(path4.join(outDir, "dual-lens-info.json"), v)
+  );
+  await capture("streamCombinationTest", async () => {
+    let dualLensInfo;
+    try {
+      dualLensInfo = await api.getDualLensChannelInfo(channel);
+    } catch {
+    }
+    const isMultifocal = dualLensInfo?.isDualLens === true;
+    const channelCount = dualLensInfo?.streamChannelCount ?? 1;
+    const allStreams = [];
+    const profiles = ["main", "sub", "ext"];
+    for (let ch = 0; ch < channelCount; ch++) {
+      for (const p of profiles) {
+        const label = channelCount > 1 ? `ch${ch}_${p}` : p;
+        allStreams.push({ ch, profile: p, label });
+      }
+    }
+    const pairs = [];
+    for (let i = 0; i < allStreams.length; i++) {
+      for (let j = i + 1; j < allStreams.length; j++) {
+        pairs.push([allStreams[i], allStreams[j]]);
+      }
+    }
+    const expectedStreamType = { main: 0, sub: 1, ext: 0 };
+    const expectedCompat = [];
+    for (const [a, b] of pairs) {
+      const stA = expectedStreamType[a.profile];
+      const stB = expectedStreamType[b.profile];
+      const sameChannel = a.ch === b.ch;
+      let expectedOk;
+      let reason;
+      if (sameChannel && stA === stB) {
+        expectedOk = false;
+        reason = `same streamType (${stA}) on same channel`;
+      } else if (!sameChannel && a.profile === b.profile) {
+        expectedOk = false;
+        reason = `multifocal rejects same profile (${a.profile}) across channels`;
+      } else if (!sameChannel && stA === stB) {
+        expectedOk = false;
+        reason = `same streamType (${stA}) across channels`;
+      } else {
+        expectedOk = true;
+        reason = `different streamTypes (${stA} vs ${stB})`;
+      }
+      expectedCompat.push({ pair: [a.label, b.label], expectedOk, reason });
+    }
+    const results = [];
+    const TEST_DURATION_MS = 4e3;
+    for (let pairIdx = 0; pairIdx < pairs.length; pairIdx++) {
+      const [a, b] = pairs[pairIdx];
+      const expected = expectedCompat[pairIdx];
+      log(`    testing ${a.label}+${b.label} on shared socket...`);
+      let session;
+      try {
+        session = await api.createDedicatedSession(
+          `test:combo:${a.label}_${b.label}`
+        );
+      } catch (e) {
+        const result2 = {
+          pair: [a.label, b.label],
+          ok: false,
+          framesA: 0,
+          framesB: 0,
+          mismatches: 0,
+          error: `session: ${e instanceof Error ? e.message : String(e)}`,
+          durationMs: 0,
+          expectedOk: expected.expectedOk,
+          expectedReason: expected.reason,
+          matchesExpected: !expected.expectedOk
+          // failed as expected if we expected failure
+        };
+        results.push(result2);
+        continue;
+      }
+      const testClient = session.client;
+      let framesA = 0;
+      let framesB = 0;
+      let mismatches = 0;
+      const start = Date.now();
+      const stTypes = {
+        main: /* @__PURE__ */ new Set([0, 2]),
+        sub: /* @__PURE__ */ new Set([1, 3]),
+        ext: /* @__PURE__ */ new Set([0, 2])
+      };
+      const setA = stTypes[a.profile];
+      const setB = stTypes[b.profile];
+      const onFrame = (frame) => {
+        if (frame.header?.cmdId !== BC_CMD_ID_VIDEO) return;
+        const st = frame.header.streamType;
+        if (setA.has(st)) framesA++;
+        else if (setB.has(st)) framesB++;
+        else mismatches++;
+      };
+      testClient.on("frame", onFrame);
+      let error;
+      try {
+        await api.startVideoStream(a.ch, a.profile, { client: testClient });
+        await api.startVideoStream(b.ch, b.profile, { client: testClient });
+        await new Promise((r) => setTimeout(r, TEST_DURATION_MS));
+        await api.stopVideoStream(a.ch, a.profile, { client: testClient }).catch(() => {
+        });
+        await api.stopVideoStream(b.ch, b.profile, { client: testClient }).catch(() => {
+        });
+      } catch (e) {
+        error = e instanceof Error ? e.message : String(e);
+      } finally {
+        testClient.removeListener("frame", onFrame);
+        await session.release().catch(() => {
+        });
+      }
+      const elapsed = Date.now() - start;
+      const ok2 = !error && framesA > 0 && framesB > 0 && mismatches === 0;
+      const result = {
+        pair: [a.label, b.label],
+        ok: ok2,
+        framesA,
+        framesB,
+        mismatches,
+        ...error ? { error } : {},
+        durationMs: elapsed,
+        expectedOk: expected.expectedOk,
+        expectedReason: expected.reason,
+        matchesExpected: ok2 === expected.expectedOk
+      };
+      results.push(result);
+      const matchStr = result.matchesExpected ? "" : " *** UNEXPECTED ***";
+      log(`    ${a.label}+${b.label}: ${ok2 ? "OK" : "FAIL"} (expected=${expected.expectedOk ? "OK" : "FAIL"}) A=${framesA} B=${framesB} mismatch=${mismatches}${matchStr}`);
+    }
+    const unexpected = results.filter((r) => !r.matchesExpected);
+    return {
+      isMultifocal,
+      channelCount,
+      results,
+      summary: {
+        total: results.length,
+        ok: results.filter((r) => r.ok).length,
+        failed: results.filter((r) => !r.ok).length,
+        matchesExpected: results.filter((r) => r.matchesExpected).length,
+        unexpected: unexpected.map((r) => `${r.pair[0]}+${r.pair[1]}: got ${r.ok ? "OK" : "FAIL"}, expected ${r.expectedOk ? "OK" : "FAIL"}`)
+      }
+    };
+  }, (v) => writeJsonSafe(path4.join(outDir, "stream-combination-test.json"), v));
+  const total = Object.keys(calls).length;
+  const ok = Object.values(calls).filter((c) => c.ok).length;
+  const failed = total - ok;
+  const summary = { total, ok, failed, errors };
+  writeJsonSafe(path4.join(outDir, "_summary.json"), {
+    collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    model: info?.type ?? "unknown",
+    itemNo: info?.itemNo ?? "unknown",
+    firmwareVersion: info?.firmwareVersion ?? "unknown",
+    channel,
+    ...summary,
+    calls: Object.fromEntries(
+      Object.entries(calls).map(([k, v]) => [
+        k,
+        v.ok ? "ok" : `FAILED: ${v.error}`
+      ])
+    )
+  });
+  log(`
+  Summary: ${ok}/${total} ok, ${failed} failed`);
+  if (errors.length) {
+    log(`  Errors:`);
+    for (const err of errors) {
+      log(`    - ${err}`);
+    }
+  }
+  return { calls, outDir, summary };
+}
+var fs4, path4, import_node_child_process2, import_node_path, REDACT_KEYS, MASK_KEYS, IPV4_RE, MAC_RE;
 var init_DiagnosticsTools = __esm({
   "src/debug/DiagnosticsTools.ts"() {
     "use strict";
@@ -7224,6 +7635,27 @@ var init_DiagnosticsTools = __esm({
     init_H265Converter();
     init_constants();
     init_xml();
+    REDACT_KEYS = /* @__PURE__ */ new Set([
+      "password",
+      "pass",
+      "token",
+      "secret",
+      "apiKey",
+      "api_key"
+    ]);
+    MASK_KEYS = /* @__PURE__ */ new Set([
+      "serialNumber",
+      "serial",
+      "uid",
+      "mac",
+      "ssid",
+      "wifiPassword",
+      "userName",
+      "username",
+      "user"
+    ]);
+    IPV4_RE = /\b(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\b/g;
+    MAC_RE = /\b([0-9a-fA-F]{2}[:-]){5}[0-9a-fA-F]{2}\b/g;
   }
 });
 
@@ -14680,7 +15112,7 @@ function computeDeviceCapabilities(params) {
   const ptzControlRaw = supportItem ? supportItem.ptzControl : void 0;
   const supportExplicitlyDefinesPtz = ptzTypeRaw !== void 0 || ptzControlRaw !== void 0;
   const ptzExplicitlyDisabledBySupportItem = supportExplicitlyDefinesPtz && !isTruthyNumberLike(ptzTypeRaw) && !isTruthyNumberLike(ptzControlRaw);
-  const hasPtzFromSupportItem = isTruthyNumberLike(ptzTypeRaw) || isTruthyNumberLike(ptzControlRaw) || isTruthyNumberLike(supportItem?.ptzPreset);
+  const hasPtzFromSupportItem = isTruthyNumberLike(ptzTypeRaw);
   const ptzDisabledBySupport = (ptzMode === "none" || ptzMode === "0") && !hasPtzFromSupportItem;
   const hasBatteryFromSupport = supportItem ? isTruthyNumberLike(supportItem.battery) : false;
   const ptzPresetRaw = supportItem ? supportItem.ptzPreset : void 0;
@@ -14744,6 +15176,17 @@ function computeDeviceCapabilities(params) {
   if (ptzMode !== void 0) result.ptzMode = ptzMode;
   return result;
 }
+function xmlIndicatesFloodlight(xml) {
+  if (/(<FloodlightTask\b|<FloodlightManual\b|<FloodlightStatusList\b)/i.test(
+    xml
+  )) {
+    return true;
+  }
+  if (/<WhiteLed\b/i.test(xml)) {
+    return /(<brightness_cur>|<bright>|<LightingSchedule\b)/i.test(xml);
+  }
+  return false;
+}
 
 // src/reolink/baichuan/utils/abilityInfo.ts
 init_xml();
@@ -23780,9 +24223,7 @@ ${stderr}`)
         `probeFloodlightSupportByCmd289: received XML for channel ${ch}:
 ${xml}`
       );
-      return /(<FloodlightTask\b|<FloodlightManual\b|<FloodlightStatusList\b|<WhiteLed\b)/i.test(
-        xml
-      );
+      return xmlIndicatesFloodlight(xml);
     } catch {
       return false;
     }