@sgintokic/baileys 0.0.2

package/lib/Utils/link-preview.js

@@ -0,0 +1,91 @@
+import { prepareWAMessageMedia } from "./messages.js";
+import { extractImageThumb, getHttpStream } from "./messages-media.js";
+const THUMBNAIL_WIDTH_PX = 192;
+/** Fetches an image and generates a thumbnail for it */ const getCompressedJpegThumbnail =
+  async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+  };
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */ export const getUrlInfo = async (
+  text,
+  opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3e3 } },
+) => {
+  try {
+    // retries
+    const retries = 0;
+    const maxRetry = 5;
+    const { getLinkPreview } = await import("link-preview-js");
+    let previewLink = text;
+    if (!text.startsWith("https://") && !text.startsWith("http://")) {
+      previewLink = "https://" + previewLink;
+    }
+    const info = await getLinkPreview(previewLink, {
+      ...opts.fetchOpts,
+      followRedirects: "follow",
+      handleRedirects: (baseURL, forwardedURL) => {
+        const urlObj = new URL(baseURL);
+        const forwardedURLObj = new URL(forwardedURL);
+        if (retries >= maxRetry) {
+          return false;
+        }
+        if (
+          forwardedURLObj.hostname === urlObj.hostname ||
+          forwardedURLObj.hostname === "www." + urlObj.hostname ||
+          "www." + forwardedURLObj.hostname === urlObj.hostname
+        ) {
+          retries + 1;
+          return true;
+        } else {
+          return false;
+        }
+      },
+      headers: opts.fetchOpts?.headers,
+    });
+    if (info && "title" in info && info.title) {
+      const [image] = info.images;
+      const urlInfo = {
+        "canonical-url": info.url,
+        "matched-text": text,
+        title: info.title,
+        description: info.description,
+        originalThumbnailUrl: image,
+      };
+      if (opts.uploadImage) {
+        const { imageMessage } = await prepareWAMessageMedia(
+          { image: { url: image } },
+          {
+            upload: opts.uploadImage,
+            mediaTypeOverride: "thumbnail-link",
+            options: opts.fetchOpts,
+          },
+        );
+        urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
+          ? Buffer.from(imageMessage.jpegThumbnail)
+          : undefined;
+        urlInfo.highQualityThumbnail = imageMessage || undefined;
+      } else {
+        try {
+          urlInfo.jpegThumbnail = image
+            ? (await getCompressedJpegThumbnail(image, opts)).buffer
+            : undefined;
+        } catch (error) {
+          opts.logger?.debug(
+            { err: error.stack, url: previewLink },
+            "error in generating thumbnail",
+          );
+        }
+      }
+      return urlInfo;
+    }
+  } catch (error) {
+    if (!error.message.includes("receive a valid")) {
+      throw error;
+    }
+  }
+};

package/lib/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from "pino";
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,6 @@
+import { LTHashAntiTampering } from "whatsapp-rust-bridge";
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */ export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/make-mutex.js

@@ -0,0 +1,31 @@
+import { Mutex as AsyncMutex } from "async-mutex";
+export const makeMutex = () => {
+  const mutex = new AsyncMutex();
+  return {
+    mutex(code) {
+      return mutex.runExclusive(code);
+    },
+  };
+};
+export const makeKeyedMutex = () => {
+  const map = new Map();
+  return {
+    async mutex(key, task) {
+      let entry = map.get(key);
+      if (!entry) {
+        entry = { mutex: new AsyncMutex(), refCount: 0 };
+        map.set(key, entry);
+      }
+      entry.refCount++;
+      try {
+        return await entry.mutex.runExclusive(task);
+      } finally {
+        entry.refCount--;
+        // only delete it if this is still the current entry
+        if (entry.refCount === 0 && map.get(key) === entry) {
+          map.delete(key);
+        }
+      }
+    },
+  };
+};

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,240 @@
+import { LRUCache } from "lru-cache";
+/** Number of sent messages to cache in memory for handling retry receipts */ const RECENT_MESSAGES_SIZE = 512;
+const MESSAGE_KEY_SEPARATOR = "\0";
+/** Timeout for session recreation - 1 hour */ const RECREATE_SESSION_TIMEOUT =
+  60 * 60 * 1e3; // 1 hour in milliseconds
+const PHONE_REQUEST_DELAY = 3e3;
+// Retry reason codes matching WhatsApp Web's Signal error codes.
+export var RetryReason;
+(function (RetryReason) {
+  RetryReason[(RetryReason["UnknownError"] = 0)] = "UnknownError";
+  RetryReason[(RetryReason["SignalErrorNoSession"] = 1)] =
+    "SignalErrorNoSession";
+  RetryReason[(RetryReason["SignalErrorInvalidKey"] = 2)] =
+    "SignalErrorInvalidKey";
+  RetryReason[(RetryReason["SignalErrorInvalidKeyId"] = 3)] =
+    "SignalErrorInvalidKeyId";
+  /** MAC verification failed - most common cause of decryption failures */ RetryReason[
+    (RetryReason["SignalErrorInvalidMessage"] = 4)
+  ] = "SignalErrorInvalidMessage";
+  RetryReason[(RetryReason["SignalErrorInvalidSignature"] = 5)] =
+    "SignalErrorInvalidSignature";
+  RetryReason[(RetryReason["SignalErrorFutureMessage"] = 6)] =
+    "SignalErrorFutureMessage";
+  /** Explicit MAC failure - session is definitely out of sync */ RetryReason[
+    (RetryReason["SignalErrorBadMac"] = 7)
+  ] = "SignalErrorBadMac";
+  RetryReason[(RetryReason["SignalErrorInvalidSession"] = 8)] =
+    "SignalErrorInvalidSession";
+  RetryReason[(RetryReason["SignalErrorInvalidMsgKey"] = 9)] =
+    "SignalErrorInvalidMsgKey";
+  RetryReason[(RetryReason["BadBroadcastEphemeralSetting"] = 10)] =
+    "BadBroadcastEphemeralSetting";
+  RetryReason[(RetryReason["UnknownCompanionNoPrekey"] = 11)] =
+    "UnknownCompanionNoPrekey";
+  RetryReason[(RetryReason["AdvFailure"] = 12)] = "AdvFailure";
+  RetryReason[(RetryReason["StatusRevokeDelay"] = 13)] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */ const MAC_ERROR_CODES =
+  new Set([
+    RetryReason.SignalErrorInvalidMessage,
+    RetryReason.SignalErrorBadMac,
+  ]);
+export class MessageRetryManager {
+  constructor(logger, maxMsgRetryCount) {
+    this.logger = logger;
+    this.recentMessagesMap = new LRUCache({
+      max: RECENT_MESSAGES_SIZE,
+      ttl: 5 * 60 * 1e3,
+      ttlAutopurge: true,
+      dispose: (_value, key) => {
+        const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+        if (separatorIndex > -1) {
+          const messageId = key.slice(
+            separatorIndex + MESSAGE_KEY_SEPARATOR.length,
+          );
+          this.messageKeyIndex.delete(messageId);
+        }
+      },
+    });
+    this.messageKeyIndex = new Map();
+    this.sessionRecreateHistory = new LRUCache({
+      ttl: RECREATE_SESSION_TIMEOUT * 2,
+      ttlAutopurge: true,
+    });
+    this.retryCounters = new LRUCache({
+      ttl: 15 * 60 * 1e3,
+      ttlAutopurge: true,
+      updateAgeOnGet: true,
+    }); // 15 minutes TTL
+    this.pendingPhoneRequests = {};
+    this.maxMsgRetryCount = 5;
+    this.statistics = {
+      totalRetries: 0,
+      successfulRetries: 0,
+      failedRetries: 0,
+      mediaRetries: 0,
+      sessionRecreations: 0,
+      phoneRequests: 0,
+    };
+    this.maxMsgRetryCount = maxMsgRetryCount;
+  }
+  /**
+   * Add a recent message to the cache for retry handling
+   */ addRecentMessage(to, id, message) {
+    const key = { to: to, id: id };
+    const keyStr = this.keyToString(key);
+    // Add new message
+    this.recentMessagesMap.set(keyStr, {
+      message: message,
+      timestamp: Date.now(),
+    });
+    this.messageKeyIndex.set(id, keyStr);
+    this.logger.debug(`Added message to retry cache: ${to}/${id}`);
+  }
+  /**
+   * Get a recent message from the cache
+   */ getRecentMessage(to, id) {
+    const key = { to: to, id: id };
+    const keyStr = this.keyToString(key);
+    return this.recentMessagesMap.get(keyStr);
+  }
+  /**
+   * Check if a session should be recreated based on retry count, history, and error code.
+   * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+   */ shouldRecreateSession(jid, hasSession, errorCode) {
+    // If we don't have a session, always recreate
+    if (!hasSession) {
+      this.sessionRecreateHistory.set(jid, Date.now());
+      this.statistics.sessionRecreations++;
+      return {
+        reason: "we don't have a Signal session with them",
+        recreate: true,
+      };
+    }
+    // IMMEDIATE recreation for MAC errors - session is definitely out of sync
+    if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+      this.sessionRecreateHistory.set(jid, Date.now());
+      this.statistics.sessionRecreations++;
+      this.logger.warn(
+        { jid: jid, errorCode: RetryReason[errorCode] },
+        "MAC error detected, forcing immediate session recreation",
+      );
+      return {
+        reason: `MAC error (code ${errorCode}: ${RetryReason[errorCode]}), immediate session recreation`,
+        recreate: true,
+      };
+    }
+    const now = Date.now();
+    const prevTime = this.sessionRecreateHistory.get(jid);
+    // If no previous recreation or it's been more than an hour
+    if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+      this.sessionRecreateHistory.set(jid, now);
+      this.statistics.sessionRecreations++;
+      return {
+        reason: "retry count > 1 and over an hour since last recreation",
+        recreate: true,
+      };
+    }
+    return { reason: "", recreate: false };
+  }
+  /**
+   * Parse error code from retry receipt's retry node.
+   * Returns undefined if no error code is present.
+   */ parseRetryErrorCode(errorAttr) {
+    if (errorAttr === undefined || errorAttr === "") {
+      return undefined;
+    }
+    const code = parseInt(errorAttr, 10);
+    if (Number.isNaN(code)) {
+      return undefined;
+    }
+    // Validate it's a known RetryReason
+    if (
+      code >= RetryReason.UnknownError &&
+      code <= RetryReason.StatusRevokeDelay
+    ) {
+      return code;
+    }
+    return RetryReason.UnknownError;
+  }
+  /**
+   * Check if an error code indicates a MAC failure
+   */ isMacError(errorCode) {
+    return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+  }
+  /**
+   * Increment retry counter for a message
+   */ incrementRetryCount(messageId) {
+    this.retryCounters.set(
+      messageId,
+      (this.retryCounters.get(messageId) || 0) + 1,
+    );
+    this.statistics.totalRetries++;
+    return this.retryCounters.get(messageId);
+  }
+  /**
+   * Get retry count for a message
+   */ getRetryCount(messageId) {
+    return this.retryCounters.get(messageId) || 0;
+  }
+  /**
+   * Check if message has exceeded maximum retry attempts
+   */ hasExceededMaxRetries(messageId) {
+    return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+  }
+  /**
+   * Mark retry as successful
+   */ markRetrySuccess(messageId) {
+    this.statistics.successfulRetries++;
+    // Clean up retry counter for successful message
+    this.retryCounters.delete(messageId);
+    this.cancelPendingPhoneRequest(messageId);
+    this.removeRecentMessage(messageId);
+  }
+  /**
+   * Mark retry as failed
+   */ markRetryFailed(messageId) {
+    this.statistics.failedRetries++;
+    this.retryCounters.delete(messageId);
+    this.cancelPendingPhoneRequest(messageId);
+    this.removeRecentMessage(messageId);
+  }
+  /**
+   * Schedule a phone request with delay
+   */ schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+    // Cancel any existing request for this message
+    this.cancelPendingPhoneRequest(messageId);
+    this.pendingPhoneRequests[messageId] = setTimeout(() => {
+      delete this.pendingPhoneRequests[messageId];
+      this.statistics.phoneRequests++;
+      callback();
+    }, delay);
+    this.logger.debug(
+      `Scheduled phone request for message ${messageId} with ${delay}ms delay`,
+    );
+  }
+  /**
+   * Cancel pending phone request
+   */ cancelPendingPhoneRequest(messageId) {
+    const timeout = this.pendingPhoneRequests[messageId];
+    if (timeout) {
+      clearTimeout(timeout);
+      delete this.pendingPhoneRequests[messageId];
+      this.logger.debug(
+        `Cancelled pending phone request for message ${messageId}`,
+      );
+    }
+  }
+  keyToString(key) {
+    return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+  }
+  removeRecentMessage(messageId) {
+    const keyStr = this.messageKeyIndex.get(messageId);
+    if (!keyStr) {
+      return;
+    }
+    this.recentMessagesMap.delete(keyStr);
+    this.messageKeyIndex.delete(messageId);
+  }
+}