@apocaliss92/nodelink-js 0.4.26 → 0.4.28

package/dist/index.js

@@ -13,6 +13,7 @@ import {
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
+  _resetEmailPushBusForTests,
   abilitiesHasAny,
   asLogger,
   autoDetectDeviceType,
@@ -35,6 +36,7 @@ import {
   discoverViaTcpPortScan,
   discoverViaUdpBroadcast,
   discoverViaUdpDirect,
+  emitEmailPushEvent,
   encodeHeader,
   encodeMotionSensitivityListXml,
   encodeShelterCoord,
@@ -43,21 +45,27 @@ import {
   extractCanvasFromShelterXml,
   flattenAbilitiesForChannel,
   getConstructedVideoStreamOptions,
+  getEmailPushCameraResolver,
   getGlobalLogger,
+  getLastEmailPushEvent,
+  getRecentEmailPushEvents,
   getSupportItemForChannel,
   getVideoStream,
   isDualLenseModel,
   isNvrHubModel,
   isTcpFailureThatShouldFallbackToUdp,
+  mapEmailPushInferredType,
   maskUid,
   normalizeUid,
+  onEmailPushEvent,
   parseSupportXml,
   patchAiDetectCfgXml,
   patchMotionSensitivityListXml,
   patchShelterXml,
+  setEmailPushCameraResolver,
   setGlobalLogger,
   xmlIndicatesFloodlight
-} from "./chunk-F3XCYKYT.js";
+} from "./chunk-NQ7D5TLR.js";
 import {
   ReolinkCgiApi,
   ReolinkHttpClient,
@@ -6003,9 +6011,9 @@ var BaichuanMjpegServer = class extends EventEmitter5 {
     this.started = true;
     const port = this.options.port ?? 8080;
     const host = this.options.host ?? "0.0.0.0";
-    const path2 = this.options.path ?? "/mjpeg";
+    const path3 = this.options.path ?? "/mjpeg";
     this.httpServer = http5.createServer((req, res) => {
-      this.handleRequest(req, res, path2);
+      this.handleRequest(req, res, path3);
     });
     return new Promise((resolve, reject) => {
       this.httpServer.on("error", (err) => {
@@ -6015,9 +6023,9 @@ var BaichuanMjpegServer = class extends EventEmitter5 {
       this.httpServer.listen(port, host, () => {
         this.log(
           "info",
-          `MJPEG server started on http://${host}:${port}${path2}`
+          `MJPEG server started on http://${host}:${port}${path3}`
         );
-        this.emit("started", { host, port, path: path2 });
+        this.emit("started", { host, port, path: path3 });
         resolve();
       });
     });
@@ -8274,6 +8282,272 @@ function base64DecodeToBytes(b64) {
   }
   return out.subarray(0, outIdx);
 }
+
+// src/emailPush/server.ts
+import { SMTPServer } from "smtp-server";
+import { simpleParser } from "mailparser";
+
+// src/emailPush/tls.ts
+import fs2 from "fs";
+import path2 from "path";
+async function loadEmailPushTls(params) {
+  const certPath = path2.join(params.dir, "cert.pem");
+  const keyPath = path2.join(params.dir, "key.pem");
+  const warn = params.warn ?? ((m) => console.warn(`[email-push-tls] ${m}`));
+  if (!fs2.existsSync(certPath) || !fs2.existsSync(keyPath)) {
+    warn(
+      `Email-push TLS requested but ${certPath} or ${keyPath} is missing. Place a PEM cert+key under that directory to enable STARTTLS, or disable TLS in the consumer config to silence this warning.`
+    );
+    return void 0;
+  }
+  return {
+    cert: fs2.readFileSync(certPath),
+    key: fs2.readFileSync(keyPath)
+  };
+}
+
+// src/emailPush/server.ts
+async function defaultLoadTls(dir, warn) {
+  return loadEmailPushTls({ dir, warn });
+}
+function classifyMessage(parsed) {
+  const haystack = `${parsed.subject ?? ""} ${parsed.text ?? ""}`.toLowerCase();
+  if (/person|people|human/.test(haystack)) return "people";
+  if (/vehicle|car|truck/.test(haystack)) return "vehicle";
+  if (/dog[_\s-]?cat|pet|animal/.test(haystack)) return "animal";
+  if (/face/.test(haystack)) return "face";
+  if (/package|parcel/.test(haystack)) return "package";
+  if (/doorbell|ring(?:ing)?\s+button/.test(haystack)) return "doorbell";
+  if (/motion|alarm|alert|detect/.test(haystack)) return "motion";
+  return "other";
+}
+function getCameraEmailAddress(cameraId, domain) {
+  return `cam-${cameraId}@${domain}`;
+}
+function createEmailPushServer(params) {
+  const log = {
+    debug: params.logger?.debug ?? (() => {
+    }),
+    info: params.logger?.info ?? (() => {
+    }),
+    warn: params.logger?.warn ?? (() => {
+    }),
+    error: params.logger?.error ?? (() => {
+    })
+  };
+  let config = params.config;
+  let server;
+  let status = buildInitialStatus(config);
+  function parseRecipient(rcpt) {
+    const [local, domain] = rcpt.toLowerCase().split("@");
+    if (!local || !domain) return void 0;
+    return { local, domain };
+  }
+  function resolveCameraIdFromRecipient(rcpt) {
+    const parsed = parseRecipient(rcpt);
+    if (!parsed) return void 0;
+    if (parsed.domain !== config.domain.toLowerCase()) return void 0;
+    const match = parsed.local.match(/^cam-(.+)$/);
+    if (!match || !match[1]) return void 0;
+    return params.cameraResolver(match[1]);
+  }
+  async function handleIncomingMessage(cameraId, recipient, raw) {
+    let parsed;
+    try {
+      parsed = await simpleParser(raw);
+    } catch (err) {
+      log.warn(
+        `Failed to parse mail for ${cameraId}: ${err instanceof Error ? err.message : err}`
+      );
+      status.messagesRejected++;
+      return;
+    }
+    const receivedAtMs = Date.now();
+    const event = {
+      cameraId,
+      recipient,
+      inferredType: classifyMessage(parsed),
+      receivedAtMs,
+      subject: parsed.subject ?? "",
+      from: typeof parsed.from === "object" && parsed.from !== null && "text" in parsed.from ? String(parsed.from.text) : "",
+      bodyExcerpt: (parsed.text ?? "").slice(0, 500)
+    };
+    status.messagesAccepted++;
+    log.info(
+      `Email push for camera=${cameraId} type=${event.inferredType} subject="${event.subject.slice(0, 80)}"`
+    );
+    emitEmailPushEvent(event);
+  }
+  async function start() {
+    if (server) {
+      log.debug("startEmailPushServer called but server already running");
+      return;
+    }
+    const tlsOptions = config.tls ? await (params.loadTls ?? defaultLoadTls)(
+      config.tlsDir ?? "./email-push-tls",
+      (m) => log.warn(m)
+    ) : void 0;
+    status = buildInitialStatus(config);
+    const next = new SMTPServer({
+      authOptional: !config.requireAuth,
+      disabledCommands: config.requireAuth ? [] : ["AUTH"],
+      allowInsecureAuth: !config.tls,
+      size: config.maxMessageBytes,
+      logger: {
+        info: (...args) => log.debug(`[smtp] ${args.map((a) => String(a)).join(" ")}`),
+        debug: (...args) => log.debug(`[smtp] ${args.map((a) => String(a)).join(" ")}`),
+        error: (...args) => log.warn(`[smtp] ${args.map((a) => String(a)).join(" ")}`)
+      },
+      ...tlsOptions ? { secure: false, ...tlsOptions } : {},
+      onConnect(session, callback) {
+        log.info(
+          `SMTP connect from ${session.remoteAddress} (sessionId=${session.id})`
+        );
+        callback();
+      },
+      onClose(session) {
+        log.debug(
+          `SMTP close ${session.remoteAddress} (sessionId=${session.id})`
+        );
+      },
+      onMailFrom(address, session, callback) {
+        log.info(
+          `SMTP MAIL FROM ${address.address} (sessionId=${session.id})`
+        );
+        callback();
+      },
+      onAuth(auth, session, callback) {
+        const expectedUser = config.authUsername;
+        const expectedPass = config.authPassword;
+        if (!expectedUser || !expectedPass) {
+          log.warn(
+            `SMTP AUTH rejected from ${session.remoteAddress} (sessionId=${session.id}): server has no credentials configured`
+          );
+          return callback(new Error("Email push auth not configured"));
+        }
+        const stripDomain = (u) => {
+          const at = u.lastIndexOf("@");
+          if (at < 0) return u;
+          const local = u.slice(0, at);
+          const domain = u.slice(at + 1).toLowerCase();
+          return domain === config.domain.toLowerCase() ? local : u;
+        };
+        const triedUserNorm = stripDomain(auth.username ?? "");
+        const expectedUserNorm = stripDomain(expectedUser);
+        if (triedUserNorm === expectedUserNorm && auth.password === expectedPass) {
+          log.info(
+            `SMTP AUTH ok method=${auth.method} user=${auth.username} (sessionId=${session.id})`
+          );
+          return callback(null, { user: auth.username });
+        }
+        log.warn(
+          `SMTP AUTH FAIL method=${auth.method} from=${session.remoteAddress} triedUser="${auth.username}" expectedUser="${expectedUser}" triedPasswordLen=${auth.password?.length ?? 0} (sessionId=${session.id})`
+        );
+        return callback(new Error("Invalid username or password"));
+      },
+      onRcptTo(address, _session, callback) {
+        const cameraId = resolveCameraIdFromRecipient(address.address);
+        if (!cameraId) {
+          status.messagesRejected++;
+          return callback(
+            new Error(
+              `Unknown recipient ${address.address} (not registered)`
+            )
+          );
+        }
+        callback();
+      },
+      onData(stream, session, callback) {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+          const recipients = session.envelope.rcptTo?.map((r) => r.address) ?? [];
+          const buffer = Buffer.concat(chunks);
+          const matched = recipients.map((r) => ({
+            recipient: r,
+            cameraId: resolveCameraIdFromRecipient(r)
+          })).filter(
+            (m) => Boolean(m.cameraId)
+          );
+          if (matched.length === 0) {
+            status.messagesRejected++;
+            return callback(new Error("No recognised recipients"));
+          }
+          Promise.all(
+            matched.map(
+              (m) => handleIncomingMessage(m.cameraId, m.recipient, buffer)
+            )
+          ).then(() => callback()).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`Email push pipeline error: ${msg}`);
+            status.lastErrorMessage = msg;
+            callback(new Error(msg));
+          });
+        });
+        stream.on("error", (err) => {
+          log.warn(`SMTP stream error: ${err.message}`);
+          callback(err);
+        });
+      }
+    });
+    next.on("error", (err) => {
+      status.lastErrorMessage = err.message;
+      log.error(`Email push server error: ${err.message}`);
+    });
+    await new Promise((resolve, reject) => {
+      next.listen(config.port, config.bindHost, () => {
+        status.running = true;
+        status.startedAtMs = Date.now();
+        log.info(
+          `Email push SMTP listening on ${config.bindHost}:${config.port} (domain=${config.domain}, auth=${config.requireAuth}, tls=${config.tls})`
+        );
+        resolve();
+      });
+      next.once("error", reject);
+    });
+    server = next;
+  }
+  async function stop() {
+    if (!server) return;
+    const active = server;
+    server = void 0;
+    await new Promise((resolve) => {
+      active.close(() => resolve());
+    });
+    status.running = false;
+    log.info("Email push SMTP server stopped");
+  }
+  async function restart() {
+    await stop();
+    await start();
+  }
+  return {
+    start,
+    stop,
+    restart,
+    getStatus() {
+      return { ...status };
+    },
+    updateConfig(next) {
+      config = next;
+    }
+  };
+}
+function buildInitialStatus(config) {
+  return {
+    enabled: true,
+    running: false,
+    port: config.port,
+    bindHost: config.bindHost,
+    domain: config.domain,
+    requireAuth: config.requireAuth,
+    tls: config.tls,
+    messagesAccepted: 0,
+    messagesRejected: 0,
+    startedAtMs: void 0,
+    lastErrorMessage: void 0
+  };
+}
 export {
   AesStreamDecryptor,
   AutodiscoveryClient,
@@ -8446,6 +8720,7 @@ export {
   ReolinkCgiApi,
   ReolinkHttpClient,
   Rfc4571Muxer,
+  _resetEmailPushBusForTests,
   abilitiesHasAny,
   aesDecrypt,
   aesEncrypt,
@@ -8491,6 +8766,7 @@ export {
   createBaichuanEndpointsServer,
   createDebugGateLogger,
   createDiagnosticsBundle,
+  createEmailPushServer,
   createLogger,
   createMjpegBoundary,
   createNativeStream,
@@ -8518,6 +8794,7 @@ export {
   discoverViaTcpPortScan,
   discoverViaUdpBroadcast,
   discoverViaUdpDirect,
+  emitEmailPushEvent,
   encodeHeader,
   encodeMotionScopeBitmap,
   encodeMotionSensitivityListXml,
@@ -8534,10 +8811,14 @@ export {
   flattenAbilitiesForChannel,
   formatMjpegFrame,
   fullCoverageScope,
+  getCameraEmailAddress,
   getConstructedVideoStreamOptions,
+  getEmailPushCameraResolver,
   getGlobalLogger,
   getH265NalType,
+  getLastEmailPushEvent,
   getMjpegContentType,
+  getRecentEmailPushEvents,
   getSupportItemForChannel,
   getVideoStream,
   getVideoclipClientInfo,
@@ -8552,12 +8833,15 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   isValidH264AnnexBAccessUnit,
   isValidH265AnnexBAccessUnit,
+  loadEmailPushTls,
+  mapEmailPushInferredType,
   maskUid,
   md5HexUpper,
   md5StrModern,
   normalizeDayNightMode,
   normalizeOpenClose,
   normalizeUid,
+  onEmailPushEvent,
   packetizeAacAdtsFrame,
   packetizeAacRawFrame,
   packetizeH264,
@@ -8575,6 +8859,7 @@ export {
   runMultifocalDiagnosticsConsecutively,
   sampleStreams,
   sanitizeFixtureData,
+  setEmailPushCameraResolver,
   setGlobalLogger,
   splitAnnexBToNalPayloads,
   splitAnnexBToNals,