@diegoaltoworks/chatter 0.28.0 → 0.30.0

package/dist/channels/whatsapp/index.js

@@ -0,0 +1,810 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/channels/whatsapp/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LEASE_HEARTBEAT_MS: () => LEASE_HEARTBEAT_MS,
+  LEASE_STALE_MS: () => LEASE_STALE_MS,
+  LEASE_WAIT_MS: () => LEASE_WAIT_MS,
+  acquireSessionLease: () => acquireSessionLease,
+  canAcquireLease: () => canAcquireLease,
+  createTursoWaLeaseStore: () => createTursoWaLeaseStore,
+  createWhatsAppChannel: () => createWhatsAppChannel,
+  createWhatsAppInboundHandler: () => createWhatsAppInboundHandler,
+  decrypt: () => decrypt,
+  encrypt: () => encrypt,
+  extractText: () => extractText,
+  isGroupJid: () => isGroupJid,
+  jidToPhoneNumber: () => jidToPhoneNumber,
+  jidsMatch: () => jidsMatch,
+  loadBaileys: () => loadBaileys,
+  messageContext: () => messageContext,
+  reconnectDelayMs: () => reconnectDelayMs,
+  senderNameFor: () => senderNameFor,
+  senderPhoneFor: () => senderPhoneFor,
+  shutdownWaSessions: () => shutdownWaSessions,
+  useTursoAuthState: () => useTursoAuthState
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/channels/whatsapp/crypto.ts
+var import_node_crypto = require("node:crypto");
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+function deriveKey(secret) {
+  return (0, import_node_crypto.createHash)("sha256").update(secret, "utf-8").digest();
+}
+function encrypt(plaintext, secret) {
+  const iv = (0, import_node_crypto.randomBytes)(IV_LENGTH);
+  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", deriveKey(secret), iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), ciphertext]).toString("base64");
+}
+function decrypt(payload, secret) {
+  const raw = Buffer.from(payload, "base64");
+  const iv = raw.subarray(0, IV_LENGTH);
+  const tag = raw.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
+  const ciphertext = raw.subarray(IV_LENGTH + TAG_LENGTH);
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-gcm", deriveKey(secret), iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf-8");
+}
+
+// src/channels/whatsapp/authState.ts
+var schemaReady = /* @__PURE__ */ new WeakMap();
+function ensureAuthSchema(client) {
+  let ready = schemaReady.get(client);
+  if (!ready) {
+    ready = client.execute("CREATE TABLE IF NOT EXISTS wa_auth (id TEXT PRIMARY KEY, value TEXT NOT NULL)").catch((error) => {
+      schemaReady.delete(client);
+      throw error;
+    });
+    schemaReady.set(client, ready);
+  }
+  return ready;
+}
+async function useTursoAuthState(db, secret, sessionId, runtime) {
+  await ensureAuthSchema(db);
+  const rowId = (id) => sessionId === "default" ? id : `s:${sessionId}/${id}`;
+  async function read(id) {
+    const result = await db.execute({
+      sql: "SELECT value FROM wa_auth WHERE id = ?",
+      args: [rowId(id)]
+    });
+    const row = result.rows[0];
+    if (!row) return null;
+    return JSON.parse(decrypt(row.value, secret), runtime.bufferJSON.reviver);
+  }
+  async function write(id, value) {
+    const payload = encrypt(JSON.stringify(value, runtime.bufferJSON.replacer), secret);
+    await db.execute({
+      sql: "INSERT OR REPLACE INTO wa_auth (id, value) VALUES (?, ?)",
+      args: [rowId(id), payload]
+    });
+  }
+  async function remove(id) {
+    await db.execute({ sql: "DELETE FROM wa_auth WHERE id = ?", args: [rowId(id)] });
+  }
+  const creds = await read("creds") ?? runtime.initAuthCreds();
+  return {
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(
+            ids.map(async (id) => {
+              let value = await read(`${type}-${id}`);
+              if (type === "app-state-sync-key" && value) {
+                value = runtime.appStateSyncKeyFromObject(
+                  value
+                );
+              }
+              if (value) data[id] = value;
+            })
+          );
+          return data;
+        },
+        set: async (data) => {
+          const jobs = [];
+          for (const category of Object.keys(data)) {
+            const entries = data[category];
+            if (!entries) continue;
+            for (const id of Object.keys(entries)) {
+              const value = entries[id];
+              jobs.push(value ? write(`${category}-${id}`, value) : remove(`${category}-${id}`));
+            }
+          }
+          await Promise.all(jobs);
+        }
+      }
+    },
+    saveCreds: () => write("creds", creds),
+    clear: async () => {
+      if (sessionId === "default") {
+        await db.execute("DELETE FROM wa_auth WHERE id NOT LIKE 's:%'");
+      } else {
+        await db.execute({
+          sql: "DELETE FROM wa_auth WHERE id LIKE ?",
+          args: [`s:${sessionId}/%`]
+        });
+      }
+    }
+  };
+}
+
+// src/channels/whatsapp/baileys.ts
+function wrapMissingBaileysError(cause) {
+  return new Error(
+    "The WhatsApp channel ('@diegoaltoworks/chatter/whatsapp') requires the optional peer dependency '@whiskeysockets/baileys', which is not installed. Install it with `bun add @whiskeysockets/baileys` (or npm/pnpm/yarn) to use this channel.",
+    { cause }
+  );
+}
+var cached;
+function loadBaileys() {
+  if (!cached) {
+    cached = import("@whiskeysockets/baileys").catch((error) => {
+      cached = void 0;
+      throw wrapMissingBaileysError(error);
+    });
+  }
+  return cached;
+}
+function silentLogger() {
+  const noop = () => void 0;
+  const logger = {
+    level: "silent",
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop
+  };
+  logger.child = () => logger;
+  return logger;
+}
+
+// src/channels/whatsapp/lease.ts
+var LEASE_STALE_MS = 9e4;
+var LEASE_HEARTBEAT_MS = 3e4;
+var LEASE_WAIT_MS = 3e4;
+function canAcquireLease(existing, instanceId, now, staleMs = LEASE_STALE_MS) {
+  if (!existing) return true;
+  if (existing.instanceId === instanceId) return true;
+  return now - existing.heartbeatAt >= staleMs;
+}
+var schemaReady2 = /* @__PURE__ */ new WeakMap();
+function ensureWaLeaseSchema(client) {
+  let ready = schemaReady2.get(client);
+  if (!ready) {
+    ready = client.execute(
+      `CREATE TABLE IF NOT EXISTS wa_lease (
+          session_id TEXT PRIMARY KEY,
+          instance_id TEXT NOT NULL,
+          heartbeat_at INTEGER NOT NULL
+        )`
+    ).catch((error) => {
+      schemaReady2.delete(client);
+      throw error;
+    });
+    schemaReady2.set(client, ready);
+  }
+  return ready;
+}
+function createTursoWaLeaseStore(client) {
+  return {
+    async tryAcquire(sessionId, instanceId, now, staleMs) {
+      await ensureWaLeaseSchema(client);
+      const result = await client.execute({
+        sql: `INSERT INTO wa_lease (session_id, instance_id, heartbeat_at) VALUES (?, ?, ?)
+              ON CONFLICT(session_id) DO UPDATE SET
+                instance_id = excluded.instance_id,
+                heartbeat_at = excluded.heartbeat_at
+              WHERE wa_lease.instance_id = excluded.instance_id
+                 OR wa_lease.heartbeat_at <= excluded.heartbeat_at - ?
+              RETURNING instance_id`,
+        args: [sessionId, instanceId, now, staleMs]
+      });
+      const row = result.rows[0];
+      return Boolean(row) && row.instance_id === instanceId;
+    },
+    async release(sessionId, instanceId) {
+      await ensureWaLeaseSchema(client);
+      await client.execute({
+        sql: "DELETE FROM wa_lease WHERE session_id = ? AND instance_id = ?",
+        args: [sessionId, instanceId]
+      });
+    }
+  };
+}
+
+// src/channels/whatsapp/channel.ts
+var RECONNECT_DELAY_MS = 5e3;
+var RECONNECT_MAX_DELAY_MS = 10 * 60 * 1e3;
+function reconnectDelayMs(failures) {
+  return Math.min(RECONNECT_DELAY_MS * 2 ** Math.min(failures, 20), RECONNECT_MAX_DELAY_MS);
+}
+async function shutdownWaSessions(sessions) {
+  await Promise.all(
+    [...sessions.values()].map(async (handle) => {
+      handle.stopHeartbeat();
+      handle.sock.end(void 0);
+      await handle.release().catch(() => void 0);
+    })
+  );
+}
+async function loseSession(sessionId, sessions) {
+  const handle = sessions.get(sessionId);
+  if (!handle) return;
+  sessions.delete(sessionId);
+  await shutdownWaSessions(/* @__PURE__ */ new Map([[sessionId, handle]]));
+}
+async function acquireSessionLease(sessionId, deps) {
+  const { leaseStore, instanceId, sessions, isStopped, connect } = deps;
+  const now = deps.now ?? Date.now;
+  const staleMs = deps.staleMs ?? LEASE_STALE_MS;
+  const heartbeatMs = deps.heartbeatMs ?? LEASE_HEARTBEAT_MS;
+  const waitMs = deps.waitMs ?? LEASE_WAIT_MS;
+  const schedule = deps.schedule ?? ((fn, ms) => void setTimeout(fn, ms));
+  if (isStopped()) return;
+  const retry = () => {
+    schedule(
+      () => void acquireSessionLease(sessionId, deps).catch(
+        (error) => console.error(`WhatsApp[${sessionId}]: lease re-check failed:`, error)
+      ),
+      waitMs
+    );
+  };
+  let acquired;
+  try {
+    acquired = await leaseStore.tryAcquire(sessionId, instanceId, now(), staleMs);
+  } catch (error) {
+    console.warn(`WhatsApp[${sessionId}]: lease acquire failed, retrying:`, error);
+    retry();
+    return;
+  }
+  if (!acquired) {
+    console.warn(`WhatsApp[${sessionId}]: lease held by another instance, re-checking later`);
+    retry();
+    return;
+  }
+  const heartbeat = setInterval(() => {
+    void leaseStore.tryAcquire(sessionId, instanceId, now(), staleMs).then((stillHeld) => {
+      if (stillHeld || isStopped()) return;
+      console.error(`WhatsApp[${sessionId}]: lost the lease to another instance \u2014 disconnecting`);
+      void loseSession(sessionId, sessions).then(retry);
+    }).catch((error) => console.warn(`WhatsApp[${sessionId}]: lease heartbeat failed:`, error));
+  }, heartbeatMs);
+  if (typeof heartbeat === "object" && "unref" in heartbeat) heartbeat.unref();
+  sessions.set(sessionId, {
+    sock: { end: () => void 0 },
+    stopHeartbeat: () => clearInterval(heartbeat),
+    release: () => leaseStore.release(sessionId, instanceId)
+  });
+  try {
+    await connect(sessionId);
+  } catch (error) {
+    console.error(`WhatsApp[${sessionId}]: connect failed right after acquiring the lease:`, error);
+    await loseSession(sessionId, sessions);
+    retry();
+  }
+}
+function senderNameFor(channelName, sessionId) {
+  return sessionId === "default" ? channelName : `${channelName}:${sessionId}`;
+}
+function createWhatsAppChannel(config) {
+  const channelName = "whatsapp";
+  const sessionIds = config.sessionIds && config.sessionIds.length > 0 ? config.sessionIds : ["default"];
+  const now = config.now ?? Date.now;
+  const schedule = config.schedule ?? ((fn, ms) => void setTimeout(fn, ms));
+  const staleMs = config.staleMs ?? LEASE_STALE_MS;
+  const heartbeatMs = config.heartbeatMs ?? LEASE_HEARTBEAT_MS;
+  const waitMs = config.waitMs ?? LEASE_WAIT_MS;
+  const loadBaileys2 = config.loadBaileys ?? loadBaileys;
+  let stopped = false;
+  const instanceId = crypto.randomUUID();
+  const sessions = /* @__PURE__ */ new Map();
+  const failureCounts = /* @__PURE__ */ new Map();
+  const registeredSenderNames = /* @__PURE__ */ new Map();
+  let senders;
+  return {
+    name: channelName,
+    async start(deps) {
+      const db = deps.db;
+      const leaseStore = createTursoWaLeaseStore(db);
+      senders = deps.senders;
+      await loadBaileys2();
+      async function connect(sessionId) {
+        if (stopped || !sessions.has(sessionId)) return;
+        const baileys = await loadBaileys2();
+        const runtime = {
+          bufferJSON: baileys.BufferJSON,
+          initAuthCreds: baileys.initAuthCreds,
+          appStateSyncKeyFromObject: (value) => baileys.proto.Message.AppStateSyncKeyData.fromObject(value)
+        };
+        const { state, saveCreds } = await useTursoAuthState(
+          db,
+          config.sessionSecret,
+          sessionId,
+          runtime
+        );
+        if (!state.creds.registered) {
+          console.warn(
+            `WhatsApp[${sessionId}]: no paired session found \u2014 pair it first (see docs/channels.md). Re-checking in 60s.`
+          );
+          schedule(() => void connect(sessionId).catch(() => void 0), 6e4);
+          return;
+        }
+        const { version } = await baileys.fetchLatestBaileysVersion();
+        const logger = silentLogger();
+        const sock = baileys.makeWASocket({
+          version,
+          auth: {
+            creds: state.creds,
+            // biome-ignore lint/suspicious/noExplicitAny: silentLogger is structurally pino-compatible; Baileys' logger type is not exported
+            keys: baileys.makeCacheableSignalKeyStore(state.keys, logger)
+          },
+          // biome-ignore lint/suspicious/noExplicitAny: silentLogger is structurally pino-compatible; Baileys' logger type is not exported
+          logger,
+          markOnlineOnConnect: false,
+          syncFullHistory: false
+        });
+        const leaseHandle = sessions.get(sessionId);
+        if (leaseHandle) leaseHandle.sock = sock;
+        sock.ev.on(
+          "creds.update",
+          () => void saveCreds().catch(
+            (error) => console.warn(`WhatsApp[${sessionId}]: creds save failed:`, error)
+          )
+        );
+        sock.ev.on("connection.update", (update) => {
+          const { connection, lastDisconnect } = update;
+          if (connection === "open") {
+            failureCounts.set(sessionId, 0);
+            console.log(`WhatsApp[${sessionId}]: connected as ${sock.user?.id ?? "unknown"}`);
+            const senderName = senderNameFor(channelName, sessionId);
+            const sender = {
+              sendText: async (chatId, text) => {
+                await sock.sendMessage(chatId, { text });
+              }
+            };
+            deps.senders.register(senderName, sender);
+            registeredSenderNames.set(sessionId, senderName);
+          }
+          if (connection === "close") {
+            const senderName = registeredSenderNames.get(sessionId);
+            if (senderName) {
+              deps.senders.unregister(senderName);
+              registeredSenderNames.delete(sessionId);
+            }
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            if (statusCode === baileys.DisconnectReason.loggedOut) {
+              console.error(
+                `WhatsApp[${sessionId}]: session logged out \u2014 re-pair to reconnect (see docs/channels.md).`
+              );
+              void loseSession(sessionId, sessions);
+              return;
+            }
+            if (!stopped && sessions.has(sessionId)) {
+              const delay = reconnectDelayMs(failureCounts.get(sessionId) ?? 0);
+              failureCounts.set(sessionId, (failureCounts.get(sessionId) ?? 0) + 1);
+              console.warn(
+                `WhatsApp[${sessionId}]: connection closed (${statusCode ?? "?"}), reconnecting in ${Math.round(delay / 1e3)}s...`
+              );
+              schedule(
+                () => void connect(sessionId).catch(
+                  (error) => console.error(`WhatsApp[${sessionId}]: reconnect failed:`, error)
+                ),
+                delay
+              );
+            }
+          }
+        });
+        if (config.onMessage) {
+          sock.ev.on("messages.upsert", async ({ messages, type }) => {
+            if (type !== "notify") return;
+            for (const message of messages) {
+              try {
+                await config.onMessage?.({ sessionId, sock, message });
+              } catch (error) {
+                console.warn(`WhatsApp[${sessionId}]: onMessage handler failed:`, error);
+              }
+            }
+          });
+        }
+      }
+      for (const sessionId of sessionIds) {
+        void acquireSessionLease(sessionId, {
+          leaseStore,
+          instanceId,
+          sessions,
+          isStopped: () => stopped,
+          connect,
+          now,
+          staleMs,
+          heartbeatMs,
+          waitMs,
+          schedule
+        }).catch((error) => console.error(`WhatsApp[${sessionId}]: failed to start:`, error));
+      }
+    },
+    async stop() {
+      stopped = true;
+      for (const senderName of registeredSenderNames.values()) {
+        senders?.unregister(senderName);
+      }
+      registeredSenderNames.clear();
+      await shutdownWaSessions(sessions);
+    }
+  };
+}
+
+// src/core/guardrails.ts
+function detectLeakage(text) {
+  const flags = [
+    /system prompt/i,
+    /hidden instruction/i,
+    /here (are|is) (my|the) rules/i,
+    /BEGIN SYSTEM PROMPT/i,
+    /tool instructions/i
+  ];
+  return flags.some((rx) => rx.test(text));
+}
+function scrubOutput(text) {
+  return text.replace(/sk-[A-Za-z0-9]{15,}/g, "[REDACTED]").replace(/AIza[0-9A-Za-z_-]{30,}/g, "[REDACTED]");
+}
+function guardOutput(text) {
+  if (detectLeakage(text)) {
+    return "Sorry, I can't share internal instructions. How else can I help?";
+  }
+  return scrubOutput(text);
+}
+
+// src/core/llm.ts
+var DEFAULT_MODEL = "gpt-4o";
+async function completeOnce({
+  client,
+  system,
+  messages,
+  temperature = 0.2,
+  model = DEFAULT_MODEL
+}) {
+  const res = await client.chat.completions.create({
+    model,
+    temperature,
+    messages: [{ role: "system", content: system }, ...messages]
+  });
+  const text = res.choices[0]?.message?.content ?? "";
+  return {
+    content: guardOutput(text),
+    usage: res.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+
+// src/core/answer.ts
+var noUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+async function runAnswerFn(answerFn, { system, messages, mode, sender }) {
+  const result = await answerFn({ system, messages, mode, sender });
+  const raw = typeof result === "string" ? result : result?.content;
+  const usage = typeof result === "string" ? void 0 : result?.usage;
+  return {
+    content: guardOutput(typeof raw === "string" ? raw : ""),
+    usage: usage ?? noUsage()
+  };
+}
+async function answerOnce({
+  answerFn,
+  client,
+  system,
+  messages,
+  mode,
+  sender,
+  temperature,
+  model
+}) {
+  if (answerFn) {
+    return runAnswerFn(answerFn, { system, messages, mode, sender });
+  }
+  return completeOnce({ client, system, messages, temperature, model });
+}
+
+// src/core/buckets.ts
+function defaultBuckets(mode) {
+  return ["base", mode];
+}
+function isIdentified(sender) {
+  return typeof sender === "string" && sender.trim().length > 0;
+}
+function normalize(buckets) {
+  const out = [];
+  for (const raw of buckets) {
+    if (typeof raw !== "string") continue;
+    const bucket = raw.trim();
+    if (bucket && !out.includes(bucket)) out.push(bucket);
+  }
+  return out;
+}
+async function resolveBuckets({
+  mode,
+  sender,
+  bucketsFor
+}) {
+  if (!bucketsFor) return void 0;
+  const identified = isIdentified(sender);
+  const requested = await bucketsFor(identified ? { mode, sender } : { mode });
+  if (!Array.isArray(requested)) return void 0;
+  const cleaned = normalize(requested);
+  if (identified) return cleaned;
+  const ceiling = new Set(defaultBuckets(mode));
+  return cleaned.filter((bucket) => ceiling.has(bucket));
+}
+
+// src/core/pipeline.ts
+var MODE_SETTINGS = {
+  public: { topK: 6, label: "Context" },
+  private: { topK: 8, label: "Internal Context" }
+};
+async function prepareChat({
+  store,
+  prompts,
+  mode,
+  messages,
+  personaLayer,
+  channelHint,
+  buckets
+}) {
+  const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+  if (!lastUserMsg) {
+    throw new Error("no user message found in conversation");
+  }
+  const { topK, label } = MODE_SETTINGS[mode];
+  const ctx = await store.query(lastUserMsg.content, topK, buckets ?? defaultBuckets(mode));
+  const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
+  const hint = channelHint?.trim();
+  const system = [
+    prompts.baseSystemRules,
+    persona,
+    ...hint ? [hint] : [],
+    `${label}:
+${ctx.join("\n\n")}`
+  ].join("\n\n");
+  return { system, messages };
+}
+
+// src/channels/gates.ts
+function matches(re, text) {
+  return new RegExp(re.source, re.flags.replace(/[gy]/g, "")).test(text);
+}
+function decideChannelAction(msg, config) {
+  if (msg.fromBot || !msg.text.trim()) return "ignore";
+  if (!msg.isDirectMessage) {
+    if (config.allowedChats.length > 0 && !config.allowedChats.includes(msg.chatId)) {
+      return "ignore";
+    }
+    if (config.muteRegex && matches(config.muteRegex, msg.text)) return "mute";
+    if (config.unmuteRegex && matches(config.unmuteRegex, msg.text)) return "unmute";
+    if (config.mutedChats.has(msg.chatId)) return "ignore";
+    return msg.mentionsBot || msg.isReplyToBot ? "reply" : "ignore";
+  }
+  return "reply";
+}
+function createSlidingWindowRateLimiter(maxPerWindow, windowMs, now = Date.now) {
+  const log = /* @__PURE__ */ new Map();
+  return function allow(key) {
+    const cutoff = now() - windowMs;
+    const entries = (log.get(key) ?? []).filter((t) => t > cutoff);
+    if (entries.length >= maxPerWindow) {
+      if (entries.length > 0) log.set(key, entries);
+      else log.delete(key);
+      return false;
+    }
+    entries.push(now());
+    log.set(key, entries);
+    return true;
+  };
+}
+function underReplyRateLimit(msg, limiters) {
+  return msg.isDirectMessage ? limiters.dm(msg.chatId) : limiters.group(msg.chatId);
+}
+function isFromAnySession(id, registry) {
+  if (!id) return false;
+  for (const ids of registry.values()) {
+    if (ids.includes(id)) return true;
+  }
+  return false;
+}
+function isEffectivelyFromSelf(msg, registry) {
+  return msg.fromBot || isFromAnySession(msg.senderId, registry);
+}
+
+// src/channels/whatsapp/inbound.ts
+function isGroupJid(jid) {
+  return jid.endsWith("@g.us");
+}
+function jidsMatch(a, b) {
+  if (!a || !b) return false;
+  const bare = (jid) => jid.split("@")[0]?.split(":")[0] ?? jid;
+  return bare(a) === bare(b);
+}
+function jidToPhoneNumber(jid) {
+  const bare = jid.split("@")[0]?.split(":")[0] ?? "";
+  return bare.startsWith("+") ? bare : `+${bare}`;
+}
+function normalizeJid(jid) {
+  const [user = "", domain] = jid.split("@");
+  const bareUser = user.split(":")[0] ?? user;
+  return domain ? `${bareUser}@${domain}` : bareUser;
+}
+async function senderPhoneFor(sock, message, chatJid) {
+  const key = message.key;
+  let jid = [key.participantPn, key.senderPn, key.participant, key.remoteJidAlt, chatJid].find(
+    (candidate) => typeof candidate === "string" && candidate.length > 0
+  ) ?? chatJid;
+  if (jid.endsWith("@lid")) {
+    try {
+      const mapped = await sock.signalRepository?.lidMapping?.getPNForLID?.(jid);
+      if (mapped) jid = mapped;
+    } catch {
+    }
+  }
+  return jid.endsWith("@lid") ? `lid:${jid.split("@")[0]?.split(":")[0] ?? jid}` : jidToPhoneNumber(jid);
+}
+function messageContext(message) {
+  const content = message.message;
+  const contextInfo = content?.extendedTextMessage?.contextInfo ?? content?.imageMessage?.contextInfo ?? content?.videoMessage?.contextInfo ?? content?.documentMessage?.contextInfo;
+  return {
+    mentionedJids: contextInfo?.mentionedJid ?? [],
+    quotedParticipantJid: contextInfo?.participant ?? void 0
+  };
+}
+function extractText(message) {
+  const content = message.message;
+  if (!content) return "";
+  return content.conversation ?? content.extendedTextMessage?.text ?? content.imageMessage?.caption ?? content.videoMessage?.caption ?? content.documentMessage?.caption ?? "";
+}
+var DEFAULT_GROUP_RATE_LIMIT = { max: 30, windowMs: 60 * 60 * 1e3 };
+var DEFAULT_DM_RATE_LIMIT = { max: 20, windowMs: 60 * 60 * 1e3 };
+async function resolvePersonaLayer(config, ctx) {
+  if (!config.personaResolver) return void 0;
+  try {
+    return await config.personaResolver(ctx);
+  } catch {
+    return void 0;
+  }
+}
+function createWhatsAppInboundHandler(config) {
+  const mutedChats = /* @__PURE__ */ new Set();
+  const now = config.now ?? Date.now;
+  const group = config.groupRateLimit ?? DEFAULT_GROUP_RATE_LIMIT;
+  const dm = config.dmRateLimit ?? DEFAULT_DM_RATE_LIMIT;
+  const underGroupRateLimit = createSlidingWindowRateLimiter(group.max, group.windowMs, now);
+  const underDmRateLimit = createSlidingWindowRateLimiter(dm.max, dm.windowMs, now);
+  return async function handleWhatsAppMessage(event) {
+    const { sessionId, sock, message } = event;
+    try {
+      const chatId = message.key.remoteJid ?? "";
+      if (!chatId || chatId === "status@broadcast") return;
+      const text = extractText(message);
+      const context = messageContext(message);
+      const senderId = message.key.participant ?? chatId;
+      const ownIds = [sock.user?.id, sock.user?.lid].filter((id) => Boolean(id)).map(normalizeJid);
+      config.registry.set(sessionId, ownIds);
+      const fromBot = isEffectivelyFromSelf(
+        { fromBot: message.key.fromMe ?? false, senderId: normalizeJid(senderId) },
+        config.registry
+      );
+      const msg = {
+        chatId,
+        senderId,
+        text,
+        isDirectMessage: !isGroupJid(chatId),
+        mentionsBot: context.mentionedJids.some((jid) => ownIds.some((own) => jidsMatch(jid, own))),
+        isReplyToBot: ownIds.some((own) => jidsMatch(context.quotedParticipantJid, own)),
+        fromBot
+      };
+      const action = decideChannelAction(msg, {
+        allowedChats: config.allowedChats ?? [],
+        mutedChats,
+        muteRegex: config.muteRegex,
+        unmuteRegex: config.unmuteRegex
+      });
+      if (action === "mute") {
+        mutedChats.add(chatId);
+        if (config.muteReply) await sock.sendMessage(chatId, { text: config.muteReply });
+        return;
+      }
+      if (action === "unmute") {
+        mutedChats.delete(chatId);
+        if (config.unmuteReply) await sock.sendMessage(chatId, { text: config.unmuteReply });
+        return;
+      }
+      if (action !== "reply") return;
+      if (!underReplyRateLimit(msg, { dm: underDmRateLimit, group: underGroupRateLimit })) {
+        return;
+      }
+      const senderPhone = await senderPhoneFor(sock, message, chatId);
+      const personaLayer = await resolvePersonaLayer(config, { senderPhone, text });
+      const buckets = await resolveBuckets({
+        mode: "public",
+        sender: senderPhone,
+        bucketsFor: config.bucketsFor
+      });
+      const messages = [{ role: "user", content: text }];
+      const { system } = await prepareChat({
+        store: config.store,
+        prompts: config.prompts,
+        mode: "public",
+        messages,
+        personaLayer,
+        channelHint: config.channelHint,
+        buckets
+      });
+      const { content } = await answerOnce({
+        answerFn: config.answerFn,
+        client: config.client,
+        system,
+        messages,
+        mode: "public",
+        sender: senderPhone,
+        model: config.model
+      });
+      if (content) {
+        await sock.sendMessage(chatId, { text: content }, { quoted: message });
+      }
+    } catch (error) {
+      console.warn(`WhatsApp[${sessionId}]: inbound message handling failed:`, error);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LEASE_HEARTBEAT_MS,
+  LEASE_STALE_MS,
+  LEASE_WAIT_MS,
+  acquireSessionLease,
+  canAcquireLease,
+  createTursoWaLeaseStore,
+  createWhatsAppChannel,
+  createWhatsAppInboundHandler,
+  decrypt,
+  encrypt,
+  extractText,
+  isGroupJid,
+  jidToPhoneNumber,
+  jidsMatch,
+  loadBaileys,
+  messageContext,
+  reconnectDelayMs,
+  senderNameFor,
+  senderPhoneFor,
+  shutdownWaSessions,
+  useTursoAuthState
+});