crewly 1.20.122 → 1.20.123

package/dist/backend/backend/src/services/whatsapp/whatsapp-draft-gate.js

@@ -0,0 +1,82 @@
+/**
+ * WhatsApp Draft Send Gate
+ *
+ * Decides whether a reply draft may be sent. Owner decision (2026-09-24):
+ * nothing is ever sent to WhatsApp without the owner's explicit
+ * confirmation, one message at a time.
+ *
+ * - A request with no `X-Agent-Session` header is the owner (dashboard,
+ *   mobile, portal) — the click is the confirmation.
+ * - An agent may send only when a genuine owner chat message (from
+ *   `ChatV2Service.getRecentOwnerMessageContents`, which agents cannot
+ *   write) created after the draft says 「发 W12」 for this draft's code, and
+ *   the draft is at most `DRAFT_CONFIRM_WINDOW_MS` old. Because the owner
+ *   message must post-date the draft, bounding the draft's age also bounds
+ *   the confirmation to that window.
+ *
+ * @module services/whatsapp/whatsapp-draft-gate
+ */
+import { WHATSAPP_CONSTANTS } from '../../constants.js';
+import { parseDraftCode } from './whatsapp-inbox.store.js';
+/** Milliseconds per minute (for human-readable window text). */
+const MS_PER_MINUTE = 60 * 1000;
+/**
+ * Whether one owner message confirms sending a given draft.
+ *
+ * @param text - Owner message text
+ * @param draft - The draft
+ * @returns True for 「发 W12」 / 「发送 12」 / "send #W12" / 「确认发送 W12」 naming this draft
+ */
+export function isConfirmationFor(text, draft) {
+    const m = WHATSAPP_CONSTANTS.DRAFT_CONFIRM_PATTERN.exec(text.trim());
+    if (!m)
+        return false;
+    return parseDraftCode(m[2]) === draft.seq;
+}
+/**
+ * Decide whether the caller may send this draft now.
+ *
+ * @param ctx - Draft, caller, owner-message source, clock
+ * @returns Allowed (and why), or refused (and why)
+ */
+export function decideDraftSend(ctx) {
+    if (!ctx.agentSession)
+        return { allowed: true, via: 'owner' };
+    if (ctx.now - ctx.draft.createdAt > WHATSAPP_CONSTANTS.DRAFT_CONFIRM_WINDOW_MS) {
+        return { allowed: false, reason: 'window_expired' };
+    }
+    const confirmation = ctx.ownerMessagesSince(ctx.draft.createdAt).find((t) => isConfirmationFor(t, ctx.draft));
+    return confirmation !== undefined
+        ? { allowed: true, via: 'owner_confirmation', confirmation }
+        : { allowed: false, reason: 'no_confirmation' };
+}
+/**
+ * The instruction an agent must follow after drafting: show the owner the
+ * draft and ask for 「发 <code>」.
+ *
+ * @param draft - The draft
+ * @param recipient - Human label for the recipient (chat name or JID)
+ * @returns Instruction text
+ */
+export function buildOwnerConfirmPrompt(draft, recipient) {
+    return (`Draft ${draft.code} is saved but NOT sent. Show the owner the recipient (${recipient}), ` +
+        `the exact draft text, and the code ${draft.code}, and ask them to reply 「发 ${draft.code}」 to send it ` +
+        `(or send/discard it from the dashboard). Do not send it until they do.`);
+}
+/**
+ * Human message for a refused agent send.
+ *
+ * @param draft - The draft
+ * @param reason - Refusal reason
+ * @returns Message for the 403 body
+ */
+export function buildRefusalMessage(draft, reason) {
+    const windowMinutes = Math.round(WHATSAPP_CONSTANTS.DRAFT_CONFIRM_WINDOW_MS / MS_PER_MINUTE);
+    if (reason === 'window_expired') {
+        return (`Draft ${draft.code} is older than ${windowMinutes} minutes, so it can no longer be sent on the owner's ` +
+            `chat confirmation. Ask the owner to send it from the dashboard, or write a fresh draft and ask them to reply 「发 <new code>」.`);
+    }
+    return (`The owner has not confirmed draft ${draft.code}. Show the owner the draft (recipient and exact text) ` +
+        `and ask them to reply 「发 ${draft.code}」. Only then call send again. Never send without it.`);
+}
+//# sourceMappingURL=whatsapp-draft-gate.js.map

package/dist/backend/backend/src/services/whatsapp/whatsapp-draft-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-draft-gate.js","sourceRoot":"","sources":["../../../../../../backend/src/services/whatsapp/whatsapp-draft-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,gEAAgE;AAChE,MAAM,aAAa,GAAG,EAAE,GAAG,IAAI,CAAC;AAsBhC;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,KAAiC;IAC/E,MAAM,CAAC,GAAG,kBAAkB,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IACrE,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACrB,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,GAAqB;IACnD,IAAI,CAAC,GAAG,CAAC,YAAY;QAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;IAC9D,IAAI,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,SAAS,GAAG,kBAAkB,CAAC,uBAAuB,EAAE,CAAC;QAC/E,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;IACtD,CAAC;IACD,MAAM,YAAY,GAAG,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9G,OAAO,YAAY,KAAK,SAAS;QAC/B,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,oBAAoB,EAAE,YAAY,EAAE;QAC5D,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAA2C,EAAE,SAAiB;IACpG,OAAO,CACL,SAAS,KAAK,CAAC,IAAI,yDAAyD,SAAS,KAAK;QAC1F,sCAAsC,KAAK,CAAC,IAAI,8BAA8B,KAAK,CAAC,IAAI,eAAe;QACvG,wEAAwE,CACzE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAkC,EAAE,MAAwB;IAC9F,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,uBAAuB,GAAG,aAAa,CAAC,CAAC;IAC7F,IAAI,MAAM,KAAK,gBAAgB,EAAE,CAAC;QAChC,OAAO,CACL,SAAS,KAAK,CAAC,IAAI,kBAAkB,aAAa,uDAAuD;YACzG,8HAA8H,CAC/H,CAAC;IACJ,CAAC;IACD,OAAO,CACL,qCAAqC,KAAK,CAAC,IAAI,wDAAwD;QACvG,4BAA4B,KAAK,CAAC,IAAI,sDAAsD,CAC7F,CAAC;AACJ,CAAC"}

package/dist/backend/backend/src/services/whatsapp/whatsapp-inbox-capture.d.ts

@@ -0,0 +1,184 @@
+/**
+ * WhatsApp Inbox Capture
+ *
+ * Turns Baileys events into inbox-store rows. Used only in `inbox` mode.
+ * Unlike the assistant path (`WhatsAppService.handleIncomingMessage`) nothing
+ * is dropped for being the owner's own message, a group message, media, or
+ * from a contact outside `allowedContacts` — the inbox has to know whether
+ * the owner already replied, and it is the owner's own account.
+ *
+ * Media are never downloaded: a message is recorded as its kind plus caption
+ * (or file name for documents).
+ *
+ * Baileys shapes relied on (v7, `@whiskeysockets/baileys` typings):
+ * - `messages.upsert`: `{ messages: WAMessage[], type: 'notify' | 'append' }`
+ * - `messaging-history.set`: `{ chats: Chat[], contacts: Contact[], messages: WAMessage[], syncType? }`
+ * - `contacts.upsert` / `contacts.update`: `Contact[]` (`id`, `name` = address book, `notify` = their pushName)
+ * - `chats.upsert` / `chats.update`: `Chat[]` (`id`, `name`, `conversationTimestamp`)
+ * - `groups.upsert` / `groups.update`: `GroupMetadata[]` (`id`, `subject`)
+ * - `WAMessage.key.remoteJidAlt` / `participantAlt` (v7 LID↔PN alternates)
+ * - `messageTimestamp`: seconds, as number, numeric string or protobuf Long
+ *
+ * @module services/whatsapp/whatsapp-inbox-capture
+ */
+import type { WhatsAppInboxMessage, WhatsAppMessageKind } from '../../types/whatsapp.types.js';
+import type { UpsertChatInput, WhatsAppInboxStore } from './whatsapp-inbox.store.js';
+/** Loose record type for untyped Baileys payloads. */
+type Rec = Record<string, unknown>;
+/**
+ * Convert a Baileys timestamp (seconds as number, numeric string, or
+ * protobuf Long with `toNumber()` / `low`+`high`) to epoch ms.
+ *
+ * @param ts - Raw timestamp
+ * @returns Epoch ms, or null when unparseable / non-positive
+ */
+export declare function toEpochMs(ts: unknown): number | null;
+/**
+ * Whether a JID is a group chat.
+ *
+ * @param jid - JID
+ * @returns True for `...@g.us`
+ */
+export declare function isGroupJid(jid: string): boolean;
+/**
+ * Pick the canonical JID for a person: prefer the phone-number form when
+ * Baileys supplies it as the alternate of a LID, so the same person's
+ * messages (some keyed by LID, some by phone number) land in one chat.
+ *
+ * @param jid - Primary JID (`remoteJid` / `participant`)
+ * @param alt - Alternate JID (`remoteJidAlt` / `participantAlt`)
+ * @returns The canonical JID
+ */
+export declare function canonicalJid(jid: string, alt?: string): string;
+/**
+ * Strip wrapper messages (disappearing, view-once, edited, doc-with-caption).
+ *
+ * @param content - `WAMessage.message`
+ * @returns The innermost content object, or undefined
+ */
+export declare function unwrapMessageContent(content: unknown): Rec | undefined;
+/**
+ * Classify message content into a stored kind and its text/caption.
+ *
+ * @param content - `WAMessage.message` (wrappers allowed)
+ * @returns `{ kind, text }`, or null when this is not a user-visible message
+ *   (protocol message, reaction, empty envelope)
+ */
+export declare function classifyMessageContent(content: unknown): {
+    kind: WhatsAppMessageKind;
+    text: string;
+} | null;
+/** Result of parsing one Baileys message. */
+export interface ParsedWhatsAppMessage {
+    /** Row for the store */
+    message: WhatsAppInboxMessage;
+    /** Whether the chat is a group */
+    isGroup: boolean;
+    /** Sender's self-chosen name, when the message carried one (not for own messages) */
+    pushName: string | null;
+}
+/**
+ * Parse a Baileys `WAMessage` into an inbox row.
+ *
+ * @param raw - The WAMessage
+ * @param ownJid - The connected account's JID (sender of `fromMe` messages), if known
+ * @returns The parsed message, or null when it is not storable (no id/chat,
+ *   status broadcast, protocol-only content, no timestamp)
+ */
+export declare function parseBaileysMessage(raw: unknown, ownJid?: string | null): ParsedWhatsAppMessage | null;
+/**
+ * Chat row from a Baileys `Contact`: the address-book name outranks the
+ * contact's own pushName (`notify`) and business `verifiedName`.
+ *
+ * @param contact - Contact (full or partial update)
+ * @returns Upsert input, or null when the contact names nothing useful
+ */
+export declare function chatFromContact(contact: unknown): UpsertChatInput | null;
+/**
+ * Chat row from a Baileys `Chat` (history sync, `chats.upsert/update`).
+ *
+ * @param chat - Chat
+ * @returns Upsert input, or null without an id / for the status pseudo-chat
+ */
+export declare function chatFromChat(chat: unknown): UpsertChatInput | null;
+/**
+ * Chat row from Baileys `GroupMetadata` (subject = group name).
+ *
+ * @param group - Group metadata (full or partial)
+ * @returns Upsert input, or null without an id
+ */
+export declare function chatFromGroup(group: unknown): UpsertChatInput | null;
+/** Optional hooks for {@link WhatsAppInboxCapture}. */
+export interface WhatsAppInboxCaptureOptions {
+    /** The connected account's JID (sender of own messages) */
+    getOwnJid?: () => string | null;
+    /** Fetch a group's subject for a group we have no name for (best effort) */
+    fetchGroupSubject?: (jid: string) => Promise<string | null>;
+    /** Clock (tests) */
+    now?: () => number;
+}
+/**
+ * Writes Baileys events into a {@link WhatsAppInboxStore}.
+ *
+ * Every handler is defensive: a malformed payload is skipped, never thrown,
+ * because it runs inside the socket's event loop.
+ */
+export declare class WhatsAppInboxCapture {
+    private readonly store;
+    private readonly opts;
+    private readonly groupLookups;
+    /**
+     * @param store - Destination store
+     * @param opts - Own-JID accessor, group-subject fetcher, clock
+     */
+    constructor(store: WhatsAppInboxStore, opts?: WhatsAppInboxCaptureOptions);
+    /**
+     * Store one message and name its chat.
+     *
+     * @param raw - A WAMessage
+     * @returns True when stored
+     */
+    captureMessage(raw: unknown): boolean;
+    /**
+     * Handle `messages.upsert` (both `notify` and `append`: own messages sent
+     * from the phone and backfills arrive as `append`).
+     *
+     * @param upsert - `{ messages, type }`
+     * @returns Number of messages stored
+     */
+    onMessagesUpsert(upsert: unknown): number;
+    /**
+     * Handle `messaging-history.set`: seed chats, contact names and recent
+     * messages. Messages older than `HISTORY_SYNC_MAX_AGE_MS` are skipped.
+     *
+     * @param payload - `{ chats, contacts, messages }`
+     * @returns Number of messages stored
+     */
+    onHistorySet(payload: unknown): number;
+    /**
+     * Handle `contacts.upsert` / `contacts.update`.
+     *
+     * @param contacts - Contact list
+     */
+    onContacts(contacts: unknown): void;
+    /**
+     * Handle `chats.upsert` / `chats.update`.
+     *
+     * @param chats - Chat list
+     */
+    onChats(chats: unknown): void;
+    /**
+     * Handle `groups.upsert` / `groups.update`.
+     *
+     * @param groups - Group metadata list
+     */
+    onGroups(groups: unknown): void;
+    /**
+     * Look a group's subject up once per process when we have no name for it.
+     *
+     * @param jid - Group JID
+     */
+    private maybeFetchGroupName;
+}
+export {};
+//# sourceMappingURL=whatsapp-inbox-capture.d.ts.map

package/dist/backend/backend/src/services/whatsapp/whatsapp-inbox-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-inbox-capture.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/whatsapp/whatsapp-inbox-capture.ts"],"names":[],"mappings":"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"}

package/dist/backend/backend/src/services/whatsapp/whatsapp-inbox-capture.js

@@ -0,0 +1,420 @@
+/**
+ * WhatsApp Inbox Capture
+ *
+ * Turns Baileys events into inbox-store rows. Used only in `inbox` mode.
+ * Unlike the assistant path (`WhatsAppService.handleIncomingMessage`) nothing
+ * is dropped for being the owner's own message, a group message, media, or
+ * from a contact outside `allowedContacts` — the inbox has to know whether
+ * the owner already replied, and it is the owner's own account.
+ *
+ * Media are never downloaded: a message is recorded as its kind plus caption
+ * (or file name for documents).
+ *
+ * Baileys shapes relied on (v7, `@whiskeysockets/baileys` typings):
+ * - `messages.upsert`: `{ messages: WAMessage[], type: 'notify' | 'append' }`
+ * - `messaging-history.set`: `{ chats: Chat[], contacts: Contact[], messages: WAMessage[], syncType? }`
+ * - `contacts.upsert` / `contacts.update`: `Contact[]` (`id`, `name` = address book, `notify` = their pushName)
+ * - `chats.upsert` / `chats.update`: `Chat[]` (`id`, `name`, `conversationTimestamp`)
+ * - `groups.upsert` / `groups.update`: `GroupMetadata[]` (`id`, `subject`)
+ * - `WAMessage.key.remoteJidAlt` / `participantAlt` (v7 LID↔PN alternates)
+ * - `messageTimestamp`: seconds, as number, numeric string or protobuf Long
+ *
+ * @module services/whatsapp/whatsapp-inbox-capture
+ */
+import { WHATSAPP_CONSTANTS } from '../../constants.js';
+/** Milliseconds per second (Baileys timestamps are seconds). */
+const MS_PER_SECOND = 1000;
+/** Max wrapper depth unwrapped (ephemeral → viewOnce → ...), as Baileys does. */
+const MAX_UNWRAP_DEPTH = 5;
+/** Wrapper message keys whose `.message` holds the real content. */
+const WRAPPER_KEYS = [
+    'ephemeralMessage',
+    'viewOnceMessage',
+    'viewOnceMessageV2',
+    'viewOnceMessageV2Extension',
+    'documentWithCaptionMessage',
+    'editedMessage',
+];
+/**
+ * Content keys that are not user-visible messages (receipts of protocol
+ * work, reactions, key distribution). A message carrying only these is not
+ * stored.
+ */
+const NON_MESSAGE_KEYS = new Set([
+    'protocolMessage',
+    'reactionMessage',
+    'senderKeyDistributionMessage',
+    'messageContextInfo',
+    'pollUpdateMessage',
+    'keepInChatMessage',
+    'encReactionMessage',
+]);
+/**
+ * Narrow an unknown to a plain object.
+ *
+ * @param v - Anything
+ * @returns The object, or undefined
+ */
+function asRec(v) {
+    return v && typeof v === 'object' ? v : undefined;
+}
+/**
+ * Read a non-empty string field.
+ *
+ * @param v - Anything
+ * @returns The string, or undefined when absent/blank
+ */
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/**
+ * Convert a Baileys timestamp (seconds as number, numeric string, or
+ * protobuf Long with `toNumber()` / `low`+`high`) to epoch ms.
+ *
+ * @param ts - Raw timestamp
+ * @returns Epoch ms, or null when unparseable / non-positive
+ */
+export function toEpochMs(ts) {
+    let seconds = null;
+    if (typeof ts === 'number')
+        seconds = ts;
+    else if (typeof ts === 'bigint')
+        seconds = Number(ts);
+    else if (typeof ts === 'string' && /^\d+$/.test(ts))
+        seconds = Number(ts);
+    else {
+        const r = asRec(ts);
+        if (r && typeof r.toNumber === 'function')
+            seconds = r.toNumber();
+        else if (r && typeof r.low === 'number') {
+            const high = typeof r.high === 'number' ? r.high : 0;
+            seconds = high * 2 ** 32 + (r.low >>> 0);
+        }
+    }
+    if (seconds === null || !Number.isFinite(seconds) || seconds <= 0)
+        return null;
+    return Math.round(seconds * MS_PER_SECOND);
+}
+/**
+ * Whether a JID is a group chat.
+ *
+ * @param jid - JID
+ * @returns True for `...@g.us`
+ */
+export function isGroupJid(jid) {
+    return jid.endsWith(WHATSAPP_CONSTANTS.GROUP_JID_SUFFIX);
+}
+/**
+ * Pick the canonical JID for a person: prefer the phone-number form when
+ * Baileys supplies it as the alternate of a LID, so the same person's
+ * messages (some keyed by LID, some by phone number) land in one chat.
+ *
+ * @param jid - Primary JID (`remoteJid` / `participant`)
+ * @param alt - Alternate JID (`remoteJidAlt` / `participantAlt`)
+ * @returns The canonical JID
+ */
+export function canonicalJid(jid, alt) {
+    if (jid.endsWith(WHATSAPP_CONSTANTS.LID_JID_SUFFIX) && alt && alt.endsWith(WHATSAPP_CONSTANTS.USER_JID_SUFFIX)) {
+        return alt;
+    }
+    return jid;
+}
+/**
+ * Strip wrapper messages (disappearing, view-once, edited, doc-with-caption).
+ *
+ * @param content - `WAMessage.message`
+ * @returns The innermost content object, or undefined
+ */
+export function unwrapMessageContent(content) {
+    let cur = asRec(content);
+    for (let i = 0; i < MAX_UNWRAP_DEPTH && cur; i++) {
+        let inner;
+        for (const k of WRAPPER_KEYS) {
+            inner = asRec(asRec(cur[k])?.message);
+            if (inner)
+                break;
+        }
+        if (!inner)
+            break;
+        cur = inner;
+    }
+    return cur;
+}
+/**
+ * Classify message content into a stored kind and its text/caption.
+ *
+ * @param content - `WAMessage.message` (wrappers allowed)
+ * @returns `{ kind, text }`, or null when this is not a user-visible message
+ *   (protocol message, reaction, empty envelope)
+ */
+export function classifyMessageContent(content) {
+    const c = unwrapMessageContent(content);
+    if (!c)
+        return null;
+    const K = WHATSAPP_CONSTANTS.MESSAGE_KINDS;
+    const conversation = str(c.conversation);
+    if (conversation)
+        return { kind: K.TEXT, text: conversation };
+    const ext = asRec(c.extendedTextMessage);
+    if (ext)
+        return { kind: K.TEXT, text: str(ext.text) ?? '' };
+    const image = asRec(c.imageMessage);
+    if (image)
+        return { kind: K.IMAGE, text: str(image.caption) ?? '' };
+    const video = asRec(c.videoMessage) ?? asRec(c.ptvMessage);
+    if (video)
+        return { kind: K.VIDEO, text: str(video.caption) ?? '' };
+    const doc = asRec(c.documentMessage);
+    if (doc)
+        return { kind: K.DOCUMENT, text: str(doc.caption) ?? str(doc.fileName) ?? str(doc.title) ?? '' };
+    if (asRec(c.audioMessage))
+        return { kind: K.AUDIO, text: '' };
+    if (asRec(c.stickerMessage))
+        return { kind: K.STICKER, text: '' };
+    const visibleKeys = Object.keys(c).filter((k) => c[k] !== null && c[k] !== undefined && !NON_MESSAGE_KEYS.has(k));
+    if (visibleKeys.length === 0)
+        return null;
+    return { kind: K.OTHER, text: '' };
+}
+/**
+ * Parse a Baileys `WAMessage` into an inbox row.
+ *
+ * @param raw - The WAMessage
+ * @param ownJid - The connected account's JID (sender of `fromMe` messages), if known
+ * @returns The parsed message, or null when it is not storable (no id/chat,
+ *   status broadcast, protocol-only content, no timestamp)
+ */
+export function parseBaileysMessage(raw, ownJid) {
+    const r = asRec(raw);
+    const key = asRec(r?.key);
+    const remoteJid = str(key?.remoteJid);
+    const id = str(key?.id);
+    if (!r || !key || !remoteJid || !id)
+        return null;
+    if (remoteJid === WHATSAPP_CONSTANTS.STATUS_BROADCAST_JID)
+        return null;
+    const classified = classifyMessageContent(r.message);
+    if (!classified)
+        return null;
+    const ts = toEpochMs(r.messageTimestamp);
+    if (ts === null)
+        return null;
+    const fromMe = key.fromMe === true;
+    const chatId = canonicalJid(remoteJid, str(key.remoteJidAlt));
+    const isGroup = isGroupJid(chatId);
+    const participant = str(key.participant);
+    const pushName = fromMe ? null : (str(r.pushName) ?? null);
+    let senderJid;
+    if (fromMe)
+        senderJid = ownJid ?? null;
+    else if (isGroup)
+        senderJid = participant ? canonicalJid(participant, str(key.participantAlt)) : null;
+    else
+        senderJid = chatId;
+    return {
+        message: {
+            id,
+            chatId,
+            fromMe,
+            senderJid,
+            senderName: pushName,
+            text: classified.text,
+            ts,
+            kind: classified.kind,
+        },
+        isGroup,
+        pushName,
+    };
+}
+/**
+ * Chat row from a Baileys `Contact`: the address-book name outranks the
+ * contact's own pushName (`notify`) and business `verifiedName`.
+ *
+ * @param contact - Contact (full or partial update)
+ * @returns Upsert input, or null when the contact names nothing useful
+ */
+export function chatFromContact(contact) {
+    const c = asRec(contact);
+    const rawId = str(c?.id);
+    if (!c || !rawId)
+        return null;
+    const id = canonicalJid(rawId, str(c.phoneNumber));
+    const R = WHATSAPP_CONSTANTS.NAME_RANKS;
+    const saved = str(c.name);
+    if (saved)
+        return { id, name: saved, nameRank: R.CONTACT };
+    const other = str(c.notify) ?? str(c.verifiedName);
+    if (other)
+        return { id, name: other, nameRank: R.PUSH_NAME };
+    return null;
+}
+/**
+ * Chat row from a Baileys `Chat` (history sync, `chats.upsert/update`).
+ *
+ * @param chat - Chat
+ * @returns Upsert input, or null without an id / for the status pseudo-chat
+ */
+export function chatFromChat(chat) {
+    const c = asRec(chat);
+    const id = str(c?.id);
+    if (!c || !id || id === WHATSAPP_CONSTANTS.STATUS_BROADCAST_JID)
+        return null;
+    return {
+        id,
+        name: str(c.name) ?? null,
+        nameRank: WHATSAPP_CONSTANTS.NAME_RANKS.CHAT,
+        isGroup: isGroupJid(id),
+        lastMessageAt: toEpochMs(c.conversationTimestamp),
+    };
+}
+/**
+ * Chat row from Baileys `GroupMetadata` (subject = group name).
+ *
+ * @param group - Group metadata (full or partial)
+ * @returns Upsert input, or null without an id
+ */
+export function chatFromGroup(group) {
+    const g = asRec(group);
+    const id = str(g?.id);
+    if (!g || !id)
+        return null;
+    return { id, name: str(g.subject) ?? null, nameRank: WHATSAPP_CONSTANTS.NAME_RANKS.CHAT, isGroup: true };
+}
+/**
+ * Writes Baileys events into a {@link WhatsAppInboxStore}.
+ *
+ * Every handler is defensive: a malformed payload is skipped, never thrown,
+ * because it runs inside the socket's event loop.
+ */
+export class WhatsAppInboxCapture {
+    store;
+    opts;
+    groupLookups = new Set();
+    /**
+     * @param store - Destination store
+     * @param opts - Own-JID accessor, group-subject fetcher, clock
+     */
+    constructor(store, opts = {}) {
+        this.store = store;
+        this.opts = opts;
+    }
+    /**
+     * Store one message and name its chat.
+     *
+     * @param raw - A WAMessage
+     * @returns True when stored
+     */
+    captureMessage(raw) {
+        const parsed = parseBaileysMessage(raw, this.opts.getOwnJid?.() ?? null);
+        if (!parsed)
+            return false;
+        const { message, isGroup, pushName } = parsed;
+        // In a 1:1 chat the sender's pushName is a (weak) name for the chat.
+        this.store.upsertChat({
+            id: message.chatId,
+            isGroup,
+            name: !isGroup ? pushName : null,
+            nameRank: WHATSAPP_CONSTANTS.NAME_RANKS.PUSH_NAME,
+            lastMessageAt: message.ts,
+        });
+        this.store.upsertMessage(message);
+        if (isGroup)
+            this.maybeFetchGroupName(message.chatId);
+        return true;
+    }
+    /**
+     * Handle `messages.upsert` (both `notify` and `append`: own messages sent
+     * from the phone and backfills arrive as `append`).
+     *
+     * @param upsert - `{ messages, type }`
+     * @returns Number of messages stored
+     */
+    onMessagesUpsert(upsert) {
+        const messages = asRec(upsert)?.messages;
+        if (!Array.isArray(messages))
+            return 0;
+        let n = 0;
+        for (const m of messages)
+            if (this.captureMessage(m))
+                n++;
+        return n;
+    }
+    /**
+     * Handle `messaging-history.set`: seed chats, contact names and recent
+     * messages. Messages older than `HISTORY_SYNC_MAX_AGE_MS` are skipped.
+     *
+     * @param payload - `{ chats, contacts, messages }`
+     * @returns Number of messages stored
+     */
+    onHistorySet(payload) {
+        const p = asRec(payload);
+        if (!p)
+            return 0;
+        const chats = (Array.isArray(p.chats) ? p.chats : []).map(chatFromChat).filter((c) => c !== null);
+        const contacts = (Array.isArray(p.contacts) ? p.contacts : [])
+            .map(chatFromContact)
+            .filter((c) => c !== null);
+        this.store.upsertChats([...chats, ...contacts]);
+        const cutoff = (this.opts.now?.() ?? Date.now()) - WHATSAPP_CONSTANTS.HISTORY_SYNC_MAX_AGE_MS;
+        const ownJid = this.opts.getOwnJid?.() ?? null;
+        const parsed = (Array.isArray(p.messages) ? p.messages : [])
+            .map((m) => parseBaileysMessage(m, ownJid))
+            .filter((m) => m !== null && m.message.ts >= cutoff);
+        this.store.upsertChats(parsed
+            .filter((m) => !m.isGroup && m.pushName)
+            .map((m) => ({ id: m.message.chatId, name: m.pushName, nameRank: WHATSAPP_CONSTANTS.NAME_RANKS.PUSH_NAME })));
+        return this.store.upsertMessages(parsed.map((m) => m.message));
+    }
+    /**
+     * Handle `contacts.upsert` / `contacts.update`.
+     *
+     * @param contacts - Contact list
+     */
+    onContacts(contacts) {
+        if (!Array.isArray(contacts))
+            return;
+        this.store.upsertChats(contacts.map(chatFromContact).filter((c) => c !== null));
+    }
+    /**
+     * Handle `chats.upsert` / `chats.update`.
+     *
+     * @param chats - Chat list
+     */
+    onChats(chats) {
+        if (!Array.isArray(chats))
+            return;
+        this.store.upsertChats(chats.map(chatFromChat).filter((c) => c !== null));
+    }
+    /**
+     * Handle `groups.upsert` / `groups.update`.
+     *
+     * @param groups - Group metadata list
+     */
+    onGroups(groups) {
+        if (!Array.isArray(groups))
+            return;
+        this.store.upsertChats(groups.map(chatFromGroup).filter((c) => c !== null));
+    }
+    /**
+     * Look a group's subject up once per process when we have no name for it.
+     *
+     * @param jid - Group JID
+     */
+    maybeFetchGroupName(jid) {
+        const fetcher = this.opts.fetchGroupSubject;
+        if (!fetcher || this.groupLookups.has(jid))
+            return;
+        if (this.store.getChat(jid)?.name)
+            return;
+        this.groupLookups.add(jid);
+        fetcher(jid)
+            .then((subject) => {
+            if (subject)
+                this.store.upsertChat({ id: jid, name: subject, nameRank: WHATSAPP_CONSTANTS.NAME_RANKS.CHAT, isGroup: true });
+        })
+            .catch(() => {
+            // Best effort — the chat keeps its JID as the label.
+        });
+    }
+}
+//# sourceMappingURL=whatsapp-inbox-capture.js.map