sauruspro-bail 0.0.0-stage → 5.0.1

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

@@ -0,0 +1,121 @@
+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,
+            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');
+        }
+    };
+};
+//# sourceMappingURL=use-multi-file-auth-state.js.map

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,162 @@
+import { mkdir, readdir, readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+export const useSqliteAuthState = async (pathOrFolder, options = {}) => {
+  const {
+    fileName = 'auth.db',
+    migrateFromFolder,
+    logger
+  } = options;
+  const dbPath = /\.(db|sqlite|sqlite3)$/i.test(pathOrFolder) ? pathOrFolder : join(pathOrFolder, fileName);
+  const bufReplacer = (_, value) => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
+      return {
+        type: 'Buffer',
+        data: Buffer.from(value?.data || value).toString('base64')
+      };
+    }
+    return value;
+  };
+  const bufReviver = (_, value) => {
+    if (value && typeof value === 'object' && value.type === 'Buffer' && typeof value.data === 'string') {
+      return Buffer.from(value.data, 'base64');
+    }
+    return value;
+  };
+  const encode = value => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+      return Buffer.concat([Buffer.from([1]), Buffer.from(value)]);
+    }
+    return Buffer.concat([Buffer.from([0]), Buffer.from(JSON.stringify(value, bufReplacer), 'utf8')]);
+  };
+  const decode = blob => {
+    if (!blob || blob.length === 0) return null;
+    if (blob[0] === 1) return Buffer.from(blob.subarray(1));
+    return JSON.parse(Buffer.from(blob.subarray(1)).toString('utf8'), bufReviver);
+  };
+  const fixName = s => s?.replace(/\//g, '__')?.replace(/:/g, '-');
+  const keyOf = (category, id) => fixName(`${category}-${id}`);
+  let DatabaseSync;
+  try {
+    ({
+      DatabaseSync
+    } = await import('node:sqlite'));
+  } catch (err) {
+    throw new Error("useSqliteAuthState needs the built-in 'node:sqlite' module (Node 22.5+). Upgrade Node, or use useMultiFileAuthState instead.");
+  }
+  await mkdir(dirname(dbPath), {
+    recursive: true
+  }).catch(() => {});
+  const db = new DatabaseSync(dbPath);
+  db.exec('PRAGMA journal_mode = TRUNCATE');
+  db.exec('PRAGMA synchronous = NORMAL');
+  db.exec('PRAGMA busy_timeout = 5000');
+  db.exec('CREATE TABLE IF NOT EXISTS auth_state (k TEXT PRIMARY KEY, v BLOB NOT NULL) WITHOUT ROWID');
+  const qGet = db.prepare('SELECT v FROM auth_state WHERE k = ?');
+  const qUpsert = db.prepare('INSERT INTO auth_state(k,v) VALUES(?,?) ON CONFLICT(k) DO UPDATE SET v=excluded.v');
+  const qDelete = db.prepare('DELETE FROM auth_state WHERE k = ?');
+  const runTx = fn => {
+    db.exec('BEGIN');
+    try {
+      const r = fn();
+      db.exec('COMMIT');
+      return r;
+    } catch (err) {
+      db.exec('ROLLBACK');
+      throw err;
+    }
+  };
+  const readRaw = k => {
+    const row = qGet.get(k);
+    if (!row) return null;
+    try {
+      return decode(row.v);
+    } catch (err) {
+      logger?.warn?.({
+        k,
+        err: err?.message
+      }, 'sqlite-auth: failed to decode row, treating as missing');
+      return null;
+    }
+  };
+  const runMigration = async folder => {
+    let files;
+    try {
+      files = await readdir(folder);
+    } catch {
+      return 0;
+    }
+    const rows = [];
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      let value;
+      try {
+        value = JSON.parse(await readFile(join(folder, file), 'utf8'), bufReviver);
+      } catch {
+        continue;
+      }
+      if (value === null || value === undefined) continue;
+      rows.push([file.slice(0, -'.json'.length), encode(value)]);
+    }
+    runTx(() => {
+      for (const [k, v] of rows) qUpsert.run(k, v);
+    });
+    return rows.length;
+  };
+  const hasCreds = () => !!qGet.get('creds');
+  if (migrateFromFolder && !hasCreds()) {
+    const n = await runMigration(migrateFromFolder);
+    if (n > 0) logger?.info?.({
+      count: n,
+      from: migrateFromFolder
+    }, 'sqlite-auth: migrated legacy auth state');
+  }
+  let creds = readRaw('creds');
+  if (!creds) {
+    creds = initAuthCreds();
+    qUpsert.run('creds', encode(creds));
+  }
+  const keys = {
+    get: async (type, ids) => {
+      const data = {};
+      for (const id of ids) {
+        let value = readRaw(keyOf(type, id));
+        if (type === 'app-state-sync-key' && value) {
+          value = proto.Message.AppStateSyncKeyData.fromObject(value);
+        }
+        if (value !== null && value !== undefined) {
+          data[id] = value;
+        }
+      }
+      return data;
+    },
+    set: async data => {
+      const ops = [];
+      for (const category in data) {
+        for (const id in data[category]) {
+          ops.push([keyOf(category, id), data[category][id]]);
+        }
+      }
+      runTx(() => {
+        for (const [k, value] of ops) {
+          if (value === null || value === undefined) qDelete.run(k);else qUpsert.run(k, encode(value));
+        }
+      });
+    },
+    clear: async () => {
+      db.prepare("DELETE FROM auth_state WHERE k <> 'creds'").run();
+    }
+  };
+  return {
+    state: {
+      creds,
+      keys
+    },
+    saveCreds: async () => {
+      qUpsert.run('creds', encode(creds));
+    },
+    db,
+    close: () => db.close()
+  };
+};

package/lib/Utils/validate-connection.js

@@ -0,0 +1,203 @@
+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: proto.ClientPayload.UserAgent.Platform.MACOS,
+        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 };
+};
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    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();
+    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('.')) // join as string
+        .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,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        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();
+};
+//# sourceMappingURL=validate-connection.js.map