@manybot/manybot 5.7.0 → 5.9.0

package/dist/drivers/baileysAdapter.test.js

@@ -0,0 +1,378 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import test from "node:test";
+import { createStore } from "#client/store.js";
+import { createBaileysAdapter } from "#drivers/baileys/adapter.js";
+test("Baileys sends messages with the chat's disappearing-message timer", async () => {
+    const store = createStore();
+    const jid = "chat@s.whatsapp.net";
+    store.setChatEphemeralExpiration(jid, 86400);
+    store.messages.set(jid, new Map([["quoted", {
+                key: { id: "quoted", remoteJid: jid, fromMe: false },
+                message: { conversation: "original" },
+            }]]));
+    const calls = [];
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        sendMessage: async (...args) => {
+            calls.push(args);
+            return { key: { id: `sent-${calls.length}`, remoteJid: args[0] } };
+        },
+        groupMetadata: async () => ({ subject: "Group", participants: [], ephemeralDuration: 604800 }),
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const quoted = { id: "quoted", remoteJid: jid, fromMe: false };
+    await contract.sendText(jid, "text", { quoted });
+    await contract.sendImage(jid, Buffer.from("image"));
+    await contract.sendVideo(jid, Buffer.from("video"));
+    await contract.sendAudio(jid, Buffer.from("audio"));
+    await contract.sendSticker(jid, Buffer.from("sticker"));
+    await contract.sendDocument(jid, Buffer.from("document"), "file.txt", "text/plain");
+    await contract.sendPoll(jid, { name: "Poll", values: ["one"] });
+    for (const call of calls) {
+        assert.equal(call[2]?.ephemeralExpiration, 86400);
+    }
+    assert.ok((calls[0]?.[2]).quoted, "quoted and ephemeral options are merged");
+    await contract.react(jid, quoted, "👍");
+    assert.equal(calls.at(-1)?.length, 2, "reactions do not receive ephemeral send options");
+    await contract.groupMetadata("group@g.us");
+    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";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        getBusinessProfile: async () => ({ name: "Test Corp", id: "12345678" }),
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.getBusinessProfile(jid);
+    assert.deepStrictEqual(result, { name: "Test Corp", id: "12345678" });
+    const sockFail = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        getBusinessProfile: async () => { throw new Error("API error"); },
+    };
+    const { contract: contractFail } = createBaileysAdapter({ sock: sockFail, store });
+    const resultFail = await contractFail.getBusinessProfile(jid);
+    assert.strictEqual(resultFail, null);
+});
+test("Baileys adapter profilePictureUrl retrieves URL and handles error", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        profilePictureUrl: async () => "https://example.com/profile.jpg",
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.profilePictureUrl(jid);
+    assert.strictEqual(result, "https://example.com/profile.jpg");
+    const sockFail = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        profilePictureUrl: async () => { throw new Error("API error"); },
+    };
+    const { contract: contractFail } = createBaileysAdapter({ sock: sockFail, store });
+    const resultFail = await contractFail.profilePictureUrl(jid);
+    assert.strictEqual(resultFail, null);
+});
+test("Baileys adapter fetchStatus retrieves status and handles error", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        fetchStatus: async () => [{ id: jid, status: { status: "available" } }],
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.fetchStatus(jid);
+    assert.strictEqual(result, "available");
+    const sockNoArray = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        fetchStatus: async () => ({ status: "away" }),
+    };
+    const { contract: contractNoArray } = createBaileysAdapter({ sock: sockNoArray, store });
+    const resultNoArray = await contractNoArray.fetchStatus(jid);
+    assert.strictEqual(resultNoArray, "away");
+    const sockFail = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        fetchStatus: async () => { throw new Error("API error"); },
+    };
+    const { contract: contractFail } = createBaileysAdapter({ sock: sockFail, store });
+    const resultFail = await contractFail.fetchStatus(jid);
+    assert.strictEqual(resultFail, null);
+});
+test("Baileys adapter updateBlockStatus calls the underlying method", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        updateBlockStatus: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    await contract.updateBlockStatus(jid, "block");
+    assert.ok(true, "updateBlockStatus did not throw");
+    await contract.updateBlockStatus(jid, "unblock");
+    assert.ok(true, "updateBlockStatus remove did not throw");
+});
+test("Baileys adapter addOrEditContact calls the underlying method", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    const info = { fullName: "Test User", firstName: "Test", saveOnPrimaryAddressbook: true };
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        addOrEditContact: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    await contract.addOrEditContact(jid, info);
+    assert.ok(true, "addOrEditContact did not throw");
+    await contract.addOrEditContact(jid, { fullName: "Another User" });
+    assert.ok(true, "addOrEditContact second call did not throw");
+});
+test("Baileys adapter removeContact calls the underlying method", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        removeContact: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    await contract.removeContact(jid);
+    assert.ok(true, "removeContact did not throw");
+});
+test("Baileys adapter groupParticipantsUpdate calls the underlying method", async () => {
+    const store = createStore();
+    const jid = "group@g.us";
+    const users = ["user1@s.whatsapp.net", "user2@s.whatsapp.net"];
+    const action = "add";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        groupParticipantsUpdate: async () => [{ status: "success" }],
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.groupParticipantsUpdate(jid, users, action);
+    assert.deepStrictEqual(result, [{ status: "success" }]);
+    await contract.groupParticipantsUpdate(jid, ["user3@s.whatsapp.net"], "remove");
+    assert.ok(true, "groupParticipantsUpdate remove did not throw");
+});
+test("Baileys adapter groupUpdateSubject and groupUpdateDescription call underlying methods", async () => {
+    const store = createStore();
+    const jid = "group@g.us";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        groupUpdateSubject: async () => { },
+        groupUpdateDescription: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    await contract.groupUpdateSubject(jid, "New Subject");
+    assert.ok(true, "groupUpdateSubject did not throw");
+    await contract.groupUpdateDescription(jid, "New Description");
+    assert.ok(true, "groupUpdateDescription did not throw");
+});
+test("Baileys adapter groupInviteCode and groupRevokeInvite call underlying methods", async () => {
+    const store = createStore();
+    const jid = "group@g.us";
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        groupInviteCode: async () => "https://chat.whatsapp.com/AAAA",
+        groupRevokeInvite: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const code = await contract.groupInviteCode(jid);
+    assert.strictEqual(code, "https://chat.whatsapp.com/AAAA");
+    await contract.groupRevokeInvite(jid);
+    assert.ok(true, "groupRevokeInvite did not throw");
+});
+test("Baileys adapter updateProfilePicture, updateProfileName, updateProfileStatus call underlying methods", async () => {
+    const store = createStore();
+    const buffer = Buffer.from("fake-image-data");
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+        updateProfilePicture: async () => { },
+        updateProfileName: async () => { },
+        updateProfileStatus: async () => { },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    await contract.updateProfilePicture("12345678@s.whatsapp.net", buffer);
+    assert.ok(true, "updateProfilePicture did not throw");
+    await contract.updateProfileName("New Name");
+    assert.ok(true, "updateProfileName did not throw");
+    await contract.updateProfileStatus("Available");
+    assert.ok(true, "updateProfileStatus did not throw");
+});
+test("Baileys adapter me returns user info", async () => {
+    const store = createStore();
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net", lid: "12345678@lid" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const me = await contract.me();
+    assert.strictEqual(me.id, "bot@s.whatsapp.net");
+    assert.strictEqual(me.lid, "12345678@lid");
+});
+test("Baileys adapter getHistory returns messages from store", async () => {
+    const store = createStore();
+    const jid = "12345678@s.whatsapp.net";
+    store.messages.set(jid, new Map([
+        ["msg1", { key: { id: "msg1", remoteJid: jid, fromMe: false }, message: { conversation: "hello" } }],
+        ["msg2", { key: { id: "msg2", remoteJid: jid, fromMe: true }, message: { conversation: "world" } }],
+    ]));
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const history = await contract.getHistory?.(jid, { limit: 2 });
+    assert.strictEqual(history?.length, 2);
+    assert.ok(history?.some((m) => m.body === "hello"));
+    assert.ok(history?.some((m) => m.body === "world"));
+});
+test("Baileys adapter downloadMedia returns null when no raw message", async () => {
+    const store = createStore();
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.downloadMedia({ chatId: "123", id: "msg1" }, {});
+    assert.strictEqual(result, null);
+});
+test("Baileys adapter decryptPollVote returns null when no vote data", async () => {
+    const store = createStore();
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = await contract.decryptPollVote?.({
+        voteKey: { remoteJid: "123", id: "msg1" },
+        pollKey: { remoteJid: "123", id: "msg1" },
+        pollEncKey: Buffer.alloc(0),
+    });
+    assert.strictEqual(result, null);
+});
+test("Baileys adapter aggregatePollVotes returns empty array when no poll data", async () => {
+    const store = createStore();
+    const sock = {
+        ev: new EventEmitter(),
+        user: { id: "bot@s.whatsapp.net" },
+    };
+    const { contract } = createBaileysAdapter({ sock, store });
+    const result = contract.aggregatePollVotes?.({
+        pollKey: { remoteJid: "123", id: "msg1" },
+        selfJid: undefined,
+        votes: [],
+    });
+    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

@@ -0,0 +1,74 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { normalizeJid, denormalizeJid, toWireJid, splitLidPn } from "#drivers/jid.js";
+describe("drivers/jid", () => {
+    describe("normalizeJid", () => {
+        test("handles empty string or nullish input", () => {
+            assert.equal(normalizeJid(""), "");
+        });
+        test("converts @s.whatsapp.net to @c.us", () => {
+            assert.equal(normalizeJid("5511999999999@s.whatsapp.net"), "5511999999999@c.us");
+        });
+        test("removes device suffix e.g. :12@", () => {
+            assert.equal(normalizeJid("5511999999999:12@s.whatsapp.net"), "5511999999999@c.us");
+        });
+        test("leaves group @g.us untouched", () => {
+            assert.equal(normalizeJid("12036301234567890@g.us"), "12036301234567890@g.us");
+        });
+    });
+    describe("denormalizeJid", () => {
+        test("converts @c.us to @s.whatsapp.net", () => {
+            assert.equal(denormalizeJid("5511999999999@c.us"), "5511999999999@s.whatsapp.net");
+        });
+        test("leaves already wire or non-c.us JIDs untouched", () => {
+            assert.equal(denormalizeJid("12036301234567890@g.us"), "12036301234567890@g.us");
+        });
+    });
+    describe("toWireJid", () => {
+        test("returns wire format for @s.whatsapp.net, @lid, @g.us untouched", () => {
+            assert.equal(toWireJid("5511999999999@s.whatsapp.net"), "5511999999999@s.whatsapp.net");
+            assert.equal(toWireJid("12345@lid"), "12345@lid");
+            assert.equal(toWireJid("12036301234567890@g.us"), "12036301234567890@g.us");
+        });
+        test("converts @c.us JID to @s.whatsapp.net", () => {
+            assert.equal(toWireJid("5511999999999@c.us"), "5511999999999@s.whatsapp.net");
+        });
+        test("converts plain phone number / digits to @s.whatsapp.net", () => {
+            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/drivers/types.js

@@ -2,11 +2,11 @@
  * 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.
+ * implementation (Baileys today). 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.

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)) {
@@ -125,11 +108,24 @@ function interpolate(str, context = {}) {
 }
 export function t(key, context = {}) {
     ensureLoaded();
+    return translate(currentTranslations, fallbackTranslations, key, context);
+}
+/**
+ * Translates a key for an explicit language. This is useful for rendered
+ * content that accepts a language override, such as the command menu.
+ */
+export function tFor(lang, key, context = {}) {
+    ensureLoaded();
+    const targetLang = lang?.trim().toLowerCase() || currentLang || DEFAULT_LANG;
+    const targetTranslations = loadLocale(targetLang) || fallbackTranslations;
+    return translate(targetTranslations, fallbackTranslations, key, context);
+}
+function translate(targetTranslations, englishTranslations, key, context) {
     // Try current language first
-    let value = getNestedValue(currentTranslations, key);
+    let value = getNestedValue(targetTranslations, key);
     // Fallback to English if not found
     if (value === undefined) {
-        value = getNestedValue(fallbackTranslations, key);
+        value = getNestedValue(englishTranslations, key);
     }
     // If still not found, return the key
     if (value === undefined) {

package/dist/kernel/activeDriverSend.js

@@ -0,0 +1,21 @@
+/**
+ * activeDriverSend.ts
+ *
+ * Driver-neutral send helper. Ensures rate-limiting and throttling
+ * are applied to all outbound text sends from plugins, then sends
+ * through whichever single driver is currently active in the
+ * DriverManager. There is no fallback between drivers — driver
+ * selection is mutually exclusive and decided once at boot (see
+ * main.ts / driverManager.ts).
+ */
+import { waitForSendSlot } from "./sendGuard.js";
+import { getDriverManager } from "./driverManager.js";
+/**
+ * Send text using the active driver, respecting the rate-limiting send guard.
+ */
+export async function sendActiveDriverText(jid, text, opts = {}) {
+    const dm = getDriverManager();
+    const driver = dm.active();
+    await waitForSendSlot(jid, { cooldown: true, jitter: true });
+    return await driver.sendText(jid, text, opts);
+}