@diegoaltoworks/chatter 0.28.0 → 0.30.0

package/dist/bin/wa-pair.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// bin/wa-pair.ts
+var import_client = require("@libsql/client");
+
+// 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(db2, secret, sessionId2, runtime) {
+  await ensureAuthSchema(db2);
+  const rowId = (id) => sessionId2 === "default" ? id : `s:${sessionId2}/${id}`;
+  async function read(id) {
+    const result = await db2.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 db2.execute({
+      sql: "INSERT OR REPLACE INTO wa_auth (id, value) VALUES (?, ?)",
+      args: [rowId(id), payload]
+    });
+  }
+  async function remove(id) {
+    await db2.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 (sessionId2 === "default") {
+        await db2.execute("DELETE FROM wa_auth WHERE id NOT LIKE 's:%'");
+      } else {
+        await db2.execute({
+          sql: "DELETE FROM wa_auth WHERE id LIKE ?",
+          args: [`s:${sessionId2}/%`]
+        });
+      }
+    }
+  };
+}
+
+// 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;
+}
+
+// bin/wa-pair.ts
+var args = process.argv.slice(2);
+function flagValue(name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+WhatsApp pairing CLI
+
+Usage:
+  bun run wa-pair [sessionId] [options]
+
+Arguments:
+  sessionId               Which session to pair (default: "default"). Use a
+                           distinct id per WhatsApp number for multi-session.
+
+Options:
+  --code <phoneNumber>    Pair via pairing code instead of QR (digits only,
+                           e.g. 447700900123). For headless setups.
+  --reset                 Wipe the stored session first, then pair fresh.
+  --help, -h               Show this help.
+
+Environment:
+  TURSO_URL, TURSO_AUTH_TOKEN   Required. The database auth state is stored in.
+  WA_SESSION_SECRET             Required. Encrypts the stored session at rest.
+`);
+  process.exit(0);
+}
+var sessionId = args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--code") ?? "default";
+if (args.includes("--code") && !flagValue("--code")) {
+  console.error("\u274C --code requires a phone number, e.g. --code 447700900123");
+  process.exit(1);
+}
+var phoneNumber = flagValue("--code")?.replace(/[^0-9]/g, "");
+var reset = args.includes("--reset");
+var sessionSecret = process.env.WA_SESSION_SECRET;
+if (!sessionSecret) {
+  console.error("\u274C WA_SESSION_SECRET is required (any strong passphrase; keep it stable).");
+  process.exit(1);
+}
+if (!process.env.TURSO_URL) {
+  console.error("\u274C TURSO_URL is required.");
+  process.exit(1);
+}
+var db = (0, import_client.createClient)({
+  url: process.env.TURSO_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN || ""
+});
+var MAX_RECONNECTS = 12;
+var codeRequested = false;
+var reconnects = 0;
+var didReset = false;
+async function start() {
+  const baileys = await loadBaileys().catch((error) => {
+    console.error(`\u274C ${error.message}`);
+    process.exit(1);
+  });
+  const runtime = {
+    bufferJSON: baileys.BufferJSON,
+    initAuthCreds: baileys.initAuthCreds,
+    appStateSyncKeyFromObject: (value) => baileys.proto.Message.AppStateSyncKeyData.fromObject(value)
+  };
+  const { state, saveCreds, clear } = await useTursoAuthState(
+    db,
+    sessionSecret,
+    sessionId,
+    runtime
+  );
+  if (reset && !didReset) {
+    didReset = true;
+    await clear();
+    console.log(`Session "${sessionId}" wiped. Pairing fresh...`);
+    return start();
+  }
+  if (state.creds.registered && !codeRequested) {
+    console.log(
+      `Already paired. Session "${sessionId}" is connected-ready. Run with --reset to re-pair.`
+    );
+    process.exit(0);
+  }
+  const { version } = await baileys.fetchLatestBaileysVersion();
+  const noop = () => void 0;
+  const logger = {
+    level: "silent",
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop
+  };
+  logger.child = () => logger;
+  const sock = baileys.makeWASocket({
+    version,
+    auth: {
+      creds: state.creds,
+      // biome-ignore lint/suspicious/noExplicitAny: structural pino-compatible logger
+      keys: baileys.makeCacheableSignalKeyStore(state.keys, logger)
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: structural pino-compatible logger
+    logger,
+    markOnlineOnConnect: false
+  });
+  sock.ev.on("creds.update", saveCreds);
+  sock.ev.on("connection.update", async (update) => {
+    const { connection, lastDisconnect, qr } = update;
+    if (qr && !phoneNumber) {
+      const qrcodeTerminal = await import("qrcode-terminal").catch(() => void 0);
+      if (!qrcodeTerminal) {
+        console.error(
+          "\u274C QR mode requires the optional peer dependency 'qrcode-terminal'. Install it with `bun add qrcode-terminal`, or re-run with --code <phoneNumber> for pairing-code mode instead."
+        );
+        process.exit(1);
+      }
+      console.log(
+        "\nScan this QR code: WhatsApp -> Settings -> Linked Devices -> Link a Device.\n"
+      );
+      qrcodeTerminal.default.generate(qr, { small: true });
+    }
+    if (connection === "open") {
+      console.log(
+        `
+\u2705 Paired session "${sessionId}" as ${sock.user?.id}. Session saved (encrypted).`
+      );
+      console.log("The running server will pick this session up on its next connect.");
+      process.exit(0);
+    }
+    if (connection === "close") {
+      const statusCode = lastDisconnect?.error?.output?.statusCode;
+      if (codeRequested && reconnects < MAX_RECONNECTS) {
+        reconnects++;
+        console.log(
+          `Connection closed (${statusCode ?? "?"}) - reconnecting (code STILL VALID, keep going on the phone) (${reconnects}/${MAX_RECONNECTS})...`
+        );
+        setTimeout(() => void start(), 2e3);
+        return;
+      }
+      if (statusCode === baileys.DisconnectReason.loggedOut) {
+        console.error("\u274C Pairing rejected (logged out). Run wa-pair again for a fresh code.");
+      } else {
+        console.error(`\u274C Connection closed (${statusCode ?? "?"}). Run wa-pair again.`);
+      }
+      process.exit(1);
+    }
+  });
+  if (phoneNumber && !codeRequested && !state.creds.registered) {
+    setTimeout(async () => {
+      try {
+        const code = await sock.requestPairingCode(phoneNumber);
+        codeRequested = true;
+        console.log("\n==============================================");
+        console.log(`  Pairing code for +${phoneNumber}:  ${code}`);
+        console.log("==============================================");
+        console.log("On the phone: WhatsApp -> Settings -> Linked Devices ->");
+        console.log("Link a Device -> 'Link with phone number instead' -> enter the code.");
+        console.log("Waiting for confirmation (leave this running)...");
+      } catch (error) {
+        console.error("\u274C Failed to request pairing code:", error);
+        process.exit(1);
+      }
+    }, 3e3);
+  }
+}
+start().catch((error) => {
+  console.error("\u274C Unexpected error:", error);
+  process.exit(1);
+});

package/dist/channels/whatsapp/authState.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Turso/libsql-backed Baileys auth state, encrypted at rest.
+ *
+ * Same contract as Baileys' own `useMultiFileAuthState`, but rows in a
+ * `wa_auth` table instead of files, AES-GCM encrypted (see `crypto.ts`) so
+ * session material — which grants full account access — is never stored
+ * readable.
+ *
+ * Only Baileys *types* are imported here (erased at compile time, so they add
+ * no runtime dependency); the few Baileys runtime values this module needs
+ * (`BufferJSON`, `initAuthCreds`, the app-state-sync-key constructor) are
+ * passed in by the caller, which already holds them from the dynamic import
+ * in `baileys.ts` — see that module for why the import is dynamic.
+ */
+import type { Client } from "@libsql/client";
+import type { AuthenticationCreds, AuthenticationState, SignalDataTypeMap } from "@whiskeysockets/baileys";
+export interface TursoAuthStateResult {
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    /** Wipe the stored session (unlink / re-pair). */
+    clear: () => Promise<void>;
+}
+/** The slice of the dynamically-loaded Baileys module this file needs at runtime. */
+export interface AuthStateRuntime {
+    bufferJSON: {
+        replacer: (key: string, value: unknown) => unknown;
+        reviver: (key: string, value: unknown) => unknown;
+    };
+    initAuthCreds: () => AuthenticationCreds;
+    appStateSyncKeyFromObject: (value: Record<string, unknown>) => SignalDataTypeMap["app-state-sync-key"];
+}
+/**
+ * Sessions share the `wa_auth` table, namespaced by row-id prefix. The
+ * "default" session uses UNPREFIXED ids — exactly a single-session layout —
+ * so an existing default session needs no migration when multi-session
+ * support is introduced.
+ */
+export declare function useTursoAuthState(db: Client, secret: string, sessionId: string, runtime: AuthStateRuntime): Promise<TursoAuthStateResult>;
+//# sourceMappingURL=authState.d.ts.map

package/dist/channels/whatsapp/authState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authState.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/authState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,yBAAyB,CAAC;AAGjC,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,mBAAmB,CAAC;IAC3B,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,kDAAkD;IAClD,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE;QACV,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;QACnD,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;KACnD,CAAC;IACF,aAAa,EAAE,MAAM,mBAAmB,CAAC;IACzC,yBAAyB,EAAE,CACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC3B,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;CAC9C;AAiBD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,oBAAoB,CAAC,CA6E/B"}

package/dist/channels/whatsapp/authState.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=authState.test.d.ts.map

package/dist/channels/whatsapp/authState.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authState.test.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/authState.test.ts"],"names":[],"mappings":""}

package/dist/channels/whatsapp/baileys.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The one place `./whatsapp` touches the `@whiskeysockets/baileys` package at
+ * runtime. It's an OPTIONAL peer dependency — `bun install` and every core
+ * import must work without it — so nothing in this subpath may `import` it
+ * statically; every other module here takes what it needs as a value (see
+ * `AuthStateRuntime` in `authState.ts`) or a type-only import (erased at
+ * compile time, so it costs nothing at runtime).
+ *
+ * `loadBaileys()` is the single dynamic import, called lazily when a channel
+ * actually starts, so a missing package fails with an actionable message
+ * instead of a raw "Cannot find module" — or, worse, at unrelated core
+ * imports that never touch WhatsApp at all.
+ */
+import type * as BaileysModule from "@whiskeysockets/baileys";
+export type Baileys = typeof BaileysModule;
+/** Wraps a failed `import("@whiskeysockets/baileys")` in an actionable message. Exported separately so the message content is unit-testable without simulating a real missing module. */
+export declare function wrapMissingBaileysError(cause: unknown): Error;
+export declare function loadBaileys(): Promise<Baileys>;
+/** A silent, structurally pino-compatible logger — Baileys logs very verbosely by default. */
+export declare function silentLogger(): unknown;
+//# sourceMappingURL=baileys.d.ts.map

package/dist/channels/whatsapp/baileys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baileys.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/baileys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAE9D,MAAM,MAAM,OAAO,GAAG,OAAO,aAAa,CAAC;AAE3C,yLAAyL;AACzL,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAO7D;AAID,wBAAgB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAQ9C;AAED,8FAA8F;AAC9F,wBAAgB,YAAY,IAAI,OAAO,CAatC"}

package/dist/channels/whatsapp/baileys.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=baileys.test.d.ts.map

package/dist/channels/whatsapp/baileys.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baileys.test.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/baileys.test.ts"],"names":[],"mappings":""}

package/dist/channels/whatsapp/channel.d.ts

@@ -0,0 +1,95 @@
+/**
+ * WhatsApp web-client transport: a {@link Channel} that runs one Baileys
+ * socket per configured session id (one WhatsApp number each), auth state
+ * encrypted in the host's own database (`deps.db` — no second connection
+ * opened), and a deploy lease so two overlapping instances can never hold the
+ * same session's socket at once (WhatsApp treats a second connection as a
+ * takeover and logs the first one out).
+ *
+ * Message INTERPRETATION — mention/reply detection, allowlists, loop guards —
+ * is deliberately not this module's job; it hands every raw inbound message
+ * to `config.onMessage` and lets the caller apply `./channels`' reply gates.
+ * This module owns only the connection lifecycle and outbound sending.
+ *
+ * ToS note: Baileys is an unofficial WhatsApp client. Linking a number
+ * carries a real ban risk — use a number you can afford to lose, and treat
+ * this channel as opt-in, never a default.
+ */
+import type { WAMessage, WASocket } from "@whiskeysockets/baileys";
+import type { Channel } from "../index";
+import { type Baileys } from "./baileys";
+import { type WaLeaseStore } from "./lease";
+/** Exponential backoff: 5s, 10s, 20s ... capped at 10 minutes. Hammering
+ * WhatsApp every few seconds during an outage or ban aggravates ban scoring. */
+export declare function reconnectDelayMs(failures: number): number;
+export interface WhatsAppMessageEvent {
+    sessionId: string;
+    sock: WASocket;
+    message: WAMessage;
+}
+export interface WhatsAppChannelConfig {
+    /** Passphrase that encrypts auth state at rest (AES-256-GCM key material). Keep it stable across restarts and deploys — losing it means re-pairing. */
+    sessionSecret: string;
+    /** One Baileys connection per id, each a separate WhatsApp number. Defaults to `["default"]`, whose auth rows are unprefixed (a pre-multi-session deployment needs no migration). */
+    sessionIds?: string[];
+    /**
+     * Called for every raw inbound message on every session. This module does
+     * no interpretation of its own — no mention detection, no allowlists, no
+     * loop guard — so replies belong entirely to the handler; pair it with
+     * `./channels`' `decideChannelAction` and `isEffectivelyFromSelf`. A
+     * throwing/rejecting handler is caught and logged, never left to crash the
+     * socket's event loop.
+     */
+    onMessage?: (event: WhatsAppMessageEvent) => void | Promise<void>;
+    now?: () => number;
+    /** Overridable for tests; defaults to `setTimeout`. */
+    schedule?: (fn: () => void, ms: number) => void;
+    /** Overridable for tests, which fake the Baileys module instead of installing it; defaults to `loadBaileys` from `./baileys`. */
+    loadBaileys?: () => Promise<Baileys>;
+    staleMs?: number;
+    heartbeatMs?: number;
+    waitMs?: number;
+}
+/** A live, leased session: what `stop()` (or losing the lease) must tear down. */
+export interface WaSessionHandle {
+    sock: {
+        end: (error?: Error) => void;
+    };
+    stopHeartbeat: () => void;
+    release: () => Promise<void>;
+}
+/**
+ * Tears down every session in `sessions`: stop renewing, close the socket,
+ * THEN release the lease — releasing before the socket closes could let
+ * another instance connect while this one is still on the wire. Sessions run
+ * independently (`Promise.all`); one release rejecting must not block or skip
+ * the rest.
+ */
+export declare function shutdownWaSessions(sessions: Map<string, WaSessionHandle>): Promise<void>;
+export interface LeaseGatedConnectDeps {
+    leaseStore: WaLeaseStore;
+    instanceId: string;
+    sessions: Map<string, WaSessionHandle>;
+    isStopped: () => boolean;
+    /** The actual Baileys connect — registers its own reconnect-on-close loop; this only gates its FIRST call. */
+    connect: (sessionId: string) => Promise<void>;
+    now?: () => number;
+    staleMs?: number;
+    heartbeatMs?: number;
+    waitMs?: number;
+    schedule?: (fn: () => void, ms: number) => void;
+}
+/**
+ * Acquire `sessionId`'s lease before connecting — two instances must never
+ * run concurrent Baileys clients for the same session. Not holding it (or a
+ * database blip while trying) means wait and re-check instead of connecting.
+ * Once held, a heartbeat renews it for as long as the session runs; if a
+ * heartbeat ever finds the lease gone (this instance went stale and another
+ * took over), the session is torn down and this re-enters the same
+ * wait-and-retry loop rather than staying connected alongside the new holder.
+ */
+export declare function acquireSessionLease(sessionId: string, deps: LeaseGatedConnectDeps): Promise<void>;
+/** Sender-registry name for a session — the default session stays unprefixed so single-number deployments see a plain `"whatsapp"` name. */
+export declare function senderNameFor(channelName: string, sessionId: string): string;
+export declare function createWhatsAppChannel(config: WhatsAppChannelConfig): Channel;
+//# sourceMappingURL=channel.d.ts.map

package/dist/channels/whatsapp/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAIxC,OAAO,EAAE,KAAK,OAAO,EAAmD,MAAM,WAAW,CAAC;AAC1F,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,SAAS,CAAC;AAKjB;gFACgF;AAChF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,SAAS,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,uJAAuJ;IACvJ,aAAa,EAAE,MAAM,CAAC;IACtB,qLAAqL;IACrL,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,iIAAiI;IACjI,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE;QAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;KAAE,CAAC;IACvC,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ9F;AAYD,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,YAAY,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACvC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,8GAA8G;IAC9G,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Df;AAED,4IAA4I;AAC5I,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CA8L5E"}

package/dist/channels/whatsapp/channel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=channel.test.d.ts.map

package/dist/channels/whatsapp/channel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.test.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/channel.test.ts"],"names":[],"mappings":""}

package/dist/channels/whatsapp/crypto.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encryption for persisted WhatsApp session material (AES-256-GCM).
+ *
+ * The stored auth state grants full account access, so it never touches the
+ * database in plaintext. The key derives from a caller-supplied secret (any
+ * strong passphrase, kept stable across restarts and deploys).
+ */
+export declare function encrypt(plaintext: string, secret: string): string;
+export declare function decrypt(payload: string, secret: string): string;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/channels/whatsapp/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQ/D"}

package/dist/channels/whatsapp/crypto.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=crypto.test.d.ts.map

package/dist/channels/whatsapp/crypto.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.test.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/crypto.test.ts"],"names":[],"mappings":""}

package/dist/channels/whatsapp/inbound.d.ts

@@ -0,0 +1,131 @@
+/**
+ * WhatsApp inbound: turns a raw Baileys message into a reply through
+ * chatter's own pipeline (`prepareChat` + `answerOnce`), gated by
+ * `./channels`' reply gates and loop guard. `./channel` hands every raw
+ * message to `config.onMessage` uninterpreted — this module is that
+ * interpretation.
+ *
+ * Message-shape parsing (text/caption extraction, contextInfo mentions and
+ * quoted-reply resolution) is genericized from the reference implementation:
+ * text AND contextInfo live in a DIFFERENT place per message shape — plain
+ * text carries both on `extendedTextMessage`, but a photo/video/document
+ * carries its caption on its own message type and its contextInfo there too.
+ * Missing that meant mentions in photo captions were invisible and group
+ * photo requests were silently ignored.
+ *
+ * `createWhatsAppInboundHandler` needs `ServerDependencies`
+ * (`client`/`store`/`prompts`), which only exists once `createServer` builds
+ * it — after `channels` (and therefore `onMessage`) must already be
+ * configured. Wire it up from `ChatterConfig.customRoutes`, which runs
+ * before channels start and receives the same deps:
+ *
+ * ```ts
+ * let handleInbound: ((event: WhatsAppMessageEvent) => Promise<void>) | undefined;
+ * const whatsapp = createWhatsAppChannel({
+ *   sessionSecret: process.env.WA_SESSION_SECRET as string,
+ *   onMessage: (event) => handleInbound?.(event),
+ * });
+ *
+ * await createServer({
+ *   ...,
+ *   channels: [whatsapp],
+ *   customRoutes: async (app, deps) => {
+ *     handleInbound = createWhatsAppInboundHandler({
+ *       client: deps.client,
+ *       store: deps.store,
+ *       prompts: deps.prompts,
+ *       answerFn: deps.config.answerFn,
+ *       bucketsFor: deps.config.bucketsFor,
+ *       registry: new Map(),
+ *     });
+ *   },
+ * });
+ * ```
+ */
+import type { WAMessage, WASocket } from "@whiskeysockets/baileys";
+import type OpenAI from "openai";
+import { type AnswerFn } from "../../core/answer";
+import { type BucketsFor } from "../../core/buckets";
+import type { PromptLoader } from "../../core/prompts";
+import type { VectorStore } from "../../core/retrieval";
+import { type SessionIdentityRegistry } from "../gates";
+import type { WhatsAppMessageEvent } from "./channel";
+export declare function isGroupJid(jid: string): boolean;
+/** "447700900123:17@s.whatsapp.net" (device-suffixed) and "447700900123@s.whatsapp.net" match. */
+export declare function jidsMatch(a: string | undefined, b: string | undefined): boolean;
+export declare function jidToPhoneNumber(jid: string): string;
+/**
+ * Resolve the sender's real phone number. Modern WhatsApp identifies group
+ * senders (and some DM chats) by LID (anonymized `"12345@lid"`), which
+ * carries no relationship to the phone number — treating it as one silently
+ * keys per-person state on garbage. Prefer the `*Pn` fields Baileys attaches
+ * when available, then fall back to the socket's own LID mapping store.
+ *
+ * The returned string is a stable identity key, not guaranteed to be a
+ * dialable phone number: an unresolved LID returns an explicit `"lid:<id>"`
+ * marker rather than a phone-shaped fabrication (`jidToPhoneNumber("12345@lid")`
+ * would otherwise yield `"+12345"`, indistinguishable from a real number) —
+ * callers keying security or spend decisions off `sender` (`bucketsFor`,
+ * usage metering) must not mistake a LID numeral for a phone number.
+ */
+export declare function senderPhoneFor(sock: WASocket, message: WAMessage, chatJid: string): Promise<string>;
+export interface WaMessageContext {
+    mentionedJids: string[];
+    quotedParticipantJid?: string;
+}
+/**
+ * contextInfo (mentions, quoted message) lives in a DIFFERENT place per
+ * message shape: a plain text message carries it on `extendedTextMessage`,
+ * but a photo/video/document message carries it on its own type.
+ */
+export declare function messageContext(message: WAMessage): WaMessageContext;
+/** Text/caption across every shape that can carry one — plain text, a reply, or a photo/video/document caption. */
+export declare function extractText(message: WAMessage): string;
+export interface WhatsAppInboundConfig {
+    client: OpenAI;
+    store: VectorStore;
+    prompts: PromptLoader;
+    answerFn?: AnswerFn;
+    bucketsFor?: BucketsFor;
+    model?: string;
+    /**
+     * Own identities per session — share ONE registry across every session
+     * this process runs so a message from one session's own number never
+     * looks like a stranger to another (the loop-guard case a single
+     * session's `fromMe` flag can't catch). Kept in sync from every message,
+     * not just at connection open, because a session's LID identity can
+     * populate late.
+     */
+    registry: SessionIdentityRegistry;
+    /** Group chats eligible for a reply. Empty (default) = every group. Has no effect on DMs, which always reply regardless. */
+    allowedChats?: string[];
+    muteRegex?: RegExp;
+    unmuteRegex?: RegExp;
+    /** Neutral, overridable acknowledgements — this module ships no bot personality; unset = silent mute/unmute. */
+    muteReply?: string;
+    unmuteReply?: string;
+    dmRateLimit?: {
+        max: number;
+        windowMs: number;
+    };
+    groupRateLimit?: {
+        max: number;
+        windowMs: number;
+    };
+    /** Extra system-prompt section describing the delivery channel; passed through to `prepareChat`. */
+    channelHint?: string;
+    /**
+     * Optional persona layer for a sender/text pair — the resolution
+     * mechanism (registry, windowed rolls, prompt files) lives in its own
+     * module; this only plugs the result into `prepareChat`'s `personaLayer`.
+     * A throw/rejection is treated as "no persona" for that turn.
+     */
+    personaResolver?: (ctx: {
+        senderPhone: string;
+        text: string;
+    }) => string | undefined | Promise<string | undefined>;
+    now?: () => number;
+}
+/** Builds the `onMessage` handler for `createWhatsAppChannel` (see `./channel`) — see the module docstring for how to wire `ServerDependencies` into it. */
+export declare function createWhatsAppInboundHandler(config: WhatsAppInboundConfig): (event: WhatsAppMessageEvent) => Promise<void>;
+//# sourceMappingURL=inbound.d.ts.map