@bot-wa/baileys 0.0.0-stage → 0.2.0-alpha.0

package/lib/sessionPath.js

@@ -0,0 +1,52 @@
+import { existsSync, lstatSync, realpathSync, rmSync, } from 'node:fs';
+import { isAbsolute, parse, relative, resolve, sep, } from 'node:path';
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function isContained(base, target) {
+    const rel = relative(base, target);
+    return rel !== '' && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/**
+ * Resolve a session directory without allowing an identifier to escape its
+ * configured root. Session identifiers are deliberately opaque: callers that
+ * need hierarchy should configure a different `sessionsDir`, not put path
+ * separators in `session`.
+ */
+export function resolveSessionDirectory(sessionsDir = './sessions', session = 'default') {
+    if (!SESSION_ID.test(session) || session === '.' || session === '..') {
+        throw new Error('Invalid Baileys session id. Use 1-128 letters, numbers, dots, underscores or hyphens; path segments are not allowed.');
+    }
+    const base = resolve(sessionsDir);
+    if (base === parse(base).root) {
+        throw new Error('Baileys sessionsDir must not be a filesystem root');
+    }
+    const target = resolve(base, session);
+    if (!isContained(base, target)) {
+        throw new Error('Baileys session directory escaped its configured root');
+    }
+    return target;
+}
+/**
+ * Reject an existing session symlink and verify real-path containment. This
+ * prevents auth reads/writes from being redirected outside `sessionsDir`.
+ */
+export function assertSessionDirectorySafe(sessionsDir = './sessions', session = 'default') {
+    const target = resolveSessionDirectory(sessionsDir, session);
+    if (!existsSync(target))
+        return target;
+    if (lstatSync(target).isSymbolicLink()) {
+        throw new Error('Baileys session directory must not be a symbolic link');
+    }
+    const base = resolve(sessionsDir);
+    const realBase = existsSync(base) ? realpathSync(base) : base;
+    const realTarget = realpathSync(target);
+    if (!isContained(realBase, realTarget)) {
+        throw new Error('Baileys session directory escaped its configured root through a symbolic link');
+    }
+    return target;
+}
+/** Remove exactly one validated session directory. */
+export function removeSessionDirectory(sessionsDir = './sessions', session = 'default') {
+    const target = assertSessionDirectorySafe(sessionsDir, session);
+    if (existsSync(target))
+        rmSync(target, { recursive: true, force: true });
+}

package/lib/toCallEvent.d.ts

@@ -0,0 +1,19 @@
+/**
+ * toCallEvent — project a Baileys `WACallEvent` into a transport-neutral
+ * {@link CallEvent}.
+ *
+ * Identity is NOT resolved here: the provider canonicalises the caller (and
+ * the group JID) through the same LID/PN rule as every other event
+ * (`IdentityStore.resolve`, seeded from `getPNForLID` for bare LIDs) and passes
+ * the results in. This module only adds the call-specific shape: which chat a
+ * call belongs to across its status updates, and the `isVideo`/`offline` flags.
+ */
+import type { WACallEvent } from '@whiskeysockets/baileys';
+import type { CallEvent, ChatId, UserId } from '@bot-wa/core';
+/**
+ * @param from    the caller's canonical id (same id their messages carry as `senderId`).
+ * @param groupId the canonical group id when this update carries `groupJid` (Baileys only
+ *                sends it on the offer).
+ * @param groups  call id → group id, so later updates of a group call stay in the group.
+ */
+export declare function toCallEvent(call: WACallEvent, from: UserId, groupId: ChatId | undefined, groups: Map<string, ChatId>): CallEvent;

package/lib/toCallEvent.js

@@ -0,0 +1,46 @@
+/**
+ * toCallEvent — project a Baileys `WACallEvent` into a transport-neutral
+ * {@link CallEvent}.
+ *
+ * Identity is NOT resolved here: the provider canonicalises the caller (and
+ * the group JID) through the same LID/PN rule as every other event
+ * (`IdentityStore.resolve`, seeded from `getPNForLID` for bare LIDs) and passes
+ * the results in. This module only adds the call-specific shape: which chat a
+ * call belongs to across its status updates, and the `isVideo`/`offline` flags.
+ */
+/** Cap on remembered group calls (one entry per call in progress). */
+const CALL_GROUPS_MAX = 500;
+/** Statuses after which Baileys forgets a call (mirrors its own offer cache). */
+const FINAL_STATUSES = new Set(['reject', 'accept', 'timeout', 'terminate']);
+/**
+ * @param from    the caller's canonical id (same id their messages carry as `senderId`).
+ * @param groupId the canonical group id when this update carries `groupJid` (Baileys only
+ *                sends it on the offer).
+ * @param groups  call id → group id, so later updates of a group call stay in the group.
+ */
+export function toCallEvent(call, from, groupId, groups) {
+    if (groupId) {
+        groups.set(call.id, groupId);
+        if (groups.size > CALL_GROUPS_MAX) {
+            const oldest = groups.keys().next();
+            if (!oldest.done)
+                groups.delete(oldest.value);
+        }
+    }
+    const group = groups.get(call.id);
+    if (FINAL_STATUSES.has(String(call.status)))
+        groups.delete(call.id);
+    const event = {
+        id: call.id,
+        from,
+        status: String(call.status),
+        // A group call whose group is unknown (its offer was never seen) falls back to the DM.
+        chatId: group ?? from,
+        isGroup: group !== undefined,
+    };
+    if (call.isVideo !== undefined)
+        event.isVideo = call.isVideo;
+    if (call.offline !== undefined)
+        event.offline = call.offline;
+    return event;
+}

package/lib/toInbound.d.ts

@@ -0,0 +1,19 @@
+/**
+ * toInbound — normalize a raw Baileys `WAMessage` into a transport-neutral
+ * {@link InboundMessage}. All proto parsing and LID/PN identity canonicalization
+ * lives here, INSIDE the provider, so core never sees a WhatsApp concept. The
+ * emitted `chatId`/`senderId` are already stable (see {@link IdentityStore}).
+ */
+import { type WAMessage, type proto } from '@whiskeysockets/baileys';
+import { type InboundMessage } from '@bot-wa/core';
+import { type IdentityStore } from './identity.js';
+type ContextInfo = proto.IContextInfo;
+/**
+ * The reply/mention context of a message, wherever its content type keeps it
+ * (`extendedTextMessage`, `imageMessage`, `videoMessage`, `documentMessage`…).
+ * Wrapped content (disappearing mode, view once, document with caption) is
+ * unwrapped first.
+ */
+export declare function contextInfoOf(content: proto.IMessage | null | undefined): ContextInfo | undefined;
+export declare function toInbound(message: WAMessage, identity: IdentityStore): InboundMessage<WAMessage>;
+export {};

package/lib/toInbound.js

@@ -0,0 +1,177 @@
+/**
+ * toInbound — normalize a raw Baileys `WAMessage` into a transport-neutral
+ * {@link InboundMessage}. All proto parsing and LID/PN identity canonicalization
+ * lives here, INSIDE the provider, so core never sees a WhatsApp concept. The
+ * emitted `chatId`/`senderId` are already stable (see {@link IdentityStore}).
+ */
+import { normalizeMessageContent, toNumber } from '@whiskeysockets/baileys';
+import { toInboundLocation } from '@bot-wa/core';
+import { isPnUser, isLidUser, normalize } from './jid.js';
+import { canonicalKey } from './identity.js';
+const MEDIA_KINDS = new Set(['image', 'video', 'audio', 'voice', 'document', 'sticker']);
+/**
+ * The reply/mention context of a message, wherever its content type keeps it
+ * (`extendedTextMessage`, `imageMessage`, `videoMessage`, `documentMessage`…).
+ * Wrapped content (disappearing mode, view once, document with caption) is
+ * unwrapped first.
+ */
+export function contextInfoOf(content) {
+    const m = normalizeMessageContent(content);
+    if (!m)
+        return undefined;
+    for (const part of Object.values(m)) {
+        if (part && typeof part === 'object' && 'contextInfo' in part) {
+            const ctx = part.contextInfo;
+            if (ctx)
+                return ctx;
+        }
+    }
+    return undefined;
+}
+/** Plain text of a (quoted) message: its text, or the caption of its media. */
+function textOf(content) {
+    const m = normalizeMessageContent(content);
+    if (!m)
+        return '';
+    return (m.conversation ??
+        m.extendedTextMessage?.text ??
+        m.imageMessage?.caption ??
+        m.videoMessage?.caption ??
+        m.documentMessage?.caption ??
+        '');
+}
+/** Epoch seconds from a `number | Long | null` protobuf timestamp (0 when absent). */
+function timestampOf(value) {
+    const n = Number(toNumber(value ?? 0));
+    return Number.isFinite(n) ? n : 0;
+}
+export function toInbound(message, identity) {
+    const key = (message.key ?? { remoteJid: '', fromMe: false });
+    // Learn LID↔PN pairings this key exposes, then canonicalize to stable PN ids.
+    const { chatId: from, senderId: sender, isGroup: isGroupRaw, rawParticipant } = canonicalKey(key, identity, message.participant);
+    const isGroup = from.endsWith('@g.us');
+    const isBroadcast = from === 'status@broadcast' || from.endsWith('@broadcast');
+    const kind = isGroup ? 'group' : isBroadcast ? 'broadcast' : from.endsWith('@newsletter') ? 'channel' : 'dm';
+    const rawIdentity = (isGroupRaw ? rawParticipant : key.remoteJid) ?? '';
+    const senderInfo = {
+        id: sender,
+        displayName: message.pushName ?? undefined,
+        platformData: {
+            phoneNumber: isPnUser(sender) ? sender : undefined,
+            lid: isLidUser(rawIdentity) ? rawIdentity : undefined,
+        },
+    };
+    const chat = { id: from, kind, isGroup, isBroadcast };
+    let body = '';
+    let type = 'unknown';
+    let location;
+    // Unwrap disappearing-mode, view-once and document-with-caption envelopes.
+    const m = normalizeMessageContent(message.message) ?? {};
+    if (m.conversation || m.extendedTextMessage?.text) {
+        body = (m.conversation ?? m.extendedTextMessage?.text ?? '').toString();
+        type = 'text';
+    }
+    else if (m.imageMessage) {
+        type = 'image';
+        body = m.imageMessage.caption ?? '';
+    }
+    else if (m.videoMessage) {
+        type = 'video';
+        body = m.videoMessage.caption ?? '';
+    }
+    else if (m.audioMessage) {
+        type = m.audioMessage.ptt ? 'voice' : 'audio';
+    }
+    else if (m.stickerMessage) {
+        type = 'sticker';
+    }
+    else if (m.documentMessage) {
+        type = 'document';
+        body = m.documentMessage.caption ?? '';
+    }
+    else if (m.locationMessage) {
+        type = 'location';
+        const l = m.locationMessage;
+        body = l.name ?? l.address ?? '';
+        location = toInboundLocation({ latitude: l.degreesLatitude, longitude: l.degreesLongitude, name: l.name, address: l.address });
+    }
+    else if (m.liveLocationMessage) {
+        type = 'location';
+        const l = m.liveLocationMessage;
+        body = l.caption ?? '';
+        location = toInboundLocation({ latitude: l.degreesLatitude, longitude: l.degreesLongitude, live: true });
+    }
+    else if (m.contactMessage || m.contactsArrayMessage) {
+        type = 'contact';
+        body = m.contactMessage?.displayName ?? m.contactsArrayMessage?.displayName ?? '';
+    }
+    else if (m.pollCreationMessage || m.pollCreationMessageV2 || m.pollCreationMessageV3) {
+        // V3 is the single-select poll, V2 the community-announcement one.
+        type = 'poll';
+        body = (m.pollCreationMessage ?? m.pollCreationMessageV2 ?? m.pollCreationMessageV3)?.name ?? '';
+    }
+    // An encrypted vote. BaileysProvider decrypts these into `poll-vote` events and
+    // never routes them here; kept for direct callers of this low-level mapper.
+    else if (m.pollUpdateMessage) {
+        type = 'poll';
+    }
+    else if (m.buttonsResponseMessage) {
+        type = 'buttons';
+        body = m.buttonsResponseMessage.selectedDisplayText ?? '';
+    }
+    else if (m.templateButtonReplyMessage) {
+        type = 'buttons';
+        body = m.templateButtonReplyMessage.selectedDisplayText ?? '';
+    }
+    else if (m.listResponseMessage) {
+        type = 'list';
+        body = m.listResponseMessage.title ?? '';
+    }
+    let media;
+    if (MEDIA_KINDS.has(type)) {
+        const part = m[`${type === 'voice' ? 'audio' : type}Message`];
+        media = { kind: type, mimetype: part?.mimetype ?? undefined, filename: part?.fileName ?? undefined, token: message };
+    }
+    const qc = contextInfoOf(m);
+    // Every user id below is canonical like `senderId`: a LID-addressed group
+    // quotes and mentions LIDs, so a known LID (the bot's own included) maps to
+    // its PN and matches selfId, and device suffixes are stripped.
+    const canonicalUser = (jid) => identity.canonical(normalize(jid) || jid);
+    const quotedAuthor = qc?.participant ?? undefined;
+    let quoted;
+    if (qc?.quotedMessage) {
+        quoted = {
+            body: textOf(qc.quotedMessage),
+            senderId: quotedAuthor ? canonicalUser(quotedAuthor) : undefined,
+        };
+        if (qc.stanzaId) {
+            // WAMessage-shaped, so `send(…, { quoted: quoted.ref })` threads the reply.
+            const native = {
+                key: { remoteJid: key.remoteJid, id: qc.stanzaId, fromMe: false, ...(quotedAuthor ? { participant: quotedAuthor } : {}) },
+                message: qc.quotedMessage,
+            };
+            quoted.ref = { id: qc.stanzaId, chatId: from, native };
+        }
+    }
+    const mentions = (qc?.mentionedJid ?? []).map(canonicalUser);
+    return {
+        ref: { id: key.id ?? '', chatId: from, native: message },
+        chat,
+        senderInfo,
+        from,
+        sender,
+        chatId: from,
+        senderId: sender,
+        isGroup,
+        isBroadcast,
+        fromMe: !!key.fromMe,
+        type,
+        body,
+        timestamp: timestampOf(message.messageTimestamp),
+        mentions,
+        quoted,
+        media,
+        ...(location ? { location } : {}),
+        raw: message,
+    };
+}

package/lib/toOutbound.d.ts

@@ -0,0 +1,10 @@
+/**
+ * toOutbound — map a transport-neutral {@link OutboundContent} to a Baileys
+ * `AnyMessageContent`. WhatsApp has no reliable native buttons/lists, so those
+ * degrade to numbered text; Cloud-API-only kinds (`template`) and `native`
+ * throw {@link UnsupportedContentError}.
+ */
+import type { AnyMessageContent } from '@whiskeysockets/baileys';
+import { type OutboundContent } from '@bot-wa/core';
+import { type RemoteMediaConfig } from './MediaProcessor.js';
+export declare function toOutbound(content: OutboundContent, remoteMedia?: RemoteMediaConfig): Promise<AnyMessageContent>;

package/lib/toOutbound.js

@@ -0,0 +1,62 @@
+/**
+ * toOutbound — map a transport-neutral {@link OutboundContent} to a Baileys
+ * `AnyMessageContent`. WhatsApp has no reliable native buttons/lists, so those
+ * degrade to numbered text; Cloud-API-only kinds (`template`) and `native`
+ * throw {@link UnsupportedContentError}.
+ */
+import { UnsupportedContentError } from '@bot-wa/core';
+import { toMediaUpload, resolveRemoteMedia, makeSticker, transcodeToOpus } from './MediaProcessor.js';
+function vcard(phone, displayName) {
+    const digits = phone.replace(/[^\d]/g, '');
+    return ('BEGIN:VCARD\nVERSION:3.0\n' +
+        `FN:${displayName ?? phone}\n` +
+        `TEL;type=CELL;type=VOICE;waid=${digits}:${phone}\n` +
+        'END:VCARD');
+}
+function numberedButtons(text, rows, footer) {
+    const menu = rows.map((r, i) => `${i + 1}) ${r.title}`).join('\n');
+    return [text, '', menu, footer ? `\n${footer}` : ''].filter(Boolean).join('\n');
+}
+export async function toOutbound(content, remoteMedia = {}) {
+    const upload = (media) => resolveRemoteMedia(toMediaUpload(media), content.kind, remoteMedia);
+    switch (content.kind) {
+        case 'text':
+            return { text: content.text };
+        case 'image':
+            return { image: await upload(content.media), caption: content.caption, viewOnce: content.viewOnce };
+        case 'video':
+            return { video: await upload(content.media), caption: content.caption, gifPlayback: content.gifPlayback, ptv: content.ptv, viewOnce: content.viewOnce };
+        case 'audio':
+            return { audio: await upload(content.media), mimetype: 'audio/ogg; codecs=opus', ptt: false };
+        case 'voice': {
+            const opus = await transcodeToOpus(content.media);
+            return { audio: opus, mimetype: 'audio/ogg; codecs=opus', ptt: true };
+        }
+        case 'document':
+            return { document: await upload(content.media), fileName: content.filename, caption: content.caption, mimetype: content.mimetype };
+        case 'sticker': {
+            const sticker = await makeSticker(content.media, { pack: content.pack, author: content.author });
+            return { sticker };
+        }
+        case 'location':
+            return { location: { degreesLatitude: content.lat, degreesLongitude: content.lng, name: content.name, address: content.address } };
+        case 'contact':
+            return { contacts: { displayName: content.displayName ?? content.phone, contacts: [{ vcard: vcard(content.phone, content.displayName) }] } };
+        case 'form':
+            throw new UnsupportedContentError('form', 'This transport has no native forms — flow().form() asks field by field instead (capabilities.forms is not "native").');
+        case 'poll':
+            return { poll: { name: content.question, values: content.options, selectableCount: content.multiSelect ? content.options.length : 1 } };
+        case 'reaction':
+            return { react: { text: content.emoji, key: content.target.native.key } };
+        case 'buttons':
+            return { text: numberedButtons(content.text, content.buttons.map((b) => ({ title: b.title })), content.footer) };
+        case 'list':
+            return { text: numberedButtons(content.text, content.sections.flatMap((s) => s.rows), content.footer) };
+        case 'card':
+            return { text: [content.title, content.body].filter(Boolean).join('\n') };
+        case 'template':
+            throw new UnsupportedContentError('template', 'WhatsApp templates require the Cloud API transport, not Baileys.');
+        case 'native':
+            throw new UnsupportedContentError('native', 'Baileys has no native-component surface.');
+    }
+}

package/package.json

@@ -1,6 +1,73 @@
 {
   "name": "@bot-wa/baileys",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0-alpha.0",
+  "type": "module",
+  "description": "WhatsApp transport for @bot-wa/core, built on Baileys 7 (IProvider v2).",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "bot",
+    "baileys",
+    "whatsapp",
+    "provider",
+    "transport",
+    "bot-wa"
+  ],
+  "author": "Andres Aya",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andresayac/bot-wa-baileys.git",
+    "directory": "packages/baileys-provider"
+  },
+  "homepage": "https://github.com/andresayac/bot-wa-baileys/tree/main/packages/baileys-provider#readme",
+  "bugs": {
+    "url": "https://github.com/andresayac/bot-wa-baileys/issues"
+  },
+  "files": [
+    "./lib/**/*"
+  ],
+  "dependencies": {
+    "@cacheable/node-cache": "^1.5.0",
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@hapi/boom": "^10.0.1",
+    "@whiskeysockets/baileys": "7.0.0-rc14",
+    "fluent-ffmpeg": "^2.1.3",
+    "follow-redirects": "^1.16.0",
+    "mime-types": "^3.0.2",
+    "pino": "^10.3.1",
+    "qr-image": "^3.2.0",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.35.3",
+    "@bot-wa/core": "^2.0.0-alpha.2",
+    "@bot-wa/http": "^0.2.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.28",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^26.1.1",
+    "@types/qrcode-terminal": "^0.12.2",
+    "typescript": "^7.0.2",
+    "vite": "^7.3.6",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "start": "pnpm run build && tsc -p examples/tsconfig.json && node examples/bot.js",
+    "example": "pnpm run start",
+    "typecheck": "tsc -p tsconfig.test.json"
+  }
 }