@manybot/manybot 5.8.0 → 5.9.0

package/dist/drivers/baileys/messageHandler.test.js

@@ -5,6 +5,14 @@ import { handleMessage } from "#drivers/baileys/messageHandler.js";
 import { pluginRegistry } from "#kernel/pluginLoader.js";
 import { buildCommandRegistry, __setRegistryForTests } from "#kernel/commandRegistry.js";
 import { getDriverManager, _resetDriverManagerForTests } from "#kernel/driverManager.js";
+import { buildSettingsApi } from "#kernel/settingsDb.js";
+import { CONFIG } from "#config";
+// Pin the "no override" global language independently of whatever
+// ~/.manybot/manybot.toml happens to say on the machine running the
+// suite — CONFIG.LANGUAGE is read from the real config dir unless
+// MANYBOT_CONFIG_DIR is set, and i18n's `currentLang` locks in on the
+// first t()/tFor() call, so this must run before any test does.
+CONFIG.LANGUAGE = "en";
 // ── Minimal spec builders (mirrors kernel/runCommand.test.ts conventions) ──
 function emptySpec(overrides) {
     return {
@@ -12,7 +20,8 @@ function emptySpec(overrides) {
         cmd: overrides.cmd ?? "task",
         aliases: overrides.aliases ?? [],
         plugin: overrides.plugin ?? "taskPlugin",
-        function: overrides.function ?? "runFn",
+        functions: overrides.functions ?? ["runFn"],
+        loading: overrides.loading ?? null,
         text: overrides.text ?? null,
         desc: overrides.desc ?? null,
         category: overrides.category ?? null,
@@ -31,7 +40,8 @@ function emptySub(overrides) {
         id: overrides.id ?? "task::list",
         cmd: overrides.cmd ?? "list",
         aliases: overrides.aliases ?? [],
-        function: overrides.function ?? null,
+        functions: overrides.functions ?? null,
+        loading: overrides.loading ?? null,
         desc: overrides.desc ?? null,
         manual: overrides.manual ?? null,
         arguments: overrides.arguments ?? [],
@@ -42,6 +52,11 @@ function emptySub(overrides) {
 // ── Mock WaContract — only the surface handleMessage's pipeline touches ────
 function createMockContract() {
     const sentTexts = [];
+    const reactions = [];
+    const presences = [];
+    const deletions = [];
+    const edits = [];
+    const sentHistory = [];
     let msgSeq = 0;
     const contract = {
         name: "baileys",
@@ -52,7 +67,18 @@ function createMockContract() {
         on: () => () => { },
         sendText: async (jid, text) => {
             sentTexts.push({ jid, text });
-            return { id: `msg-${++msgSeq}`, chatId: jid, timestamp: Date.now() };
+            const id = `msg-${++msgSeq}`;
+            sentHistory.push({
+                id,
+                chatId: jid,
+                fromMe: true,
+                contentHash: "hash",
+                timestamp: Date.now(),
+                type: "text",
+                body: text,
+                fromPn: "5511900000000@s.whatsapp.net",
+            });
+            return { id, chatId: jid, timestamp: Date.now() };
         },
         sendImage: async () => ({ id: "x", chatId: "x", timestamp: Date.now() }),
         sendVideo: async () => ({ id: "x", chatId: "x", timestamp: Date.now() }),
@@ -60,10 +86,18 @@ function createMockContract() {
         sendSticker: async () => ({ id: "x", chatId: "x", timestamp: Date.now() }),
         sendDocument: async () => ({ id: "x", chatId: "x", timestamp: Date.now() }),
         sendPoll: async () => ({ id: "x", chatId: "x", timestamp: Date.now() }),
-        react: async () => { },
-        deleteMessage: async () => { },
-        editMessage: async () => { },
-        sendPresenceUpdate: async () => { },
+        react: async (_jid, _key, emoji) => {
+            reactions.push({ jid: _jid, emoji });
+        },
+        deleteMessage: async (_jid, _key, forEveryone) => {
+            deletions.push({ jid: _jid, forEveryone });
+        },
+        editMessage: async (_jid, key, text) => {
+            edits.push({ jid: _jid, id: key.id ?? "", text });
+        },
+        sendPresenceUpdate: async (state, jid) => {
+            presences.push({ state, jid });
+        },
         readMessages: async () => { },
         onWhatsApp: async () => [{ exists: true }],
         getBusinessProfile: async () => null,
@@ -83,9 +117,12 @@ function createMockContract() {
         updateProfileStatus: async () => { },
         me: () => ({ id: "5511900000000@s.whatsapp.net" }),
         downloadMedia: async () => null,
-        getHistory: async () => [],
+        // Mirrors real Baileys behavior: sendText's result lands in history
+        // immediately (sendFallbackGuard's verifyDelivery does a t=0 lookup
+        // here to confirm the send before the caller's await resolves).
+        getHistory: async (jid) => sentHistory.filter(m => m.chatId === jid),
     };
-    return { contract, sentTexts };
+    return { contract, sentTexts, reactions, presences, deletions, edits };
 }
 function makeBotMessage(overrides = {}) {
     return {
@@ -100,13 +137,30 @@ function makeBotMessage(overrides = {}) {
         ...overrides,
     };
 }
-function buildRegistry(specs) {
-    return buildCommandRegistry(specs, pluginRegistry);
+function buildRegistry(specs, menu) {
+    if (!menu)
+        return buildCommandRegistry(specs, pluginRegistry);
+    return buildCommandRegistry(specs, pluginRegistry, undefined, {
+        title: "ManyBot — Menu",
+        intro: "Help menu",
+        footer: null,
+        cmd: "help",
+        aliases: ["help", "menu"],
+        notFoundFallback: false,
+        welcomeMessage: null,
+        welcomeWindowDays: 3,
+        pageSize: 15,
+        ...menu,
+    });
 }
 describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
     let store;
     let contract;
     let sentTexts;
+    let reactions;
+    let presences;
+    let deletions;
+    let edits;
     let runCalls;
     let listCalls;
     beforeEach(() => {
@@ -115,6 +169,10 @@ describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
         const mock = createMockContract();
         contract = mock.contract;
         sentTexts = mock.sentTexts;
+        reactions = mock.reactions;
+        presences = mock.presences;
+        deletions = mock.deletions;
+        edits = mock.edits;
         getDriverManager().register(contract, { isPrimary: true });
         runCalls = [];
         listCalls = [];
@@ -160,7 +218,7 @@ describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
         _resetDriverManagerForTests();
     });
     test("routes a matched subcommand to the subcommand handler, not the parent's, and replies", async () => {
-        const spec = emptySpec({ subcommands: [emptySub({ function: "listFn" })] });
+        const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
         __setRegistryForTests(buildRegistry([spec]));
         const msg = makeBotMessage({ body: "!task list" });
         await handleMessage(msg, contract, store);
@@ -175,8 +233,32 @@ describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
         assert.equal(sentTexts.length, 1);
         assert.equal(sentTexts[0].text, "done");
     });
+    // Regression test for the bug where "core" (ping/status/config/...)
+    // was never actually reachable from handleMessage(): it only ever
+    // existed in a *local* allPlugins map built inside commandRegistry.ts
+    // for registry-building purposes, never in the real pluginRegistry
+    // singleton the dispatch loop iterates — so runCommand() was never
+    // called for any core.* command, even though the registry itself
+    // resolved them fine (only !menu, which has its own separate dispatch
+    // path, worked). This must keep passing with 0 real plugins active.
+    test("a matched command sourced from the 'core' pseudo-plugin still dispatches and replies", async () => {
+        pluginRegistry.delete("taskPlugin"); // 0 real plugins active, same as the reported bug
+        const spec = emptySpec({
+            id: "core::ping",
+            cmd: "ping",
+            plugin: "core",
+            functions: ["ping"],
+        });
+        __setRegistryForTests(buildRegistry([spec]));
+        const msg = makeBotMessage({ body: "!ping" });
+        await handleMessage(msg, contract, store);
+        assert.equal(sentTexts.length, 1, "core.ping replied");
+        assert.equal(sentTexts[0].text, "pong");
+        // No restore needed: the next test's beforeEach() re-registers
+        // "taskPlugin" fresh regardless of what this test left behind.
+    });
     test("a crash inside the matched command's handler is swallowed at the messageHandler boundary", async () => {
-        const spec = emptySpec({ id: "task::crash", cmd: "crashcmd", function: "crashFn" });
+        const spec = emptySpec({ id: "task::crash", cmd: "crashcmd", functions: ["crashFn"] });
         __setRegistryForTests(buildRegistry([spec]));
         const msg = makeBotMessage({ body: "!crashcmd" });
         // The whole point of this session's fix: runCommand() now genuinely
@@ -188,7 +270,7 @@ describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
         assert.equal(sentTexts.length, 0, "no reply is sent for a crashed handler");
     });
     test("the message loop keeps working for the next message after a handler crash", async () => {
-        const crashSpec = emptySpec({ id: "task::crash", cmd: "crashcmd", function: "crashFn" });
+        const crashSpec = emptySpec({ id: "task::crash", cmd: "crashcmd", functions: ["crashFn"] });
         __setRegistryForTests(buildRegistry([crashSpec]));
         await handleMessage(makeBotMessage({ body: "!crashcmd" }), contract, store);
         // Swap in a healthy command and confirm a later message still dispatches
@@ -200,4 +282,164 @@ describe("drivers/baileys/messageHandler — v6 runCommand dispatch", () => {
         assert.equal(sentTexts.length, 1);
         assert.equal(sentTexts[0].text, "done");
     });
+    // ── Loading indicator wiring ───────────────────────────────────────────
+    describe("loading indicator (v6 reaction/typing/spinner)", () => {
+        test("reaction: drops the icon then clears on success", async () => {
+            const spec = emptySpec({ loading: { type: "reaction", icon: "🛠" } });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            assert.equal(reactions.length, 2, "start + final reaction");
+            assert.equal(reactions[0].emoji, "🛠");
+            assert.equal(reactions[1].emoji, "");
+        });
+        test("reaction: replaces with onSuccess emoji on success", async () => {
+            const spec = emptySpec({ loading: { type: "reaction", icon: "⏳", onSuccess: "✅" } });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            assert.equal(reactions.at(-1)?.emoji, "✅");
+        });
+        test("typing: emits composing presence + paused on completion", async () => {
+            const spec = emptySpec({ loading: { type: "typing" } });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            assert.ok(presences.some(p => p.state === "composing"), "composing presence was emitted");
+            assert.ok(presences.some(p => p.state === "paused"), "paused presence was emitted at end");
+        });
+        test("none: never calls react or sendPresenceUpdate for the indicator", async () => {
+            const spec = emptySpec({ loading: { type: "none" } });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            // reaction is never called — the loading indicator itself is a no-op.
+            assert.equal(reactions.length, 0, "no reactions emitted");
+            // Presence still shows up from simulateState() inside ctx.send.text()
+            // (api/index.ts) humanizing every outbound send.
+            // A "none" loading spec must add zero presence calls on top of that.
+            assert.equal(presences.filter(p => p.state === "paused" && p.jid === "5511888888888@s.whatsapp.net").length, 1, "paused presence came only from simulateState path");
+        });
+        test("spinner: sends a frame message and edits it on completion", async () => {
+            const spec = emptySpec({
+                loading: {
+                    type: "spinner",
+                    frames: ["⏳", "⌛"],
+                    intervalMs: 60000, // disable the interval so the test is deterministic
+                    onSuccess: "ready",
+                },
+            });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            // The first sendText from the spinner carries the first frame.
+            const spinnerSent = sentTexts.find(s => s.text === "⏳");
+            assert.ok(spinnerSent, "spinner sent the first frame");
+            assert.ok(edits.some(e => e.text === "ready"), "spinner was edited with onSuccess text");
+            assert.equal(deletions.length, 0, "onSuccess set: spinner is edited, not deleted");
+        });
+    });
+    // ── Welcome message gating ──────────────────────────────────────────────
+    // Regression coverage for the false-positive welcome: history-sync
+    // replays the bot's own past outgoing messages as `messages.upsert`
+    // (fromMe=true) on every reconnect, and welcome must never fire for a
+    // group chat either — only for a genuinely incoming DM.
+    describe("welcome message gating", () => {
+        const WELCOME_TEXT = "Bem-vindo! Use {prefix}help.";
+        function buildWelcomeRegistry() {
+            return buildRegistry([emptySpec({})], {
+                welcomeMessage: WELCOME_TEXT,
+                welcomeWindowDays: 3,
+            });
+        }
+        // Each test uses its own sender so the shared (in-memory) settings DB
+        // never leaks "already seen" state between tests, and clears it
+        // up front regardless, mirroring kernel/commandMenu.test.ts.
+        function freshSender(id) {
+            const jid = `55110000${id}@s.whatsapp.net`;
+            buildSettingsApi("kernel", jid).delete("last_welcome_seen");
+            return { chatId: jid, fromPn: jid };
+        }
+        test("fires on a genuine first incoming DM", async () => {
+            const { chatId, fromPn } = freshSender("0001");
+            __setRegistryForTests(buildWelcomeRegistry());
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "oi" }), contract, store);
+            assert.equal(sentTexts.length, 1, "welcome was sent");
+            assert.equal(sentTexts[0].text, "Bem-vindo! Use !help.");
+        });
+        test("does not fire for a history-sync replay of the bot's own message (fromMe=true)", async () => {
+            const { chatId, fromPn } = freshSender("0002");
+            __setRegistryForTests(buildWelcomeRegistry());
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: true, body: "oi" }), contract, store);
+            assert.equal(sentTexts.length, 0, "no welcome sent for a fromMe message");
+        });
+        test("does not fire for a message received in a group chat", async () => {
+            const { fromPn } = freshSender("0003");
+            const groupChatId = "120363000000000000@g.us";
+            buildSettingsApi("kernel", groupChatId).delete("last_welcome_seen");
+            __setRegistryForTests(buildWelcomeRegistry());
+            await handleMessage(makeBotMessage({ chatId: groupChatId, fromPn, fromMe: false, body: "oi" }), contract, store);
+            assert.equal(sentTexts.length, 0, "no welcome sent for a group message");
+        });
+        test("does not fire twice within the welcome window for the same sender", async () => {
+            const { chatId, fromPn } = freshSender("0004");
+            __setRegistryForTests(buildWelcomeRegistry());
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "oi" }), contract, store);
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "oi de novo" }), contract, store);
+            assert.equal(sentTexts.length, 1, "welcome only sent once inside the window");
+        });
+        test("does not fire when the registry has no welcomeMessage configured", async () => {
+            const { chatId, fromPn } = freshSender("0005");
+            __setRegistryForTests(buildRegistry([emptySpec({})])); // default menu: welcomeMessage: null
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "oi" }), contract, store);
+            assert.equal(sentTexts.length, 0, "no welcome sent when unconfigured");
+        });
+        test("does not fire for an offline-flush misclassified receipt message (empty body)", async () => {
+            const { chatId, fromPn } = freshSender("0006");
+            __setRegistryForTests(buildWelcomeRegistry());
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "" }), contract, store);
+            assert.equal(sentTexts.length, 0, "no welcome sent for an empty body");
+        });
+        test("does not fire for an offline-flush delayed message (stale timestamp)", async () => {
+            const { chatId, fromPn } = freshSender("0007");
+            __setRegistryForTests(buildWelcomeRegistry());
+            const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
+            await handleMessage(makeBotMessage({ chatId, fromPn, fromMe: false, body: "oi", timestamp: twoHoursAgo }), contract, store);
+            assert.equal(sentTexts.length, 0, "no welcome sent for a stale message");
+        });
+    });
+    // ── Per-chat !config overrides (prefix / language) ─────────────────────
+    describe("per-chat overrides (!config prefixo / !config idioma)", () => {
+        // makeBotMessage()'s default chatId ("5511888888888@s.whatsapp.net")
+        // normalized the same way buildApi() scopes ctx.settings.
+        const normalizedChatId = "5511888888888@c.us";
+        afterEach(() => {
+            buildSettingsApi("core", normalizedChatId).deleteAll();
+        });
+        test("a saved prefix override changes which prefix the bot actually parses", async () => {
+            buildSettingsApi("core", normalizedChatId).set("chat_prefix", "#");
+            __setRegistryForTests(buildRegistry([emptySpec({})]));
+            await handleMessage(makeBotMessage({ body: "#task" }), contract, store);
+            assert.equal(runCalls.length, 1, "the new '#' prefix dispatches the command");
+            assert.equal(sentTexts[0].text, "done");
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            assert.equal(runCalls.length, 1, "the old '!' prefix no longer matches for this chat");
+        });
+        test("without an override the global prefix still works", async () => {
+            __setRegistryForTests(buildRegistry([emptySpec({})]));
+            await handleMessage(makeBotMessage({ body: "!task" }), contract, store);
+            assert.equal(runCalls.length, 1);
+            assert.equal(sentTexts[0].text, "done");
+        });
+        test("a saved language override changes the language of a kernel-authored reply (unknown subcommand)", async () => {
+            buildSettingsApi("core", normalizedChatId).set("chat_locale", "pt");
+            const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task wat" }), contract, store);
+            assert.equal(sentTexts.length, 1);
+            assert.match(sentTexts[0].text, /Subcomando "wat" desconhecido/);
+        });
+        test("without an override the unknown-subcommand reply uses the global language", async () => {
+            const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+            __setRegistryForTests(buildRegistry([spec]));
+            await handleMessage(makeBotMessage({ body: "!task wat" }), contract, store);
+            assert.equal(sentTexts.length, 1);
+            assert.match(sentTexts[0].text, /Unknown subcommand "wat"/);
+        });
+    });
 });

package/dist/drivers/baileysAdapter.test.js

@@ -40,6 +40,64 @@ test("Baileys sends messages with the chat's disappearing-message timer", async
     await contract.sendText("group@g.us", "group text");
     assert.equal((calls.at(-1)?.[2]).ephemeralExpiration, 604800);
 });
+test("toBotMessage resolves LID/PN by suffix, not by field position (addressingMode 'lid')", async () => {
+    // Modern default WhatsApp addressing: `participant` is ALREADY the LID,
+    // `participantAlt` carries the PN companion — the reverse of the legacy
+    // "pn" mode. See https://baileys.wiki/concepts/jids.
+    const store = createStore();
+    const sock = { ev: new EventEmitter(), user: { id: "bot@s.whatsapp.net" } };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const received = [];
+    contract.on("messages.upsert", (payload) => received.push(payload));
+    sock.ev.emit("messages.upsert", {
+        type: "notify",
+        messages: [{
+                key: {
+                    remoteJid: "120363999999999999@g.us",
+                    fromMe: false,
+                    id: "MSG1",
+                    participant: "98765@lid", // already LID
+                    participantAlt: "5511999999999@s.whatsapp.net", // PN companion
+                    addressingMode: "lid",
+                },
+                messageTimestamp: 1700000000,
+                pushName: "Alice",
+                message: { conversation: "oi" },
+            }],
+    });
+    const batch = received[0];
+    const msg = batch.messages[0];
+    assert.equal(msg.fromLid, "98765@lid", "fromLid must be the value that's actually @lid, regardless of which field it came from");
+    assert.equal(msg.fromPn, "5511999999999@s.whatsapp.net", "fromPn must be the value that's actually NOT @lid");
+    assert.equal(msg.participantAlt, "98765@lid", "participantAlt (consumed directly by getMsgSender) must also be suffix-verified");
+});
+test("toBotMessage resolves LID/PN by suffix, not by field position (legacy addressingMode 'pn')", async () => {
+    const store = createStore();
+    const sock = { ev: new EventEmitter(), user: { id: "bot@s.whatsapp.net" } };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const received = [];
+    contract.on("messages.upsert", (payload) => received.push(payload));
+    sock.ev.emit("messages.upsert", {
+        type: "notify",
+        messages: [{
+                key: {
+                    remoteJid: "120363999999999999@g.us",
+                    fromMe: false,
+                    id: "MSG2",
+                    participant: "5511999999999@s.whatsapp.net", // PN
+                    participantAlt: "98765@lid", // LID companion
+                    addressingMode: "pn",
+                },
+                messageTimestamp: 1700000000,
+                pushName: "Bob",
+                message: { conversation: "oi" },
+            }],
+    });
+    const batch = received[0];
+    const msg = batch.messages[0];
+    assert.equal(msg.fromLid, "98765@lid");
+    assert.equal(msg.fromPn, "5511999999999@s.whatsapp.net");
+});
 test("Baileys adapter getBusinessProfile handles success and failure", async () => {
     const store = createStore();
     const jid = "12345678@s.whatsapp.net";
@@ -279,3 +337,42 @@ test("Baileys adapter aggregatePollVotes returns empty array when no poll data",
     });
     assert.deepStrictEqual(result, []);
 });
+test("Baileys adapter passes through the real group-participants.update shape (author/action, string[] participants) and feeds LID↔PN cache", async () => {
+    const store = createStore();
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const received = [];
+    contract.on("group-participants.update", (payload) => received.push(payload));
+    // Baileys v7 ships `participants` as GroupParticipant[] (Contact & { admin?… })
+    // — each entry carries `id` (LID form, the addressing mode the group uses),
+    // `lid?` (explicit LID alias), and `phoneNumber?` (PN form). The adapter
+    // projects to a flat JID list for the kernel, but also feeds the LID↔PN
+    // cache from the richer data while it has it. See BaileysEventMap.
+    sock.ev.emit("group-participants.update", {
+        id: "120363402117932687@g.us",
+        author: "99999@lid",
+        authorPn: "5516999999999@s.whatsapp.net",
+        participants: [
+            { id: "69119495901215@lid", phoneNumber: "5516111222333@s.whatsapp.net" },
+            { id: "69119495901216@lid", phoneNumber: "5516111222444@s.whatsapp.net" },
+        ],
+        action: "add",
+    });
+    assert.deepStrictEqual(received, [{
+            id: "120363402117932687@g.us",
+            author: "99999@lid",
+            participants: [
+                "69119495901215@lid",
+                "69119495901216@lid",
+            ],
+            action: "add",
+        }]);
+    // Passive LID↔PN cache filled from the richer payload — both directions
+    // (resolveJid returns the PN, resolvePn returns the LID).
+    assert.equal(store.resolveJid("69119495901215@lid"), "5516111222333@s.whatsapp.net");
+    assert.equal(store.resolvePn("5516111222444@s.whatsapp.net"), "69119495901216@lid");
+    assert.equal(store.resolveJid("99999@lid"), "5516999999999@s.whatsapp.net");
+});

package/dist/drivers/jid.js

@@ -29,3 +29,29 @@ export function toWireJid(id) {
     const digits = trimmed.replace(/\D/g, "");
     return `${digits}@s.whatsapp.net`;
 }
+/**
+ * Split a Baileys "primary/alt" JID pair (e.g. `key.participant` +
+ * `key.participantAlt`, or `key.remoteJid` + `key.remoteJidAlt`) into its
+ * LID and PN forms.
+ *
+ * Baileys only labels the primary field as the PN and the alt field as the
+ * LID under the legacy `addressingMode: "pn"`. Under the modern default
+ * `addressingMode: "lid"` the roles are reversed — the primary field IS
+ * already the LID, and the alt field carries the PN instead (see
+ * https://baileys.wiki/concepts/jids: "Group participant fields are
+ * typically LIDs; participantAlt carries the matching PN, and vice versa").
+ *
+ * Branching on `addressingMode` itself isn't reliable either — it's been
+ * observed flip-flopping for the same conversation across rc builds (see
+ * https://github.com/WhiskeySockets/Baileys/issues/1827). The one thing
+ * that's actually trustworthy is the JID suffix itself: whichever of the
+ * two values ends in "@lid" IS the LID, regardless of which field it came
+ * from or what addressingMode claims.
+ */
+export function splitLidPn(primary, alt) {
+    const candidates = [primary, alt].filter((v) => !!v);
+    return {
+        lid: candidates.find(v => v.endsWith("@lid")),
+        pn: candidates.find(v => !v.endsWith("@lid")),
+    };
+}

package/dist/drivers/jid.test.js

@@ -1,6 +1,6 @@
 import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { normalizeJid, denormalizeJid, toWireJid } from "#drivers/jid.js";
+import { normalizeJid, denormalizeJid, toWireJid, splitLidPn } from "#drivers/jid.js";
 describe("drivers/jid", () => {
     describe("normalizeJid", () => {
         test("handles empty string or nullish input", () => {
@@ -37,4 +37,38 @@ describe("drivers/jid", () => {
             assert.equal(toWireJid("+55 (11) 99999-9999"), "5511999999999@s.whatsapp.net");
         });
     });
+    describe("splitLidPn", () => {
+        test("addressingMode 'pn' (legacy): primary is PN, alt is LID", () => {
+            const { lid, pn } = splitLidPn("5511999999999@s.whatsapp.net", "12345@lid");
+            assert.equal(lid, "12345@lid");
+            assert.equal(pn, "5511999999999@s.whatsapp.net");
+        });
+        test("addressingMode 'lid' (modern default): primary is LID, alt is PN — roles reversed", () => {
+            const { lid, pn } = splitLidPn("12345@lid", "5511999999999@s.whatsapp.net");
+            assert.equal(lid, "12345@lid");
+            assert.equal(pn, "5511999999999@s.whatsapp.net");
+        });
+        test("only primary present, and it's a LID", () => {
+            const { lid, pn } = splitLidPn("12345@lid", undefined);
+            assert.equal(lid, "12345@lid");
+            assert.equal(pn, undefined);
+        });
+        test("only primary present, and it's a PN", () => {
+            const { lid, pn } = splitLidPn("5511999999999@s.whatsapp.net", undefined);
+            assert.equal(lid, undefined);
+            assert.equal(pn, "5511999999999@s.whatsapp.net");
+        });
+        test("neither present", () => {
+            const { lid, pn } = splitLidPn(undefined, null);
+            assert.equal(lid, undefined);
+            assert.equal(pn, undefined);
+        });
+        test("group JID (@g.us) as primary with no alt is treated as pn-shaped, never as lid", () => {
+            // Not a real person's PN, but callers only ever consume `.lid` from
+            // this pairing for the group case — `.pn` is discarded there.
+            const { lid, pn } = splitLidPn("120363999999999999@g.us", undefined);
+            assert.equal(lid, undefined);
+            assert.equal(pn, "120363999999999999@g.us");
+        });
+    });
 });

package/dist/i18n/index.js

@@ -42,27 +42,10 @@ function loadLocale(lang) {
     }
 }
 /**
- * Detects the OS locale without depending on a single env var, since LANG
- * isn't reliably set on macOS GUI sessions or Windows. Used as a fallback
- * when CONFIG.LANGUAGE isn't available yet (e.g. circular import during
- * config bootstrap) or isn't set.
- */
-function detectSystemLang() {
-    try {
-        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-        if (locale)
-            return locale.split("-")[0].toLowerCase();
-    }
-    catch {
-        // Intl unavailable — fall through to env vars
-    }
-    const envLocale = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || process.env.LANGUAGE;
-    if (envLocale)
-        return envLocale.split(/[_.]/)[0].toLowerCase();
-    return DEFAULT_LANG;
-}
-/**
- * Gets configured language or falls back to system locale, then English.
+ * Gets configured language or falls back to English. `CONFIG.LANGUAGE` is
+ * the single source of truth (set from manybot.toml, defaulted to "en") —
+ * this never guesses from the OS locale, so bot output language doesn't
+ * depend on the host machine/CI environment it happens to run on.
  * @returns {string}
  */
 function getConfiguredLang() {
@@ -75,7 +58,7 @@ function getConfiguredLang() {
         // circular import while #config is still bootstrapping)
     }
     if (!lang) {
-        lang = detectSystemLang();
+        lang = DEFAULT_LANG;
     }
     const filePath = path.join(LOCALES_DIR, `${lang}.json`);
     if (!fs.existsSync(filePath)) {

package/dist/kernel/chatOverrides.js

@@ -0,0 +1,46 @@
+/**
+ * kernel/chatOverrides.ts
+ *
+ * Per-chat overrides for the bot's global command prefix and language,
+ * set via `!config prefixo` / `!config idioma` (see coreCommands.ts).
+ * Both are stored under the "core" plugin namespace in settingsDb —
+ * the same storage plugins use via `ctx.settings`, keyed by the same
+ * `normalizeJid(msg.chatId)` that `buildApi()` uses to scope
+ * `ctx.settings` — so a value written here is read back under the
+ * exact same key it was written under.
+ *
+ * Kept as a standalone leaf module (only #config, jid utils, and
+ * settingsDb as deps) so it can be imported from anywhere in the
+ * dispatch pipeline (api/index.ts, messageHandler.ts, runCommand.ts,
+ * coreCommands.ts) without risking an import cycle.
+ */
+import { getPluginSetting } from "./settingsDb.js";
+import { normalizeJid } from "#drivers/jid.js";
+import { CMD_PREFIX } from "#config";
+const CORE_PLUGIN = "core";
+/**
+ * Resolves the effective command prefix for a chat: the chat's saved
+ * override (`!config prefixo`) if one was set, else the global
+ * `CMD_PREFIX`.
+ *
+ * @param chatId - the *raw* chat id (e.g. `msg.chatId`), not yet
+ *   normalized — this function normalizes it itself so callers don't
+ *   have to know which normalization the settings layer expects.
+ */
+export function getChatPrefix(chatId) {
+    const override = getPluginSetting(CORE_PLUGIN, normalizeJid(chatId), "chat_prefix");
+    return typeof override === "string" && override.length > 0 ? override : CMD_PREFIX;
+}
+/**
+ * Resolves the effective language code for a chat: the chat's saved
+ * override (`!config idioma`) if one was set, else `undefined` so the
+ * caller can fall back to the global language (`getCurrentLang()` /
+ * plain `t()`).
+ *
+ * @param chatId - the *raw* chat id (e.g. `msg.chatId`); normalized
+ *   internally, same as {@link getChatPrefix}.
+ */
+export function getChatLocale(chatId) {
+    const override = getPluginSetting(CORE_PLUGIN, normalizeJid(chatId), "chat_locale");
+    return typeof override === "string" && override.length > 0 ? override : undefined;
+}