@manybot/manybot 5.5.4 → 5.6.0

package/dist/drivers/{whatsapp → baileys}/messageHandler.js

@@ -1,5 +1,5 @@
 /**
- * drivers/whatsapp/messageHandler.ts
+ * drivers/baileys/messageHandler.ts
  *
  * WhatsApp message pipeline.
  * Moved from kernel/messageHandler.ts to keep all WhatsApp logic together.
@@ -11,11 +11,13 @@
  *
  * Each plugin decides whether to act or ignore.
  */
-import { CHATS } from "#config";
-import { buildApi, buildChatFromMsg } from "./api/index.js";
+import { CHATS, EXCLUDE_CHATS } from "#config";
+import { buildApi, buildChatFromMsg, buildMessageContext } from "./api/index.js";
 import { pluginRegistry } from "#kernel/pluginLoader.js";
 import { runPlugin } from "#kernel/pluginGuard.js";
-import { normalizeJid, toPresenceCapable } from "./sdk/baileysSock.js";
+import { acquireChatSlot } from "#sendguard";
+import { trackIncomingForContactSave } from "#kernel/contactAutoSave.js";
+import { normalizeJid } from "#drivers/jid.js";
 const INCOMING_DEBOUNCE_MS = 0;
 const lastProcessedAt = new Map();
 // ── Dedup of already-processed messages ────────────────────────────────────
@@ -40,21 +42,34 @@ function alreadyProcessed(id) {
     return false;
 }
 /**
- * @param {WAProtoMsg} msg   - raw Baileys message
- * @param {WASocket}   sock
- * @param {WAStore}    store
+ * @param {BotMessage}   msg       - driver-neutral incoming message envelope
+ * @param {WaContract}   contract  - driver-neutral contract (replaces WASocket)
+ * @param {BotStore}     store     - in-memory store
  */
-export async function handleMessage(msg, sock, store) {
-    const rawJid = msg.key.remoteJid ?? "";
-    const jid = normalizeJid(rawJid);
+export async function handleMessage(msg, contract, store) {
+    const rawJid = msg.chatId;
+    const jid = normalizeJid(store.resolveJid(rawJid));
     if (CHATS.length > 0 && !CHATS.includes(jid)) {
         return;
     }
-    if (alreadyProcessed(msg.key.id)) {
+    if (EXCLUDE_CHATS.includes(jid)) {
+        return;
+    }
+    if (alreadyProcessed(msg.id)) {
         return;
     }
     // Mark as read/delivered to reduce the chance WhatsApp resends it
-    sock.readMessages?.([msg.key]).catch(() => { });
+    // (`msg.quotedKey`/`fromLid`/`fromPn` carry the LID/PN parts so the
+    // contract can reconstruct a proper key on each driver).
+    const rawKey = msg.id ? {
+        id: msg.id,
+        remoteJid: msg.chatId,
+        fromMe: false,
+        participant: msg.fromPn ?? msg.fromLid ?? undefined,
+    } : undefined;
+    if (rawKey) {
+        contract.readMessages([rawKey]).catch(() => { });
+    }
     // Debounce rapid bursts per chat
     if (INCOMING_DEBOUNCE_MS > 0) {
         const now = Date.now();
@@ -67,12 +82,27 @@ export async function handleMessage(msg, sock, store) {
         lastProcessedAt.set(jid, Date.now());
     }
     // Build a WAChat adapter from the message metadata
-    const chat = await buildChatFromMsg(msg, store, sock);
+    const chat = await buildChatFromMsg(msg, store, contract);
+    // Gradual contact-saving (best-effort, never blocks message handling)
+    const msgCtx = buildMessageContext(msg, contract, store);
+    const isGroup = jid.endsWith("@g.us");
+    trackIncomingForContactSave(contract, msg, msgCtx.sender, isGroup, msgCtx.hasPrefix)
+        .catch(() => { });
+    // Caps how many chats get answered at the same time — see SECURITY_LEVEL.
+    const releaseChatSlot = await acquireChatSlot(jid);
+    try {
+        await runPluginsForMessage(msg, chat, contract, store, rawJid);
+    }
+    finally {
+        releaseChatSlot();
+    }
+}
+async function runPluginsForMessage(msg, chat, contract, store, rawJid) {
     for (const plugin of pluginRegistry.values()) {
         const ctx = buildApi({
             msg,
             chat,
-            sock,
+            contract,
             store,
             pluginRegistry,
             pluginName: plugin.name,
@@ -83,7 +113,7 @@ export async function handleMessage(msg, sock, store) {
         if (useTyping) {
             // Refresh presence every 4s so WhatsApp doesn't auto-clear it
             typingInterval = setInterval(() => {
-                toPresenceCapable(sock).setPresence(rawJid, "composing").catch(() => { });
+                contract.sendPresenceUpdate("composing", rawJid).catch(() => { });
             }, 4000);
         }
         try {
@@ -92,7 +122,7 @@ export async function handleMessage(msg, sock, store) {
         finally {
             if (useTyping) {
                 clearInterval(typingInterval);
-                toPresenceCapable(sock).setPresence(rawJid, "paused").catch(() => { });
+                contract.sendPresenceUpdate("paused", rawJid).catch(() => { });
             }
         }
     }

package/dist/drivers/{whatsapp → baileys}/sdk/baileysSock.js

@@ -13,7 +13,6 @@ import { resolveLoginMethod } from "../loginPrompt.js";
 import { logger } from "#logger";
 import { t } from "#i18n";
 import { createStore } from "#client/store.js";
-import { CapabilitySet } from "#core/capabilities.js";
 import pino from "pino";
 // ── Auth path ─────────────────────────────────────────────────────────────────
 // Baileys' sock.ev wraps an internal EventEmitter that no longer exposes
@@ -122,31 +121,3 @@ export async function createSocket(authDirName = CLIENT_ID) {
     }
     return { sock, store };
 }
-/**
- * Normalize a Baileys JID to the @c.us format used in ManyBot configs.
- * Groups (@g.us) and broadcasts are passed through unchanged.
- *
- * @param {string} jid
- * @returns {string}
- */
-export function normalizeJid(jid) {
-    if (!jid)
-        return jid;
-    return jid
-        .replace(/@s\.whatsapp\.net$/, "@c.us")
-        .replace(/:\d+@/, "@");
-}
-/**
- * Minimal PresenceCapable view over a raw socket. Transitional shim used
- * by kernel code that still works with a raw sock instead of a full
- * PlatformAdapter — goes away once that code is migrated.
- *
- * @param {WASocket} sock
- * @returns {PresenceCapable}
- */
-export function toPresenceCapable(sock) {
-    return {
-        capabilities: new CapabilitySet(["presence"]),
-        setPresence: (chatId, state) => sock.sendPresenceUpdate(state, chatId),
-    };
-}

package/dist/drivers/jid.js

@@ -0,0 +1,31 @@
+// Neutral JID utilities used by both Baileys and WhatsMeow drivers.
+/**
+ * Normalize a JID to the internal "@c.us" format used in ManyBot configs.
+ * Groups (@g.us) and broadcasts are passed through unchanged.
+ */
+export function normalizeJid(jid) {
+    if (!jid)
+        return jid;
+    return jid
+        .replace(/@s\.whatsapp\.net$/, "@c.us")
+        .replace(/:\d+@/, "@");
+}
+/**
+ * Reverse of normalizeJid – convert back to the raw wire format "@s.whatsapp.net".
+ */
+export function denormalizeJid(jid) {
+    return jid.replace(/@c\.us$/, "@s.whatsapp.net");
+}
+/**
+ * Convert any identifier (phone number, already‑wire JID, or framework JID) to the
+ * wire JID format WhatsApp expects ("...@s.whatsapp.net").
+ */
+export function toWireJid(id) {
+    const trimmed = id.trim();
+    if (/@(s\.whatsapp\.net|lid|g\.us)$/.test(trimmed))
+        return trimmed;
+    if (trimmed.endsWith("@c.us"))
+        return denormalizeJid(trimmed);
+    const digits = trimmed.replace(/\D/g, "");
+    return `${digits}@s.whatsapp.net`;
+}

package/dist/drivers/types.js

@@ -0,0 +1,14 @@
+/**
+ * src/drivers/types.ts
+ *
+ * Driver-neutral envelope types shared by every WhatsApp driver
+ * implementation (Baileys today, whatsmeow in a later phase). The
+ * full driver surface (send, react, presence, contacts, groups,
+ * profile, media) is declared as `WaContract` in `#kernel/waContract.js`
+ * — every driver implements it. This module holds only the message
+ * shapes that flow across the driver boundary.
+ *
+ * Plugins depend on these types through the `WaContract` re-exports,
+ * never on a specific driver's Baileys/grpc types.
+ */
+export {};

package/dist/drivers/whatsmeow/client.js

@@ -0,0 +1,203 @@
+import { logger } from "#logger";
+import { CONFIG } from "#config";
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+import path from "path";
+import { fileURLToPath } from "node:url";
+/**
+ * Whatsmeow gRPC client implementing the WaContract interface.
+ *
+ * Phase 1 scope: only the send path (sendText) and the
+ * verification primitives (getHistory) are fully wired. Every other
+ * WaContract method throws "not implemented" — the kernel loads plugins
+ * only after `connection.update === "open"`, and a plugin that calls e.g.
+ * `groupMetadata` on a whatsmeow-primary bot will surface a clear error
+ * to the caller, not a silent no-op.
+ *
+ * Connects to the address defined in config (default localhost:50051).
+ */
+class WhatsmeowClient {
+    name = "whatsmeow";
+    client; // grpc client stub
+    ready = false;
+    handlers = new Map();
+    /**
+     * Resolve the .proto path relative to this compiled module so it works
+     * in ESM (where __dirname doesn't exist), under `node dist/main.js`
+     * (proto is copied to dist/drivers/whatsmeow/whatsmeow.proto by the
+     * build), and under a global npm install (the proto ships alongside
+     * the JS in the package's `dist/` per `files` in package.json). In
+     * dev (`tsx src/main.ts`) the proto already lives next to this source
+     * file, so the same relative path resolves correctly there too.
+     */
+    resolveProtoPath() {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        return path.resolve(here, "whatsmeow.proto");
+    }
+    loadProto() {
+        const protoPath = this.resolveProtoPath();
+        const packageDef = protoLoader.loadSync(protoPath, {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+        });
+        const grpcObj = grpc.loadPackageDefinition(packageDef);
+        return grpcObj.whatsmeow.WhatsmeowService;
+    }
+    async connect() {
+        const address = CONFIG.drivers.whatsmeow.grpcAddress ?? "localhost:50051";
+        const Service = this.loadProto();
+        this.client = new Service(address, grpc.credentials.createInsecure());
+        // Perform a health check to confirm service is ready
+        await new Promise((resolve, reject) => {
+            this.client.HealthCheck({}, (err, resp) => {
+                if (err)
+                    return reject(err);
+                this.ready = !!resp?.ready;
+                if (this.ready)
+                    resolve();
+                else
+                    reject(new Error("Whatsmeow service not ready"));
+            });
+        });
+        logger.info("[whatsmeow] connected via gRPC");
+        // Open the server-streaming event subscription. Each WaEvent that
+        // arrives is fanned out to the local on() subscribers in the
+        // neutral envelope shape.
+        const stream = this.client.SubscribeEvents({});
+        stream.on("data", (raw) => {
+            try {
+                if (raw.connState) {
+                    const state = raw.connState.state ?? "connecting";
+                    this.dispatch("connection.update", {
+                        connection: state === "open" ? "open" : state === "close" ? "close" : "connecting",
+                    });
+                }
+                else if (raw.message) {
+                    this.dispatch("messages.upsert", {
+                        messages: [raw.message],
+                        type: "notify",
+                    });
+                }
+            }
+            catch (e) {
+                logger.debug(`[whatsmeow] event dispatch failed: ${e.message}`);
+            }
+        });
+        stream.on("error", (err) => {
+            logger.warn(`[whatsmeow] event stream error: ${err.message}`);
+            this.ready = false;
+        });
+        stream.on("end", () => {
+            logger.warn(`[whatsmeow] event stream ended`);
+            this.ready = false;
+        });
+    }
+    async disconnect() {
+        if (this.client) {
+            try {
+                await new Promise((resolve) => {
+                    this.client.Disconnect({}, () => resolve());
+                });
+            }
+            catch { }
+            this.client.close();
+        }
+        this.ready = false;
+    }
+    isReady() {
+        return this.ready;
+    }
+    // ── Event fan-out ─────────────────────────────────────────────────────────
+    on(event, handler) {
+        let set = this.handlers.get(event);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(event, set);
+        }
+        set.add(handler);
+        return () => set.delete(handler);
+    }
+    dispatch(event, payload) {
+        const set = this.handlers.get(event);
+        if (!set)
+            return;
+        for (const h of set) {
+            try {
+                h(payload);
+            }
+            catch (e) {
+                logger.debug(`[whatsmeow] handler for "${event}" threw: ${e.message}`);
+            }
+        }
+    }
+    // ── Send ───────────────────────────────────────────────────────────────────
+    // Only sendText is in phase-1 scope. Media fallback is
+    // documented in the interface but explicitly deferred.
+    async sendText(jid, text, opts) {
+        const req = {
+            jid,
+            text,
+            quotedId: opts?.quoted?.id ?? "",
+            mentions: opts?.mentions ?? [],
+        };
+        return new Promise((resolve, reject) => {
+            this.client.SendText(req, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve({ id: resp.id, chatId: resp.chatId, timestamp: Number(resp.timestamp) });
+            });
+        });
+    }
+    // ── Verification primitive ─────────────────────────────────────────────────
+    async getHistory(jid, opts) {
+        const req = { jid, limit: opts?.limit ?? 5 };
+        return new Promise((resolve, reject) => {
+            this.client.GetHistory(req, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.messages ?? []);
+            });
+        });
+    }
+    // ── All other WaContract methods: stubbed for now ─────────────────────────
+    // These throw a clear error so a plugin calling them on a whatsmeow-
+    // primary bot fails loudly instead of silently no-op'ing. Coverage will
+    // grow in later phases as the whatsmeow .proto grows.
+    unimplemented(method) {
+        throw new Error(`[whatsmeow] ${method} not implemented in whatsmeow driver yet`);
+    }
+    async resolveLid(_lid) { return null; }
+    async sendImage(_jid, _buffer, _opts) { this.unimplemented("sendImage"); }
+    async sendVideo(_jid, _buffer, _opts) { this.unimplemented("sendVideo"); }
+    async sendAudio(_jid, _buffer, _opts) { this.unimplemented("sendAudio"); }
+    async sendSticker(_jid, _buffer, _opts) { this.unimplemented("sendSticker"); }
+    async sendDocument(_jid, _buffer, _filename, _mimetype, _opts) { this.unimplemented("sendDocument"); }
+    async sendPoll(_jid, _opts) { this.unimplemented("sendPoll"); }
+    async react(_jid, _target, _emoji) { this.unimplemented("react"); }
+    async deleteMessage(_jid, _target, _forEveryone) { this.unimplemented("deleteMessage"); }
+    async editMessage(_jid, _target, _text) { this.unimplemented("editMessage"); }
+    async sendPresenceUpdate(_state, _jid) { this.unimplemented("sendPresenceUpdate"); }
+    async readMessages(_keys) { this.unimplemented("readMessages"); }
+    async onWhatsApp(_jid) { this.unimplemented("onWhatsApp"); }
+    async getBusinessProfile(_jid) { this.unimplemented("getBusinessProfile"); }
+    async profilePictureUrl(_jid) { this.unimplemented("profilePictureUrl"); }
+    async fetchStatus(_jid) { this.unimplemented("fetchStatus"); }
+    async updateBlockStatus(_jid, _action) { this.unimplemented("updateBlockStatus"); }
+    async addOrEditContact(_jid, _info) { this.unimplemented("addOrEditContact"); }
+    async removeContact(_jid) { this.unimplemented("removeContact"); }
+    async groupMetadata(_jid) { this.unimplemented("groupMetadata"); }
+    async groupParticipantsUpdate(_jid, _users, _action) { this.unimplemented("groupParticipantsUpdate"); }
+    async groupUpdateSubject(_jid, _subject) { this.unimplemented("groupUpdateSubject"); }
+    async groupUpdateDescription(_jid, _description) { this.unimplemented("groupUpdateDescription"); }
+    async groupInviteCode(_jid) { this.unimplemented("groupInviteCode"); }
+    async groupRevokeInvite(_jid) { this.unimplemented("groupRevokeInvite"); }
+    async updateProfilePicture(_jid, _buffer) { this.unimplemented("updateProfilePicture"); }
+    async updateProfileName(_name) { this.unimplemented("updateProfileName"); }
+    async updateProfileStatus(_status) { this.unimplemented("updateProfileStatus"); }
+    me() { this.unimplemented("me"); }
+    async downloadMedia(_msg, _opts) { this.unimplemented("downloadMedia"); }
+}
+export const whatsmeowContract = new WhatsmeowClient();

package/dist/drivers/whatsmeow/index.js

@@ -0,0 +1,79 @@
+/**
+ * drivers/whatsmeow/index.ts
+ *
+ * Public surface of the whatsmeow driver:
+ *   - whatsmeowContract         : the raw contract (test-only / fallback path)
+ *   - wrapWithSupervisor(...)   : returns a contract whose lifecycle
+ *                                 methods (connect / disconnect / isReady)
+ *                                 are gated on the supervisor state
+ *
+ * The supervisor is the lifecycle authority for the subprocess; this
+ * proxy exists so the DriverManager sees one contract whose `isReady()`
+ * never lies — true only when both the gRPC client is up AND the
+ * subprocess has answered HealthCheck{ready:true}.
+ */
+import { whatsmeowContract } from "./client.js";
+export { whatsmeowContract };
+export { startWhatsmeowSupervisor } from "./supervisor.js";
+/**
+ * Wraps a raw whatsmeow contract so its lifecycle methods delegate to
+ * the supervisor. Send/event methods still pass through unchanged —
+ * the contract already knows how to talk gRPC; the supervisor only
+ * owns "is it safe to use right now?".
+ */
+export function wrapWithSupervisor(contract, supervisor) {
+    return {
+        name: contract.name,
+        async connect() {
+            await supervisor.whenReady();
+            await contract.connect();
+        },
+        async disconnect() {
+            // Try to stop the subprocess too — disconnecting the contract
+            // alone would leave the Go process running until the bot shuts
+            // down. Idempotent; safe to call multiple times.
+            await Promise.allSettled([
+                contract.disconnect(),
+                supervisor.shutdown(),
+            ]);
+        },
+        isReady: () => supervisor.isReady() && contract.isReady(),
+        on: (...args) => contract.on(...args),
+        resolveLid: contract.resolveLid
+            ? (lid) => contract.resolveLid(lid)
+            : undefined,
+        sendText: (...args) => contract.sendText(...args),
+        sendImage: (...args) => contract.sendImage(...args),
+        sendVideo: (...args) => contract.sendVideo(...args),
+        sendAudio: (...args) => contract.sendAudio(...args),
+        sendSticker: (...args) => contract.sendSticker(...args),
+        sendDocument: (...args) => contract.sendDocument(...args),
+        sendPoll: (...args) => contract.sendPoll(...args),
+        react: (...args) => contract.react(...args),
+        deleteMessage: (...args) => contract.deleteMessage(...args),
+        editMessage: (...args) => contract.editMessage(...args),
+        sendPresenceUpdate: (...args) => contract.sendPresenceUpdate(...args),
+        readMessages: (...args) => contract.readMessages(...args),
+        onWhatsApp: (...args) => contract.onWhatsApp(...args),
+        getBusinessProfile: (...args) => contract.getBusinessProfile(...args),
+        profilePictureUrl: (...args) => contract.profilePictureUrl(...args),
+        fetchStatus: (...args) => contract.fetchStatus(...args),
+        updateBlockStatus: (...args) => contract.updateBlockStatus(...args),
+        addOrEditContact: (...args) => contract.addOrEditContact(...args),
+        removeContact: (...args) => contract.removeContact(...args),
+        groupMetadata: (...args) => contract.groupMetadata(...args),
+        groupParticipantsUpdate: (...args) => contract.groupParticipantsUpdate(...args),
+        groupUpdateSubject: (...args) => contract.groupUpdateSubject(...args),
+        groupUpdateDescription: (...args) => contract.groupUpdateDescription(...args),
+        groupInviteCode: (...args) => contract.groupInviteCode(...args),
+        groupRevokeInvite: (...args) => contract.groupRevokeInvite(...args),
+        updateProfilePicture: (...args) => contract.updateProfilePicture(...args),
+        updateProfileName: (...args) => contract.updateProfileName(...args),
+        updateProfileStatus: (...args) => contract.updateProfileStatus(...args),
+        me: () => contract.me(),
+        downloadMedia: (...args) => contract.downloadMedia(...args),
+        getHistory: contract.getHistory
+            ? (...args) => contract.getHistory(...args)
+            : undefined,
+    };
+}

package/dist/drivers/whatsmeow/installer.js

@@ -0,0 +1,70 @@
+import { mkdirSync, writeFileSync, chmodSync } from "node:fs";
+import path from "node:path";
+import * as clack from "@clack/prompts";
+import { persistConfigValue } from "#config";
+import { t } from "#i18n";
+const SUPPORTED = [
+    { os: "linux", arch: "x64", name: "whatsmeow-service-linux-x64" },
+    { os: "linux", arch: "arm64", name: "whatsmeow-service-linux-arm64" },
+    { os: "win32", arch: "x64", name: "whatsmeow-service-windows-x64.exe" },
+];
+function detectTarget() {
+    return SUPPORTED.find((t) => t.os === process.platform && t.arch === process.arch) ?? null;
+}
+function str(val) {
+    return typeof val === "string" ? val : String(val);
+}
+async function fetchLatestTag() {
+    const res = await fetch("https://api.github.com/repos/many-bot/manybot/releases/latest");
+    if (!res.ok)
+        throw new Error(`GitHub API: ${res.status}`);
+    const data = await res.json();
+    return data.tag_name ?? "v5.6.1";
+}
+function binaryDir() {
+    return path.resolve(process.cwd(), "whatsmeow-service", "bin");
+}
+export async function promptWhatsmeowInstall() {
+    const target = detectTarget();
+    if (!target) {
+        clack.log.warn(str(t("whatsmeow.unsupportedArch", { os: process.platform, arch: process.arch })));
+        return;
+    }
+    const choice = await clack.confirm({
+        message: str(t("whatsmeow.installPrompt")),
+        initialValue: false,
+    });
+    if (clack.isCancel(choice) || !choice)
+        return;
+    const spin = clack.spinner();
+    spin.start(str(t("whatsmeow.fetchingTag")));
+    let tag;
+    try {
+        tag = await fetchLatestTag();
+    }
+    catch {
+        spin.stop(str(t("whatsmeow.fetchFailed")));
+        return;
+    }
+    const url = `https://github.com/many-bot/manybot/releases/download/${tag}/${target.name}`;
+    spin.message(str(t("whatsmeow.downloading", { url })));
+    let res;
+    try {
+        res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`${res.status}`);
+    }
+    catch (e) {
+        spin.stop(str(t("whatsmeow.downloadFailed", { reason: e.message })));
+        return;
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const dir = binaryDir();
+    mkdirSync(dir, { recursive: true });
+    const outPath = path.join(dir, "whatsmeow-service");
+    writeFileSync(outPath, buffer);
+    chmodSync(outPath, 0o755);
+    await persistConfigValue("driver_whatsmeow_enabled", "true");
+    spin.stop(str(t("whatsmeow.installed", { path: outPath })));
+    clack.note(str(t("whatsmeow.restartNotice")), str(t("whatsmeow.installTitle")));
+}