@manybot/manybot 5.8.0 → 5.9.1

package/dist/drivers/baileys/messageHandler.js

@@ -10,8 +10,16 @@
  *   3. Pass context to all active plugins
  *
  * Each plugin decides whether to act or ignore.
+ *
+ * v6 loading indicators: a matched command may declare a `loading:` spec
+ * (or reference a top-level `loading_presets:` preset) which controls
+ * the user-visible "processando..." signal — `reaction`, `typing`,
+ * `recording_audio`, `spinner`, or `none`. The spec is resolved at
+ * registry build time (defaults → category → command → sub), so by the
+ * time the dispatch path reads it we only have to apply it.
  */
-import { CHATS, EXCLUDE_CHATS, CMD_PREFIX } from "#config";
+import { CHATS, EXCLUDE_CHATS } from "#config";
+import { getChatPrefix, getChatLocale } from "#kernel/chatOverrides.js";
 import { buildApi, buildChatFromMsg, buildMessageContext } from "./api/index.js";
 import { pluginRegistry } from "#kernel/pluginLoader.js";
 import { getCommandByInvocation, getCommandRegistry } from "#kernel/commandRegistry.js";
@@ -36,6 +44,122 @@ function extractCommand(body, prefix) {
     const first = body.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
     return first.startsWith(prefix) ? first.slice(prefix.length) : "";
 }
+/**
+ * Drive the per-command loading indicator described by the registry.
+ *
+ * - `reaction`        : drop an emoji reaction on the source message,
+ *                       update with onSuccess/onError on completion.
+ * - `typing`          : native WhatsApp "typing..." presence, refreshed
+ *                       on a 4s interval; cleared on completion.
+ * - `recording_audio` : native WhatsApp "recording audio..." presence,
+ *                       same interval/clear semantics as typing.
+ * - `spinner`         : self-sent message showing a frame sequence,
+ *                       edited every `intervalMs` (default 1500); last
+ *                       frame stays on completion.
+ * - `none`            : no-op — caller doesn't see a difference.
+ *
+ * All best-effort: any driver-level failure is logged at `warn` level
+ * and swallowed so a broken indicator never breaks a command.
+ */
+function startLoadingIndicator(spec, contract, rawJid, msgKey) {
+    const noop = async () => { };
+    if (!spec)
+        return { stop: noop };
+    if (spec.type === "reaction") {
+        const icon = spec.icon ?? "⏳";
+        if (msgKey) {
+            contract.react(rawJid, msgKey, icon).catch((e) => {
+                const err = e instanceof Error ? e : new Error(String(e));
+                logger.warn(`[messageHandler] loading.reaction send failed: ${err.message}`);
+            });
+        }
+        return {
+            stop: async (outcome) => {
+                if (!msgKey)
+                    return;
+                const next = outcome === "success" ? spec.onSuccess : spec.onError;
+                try {
+                    await contract.react(rawJid, msgKey, next ?? "");
+                }
+                catch (e) {
+                    const err = e instanceof Error ? e : new Error(String(e));
+                    logger.warn(`[messageHandler] loading.reaction clear failed: ${err.message}`);
+                }
+            },
+        };
+    }
+    if (spec.type === "typing" || spec.type === "recording_audio") {
+        const presence = spec.type === "typing" ? "composing" : "recording";
+        const interval = setInterval(() => {
+            contract.sendPresenceUpdate(presence, rawJid).catch(() => { });
+        }, 4000);
+        contract.sendPresenceUpdate(presence, rawJid).catch(() => { });
+        return {
+            stop: async () => {
+                clearInterval(interval);
+                contract.sendPresenceUpdate("paused", rawJid).catch(() => { });
+            },
+        };
+    }
+    if (spec.type === "spinner") {
+        const frames = spec.frames && spec.frames.length > 0 ? spec.frames : ["⏳"];
+        const intervalMs = Math.max(1000, spec.intervalMs ?? 1500);
+        let frameIdx = 0;
+        let sentMsgId = null;
+        const cycle = async () => {
+            try {
+                if (sentMsgId === null) {
+                    const sent = await contract.sendText(rawJid, frames[0]);
+                    sentMsgId = sent.id;
+                }
+                else {
+                    frameIdx = (frameIdx + 1) % frames.length;
+                    await contract.editMessage(rawJid, { id: sentMsgId, remoteJid: rawJid, fromMe: true }, frames[frameIdx]);
+                }
+            }
+            catch {
+                // Spinner is best-effort — leave the previous frame in place
+                // when an edit fails rather than aborting the whole indicator.
+            }
+        };
+        cycle().catch(() => { });
+        const interval = setInterval(() => { cycle().catch(() => { }); }, intervalMs);
+        return {
+            stop: async (outcome) => {
+                clearInterval(interval);
+                if (sentMsgId !== null) {
+                    const finalText = outcome === "success" ? spec.onSuccess : spec.onError;
+                    try {
+                        if (finalText !== undefined) {
+                            await contract.editMessage(rawJid, { id: sentMsgId, remoteJid: rawJid, fromMe: true }, finalText);
+                        }
+                        else {
+                            await contract.deleteMessage(rawJid, { id: sentMsgId, remoteJid: rawJid, fromMe: true }, true);
+                        }
+                    }
+                    catch (e) {
+                        const err = e instanceof Error ? e : new Error(String(e));
+                        logger.warn(`[messageHandler] loading.spinner finalize failed: ${err.message}`);
+                    }
+                }
+            },
+        };
+    }
+    // `none` or any future variant — nothing to do.
+    return { stop: noop };
+}
+/**
+ * Resolve the loading spec for the matched command/sub. Subcommands win
+ * (their own chain inheritance ran at registry build time); falls back
+ * to the parent's resolved spec.
+ */
+function resolveLoadingForDispatch(entry, resolution) {
+    if (resolution.target.kind === "sub")
+        return resolution.target.sub.loading ?? entry.loading;
+    if (resolution.target.kind === "parent")
+        return entry.loading;
+    return null;
+}
 // ── Dedup of already-processed messages ────────────────────────────────────
 // WhatsApp resends messages without a delivery/read confirmation (the
 // protocol's own retry, usually up to 3 times) when the socket reconnects.
@@ -107,18 +231,39 @@ export async function handleMessage(msg, contract, store) {
     // Caps how many chats get answered at the same time — see SECURITY_LEVEL.
     const releaseChatSlot = await acquireChatSlot(jid);
     try {
-        await runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid);
+        await runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid, rawKey);
     }
     finally {
         releaseChatSlot();
     }
 }
-async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid) {
-    const command = extractCommand(msgCtx.body, CMD_PREFIX);
+async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid, rawKey) {
+    const chatPrefix = getChatPrefix(msg.chatId);
+    const chatLocale = getChatLocale(msg.chatId);
+    const command = extractCommand(msgCtx.body, chatPrefix);
     const registry = getCommandRegistry();
     // 0. Welcome message (first message within the configured window)
-    if (registry) {
-        const welcomeMsg = checkAndTriggerWelcomeMessage(msgCtx.sender, registry);
+    //
+    // Two gates before we even consider firing the welcome:
+    //
+    //   - `!msg.fromMe`: skip when the bot itself "sent" the message
+    //     that triggered this dispatch. Baileys' history-sync replays
+    //     the bot's own outgoing messages as `messages.upsert` with
+    //     `fromMe=true` on every reconnect — without this gate, the
+    //     bot would greet itself in its own DM/group on every restart
+    //     the moment history-sync completes. The welcome is for
+    //     *incoming* messages only.
+    //
+    //   - `!chat.isGroup`: skip when the message arrived in a group.
+    //     A new member joining a group shouldn't get a per-member
+    //     welcome reply inside the group's conversation — it's noise
+    //     and reads weird in front of everyone else. The welcome is
+    //     only meaningful in a 1:1 (DM) chat where the message
+    //     originates from the user being greeted, and where the reply
+    //     goes back to the same chat (`msgCtx.reply` already targets
+    //     the source chat).
+    if (registry && !msg.fromMe && !chat.isGroup) {
+        const welcomeMsg = checkAndTriggerWelcomeMessage(msgCtx.sender ?? msg.chatId, registry, { body: msgCtx.body, timestamp: msg.timestamp }, chatLocale, chatPrefix);
         if (welcomeMsg) {
             try {
                 await msgCtx.reply.text(welcomeMsg);
@@ -131,9 +276,9 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
     }
     // 1. Menu aliases match (overview / category / manual / notFound)
     if (command && registry && registry.menuAliases.has(command)) {
-        const rawArgs = msgCtx.body.trim().slice(CMD_PREFIX.length + command.length).trim();
+        const rawArgs = msgCtx.body.trim().slice(chatPrefix.length + command.length).trim();
         const scope = chat.isGroup ? "group" : "dm";
-        const menuResponse = handleMenuCommand(command, rawArgs, registry, undefined, scope);
+        const menuResponse = handleMenuCommand(command, rawArgs, registry, chatLocale, scope);
         try {
             await msgCtx.reply.text(menuResponse);
         }
@@ -150,7 +295,7 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
     // active in production. Kept separate from the `matched` top-level
     // permission pre-check further down (unchanged, still gates the whole
     // per-message plugin loop exactly as before `runCommand` existed).
-    const rawArgsForDispatch = command ? msgCtx.body.trim().slice(CMD_PREFIX.length + command.length).trim() : "";
+    const rawArgsForDispatch = command ? msgCtx.body.trim().slice(chatPrefix.length + command.length).trim() : "";
     const resolution = command ? resolveDispatch(command, rawArgsForDispatch) : { target: { kind: "none" } };
     if (matched) {
         const permApi = buildApi({
@@ -165,7 +310,7 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
         const permResult = await checkPermission(matched, {
             isGroup: permApi.chat.isGroup,
             chatId: permApi.chat.id,
-            senderId: msgCtx.sender,
+            sender: { lid: msgCtx.sender, pn: msgCtx.senderPn },
             isSenderAdmin: () => permApi.chat.isSenderAdmin(),
             isBotAdmin: () => permApi.chat.isBotAdmin(),
         });
@@ -186,7 +331,7 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
     // invoke any plugin (legacy or migrated) for this message.
     if (matched && matched.source === "text" && matched.text !== null) {
         try {
-            const textContent = resolveLocalizedString(matched.text) ?? "";
+            const textContent = resolveLocalizedString(matched.text, chatLocale) ?? "";
             await msgCtx.reply.text(textContent);
         }
         catch (e) {
@@ -216,6 +361,37 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
         }
     }
     const matchedPlugin = matched && matched.source === "plugin" ? matched : null;
+    // "core" (ping/status/config/...) is a synthetic pseudo-plugin: it only
+    // exists in a *local* `allPlugins` map built inside commandRegistry.ts
+    // for registry-building purposes — it is never inserted into the real
+    // `pluginRegistry` singleton that the loop below iterates. Left as-is,
+    // no "core"-sourced command could ever be dispatched (runCommand() would
+    // never be called for it, plugin count or not), so it's handled here
+    // explicitly, once, before the real-plugin loop.
+    if (matchedPlugin && matchedPlugin.pluginName === "core") {
+        const coreCtx = buildApi({
+            msg,
+            chat,
+            contract,
+            store,
+            pluginRegistry,
+            pluginName: "core",
+            guardOptions: {},
+        });
+        const coreLoading = startLoadingIndicator(resolveLoadingForDispatch(matchedPlugin, resolution), contract, rawJid, rawKey);
+        let coreOutcome = "success";
+        try {
+            await runCommand({ pluginName: "core", ctx: coreCtx, resolution, reply: msgCtx.reply, chatId: msg.chatId });
+        }
+        catch (e) {
+            coreOutcome = "error";
+            const err = e instanceof Error ? e : new Error(String(e));
+            logger.warn(`[messageHandler] runCommand crashed for core: ${err.message}`);
+        }
+        finally {
+            await coreLoading.stop(coreOutcome);
+        }
+    }
     for (const plugin of pluginRegistry.values()) {
         const ctx = buildApi({
             msg,
@@ -226,7 +402,7 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
             pluginName: plugin.name,
             guardOptions: plugin.guardOptions,
         });
-        const useTyping = plugin.guardOptions?.typing !== false;
+        const useTyping = !matchedPlugin && plugin.guardOptions?.typing !== false;
         let typingInterval;
         if (useTyping) {
             // Refresh presence every 4s so WhatsApp doesn't auto-clear it
@@ -244,16 +420,26 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
             // this same plugin that did NOT match the registry) keep their legacy
             // run(ctx).
             if (matchedPlugin && matchedPlugin.pluginName === plugin.name && matchedPlugin.handler) {
-                // runCommand() opts into rethrow so its Phase-8 fireAlert("plugin_crash")
-                // catch actually runs (runPlugin() swallows by default — see pluginGuard.ts).
-                // Swallow here too, at the boundary: this loop must never crash the bot,
-                // same guarantee the legacy runPlugin(plugin, ctx) branch below already has.
+                // Loading indicator: the resolved spec is read once per dispatch
+                // and drives start/stop around the runCommand call.
+                const loading = startLoadingIndicator(resolveLoadingForDispatch(matchedPlugin, resolution), contract, rawJid, rawKey);
+                let outcome = "success";
                 try {
-                    await runCommand({ pluginName: plugin.name, ctx, resolution, reply: msgCtx.reply });
+                    // runCommand() opts into rethrow so its Phase-8 fireAlert("plugin_crash")
+                    // catch actually runs (runPlugin() swallows by default — see pluginGuard.ts).
+                    // Swallow here too, at the boundary: this loop must never crash the bot,
+                    // same guarantee the legacy runPlugin(plugin, ctx) branch below already has.
+                    try {
+                        await runCommand({ pluginName: plugin.name, ctx, resolution, reply: msgCtx.reply, chatId: msg.chatId });
+                    }
+                    catch (e) {
+                        outcome = "error";
+                        const err = e instanceof Error ? e : new Error(String(e));
+                        logger.warn(`[messageHandler] runCommand crashed for plugin "${plugin.name}": ${err.message}`);
+                    }
                 }
-                catch (e) {
-                    const err = e instanceof Error ? e : new Error(String(e));
-                    logger.warn(`[messageHandler] runCommand crashed for plugin "${plugin.name}": ${err.message}`);
+                finally {
+                    await loading.stop(outcome);
                 }
             }
             else {
@@ -273,7 +459,7 @@ async function runPluginsForMessage(msg, chat, msgCtx, contract, store, rawJid)
     // alongside this fallback.
     if (!matched && command && registry?.menu.notFoundFallback) {
         try {
-            await msgCtx.reply.text(renderNotFound(command, registry));
+            await msgCtx.reply.text(renderNotFound(command, registry, chatLocale));
         }
         catch (e) {
             const err = e instanceof Error ? e : new Error(String(e));