@manybot/manybot 5.7.0 → 5.8.0

package/dist/kernel/runCommand.test.js

@@ -0,0 +1,235 @@
+import test, { describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { resolveDispatch, runCommand, renderUsage } from "#kernel/runCommand.js";
+import { buildCommandRegistry, __setRegistryForTests } from "#kernel/commandRegistry.js";
+import { pluginRegistry } from "#kernel/pluginLoader.js";
+function emptySpec(overrides) {
+    return {
+        id: overrides.id ?? "todo::add",
+        cmd: overrides.cmd ?? "todo",
+        aliases: overrides.aliases ?? [],
+        plugin: overrides.plugin ?? "todoPlugin",
+        function: overrides.function ?? "addFn",
+        text: overrides.text ?? null,
+        desc: overrides.desc ?? null,
+        category: overrides.category ?? null,
+        group: overrides.group ?? null,
+        manual: overrides.manual ?? null,
+        deprecatedMessage: overrides.deprecatedMessage ?? null,
+        notifyChanges: overrides.notifyChanges ?? null,
+        permissions: overrides.permissions ?? null,
+        messages: overrides.messages ?? null,
+        arguments: overrides.arguments ?? [],
+        subcommands: overrides.subcommands ?? [],
+    };
+}
+function emptySub(overrides) {
+    return {
+        id: overrides.id ?? "todo::list",
+        cmd: overrides.cmd ?? "list",
+        aliases: overrides.aliases ?? [],
+        function: overrides.function ?? null,
+        desc: overrides.desc ?? null,
+        manual: overrides.manual ?? null,
+        arguments: overrides.arguments ?? [],
+        permissions: overrides.permissions ?? null,
+        messages: overrides.messages ?? null,
+    };
+}
+let addCalls = [];
+let listCalls = [];
+function registerTodoPlugin() {
+    addCalls = [];
+    listCalls = [];
+    const plugin = {
+        name: "todoPlugin",
+        status: "active",
+        run: null,
+        setup: null,
+        exports: {},
+        error: null,
+        guardOptions: {},
+        commands: {
+            addFn: {
+                cmd: "todo",
+                aliases: [],
+                handler: async (ctx, input) => {
+                    addCalls.push({ ctx, input });
+                },
+            },
+            listFn: {
+                cmd: "list",
+                aliases: [],
+                handler: async (ctx, input) => {
+                    listCalls.push({ ctx, input });
+                },
+            },
+            crashFn: {
+                cmd: "crash",
+                aliases: [],
+                handler: async () => {
+                    throw new Error("boom");
+                },
+            },
+        },
+    };
+    pluginRegistry.set("todoPlugin", plugin);
+}
+function fakeCtx(overrides = {}) {
+    return {
+        chat: {
+            isGroup: overrides.isGroup ?? true,
+            id: "chat1@g.us",
+            isSenderAdmin: async () => true,
+            isBotAdmin: async () => true,
+        },
+        msg: {
+            sender: overrides.sender ?? "5511999999999@s.whatsapp.net",
+        },
+    };
+}
+function buildRegistry(specs) {
+    return buildCommandRegistry(specs, pluginRegistry);
+}
+describe("kernel/runCommand", () => {
+    beforeEach(() => {
+        registerTodoPlugin();
+    });
+    afterEach(() => {
+        pluginRegistry.delete("todoPlugin");
+        __setRegistryForTests(null);
+    });
+    test("resolveDispatch: kind none when registry is empty", () => {
+        __setRegistryForTests(buildCommandRegistry([], new Map()));
+        const { target } = resolveDispatch("todo", "");
+        assert.equal(target.kind, "none");
+    });
+    test("resolveDispatch: kind parent when no subcommands declared", () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const { target } = resolveDispatch("todo", "buy milk");
+        assert.equal(target.kind, "parent");
+        if (target.kind === "parent") {
+            assert.deepEqual(target.args, ["buy", "milk"]);
+        }
+    });
+    test("resolveDispatch: kind sub when a declared subcommand token matches", () => {
+        const spec = emptySpec({ subcommands: [emptySub({ function: "listFn" })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target } = resolveDispatch("todo", "list");
+        assert.equal(target.kind, "sub");
+        if (target.kind === "sub") {
+            assert.equal(target.sub.function, "listFn");
+        }
+    });
+    test("resolveDispatch: unmatchedSubToken falls through to parent", () => {
+        const spec = emptySpec({ subcommands: [emptySub({ function: "listFn" })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target, unmatchedSubToken } = resolveDispatch("todo", "wat now");
+        assert.equal(target.kind, "parent");
+        assert.equal(unmatchedSubToken, "wat");
+    });
+    test("runCommand: executes the parent handler and passes args through", async () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const resolution = resolveDispatch("todo", "buy milk");
+        const replies = [];
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: (t) => replies.push(t) },
+        });
+        assert.equal(result.status, "executed");
+        assert.equal(addCalls.length, 1);
+        assert.deepEqual(addCalls[0].input, { args: ["buy", "milk"], subcommand: undefined });
+        assert.equal(replies.length, 0);
+    });
+    test("runCommand: routes to the subcommand handler, not the parent's", async () => {
+        const spec = emptySpec({ subcommands: [emptySub({ function: "listFn" })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "list");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "executed");
+        assert.equal(listCalls.length, 1);
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: unmatchedSubToken replies with a usage hint and does not dispatch", async () => {
+        const spec = emptySpec({ subcommands: [emptySub({ function: "listFn" })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "wat");
+        const replies = [];
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: (t) => replies.push(t) },
+        });
+        assert.equal(result.status, "unknown_sub");
+        assert.equal(addCalls.length, 0);
+        assert.equal(replies.length, 1);
+    });
+    test("runCommand: denies on scope mismatch and does not dispatch", async () => {
+        const spec = emptySpec({ permissions: { scope: "group" } });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "buy milk");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx({ isGroup: false }),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "permission_denied");
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: rejects when a required argument is missing", async () => {
+        const spec = emptySpec({ arguments: [{ name: "item", type: "quoted_text", required: true }] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "argument_missing");
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: re-throws on handler crash after firing the alert", async () => {
+        const spec = emptySpec({ id: "todo::crash", cmd: "crashcmd", function: "crashFn" });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("crashcmd", "");
+        await assert.rejects(() => runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        }), /boom/);
+    });
+    test("resolveDispatch: kind none for an unknown invocation", () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const { target } = resolveDispatch("nope", "");
+        assert.equal(target.kind, "none");
+    });
+    test("renderUsage: builds a usage line from declared arguments", () => {
+        const spec = emptySpec({
+            arguments: [
+                { name: "item", type: "quoted_text", required: true },
+                { name: "priority", type: "choice", choices: ["low", "high"], required: false },
+            ],
+        });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target } = resolveDispatch("todo", "");
+        const usage = renderUsage(target);
+        assert.match(usage, /^!todo /);
+        assert.match(usage, /"<text>"/);
+        assert.match(usage, /\[--priority=<low\|high>\]/);
+    });
+    test("renderUsage: empty string for a none target", () => {
+        const usage = renderUsage({ kind: "none" });
+        assert.equal(usage, "");
+    });
+});

package/dist/kernel/sendFallbackGuard.js

@@ -24,11 +24,6 @@ import { waitForSendSlot } from "./sendGuard.js";
 import { getDriverManager } from "./driverManager.js";
 import { fireAlert } from "./alerts.js";
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-/**
- * Thrown by sendWithFallback when the message could not be delivered
- * through any available driver. `reason` distinguishes between
- * "primary failed and no secondary was available" vs "both failed".
- */
 export class SendFailedError extends Error {
     jid;
     driver;
@@ -42,44 +37,25 @@ export class SendFailedError extends Error {
     }
 }
 /**
- * Try the active driver, then the other one if the active one failed to
- * confirm the send. Honors `drivers.fallbackCooldownMs` (skip the active
- * if it's currently degraded) and uses `drivers.verifyWindowMs` to decide
- * how long to wait for confirmation before giving up on a given attempt.
+ * Try the active driver and verify the send. Honors `drivers.fallbackCooldownMs`
+ * (though with only one driver, degradation doesn't skip attempts) and uses
+ * `drivers.verifyWindowMs` to decide how long to wait for confirmation.
  *
  * Resolves with the SentMessageRef of the driver that actually delivered
- * the message. Rejects with SendFailedError if neither driver confirmed
- * the send (or if the only driver that could have been tried was the
- * active one and it wasn't ready).
+ * the message. Rejects with SendFailedError with reason "no_fallback" if the
+ * send could not be confirmed.
  */
 export async function sendWithFallback(jid, text, opts = {}) {
     const dm = getDriverManager();
     const drivers = CONFIG.drivers;
     const primary = dm.active();
     const primaryKey = primary.name;
-    // if the primary is in cooldown, skip straight to the secondary
-    // (don't repeat the same failing call message after message). Same
-    // try/catch as the normal path so a failing secondary here also fires
-    // send_failed_both_drivers — observability stays consistent across
-    // the degraded and fresh-primary paths.
+    // Mark as not degraded before attempting (degradation only lasts for cooldown period)
+    // With only one driver, we don't actually skip attempts when degraded - we just track
+    // that the last attempt failed so we can alert appropriately
     if (dm.isDegraded(primaryKey)) {
-        const secondary = pickSecondary(dm, primaryKey);
-        if (secondary && secondary.isReady()) {
-            try {
-                return await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ false);
-            }
-            catch (err) {
-                fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
-                throw err;
-            }
-        }
-        logger.warn({ jid, primary: primaryKey }, "send skipped primary (degraded) and no fallback ready");
-        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
-        throw new SendFailedError(jid, primaryKey, "no_fallback");
+        logger.debug({ driver: primaryKey }, "driver in degradation period but attempting send anyway (single driver mode)");
     }
-    // Normal path: try primary, verify, fall back if verification fails.
-    // waitForSendSlot is the same throttle the rest of the senders use
-    // (fallback must respect rate-limit too).
     await waitForSendSlot(jid, { cooldown: true, jitter: true });
     let primaryRef = null;
     let primarySendFailed = false;
@@ -89,28 +65,23 @@ export async function sendWithFallback(jid, text, opts = {}) {
     catch (err) {
         primarySendFailed = true;
         logger.warn({ driver: primaryKey, jid, error: String(err) }, "send threw on primary");
+        dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
+        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
+        throw new SendFailedError(jid, primaryKey, "no_fallback");
     }
     if (!primarySendFailed) {
         if (await verifyDelivery(primary, jid, primaryRef, drivers.verifyWindowMs)) {
+            // Successful send - clear any degradation state
+            dm.clearDegraded(primaryKey);
             return primaryRef;
         }
         logger.warn({ driver: primaryKey, jid, messageId: primaryRef.id }, "send not confirmed by primary");
-    }
-    dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
-    const secondary = pickSecondary(dm, primaryKey);
-    if (!secondary || !secondary.isReady()) {
+        dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
         fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
         throw new SendFailedError(jid, primaryKey, "no_fallback");
     }
-    try {
-        const fallbackRef = await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ true);
-        logger.info({ driver: secondary.name, jid, messageId: fallbackRef.id, reason: primarySendFailed ? "send threw" : "primary verification failed" }, "message sent via fallback");
-        return fallbackRef;
-    }
-    catch (err) {
-        fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
-        throw err;
-    }
+    // Should not reach here
+    throw new SendFailedError(jid, primaryKey, "no_fallback");
 }
 /**
  * Send through a specific driver and verify the result. Throws if the
@@ -178,6 +149,6 @@ async function historyContains(driver, jid, ref) {
     return history.some(m => m.fromMe && m.id === ref.id);
 }
 function pickSecondary(dm, primaryKey) {
-    const other = primaryKey === "baileys" ? "whatsmeow" : "baileys";
-    return dm.get(other);
+    // Currently Baileys is the only supported driver; returns undefined unless a test registers a secondary
+    return dm.get(primaryKey === "baileys" ? "secondary" : "baileys");
 }

package/dist/kernel/sendFallbackGuard.test.js

@@ -0,0 +1,80 @@
+import test, { describe, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { sendWithFallback, SendFailedError } from "#kernel/sendFallbackGuard.js";
+import { getDriverManager, _resetDriverManagerForTests } from "#kernel/driverManager.js";
+function createMockDriver(name, ready = true, failsSend = false, failsVerify = false) {
+    const mockRef = (id) => ({ id, chatId: "123@c.us", timestamp: Date.now() });
+    return {
+        name,
+        isReady: () => ready,
+        sendText: async (jid, text) => {
+            if (failsSend)
+                throw new Error(`${name} sendText failed`);
+            return mockRef(`msg_${name}`);
+        },
+        getHistory: async () => {
+            if (failsVerify)
+                return [];
+            return [{ id: `msg_${name}`, fromMe: true }];
+        },
+        connect: async () => { },
+        disconnect: async () => { },
+        me: () => ({ id: "123@c.us" }),
+        sendImage: async () => mockRef("image"),
+        sendVideo: async () => mockRef("video"),
+        sendAudio: async () => mockRef("audio"),
+        sendDocument: async () => mockRef("doc"),
+        sendSticker: async () => mockRef("sticker"),
+        sendLocation: async () => mockRef("loc"),
+        sendContact: async () => mockRef("contact"),
+        sendReaction: async () => { },
+        sendPoll: async () => mockRef("poll"),
+        react: async () => { },
+        deleteMessage: async () => { },
+        editMessage: async () => { },
+        sendPresenceUpdate: async () => { },
+        readMessages: async () => { },
+        onWhatsApp: async () => null,
+        getBusinessProfile: async () => null,
+        profilePictureUrl: async () => null,
+        fetchStatus: async () => null,
+        updateBlockStatus: async () => { },
+        addOrEditContact: async () => { },
+        removeContact: async () => { },
+        groupMetadata: async () => ({ subject: "Test Group", participants: [] }),
+        groupParticipantsUpdate: async () => [],
+        groupUpdateSubject: async () => { },
+        groupUpdateDescription: async () => { },
+        groupInviteCode: async () => "",
+        groupRevokeInvite: async () => "",
+        updateProfilePicture: async () => { },
+        updateProfileName: async () => { },
+        updateProfileStatus: async () => { },
+        downloadMedia: async () => null,
+        on: () => () => { },
+    };
+}
+describe("kernel/sendFallbackGuard", () => {
+    beforeEach(() => {
+        _resetDriverManagerForTests();
+    });
+    test("delivers text via primary driver when healthy", async () => {
+        const dm = getDriverManager();
+        const primary = createMockDriver("baileys");
+        dm.register(primary, { isPrimary: true });
+        const ref = await sendWithFallback("5511999999999@c.us", "hello");
+        assert.equal(ref.id, "msg_baileys");
+    });
+    test("throws SendFailedError with no_fallback when send fails", async () => {
+        const dm = getDriverManager();
+        const primaryFailing = createMockDriver("baileys", true, true);
+        dm.register(primaryFailing, { isPrimary: true });
+        await assert.rejects(async () => sendWithFallback("5511999999999@c.us", "no fallback"), (err) => err instanceof SendFailedError && err.reason === "no_fallback");
+    });
+    test("throws SendFailedError with no_fallback when verification fails", async () => {
+        const dm = getDriverManager();
+        const primaryFailing = createMockDriver("baileys", true, false, true);
+        dm.register(primaryFailing, { isPrimary: true });
+        await assert.rejects(async () => sendWithFallback("5511999999999@c.us", "verify fail"), (err) => err instanceof SendFailedError && err.reason === "no_fallback");
+    });
+});

package/dist/kernel/sendGuard.js

@@ -10,8 +10,9 @@
  *   4. Chat-concurrency gate — caps how many different chats the bot can be
  *                              actively answering at the same time
  *   5. Edit throttle         — jittered minimum gap + cap on edits per
- *                              message, so things like loading animations
- *                              don't edit on a fixed, bot-like cadence
+ *                              message. Only active at SECURITY_LEVEL
+ *                              "high"; low/medium leave edit timing to the
+ *                              caller.
  *
  * All of the above scale with SECURITY_LEVEL ("low" | "medium" | "high").
  * Higher levels are slower and more conservative — lower risk of WhatsApp's
@@ -28,8 +29,6 @@ const PROFILES = {
         chatCooldownMs: 100,
         jitterMs: { min: 30, max: 120 },
         concurrency: Infinity,
-        editIntervalMs: { min: 800, max: 2000 },
-        maxEditsPerMessage: 20,
         typingMaxMs: 2000,
     },
     medium: {
@@ -37,8 +36,6 @@ const PROFILES = {
         chatCooldownMs: 150,
         jitterMs: { min: 50, max: 200 },
         concurrency: 2,
-        editIntervalMs: { min: 1200, max: 3000 },
-        maxEditsPerMessage: 12,
         typingMaxMs: 4000,
     },
     high: {
@@ -46,9 +43,11 @@ const PROFILES = {
         chatCooldownMs: 400,
         jitterMs: { min: 150, max: 500 },
         concurrency: 1,
-        editIntervalMs: { min: 2000, max: 5000 },
-        maxEditsPerMessage: 6,
         typingMaxMs: 8000,
+        editThrottle: {
+            minGapMs: { min: 800, max: 2000 },
+            maxEditsPerMessage: 5,
+        },
     },
 };
 function currentProfile() {
@@ -147,40 +146,6 @@ export async function acquireChatSlot(jid) {
         });
     });
 }
-const editState = new Map();
-const EDIT_STATE_STALE_MS = 10 * 60 * 1000;
-function cleanupEditState(now) {
-    for (const [id, s] of editState) {
-        if (now - s.lastEditAt > EDIT_STATE_STALE_MS)
-            editState.delete(id);
-    }
-}
-/**
- * Waits for a safe edit slot for `messageId`, applying a jittered minimum
- * gap since its last edit. Returns false once the message has hit its
- * per-level edit cap — callers should skip the edit silently in that case.
- * @param {string} messageId
- * @returns {Promise<boolean>} true if the edit may proceed
- */
-export async function waitForEditSlot(messageId) {
-    const now = Date.now();
-    cleanupEditState(now);
-    const profile = currentProfile();
-    const s = editState.get(messageId) ?? { lastEditAt: 0, count: 0 };
-    if (s.count >= profile.maxEditsPerMessage) {
-        editState.set(messageId, s);
-        logger.debug(`[sendGuard] edit cap reached for ${messageId}`);
-        return false;
-    }
-    const minGap = randomBetween(profile.editIntervalMs);
-    const wait = s.lastEditAt + minGap - Date.now();
-    if (wait > 0)
-        await sleep(wait);
-    s.lastEditAt = Date.now();
-    s.count += 1;
-    editState.set(messageId, s);
-    return true;
-}
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
  * Wait for a safe send slot: global rate → per-chat cooldown → jitter.
@@ -208,6 +173,37 @@ export async function waitForSendSlot(jid, { cooldown = true, jitter = true } =
         await sleep(randomBetween(currentProfile().jitterMs));
     recordSend(jid);
 }
+// ── Edit throttle ─────────────────────────────────────────────────────────────
+// Only enforced when the active profile defines `editThrottle` (currently
+// just "high"). low/medium always allow immediately.
+const editState = new Map();
+/**
+ * Wait for a safe edit slot for `messageId`, then record the edit.
+ * Returns `false` if the per-message edit cap has been reached — the
+ * caller should drop the edit instead of sending it.
+ *
+ * @param {string} messageId
+ * @returns {Promise<boolean>} whether the edit is allowed to proceed
+ */
+export async function waitForEditSlot(messageId) {
+    const throttle = currentProfile().editThrottle;
+    if (!throttle)
+        return true;
+    const state = editState.get(messageId) ?? { count: 0, lastEditAt: 0 };
+    if (state.count >= throttle.maxEditsPerMessage) {
+        logger.debug(`[sendGuard] edit cap (${throttle.maxEditsPerMessage}) reached for message ${messageId} — dropping edit`);
+        return false;
+    }
+    const gap = randomBetween(throttle.minGapMs);
+    const elapsed = Date.now() - state.lastEditAt;
+    if (state.lastEditAt > 0 && elapsed < gap) {
+        await sleep(gap - elapsed);
+    }
+    state.count++;
+    state.lastEditAt = Date.now();
+    editState.set(messageId, state);
+    return true;
+}
 /**
  * Show a presence indicator for `ms` milliseconds, then clear it.
  * Best-effort — errors are swallowed.

package/dist/kernel/sendGuard.test.js

@@ -0,0 +1,102 @@
+import test, { describe, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { CONFIG } from "#config";
+import { typingDuration, mediaDuration, acquireChatSlot, simulateState, waitForSendSlot } from "#kernel/sendGuard.js";
+describe("kernel/sendGuard", () => {
+    beforeEach(() => {
+        CONFIG.SECURITY_LEVEL = "medium";
+    });
+    describe("typingDuration", () => {
+        test("returns 0 for empty or invalid text", () => {
+            assert.equal(typingDuration(""), 0);
+            assert.equal(typingDuration(null), 0);
+        });
+        test("calculates duration based on CPS and caps at profile typingMaxMs", () => {
+            CONFIG.SECURITY_LEVEL = "medium"; // typingMaxMs = 4000
+            // 90 chars at 90 CPS = 1000 ms
+            const text90 = "a".repeat(90);
+            assert.equal(typingDuration(text90), 1000);
+            // 900 chars at 90 CPS = 10000 ms -> capped at 4000 ms
+            const text900 = "a".repeat(900);
+            assert.equal(typingDuration(text900), 4000);
+        });
+        test("respects SECURITY_LEVEL profile caps", () => {
+            const text900 = "a".repeat(900);
+            CONFIG.SECURITY_LEVEL = "low"; // cap = 2000
+            assert.equal(typingDuration(text900), 2000);
+            CONFIG.SECURITY_LEVEL = "high"; // cap = 8000
+            assert.equal(typingDuration(text900), 8000);
+        });
+    });
+    describe("mediaDuration", () => {
+        test("returns base jitter range when no caption is provided", () => {
+            const duration = mediaDuration();
+            assert.ok(duration >= 400 && duration <= 1000);
+        });
+        test("adds typing duration when caption is provided", () => {
+            CONFIG.SECURITY_LEVEL = "medium";
+            const text90 = "a".repeat(90); // 1000ms typing
+            const duration = mediaDuration(text90);
+            assert.ok(duration >= 1400 && duration <= 2000);
+        });
+    });
+    describe("acquireChatSlot (concurrency gate)", () => {
+        test("allows up to profile concurrency before blocking", async () => {
+            CONFIG.SECURITY_LEVEL = "high"; // concurrency = 1
+            const release1 = await acquireChatSlot("chat1");
+            let slot2Acquired = false;
+            const promise2 = acquireChatSlot("chat2").then(rel => {
+                slot2Acquired = true;
+                return rel;
+            });
+            // Give microtask tick to verify slot2 is waiting
+            await new Promise(r => setImmediate(r));
+            assert.equal(slot2Acquired, false);
+            // Release slot 1 allows slot 2 to proceed
+            release1();
+            const release2 = await promise2;
+            assert.equal(slot2Acquired, true);
+            release2();
+        });
+    });
+    describe("simulateState", () => {
+        test("sends presence update composing/recording, waits, then sends paused", async (t) => {
+            t.mock.timers.enable({ apis: ["setTimeout"] });
+            const updates = [];
+            const mockContract = {
+                sendPresenceUpdate: async (state, jid) => {
+                    updates.push({ state, jid });
+                }
+            };
+            const simPromise = simulateState(mockContract, "123@c.us", 1000, "typing");
+            // simulateState awaits the first presence update before scheduling its
+            // timeout, so let that continuation run before advancing mock time.
+            await Promise.resolve();
+            t.mock.timers.tick(1000);
+            await simPromise;
+            assert.deepEqual(updates, [
+                { state: "composing", jid: "123@c.us" },
+                { state: "paused", jid: "123@c.us" }
+            ]);
+        });
+        test("handles non-fatal contract errors gracefully", async () => {
+            const failingContract = {
+                sendPresenceUpdate: async () => {
+                    throw new Error("Network error");
+                }
+            };
+            // Should not throw exception
+            await assert.doesNotReject(async () => {
+                await simulateState(failingContract, "123@c.us", 100, "typing");
+            });
+        });
+    });
+    describe("waitForSendSlot", () => {
+        test("completes send throttle without errors", async (t) => {
+            t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+            const sendPromise = waitForSendSlot("123@c.us", { cooldown: false, jitter: false });
+            t.mock.timers.tick(500);
+            await sendPromise;
+        });
+    });
+});

package/dist/kernel/settingsDb.js

@@ -14,9 +14,10 @@ import { DatabaseSync } from "node:sqlite";
 import path from "path";
 import { mkdirSync } from "fs";
 import { CONFIG_DIR } from "#config";
-// ── DB init ───────────────────────────────────────────────────────────────────
-const DB_PATH = path.join(CONFIG_DIR, "settings.db");
-mkdirSync(path.dirname(DB_PATH), { recursive: true });
+const DB_PATH = process.env.NODE_ENV === "test" ? ":memory:" : path.join(CONFIG_DIR, "settings.db");
+if (DB_PATH !== ":memory:") {
+    mkdirSync(path.dirname(DB_PATH), { recursive: true });
+}
 const db = new DatabaseSync(DB_PATH);
 db.exec("PRAGMA journal_mode = WAL");
 db.exec("PRAGMA foreign_keys = ON");