ruby-baileys 0.0.0-stage → 1.5.17

package/src/Utils/validate-connection.d.ts

@@ -0,0 +1,44 @@
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+export function generateLoginNode(userJid: any, config: any): proto.ClientPayload;
+export function generateRegistrationNode({ registrationId, signedPreKey, signedIdentityKey }: {
+    registrationId: any;
+    signedPreKey: any;
+    signedIdentityKey: any;
+}, config: any): proto.ClientPayload;
+export function configureSuccessfulPairing(stanza: any, { advSecretKey, signedIdentityKey, signalIdentities }: {
+    advSecretKey: any;
+    signedIdentityKey: any;
+    signalIdentities: any;
+}): {
+    creds: {
+        account: proto.ADVSignedDeviceIdentity;
+        me: {
+            id: any;
+            name: any;
+            lid: any;
+        };
+        signalIdentities: any[];
+        platform: any;
+    };
+    reply: {
+        tag: string;
+        attrs: {
+            to: string;
+            type: string;
+            id: any;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: {
+                tag: string;
+                attrs: {
+                    'key-index': string;
+                };
+                content: any;
+            }[];
+        }[];
+    };
+};
+export function encodeSignedDeviceIdentity(account: any, includeSignatureKey: any): any;
+import { proto } from '../../WAProto/index.js';

package/src/Utils/validate-connection.js

@@ -0,0 +1,208 @@
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+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 };
+};
+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);
+    }
+    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,
+
+        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) => {
+
+    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,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};

package/src/Utils/voice-recognition.d.ts

@@ -0,0 +1,53 @@
+export type VoiceRecognitionContext = {
+    message: any;
+    audioMessage: any;
+    chatJid: string;
+    senderJid: string;
+    isGroup: boolean;
+};
+export type VoiceTranscriptionInput = VoiceRecognitionContext & {
+    buffer: Buffer;
+    mimetype: string;
+};
+export type VoiceTranscriptionResult = string | {
+    text?: string;
+    transcript?: string;
+    language?: string;
+    confidence?: number;
+    [key: string]: any;
+};
+export type VoiceRecognitionOptions = {
+    enabled?: boolean;
+    transcribe: (input: VoiceTranscriptionInput) => VoiceTranscriptionResult | Promise<VoiceTranscriptionResult>;
+    wakePhrases?: string | string[];
+    getWakePhrases?: (context: VoiceRecognitionContext) => string | string[] | undefined | Promise<string | string[] | undefined>;
+    shouldProcess?: (context: VoiceRecognitionContext) => boolean | Promise<boolean>;
+    allowQuotedActivation?: boolean;
+    pttOnly?: boolean;
+    maxDuration?: number;
+    maxBytes?: number;
+    downloadOptions?: any;
+};
+export type VoiceRecognitionEvent = VoiceRecognitionContext & {
+    transcript: string;
+    commandText: string;
+    activation: 'quoted' | 'wake-phrase' | null;
+    wakePhrase: string | null;
+    language?: string;
+    confidence?: number;
+    [key: string]: any;
+};
+export function normalizeVoiceText(value: any): string;
+export function matchVoiceWakePhrase(transcript: any, phrases?: string | string[]): {
+    phrase: string;
+    normalizedPhrase: string;
+    normalizedTranscript: string;
+} | null;
+export function removeVoiceWakePhrase(transcript: any, wakePhrase: any): string;
+export function bindVoiceRecognition(sock: any, config?: {
+    voiceRecognition?: VoiceRecognitionOptions;
+    getMessage?: (key: any) => Promise<any>;
+    logger?: any;
+}, dependencies?: {
+    downloadContentFromMessage?: (...args: any[]) => Promise<any>;
+}): () => void;

package/src/Utils/voice-recognition.js

@@ -0,0 +1,219 @@
+import { downloadContentFromMessage } from './messages-media.js';
+import { normalizeMessageContent } from './messages.js';
+import { areJidsSameUser, isJidGroup, jidNormalizedUser } from '../WABinary/index.js';
+
+const DEFAULT_MAX_DURATION = 60;
+const DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
+
+const streamToBuffer = async (stream, maxBytes) => {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.from(chunk);
+        total += buffer.length;
+        if (maxBytes && total > maxBytes) {
+            throw new Error('voice message exceeds maxBytes');
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+};
+
+export const normalizeVoiceText = value => String(value ?? '')
+    .normalize('NFKD')
+    .replace(/\p{M}/gu, '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+export const matchVoiceWakePhrase = (transcript, phrases = []) => {
+    const normalizedTranscript = normalizeVoiceText(transcript);
+    if (!normalizedTranscript) {
+        return null;
+    }
+    const candidates = [...new Map((Array.isArray(phrases) ? phrases : [phrases])
+        .map(phrase => ({ raw: String(phrase ?? '').trim(), normalized: normalizeVoiceText(phrase) }))
+        .filter(phrase => phrase.normalized)
+        .map(phrase => [phrase.normalized, phrase])).values()]
+        .sort((a, b) => b.normalized.length - a.normalized.length);
+    for (const phrase of candidates) {
+        const index = ` ${normalizedTranscript} `.indexOf(` ${phrase.normalized} `);
+        if (index >= 0) {
+            return {
+                phrase: phrase.raw,
+                normalizedPhrase: phrase.normalized,
+                normalizedTranscript
+            };
+        }
+    }
+    return null;
+};
+
+export const removeVoiceWakePhrase = (transcript, wakePhrase) => {
+    const normalizedTranscript = normalizeVoiceText(transcript);
+    const normalizedPhrase = normalizeVoiceText(wakePhrase);
+    if (!normalizedPhrase) {
+        return normalizedTranscript;
+    }
+    const words = normalizedTranscript.split(' ');
+    const phraseWords = normalizedPhrase.split(' ');
+    for (let index = 0; index <= words.length - phraseWords.length; index += 1) {
+        if (phraseWords.every((word, offset) => words[index + offset] === word)) {
+            words.splice(index, phraseWords.length);
+            break;
+        }
+    }
+    return words.join(' ').trim();
+};
+
+const getVoiceSenderJid = message => jidNormalizedUser(message?.key?.participantAlt ||
+    message?.key?.participant ||
+    message?.key?.remoteJidAlt ||
+    message?.key?.remoteJid);
+
+const isQuotedToSelf = async ({ message, audioMessage, meId, meLid, getMessage }) => {
+    const contextInfo = audioMessage?.contextInfo;
+    if (!contextInfo?.quotedMessage && !contextInfo?.stanzaId) {
+        return false;
+    }
+    const quotedAuthor = contextInfo.participantAlt || contextInfo.participant;
+    if (quotedAuthor && (areJidsSameUser(quotedAuthor, meId) || areJidsSameUser(quotedAuthor, meLid))) {
+        return true;
+    }
+    if (!contextInfo.stanzaId || typeof getMessage !== 'function') {
+        return false;
+    }
+    const target = await getMessage({
+        remoteJid: message.key.remoteJid,
+        remoteJidAlt: message.key.remoteJidAlt,
+        participant: quotedAuthor,
+        id: contextInfo.stanzaId
+    });
+    return target?.key?.fromMe === true;
+};
+
+const normalizeTranscriptionResult = value => {
+    if (typeof value === 'string') {
+        return { text: value };
+    }
+    if (value && typeof value === 'object') {
+        return {
+            ...value,
+            text: String(value.text ?? value.transcript ?? '')
+        };
+    }
+    return { text: '' };
+};
+
+const getWakePhrases = async (voiceRecognition, context) => {
+    const staticPhrases = Array.isArray(voiceRecognition.wakePhrases)
+        ? voiceRecognition.wakePhrases
+        : voiceRecognition.wakePhrases
+            ? [voiceRecognition.wakePhrases]
+            : [];
+    const dynamicPhrases = typeof voiceRecognition.getWakePhrases === 'function'
+        ? await voiceRecognition.getWakePhrases(context)
+        : [];
+    return [...new Set([
+        ...staticPhrases,
+        ...(Array.isArray(dynamicPhrases) ? dynamicPhrases : dynamicPhrases ? [dynamicPhrases] : [])
+    ].map(value => String(value ?? '').trim()).filter(Boolean))];
+};
+
+export const bindVoiceRecognition = (sock, config = {}, dependencies = {}) => {
+    const voiceRecognition = config.voiceRecognition;
+    if (!voiceRecognition?.enabled || typeof voiceRecognition.transcribe !== 'function') {
+        return () => undefined;
+    }
+    const downloadContent = dependencies.downloadContentFromMessage || downloadContentFromMessage;
+    const getMessage = config.getMessage;
+    const logger = config.logger;
+    const handler = async ({ messages, type }) => {
+        if (type !== 'notify') {
+            return;
+        }
+        for (const message of messages || []) {
+            try {
+                if (
+                       !message?.message ||
+                          (message.key?.fromMe && !voiceRecognition.allowFromMe)
+                         ) {
+                          continue
+                      }
+                const content = normalizeMessageContent(message.message);
+                const audioMessage = content?.audioMessage;
+                if (!audioMessage) {
+                    continue;
+                }
+                if ((voiceRecognition.pttOnly ?? true) && !audioMessage.ptt) {
+                    continue;
+                }
+                const maxDuration = Number.isFinite(voiceRecognition.maxDuration)
+                    ? Math.max(0, Number(voiceRecognition.maxDuration))
+                    : DEFAULT_MAX_DURATION;
+                if (maxDuration && Number(audioMessage.seconds || 0) > maxDuration) {
+                    continue;
+                }
+                const chatJid = jidNormalizedUser(message.key.remoteJid);
+                const senderJid = getVoiceSenderJid(message);
+                const context = {
+                    message,
+                    audioMessage,
+                    chatJid,
+                    senderJid,
+                    isGroup: isJidGroup(chatJid)
+                };
+                if (typeof voiceRecognition.shouldProcess === 'function' && !(await voiceRecognition.shouldProcess(context))) {
+                    continue;
+                }
+                const maxBytes = Number.isFinite(voiceRecognition.maxBytes)
+                    ? Math.max(0, Number(voiceRecognition.maxBytes))
+                    : DEFAULT_MAX_BYTES;
+                const declaredBytes = Number(audioMessage.fileLength?.toString?.() || audioMessage.fileLength || 0);
+                if (maxBytes && declaredBytes > maxBytes) {
+                    continue;
+                }
+                const stream = await downloadContent(audioMessage, 'audio', voiceRecognition.downloadOptions || {});
+                const buffer = await streamToBuffer(stream, maxBytes);
+                const transcription = normalizeTranscriptionResult(await voiceRecognition.transcribe({
+                    ...context,
+                    buffer,
+                    mimetype: audioMessage.mimetype || 'audio/ogg; codecs=opus'
+                }));
+                const transcript = transcription.text.trim();
+                if (!transcript) {
+                    continue;
+                }
+                const meId = sock.authState?.creds?.me?.id;
+                const meLid = sock.authState?.creds?.me?.lid;
+                const quoted = (voiceRecognition.allowQuotedActivation ?? true)
+                    ? await isQuotedToSelf({ message, audioMessage, meId, meLid, getMessage })
+                    : false;
+                const phrases = quoted ? [] : await getWakePhrases(voiceRecognition, context);
+                const wake = quoted ? null : matchVoiceWakePhrase(transcript, phrases);
+                const activation = quoted ? 'quoted' : wake ? 'wake-phrase' : null;
+                const commandText = wake
+                    ? removeVoiceWakePhrase(transcript, wake.normalizedPhrase)
+                    : normalizeVoiceText(transcript);
+                const event = {
+                    ...context,
+                    ...transcription,
+                    transcript,
+                    commandText,
+                    activation,
+                    wakePhrase: wake?.phrase || null
+                };
+                sock.ev.emit('voice.transcription', event);
+                if (activation) {
+                    sock.ev.emit('voice.command', event);
+                }
+            }
+            catch (error) {
+                logger?.warn({ err: error, key: message?.key }, 'voice recognition failed');
+            }
+        }
+    };
+    sock.ev.on('messages.upsert', handler);
+    return () => sock.ev.off('messages.upsert', handler);
+};

package/src/Voip/audio-feeder.d.ts

@@ -0,0 +1,25 @@
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+export declare class AudioFeeder {
+    constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string, hooks?: {
+        onTrackStart?: (track: string) => void;
+        onTrackEnd?: (track: string) => void;
+        onIdle?: () => void;
+        ffmpegPath?: string;
+    });
+    readonly queuedChunks: number;
+    droppedChunks: number;
+    underflowChunks: number;
+    rebuffers: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    readonly playlistLength: number;
+    readonly currentTrack: string | null;
+    readonly idle: boolean;
+    tracksPlayed: number;
+    enqueue(source: string | string[]): number;
+    clearPlaylist(): void;
+    skip(): boolean;
+    start(playlist?: string[]): void;
+    stop(): void;
+}
+export default AudioFeeder;