@sgintokic/baileys 0.0.2

package/lib/Utils/use-multi-file-auth-state.js

@@ -0,0 +1,116 @@
+import { Mutex } from "async-mutex";
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+import { proto } from "../../WAProto/index.js";
+import { initAuthCreds } from "./auth-utils.js";
+import { BufferJSON } from "./generics.js";
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map();
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+  let mutex = fileLocks.get(path);
+  if (!mutex) {
+    mutex = new Mutex();
+    fileLocks.set(path, mutex);
+  }
+  return mutex;
+};
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */ export const useMultiFileAuthState = async (folder) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const writeData = async (data, file) => {
+    const filePath = join(folder, fixFileName(file));
+    const mutex = getFileLock(filePath);
+    return mutex.acquire().then(async (release) => {
+      try {
+        await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+      } finally {
+        release();
+      }
+    });
+  };
+  const readData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return await mutex.acquire().then(async (release) => {
+        try {
+          const data = await readFile(filePath, { encoding: "utf-8" });
+          return JSON.parse(data, BufferJSON.reviver);
+        } finally {
+          release();
+        }
+      });
+    } catch (error) {
+      return null;
+    }
+  };
+  const removeData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return mutex.acquire().then(async (release) => {
+        try {
+          await unlink(filePath);
+        } catch {
+        } finally {
+          release();
+        }
+      });
+    } catch {}
+  };
+  const folderInfo = await stat(folder).catch(() => {});
+  if (folderInfo) {
+    if (!folderInfo.isDirectory()) {
+      throw new Error(
+        `found something that is not a directory at ${folder}, either delete it or specify a different location`,
+      );
+    }
+  } else {
+    await mkdir(folder, { recursive: true });
+  }
+  const fixFileName = (file) => file?.replace(/\//g, "__")?.replace(/:/g, "-");
+  const creds = (await readData("creds.json")) || initAuthCreds();
+  return {
+    state: {
+      creds: creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(
+            ids.map(async (id) => {
+              let value = await readData(`${type}-${id}.json`);
+              if (type === "app-state-sync-key" && value) {
+                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+              }
+              data[id] = value;
+            }),
+          );
+          return data;
+        },
+        set: async (data) => {
+          const tasks = [];
+          for (const category in data) {
+            for (const id in data[category]) {
+              const value = data[category][id];
+              const file = `${category}-${id}.json`;
+              tasks.push(value ? writeData(value, file) : removeData(file));
+            }
+          }
+          await Promise.all(tasks);
+        },
+      },
+    },
+    saveCreds: async () => {
+      return writeData(creds, "creds.json");
+    },
+  };
+};

package/lib/Utils/use-single-file-auth-state.js

@@ -0,0 +1,94 @@
+import { readFile, rename, stat, writeFile } from "fs/promises";
+import { DEFAULT_CACHE_TTLS } from "../Defaults/index.js";
+import { proto } from "../../WAProto/index.js";
+import { initAuthCreds } from "./auth-utils.js";
+import { BufferJSON } from "./generics.js";
+// Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
+const FLUSH_TIMEOUT_MS = 3e3;
+export const useSingleFileAuthState = async (fileName) => {
+  const cache = new Map();
+  let isLoaded, isWriting, isNeedWrite, flushTimeout, loadPromise;
+  const loadKey = () => {
+    if (isLoaded) return;
+    if (loadPromise) return loadPromise;
+    loadPromise = (async () => {
+      try {
+        const data = JSON.parse(
+          await readFile(fileName, "utf-8"),
+          BufferJSON.reviver,
+        );
+        for (const [keyName, value] of Object.entries(data)) {
+          cache.set(keyName, value);
+        }
+      } catch {}
+      isLoaded = true;
+      loadPromise = null;
+    })();
+    return loadPromise;
+  };
+  const flushKey = () => {
+    if (flushTimeout) return;
+    flushTimeout = setTimeout(async () => {
+      flushTimeout = null;
+      if (isWriting) {
+        isNeedWrite = true;
+        return;
+      }
+      isWriting = true;
+      do {
+        isNeedWrite = false;
+        const tempFile = fileName + ".temp";
+        const value = Object.fromEntries(cache);
+        await writeFile(tempFile, JSON.stringify(value, BufferJSON.replacer));
+        await rename(tempFile, fileName);
+      } while (isNeedWrite);
+      isWriting = false;
+    }, FLUSH_TIMEOUT_MS);
+  };
+  const writeKey = (keyName, value) => {
+    cache.set(keyName, value);
+    flushKey();
+  };
+  const removeKey = (keyName) => {
+    cache.delete(keyName);
+    flushKey();
+  };
+  const fileInfo = await stat(fileName).catch(() => null);
+  if (!fileInfo) {
+    await writeFile(fileName, "{}");
+  } else if (!fileInfo.isFile()) {
+    throw new Error(
+      `found something that is not a file at ${fileName}, either delete it or specify a different location`,
+    );
+  }
+  await loadKey();
+  const creds = cache.get("creds") || initAuthCreds();
+  return {
+    state: {
+      creds: creds,
+      keys: {
+        get: (type, ids) => {
+          const data = {};
+          for (const id of ids) {
+            let value = cache.get(type + id);
+            if (type === "app-state-sync-key" && value) {
+              value = proto.Message.AppStateSyncKeyData.fromObject(value);
+            }
+            data[id] = value;
+          }
+          return data;
+        },
+        set: (data) => {
+          for (const category in data) {
+            for (const id in data[category]) {
+              const keyName = category + id;
+              const value = data[category][id];
+              value ? writeKey(keyName, value) : removeKey(keyName);
+            }
+          }
+        },
+      },
+    },
+    saveCreds: () => writeKey("creds", creds),
+  };
+};

package/lib/Utils/validate-connection.js

@@ -0,0 +1,235 @@
+import { Boom } from "@hapi/boom";
+import { createHash } from "crypto";
+import { proto } from "../../WAProto/index.js";
+import {
+  KEY_BUNDLE_TYPE,
+  WA_ADV_ACCOUNT_SIG_PREFIX,
+  WA_ADV_DEVICE_SIG_PREFIX,
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX,
+} from "../Defaults/index.js";
+import {
+  getBinaryNodeChild,
+  jidDecode,
+  S_WHATSAPP_NET,
+} from "../WABinary/index.js";
+import { Curve, hmacSign } from "./crypto.js";
+import { encodeBigEndian } from "./generics.js";
+import { createSignalIdentity } from "./signal.js";
+const getUserAgent = (config) => {
+  return {
+    appVersion: {
+      primary: config.version[0],
+      secondary: config.version[1],
+      tertiary: config.version[2],
+    },
+    platform: config.browser[1].toLocaleLowerCase().includes("android")
+      ? proto.ClientPayload.UserAgent.Platform.ANDROID
+      : proto.ClientPayload.UserAgent.Platform.WEB,
+    releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+    osVersion: "0.1",
+    device: "Desktop",
+    osBuildNumber: "0.1",
+    localeLanguageIso6391: "en",
+    mnc: "000",
+    mcc: "000",
+    localeCountryIso31661Alpha2: config.countryCode,
+  };
+};
+const PLATFORM_MAP = {
+  "Mac OS": proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+  Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32,
+};
+const getWebInfo = (config) => {
+  let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+  if (
+    config.syncFullHistory &&
+    PLATFORM_MAP[config.browser[0]] &&
+    config.browser[1] === "Desktop"
+  ) {
+    webSubPlatform = PLATFORM_MAP[config.browser[0]];
+  }
+  return { webSubPlatform: webSubPlatform };
+};
+const getClientPayload = (config) => {
+  const payload = {
+    connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+    connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+    userAgent: getUserAgent(config),
+  };
+  if (!config.browser[1].toLocaleLowerCase().includes("android")) {
+    payload.webInfo = getWebInfo(config);
+  }
+  return payload;
+};
+export const generateLoginNode = (userJid, config) => {
+  const { user, device } = jidDecode(userJid);
+  const payload = {
+    ...getClientPayload(config),
+    passive: true,
+    pull: true,
+    username: +user,
+    device: device,
+    // TODO: investigate (hard set as false atm)
+    lidDbMigrated: false,
+  };
+  return proto.ClientPayload.fromObject(payload);
+};
+const getPlatformType = (platform) => {
+  const platformType = platform.toUpperCase();
+  if (platformType === "ANDROID") {
+    return proto.DeviceProps.PlatformType.ANDROID_PHONE;
+  }
+  return (
+    proto.DeviceProps.PlatformType[platformType] ||
+    proto.DeviceProps.PlatformType.CHROME
+  );
+};
+export const generateRegistrationNode = (
+  { registrationId, signedPreKey, signedIdentityKey },
+  config,
+) => {
+  // the app version needs to be md5 hashed
+  // and passed in
+  const appVersionBuf = createHash("md5")
+    .update(config.version.join("."))
+    .digest();
+  const companion = {
+    os: config.browser[0],
+    platformType: getPlatformType(config.browser[1]),
+    requireFullSync: config.syncFullHistory,
+    historySyncConfig: {
+      storageQuotaMb: 10240,
+      inlineInitialPayloadInE2EeMsg: true,
+      recentSyncDaysLimit: undefined,
+      supportCallLogHistory: false,
+      supportBotUserAgentChatHistory: true,
+      supportCagReactionsAndPolls: true,
+      supportBizHostedMsg: true,
+      supportRecentSyncChunkMessageCountTuning: true,
+      supportHostedGroupMsg: true,
+      supportFbidBotChatHistory: true,
+      supportAddOnHistorySyncMigration: undefined,
+      supportMessageAssociation: true,
+      supportGroupHistory: false,
+      onDemandReady: undefined,
+      supportGuestChat: undefined,
+    },
+    version: { primary: 10, secondary: 15, tertiary: 7 },
+  };
+  const companionProto = proto.DeviceProps.encode(companion).finish();
+  const registerPayload = {
+    ...getClientPayload(config),
+    passive: false,
+    pull: false,
+    devicePairingData: {
+      buildHash: appVersionBuf,
+      deviceProps: companionProto,
+      eRegid: encodeBigEndian(registrationId),
+      eKeytype: KEY_BUNDLE_TYPE,
+      eIdent: signedIdentityKey.public,
+      eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+      eSkeyVal: signedPreKey.keyPair.public,
+      eSkeySig: signedPreKey.signature,
+    },
+  };
+  return proto.ClientPayload.fromObject(registerPayload);
+};
+export const configureSuccessfulPairing = (
+  stanza,
+  { advSecretKey, signedIdentityKey, signalIdentities },
+) => {
+  const msgId = stanza.attrs.id;
+  const pairSuccessNode = getBinaryNodeChild(stanza, "pair-success");
+  const deviceIdentityNode = getBinaryNodeChild(
+    pairSuccessNode,
+    "device-identity",
+  );
+  const platformNode = getBinaryNodeChild(pairSuccessNode, "platform");
+  const deviceNode = getBinaryNodeChild(pairSuccessNode, "device");
+  const businessNode = getBinaryNodeChild(pairSuccessNode, "biz");
+  if (!deviceIdentityNode || !deviceNode) {
+    throw new Boom("Missing device-identity or device in pair success node", {
+      data: stanza,
+    });
+  }
+  const bizName = businessNode?.attrs.name;
+  const jid = deviceNode.attrs.jid;
+  const lid = deviceNode.attrs.lid;
+  const { details, hmac, accountType } =
+    proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+  let hmacPrefix = Buffer.from([]);
+  if (
+    accountType !== undefined &&
+    accountType === proto.ADVEncryptionType.HOSTED
+  ) {
+    hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+  }
+  const advSign = hmacSign(
+    Buffer.concat([hmacPrefix, details]),
+    Buffer.from(advSecretKey, "base64"),
+  );
+  if (Buffer.compare(hmac, advSign) !== 0) {
+    throw new Boom("Invalid account signature");
+  }
+  const account = proto.ADVSignedDeviceIdentity.decode(details);
+  const {
+    accountSignatureKey,
+    accountSignature,
+    details: deviceDetails,
+  } = account;
+  const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+  const accountSignaturePrefix =
+    deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+      ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+      : WA_ADV_ACCOUNT_SIG_PREFIX;
+  const accountMsg = Buffer.concat([
+    accountSignaturePrefix,
+    deviceDetails,
+    signedIdentityKey.public,
+  ]);
+  if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+    throw new Boom("Failed to verify account signature");
+  }
+  const deviceMsg = Buffer.concat([
+    WA_ADV_DEVICE_SIG_PREFIX,
+    deviceDetails,
+    signedIdentityKey.public,
+    accountSignatureKey,
+  ]);
+  account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+  const identity = createSignalIdentity(lid, accountSignatureKey);
+  const accountEnc = encodeSignedDeviceIdentity(account, false);
+  const reply = {
+    tag: "iq",
+    attrs: { to: S_WHATSAPP_NET, type: "result", id: msgId },
+    content: [
+      {
+        tag: "pair-device-sign",
+        attrs: {},
+        content: [
+          {
+            tag: "device-identity",
+            attrs: { "key-index": deviceIdentity.keyIndex.toString() },
+            content: accountEnc,
+          },
+        ],
+      },
+    ],
+  };
+  const authUpdate = {
+    account: account,
+    me: { id: jid, name: bizName, lid: lid },
+    signalIdentities: [...(signalIdentities || []), identity],
+    platform: platformNode?.attrs.name,
+  };
+  return { creds: authUpdate, reply: reply };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+  account = { ...account };
+  // set to null if we are not to include the signature key
+  // or if we are including the signature key but it is empty
+  if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+    account.accountSignatureKey = null;
+  }
+  return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};