@diegoaltoworks/chatter 0.27.0 → 0.29.0

package/dist/channels/whatsapp/index.mjs

@@ -0,0 +1,428 @@
+// src/channels/whatsapp/crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+function deriveKey(secret) {
+  return createHash("sha256").update(secret, "utf-8").digest();
+}
+function encrypt(plaintext, secret) {
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = 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 = 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);
+    }
+  };
+}
+export {
+  LEASE_HEARTBEAT_MS,
+  LEASE_STALE_MS,
+  LEASE_WAIT_MS,
+  acquireSessionLease,
+  canAcquireLease,
+  createTursoWaLeaseStore,
+  createWhatsAppChannel,
+  decrypt,
+  encrypt,
+  loadBaileys,
+  reconnectDelayMs,
+  senderNameFor,
+  shutdownWaSessions,
+  useTursoAuthState
+};

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

@@ -0,0 +1,42 @@
+/**
+ * Deploy-overlap protection: at most one running instance may hold a given
+ * WhatsApp session's Baileys connection at a time.
+ *
+ * Rolling deploys can briefly run the outgoing and incoming revision side by
+ * side, and Baileys/WhatsApp treats a second concurrent connection as a
+ * takeover — it logs the first one out. The lease lives in Turso (`wa_lease`)
+ * so it's visible to every instance. Acquiring/renewing is a single atomic
+ * upsert — see `createTursoWaLeaseStore` — so two instances racing the same
+ * row can never both believe they hold it.
+ */
+import type { Client } from "@libsql/client";
+/** Stale after this long without a heartbeat — a crashed holder's lease frees up. */
+export declare const LEASE_STALE_MS = 90000;
+/** How often a holder renews its lease while connected. */
+export declare const LEASE_HEARTBEAT_MS = 30000;
+/** How long a non-holder waits before re-checking whether the lease freed up. */
+export declare const LEASE_WAIT_MS = 30000;
+export interface WaLeaseRow {
+    instanceId: string;
+    heartbeatAt: number;
+}
+/**
+ * Pure: may `instanceId` take (or keep) the lease right now, given the
+ * current row (null = never held)? Mirrors the SQL WHERE clause in
+ * `createTursoWaLeaseStore` — keep the two in sync.
+ */
+export declare function canAcquireLease(existing: WaLeaseRow | null, instanceId: string, now: number, staleMs?: number): boolean;
+export interface WaLeaseStore {
+    /** Atomically acquires or renews the lease; resolves true iff `instanceId` now holds it. */
+    tryAcquire(sessionId: string, instanceId: string, now: number, staleMs: number): Promise<boolean>;
+    /** Releases the lease iff still held by `instanceId` (no-op otherwise — a late release must never undo a takeover). */
+    release(sessionId: string, instanceId: string): Promise<void>;
+}
+/**
+ * A Turso-backed `WaLeaseStore`. The WHERE clause on DO UPDATE encodes
+ * `canAcquireLease`: SQLite skips the update (and RETURNING yields no row)
+ * when it's false, so a losing racer sees zero rows back — no separate
+ * read-then-write, no race window.
+ */
+export declare function createTursoWaLeaseStore(client: Client): WaLeaseStore;
+//# sourceMappingURL=lease.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lease.d.ts","sourceRoot":"","sources":["../../../src/channels/whatsapp/lease.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,qFAAqF;AACrF,eAAO,MAAM,cAAc,QAAS,CAAC;AACrC,2DAA2D;AAC3D,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,iFAAiF;AACjF,eAAO,MAAM,aAAa,QAAS,CAAC;AAEpC,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,UAAU,GAAG,IAAI,EAC3B,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAuB,GAC/B,OAAO,CAIT;AAED,MAAM,WAAW,YAAY;IAC3B,4FAA4F;IAC5F,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClG,uHAAuH;IACvH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAuBD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAyBpE"}

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

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

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

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

package/dist/index.d.ts

@@ -12,6 +12,7 @@
  */
 export type { ApiKeyOptions, ApiKeyPayload, VerifyResult } from "./auth";
 export { ApiKeyManager } from "./auth";
+export type { Channel } from "./channels";
 export type { ChatBotConfig, ChatButtonConfig, ChatConfig, ChatMessage, ChatMode, StreamCallbacks, } from "./client";
 export { Chat, ChatBot, ChatButton } from "./client";
 export type { AnswerFn, AnswerFnInput, AnswerFnResult, AnswerOptions, AnswerUsage, } from "./core/answer";
@@ -39,6 +40,7 @@ export { demoRoutes } from "./routes/demo";
 export { openaiRoutes } from "./routes/openai";
 export { privateRoutes } from "./routes/private";
 export { publicRoutes } from "./routes/public";
+export type { ChatterApp } from "./server";
 export { createServer } from "./server";
 export type { BotBranding, BotChatConfig, BotIdentity, ChatterConfig, CustomRoutes, EmbeddingChunk, KnowledgeDocument, ServerDependencies, } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,eAAe,GAChB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,YAAY,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAIvC,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,eAAe,GAChB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,YAAY,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -33171,6 +33171,58 @@ var import_hono5 = require("hono");
 var import_bun = require("hono/bun");
 var import_openai2 = __toESM(require("openai"));
 
+// src/channels/senders.ts
+function createSenderRegistry() {
+  const senders = /* @__PURE__ */ new Map();
+  return {
+    register(name, sender) {
+      if (senders.has(name)) {
+        console.warn(`Channel sender "${name}" is already registered; overwriting.`);
+      }
+      senders.set(name, sender);
+    },
+    unregister(name) {
+      senders.delete(name);
+    },
+    available(name) {
+      return senders.has(name);
+    },
+    async sendText(name, chatId, text) {
+      const sender = senders.get(name);
+      if (!sender) return false;
+      try {
+        await sender.sendText(chatId, text);
+        return true;
+      } catch (error51) {
+        console.warn(`Channel sender "${name}" sendText failed:`, error51);
+        return false;
+      }
+    },
+    async sendVoice(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendVoice) return false;
+      try {
+        await sender.sendVoice(chatId, payload);
+        return true;
+      } catch (error51) {
+        console.warn(`Channel sender "${name}" sendVoice failed:`, error51);
+        return false;
+      }
+    },
+    async sendMedia(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendMedia) return false;
+      try {
+        await sender.sendMedia(chatId, payload);
+        return true;
+      } catch (error51) {
+        console.warn(`Channel sender "${name}" sendMedia failed:`, error51);
+        return false;
+      }
+    }
+  };
+}
+
 // src/core/widgets.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
@@ -33296,7 +33348,8 @@ async function createServer(config2) {
     app.get("/demo/chatbot", (0, import_bun.serveStatic)({ path: `${publicDir}/demo-chatbot.html` }));
     app.get("/demo/react", (0, import_bun.serveStatic)({ path: `${publicDir}/react-demo.html` }));
   }
-  const deps = { client, store, db, config: config2, prompts, apiKeyManager };
+  const senders = createSenderRegistry();
+  const deps = { client, store, db, config: config2, prompts, apiKeyManager, senders };
   if (enablePublic) {
     app.route("/", publicRoutes(deps));
   }
@@ -33312,8 +33365,36 @@ async function createServer(config2) {
   if (config2.customRoutes) {
     await config2.customRoutes(app, deps);
   }
+  const started = [];
+  if (config2.channels && config2.channels.length > 0) {
+    for (const channel of config2.channels) {
+      try {
+        await channel.start(deps);
+        started.push(channel);
+        console.log(`\u2705 Channel "${channel.name}" started`);
+      } catch (error51) {
+        console.error(`\u274C Channel "${channel.name}" failed to start:`, error51);
+      }
+    }
+  }
   console.log(`\u2705 ${config2.bot.name} server ready`);
-  return app;
+  return Object.assign(app, {
+    // Scoped to this call's started channels, not global — two servers in
+    // one process each stop only their own. A channel's `stop()` throwing
+    // (sync or async) is caught per-channel so one misbehaving channel can't
+    // stop the rest from cleaning up.
+    stopChannels: async () => {
+      await Promise.allSettled(
+        started.map(async (channel) => {
+          try {
+            await channel.stop?.();
+          } catch (error51) {
+            console.error(`Channel "${channel.name}" failed to stop:`, error51);
+          }
+        })
+      );
+    }
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {