morpho-socket 0.0.0-stage → 0.2.0

package/packages/message/index.js

@@ -0,0 +1,317 @@
+// @morpho/message
+//
+// Problema que isto resolve: o objeto cru do Baileys (msg.message) tem a mensagem de verdade escondida
+// dentro de "embrulhos" (ephemeralMessage, viewOnceMessageV2, editedMessage...) e cada coisa mora num
+// lugar diferente (texto em .conversation OU .extendedTextMessage.text OU .imageMessage.caption; menções
+// e citação em .contextInfo de qualquer tipo). No Morvyn isso estava refeito em 4 arquivos, cada um
+// com um pedaço da lógica. Aqui vira UMA função: parse(msg) → objeto simples e sempre do mesmo formato.
+//
+//   const { parse, findMedia } = require("@morpho/message")
+//   const m = parse(msg)
+//   m.type      // "text" | "image" | "video" | "gif" | "videoNote" | "audio" | "voice" | "sticker" | "document" | ...
+//   m.text      // texto ou legenda ("" se não tem)
+//   m.mentions  // jids marcados (em QUALQUER tipo de mensagem, não só texto)
+//   m.media     // { type, mimetype, seconds, size, ptt, animated, viewOnce, node... } ou null
+//   m.quoted    // a mensagem citada, já parseada do mesmo jeito (ou null)
+//
+// Nunca lança erro: msg nula, sem descriptografar ou de tipo desconhecido vira type "empty"/"unknown".
+
+// "embrulhos": a mensagem de verdade está dentro de .message
+const WRAPPERS = [
+  "ephemeralMessage",            // chat com mensagens temporárias
+  "viewOnceMessage",             // visualização única
+  "viewOnceMessageV2",
+  "viewOnceMessageV2Extension",
+  "documentWithCaptionMessage",  // documento com legenda
+  "editedMessage",               // mensagem editada
+  "deviceSentMessage",           // enviada por outro aparelho do próprio bot
+  "groupMentionedMessage",
+  "botInvokeMessage",
+  "lottieStickerMessage"         // figurinha lottie: o stickerMessage está dentro
+]
+
+// chaves que não são o conteúdo
+const IGNORE = new Set(["messageContextInfo", "senderKeyDistributionMessage"])
+
+// chave do Baileys → tipo simples (função = depende do conteúdo)
+const TYPE_OF_KIND = {
+  conversation: "text",
+  extendedTextMessage: "text",
+  imageMessage: "image",
+  videoMessage: n => (n?.gifPlayback ? "gif" : "video"),
+  ptvMessage: "videoNote",       // vídeo redondo
+  audioMessage: n => (n?.ptt ? "voice" : "audio"),
+  stickerMessage: "sticker",
+  documentMessage: "document",
+  contactMessage: "contact",
+  contactsArrayMessage: "contact",
+  locationMessage: "location",
+  liveLocationMessage: "location",
+  pollCreationMessage: "poll",
+  pollCreationMessageV2: "poll",
+  pollCreationMessageV3: "poll",
+  pollUpdateMessage: "pollVote",
+  reactionMessage: "reaction",
+  buttonsMessage: "interactive",
+  listMessage: "interactive",
+  templateMessage: "interactive",
+  interactiveMessage: "interactive",
+  buttonsResponseMessage: "reply",
+  listResponseMessage: "reply",
+  templateButtonReplyMessage: "reply",
+  interactiveResponseMessage: "reply",
+  groupInviteMessage: "invite",
+  eventMessage: "event",
+  albumMessage: "album",
+  productMessage: "other",
+  orderMessage: "other",
+  requestPaymentMessage: "other",
+  sendPaymentMessage: "other",
+  callLogMesssage: "other",      // (sic) o nome vem assim do WhatsApp
+  newsletterAdminInviteMessage: "other"
+}
+
+// chave do Baileys → tipo de mídia (o mesmo nome que o downloadContentFromMessage espera)
+const MEDIA_OF_KIND = {
+  imageMessage: "image",
+  videoMessage: "video",
+  ptvMessage: "video",
+  audioMessage: "audio",
+  stickerMessage: "sticker",
+  documentMessage: "document"
+}
+
+const MEDIA_TYPES = ["image", "video", "audio", "sticker", "document"]
+
+// número, texto, bigint ou Long do protobuf (fileLength, seconds, messageTimestamp...) → number
+function toNumber(v) {
+  if (v == null) return 0
+  if (typeof v === "number") return Number.isFinite(v) ? v : 0
+  if (typeof v === "bigint") return Number(v)
+  if (typeof v === "string") { const n = Number(v); return Number.isFinite(n) ? n : 0 }
+  if (typeof v === "object") {
+    if (typeof v.toNumber === "function") return toNumber(v.toNumber())
+    if (typeof v.low === "number" && typeof v.high === "number") return (v.high >>> 0) * 4294967296 + (v.low >>> 0)
+  }
+  return 0
+}
+
+const isObj = x => x !== null && typeof x === "object"
+
+// tira os embrulhos. { message, viewOnce, edited, ephemeral } — message é o que está dentro (ou null)
+function unwrap(message) {
+  let m = isObj(message) ? message : null
+  let viewOnce = false, edited = false, ephemeral = false
+  for (let i = 0; i < 10 && m; i++) {
+    const k = WRAPPERS.find(w => m[w])
+    if (!k) break
+    if (k.startsWith("viewOnce")) viewOnce = true
+    else if (k === "editedMessage") edited = true
+    else if (k === "ephemeralMessage") ephemeral = true
+    m = isObj(m[k]) && isObj(m[k].message) ? m[k].message : null
+  }
+  return { message: m, viewOnce, edited, ephemeral }
+}
+
+// acha o conteúdo de verdade. Edição vira o conteúdo NOVO com edited=true; apagar vira { revoked }.
+function resolve(message) {
+  let { message: m, viewOnce, edited, ephemeral } = unwrap(message)
+  let editTarget = null, revoked = null, protocol = null
+
+  for (let i = 0; i < 3 && m; i++) {
+    const kind = Object.keys(m).find(k => !IGNORE.has(k) && m[k] != null)
+    if (!kind) return { kind: null, node: null, viewOnce, edited, ephemeral, editTarget, revoked, protocol }
+    const node = m[kind]
+
+    if (kind === "protocolMessage") {
+      const t = node?.type
+      if ((t === 14 || t === "MESSAGE_EDIT") && isObj(node.editedMessage)) {
+        edited = true
+        editTarget = node.key || null
+        const inner = unwrap(node.editedMessage)
+        viewOnce = viewOnce || inner.viewOnce
+        ephemeral = ephemeral || inner.ephemeral
+        m = inner.message
+        continue
+      }
+      if (t === 0 || t === "REVOKE") revoked = node?.key || null
+      else if (t === 3 || t === "EPHEMERAL_SETTING") protocol = "ephemeralSetting"
+      else protocol = String(t ?? "unknown")
+    }
+    return { kind, node, viewOnce, edited, ephemeral, editTarget, revoked, protocol }
+  }
+  return { kind: null, node: null, viewOnce, edited, ephemeral, editTarget, revoked, protocol }
+}
+
+function textOf(kind, node) {
+  if (kind === "conversation") return typeof node === "string" ? node : ""
+  if (!isObj(node)) return ""
+  switch (kind) {
+    case "extendedTextMessage": return String(node.text || "")
+    case "imageMessage":
+    case "videoMessage":
+    case "documentMessage": return String(node.caption || "")
+    default: return ""
+  }
+}
+
+// resposta de botão / lista / modelo / botão nativo → { id, text } (id null se não deu para ler)
+function selectionOf(kind, node) {
+  if (!isObj(node)) return null
+  switch (kind) {
+    case "buttonsResponseMessage":
+      return { id: node.selectedButtonId ?? null, text: String(node.selectedDisplayText || "") }
+    case "listResponseMessage":
+      return { id: node.singleSelectReply?.selectedRowId ?? null, text: String(node.title || "") }
+    case "templateButtonReplyMessage":
+      return { id: node.selectedId ?? null, text: String(node.selectedDisplayText || "") }
+    case "interactiveResponseMessage": {
+      let id = null
+      const json = node.nativeFlowResponseMessage?.paramsJson
+      if (json) { try { id = JSON.parse(json)?.id ?? null } catch { /* json inválido: sem id */ } }
+      return { id, text: String(node.body?.text || "") }
+    }
+    default: return null
+  }
+}
+
+function mediaOf(kind, node, viewOnce) {
+  const type = MEDIA_OF_KIND[kind]
+  if (!type || !isObj(node)) return null
+  const mimetype = String(node.mimetype || "")
+  let family = type
+  if (type === "document") {
+    const f = mimetype.split("/")[0]
+    family = f === "image" || f === "video" || f === "audio" ? f : "other"
+  }
+  return {
+    type,                                   // "image" | "video" | "audio" | "sticker" | "document"
+    kind,                                   // chave original (ptvMessage continua type "video")
+    family,                                 // igual a type, exceto documento: "image"/"video"/"audio" pelo mimetype, ou "other"
+    mimetype,
+    seconds: toNumber(node.seconds),
+    size: toNumber(node.fileLength),
+    ptt: !!node.ptt,
+    gif: !!node.gifPlayback,
+    round: kind === "ptvMessage",
+    animated: !!node.isAnimated,
+    fileName: node.fileName || null,
+    caption: String(node.caption || ""),
+    width: toNumber(node.width),
+    height: toNumber(node.height),
+    viewOnce: !!viewOnce || node.viewOnce === true,
+    node                                    // o que vai para o downloadContentFromMessage(node, type)
+  }
+}
+
+function lazy(obj, name, fn) {
+  let done = false, val
+  Object.defineProperty(obj, name, {
+    enumerable: true, configurable: true,
+    get() { if (!done) { val = fn(); done = true } return val }
+  })
+}
+
+const cache = new WeakMap()
+
+function build(msg) {
+  const key = isObj(msg?.key) ? msg.key : {}
+  const chat = key.remoteJid || null
+  const participant = key.participant || null
+  const r = resolve(msg?.message)
+
+  let type
+  if (!msg?.message) type = msg?.messageStubType ? "system" : "empty"
+  else if (!r.kind) type = "empty"
+  else if (r.revoked) type = "revoke"
+  else if (r.kind === "protocolMessage") type = "system"
+  else {
+    const t = TYPE_OF_KIND[r.kind]
+    type = typeof t === "function" ? t(r.node) : (t || "unknown")
+  }
+
+  const node = r.node
+  const context = isObj(node) && isObj(node.contextInfo) ? node.contextInfo : null
+  const media = mediaOf(r.kind, node, r.viewOnce)
+  const reaction = r.kind === "reactionMessage" && isObj(node) ? { emoji: String(node.text || ""), key: node.key || null } : null
+
+  const m = {
+    // quem / onde (ainda crus: o @morpho/jid é que resolve LID → número)
+    id: key.id || null,
+    chat,
+    sender: participant || chat,
+    senderAlt: key.participantAlt || key.remoteJidAlt || null,
+    fromMe: !!key.fromMe,
+    isGroup: !!chat && chat.endsWith("@g.us"),
+    isStatus: chat === "status@broadcast",
+    isNewsletter: !!chat && chat.endsWith("@newsletter"),
+    pushName: msg?.pushName || "",
+    timestamp: toNumber(msg?.messageTimestamp),
+    key: msg?.key || null,
+
+    // o que é
+    type,                                   // ver lista no topo; "unknown" = chave que o Morpho ainda não conhece (veja m.kind)
+    kind: r.kind,                           // chave original do Baileys, ex.: "imageMessage"
+    text: textOf(r.kind, node),
+    media,
+    selection: r.kind && type === "reply" ? selectionOf(r.kind, node) : null,
+    reaction,
+    pollKey: r.kind === "pollUpdateMessage" ? (node?.pollCreationMessageKey || null) : null,
+
+    // detalhes
+    mentions: Array.isArray(context?.mentionedJid) ? context.mentionedJid.slice() : [],
+    forwarded: !!context?.isForwarded,
+    viewOnce: r.viewOnce || (isObj(node) && node.viewOnce === true),
+    edited: r.edited,
+    editTarget: r.editTarget,               // key da mensagem que foi editada (só quando edited)
+    revoked: r.revoked,                     // key da mensagem apagada (só quando type "revoke")
+    ephemeral: r.ephemeral,                 // chegou num chat de mensagens temporárias
+    expiration: toNumber(context?.expiration), // segundos até sumir (0 = não some)
+    stub: msg?.messageStubType ?? null,
+    protocol: r.protocol,                   // "ephemeralSetting" | código do protocolo | null
+
+    context,                                // contextInfo cru
+    node                                    // conteúdo cru (string no caso de conversation)
+  }
+
+  lazy(m, "quoted", () => {
+    if (!context?.quotedMessage) return null
+    return parse({
+      key: { id: context.stanzaId || null, remoteJid: context.remoteJid || chat, participant: context.participant || undefined },
+      message: context.quotedMessage
+    })
+  })
+
+  Object.defineProperty(m, "is", { value: (...types) => types.includes(m.type), enumerable: false })
+  return m
+}
+
+// Parseia uma mensagem do Baileys (o item de messages.upsert). Parsear a mesma msg de novo devolve o mesmo objeto.
+function parse(msg) {
+  if (!isObj(msg)) return build(null)
+  let p = cache.get(msg)
+  if (!p) { p = build(msg); cache.set(msg, p) }
+  return p
+}
+
+// Acha a mídia que o comando deve usar. Por padrão a da mensagem MARCADA tem prioridade (responder uma figurinha
+// com /s), senão a da própria mensagem — igual ao utils/midia.js do Morvyn.
+//   types:    ["image", "video", ...]   (padrão: todos)
+//   families: ["image", "video", "audio"]  (para pegar também documento que é, na verdade, imagem/vídeo/áudio)
+//   quoted:   "prefer" (padrão) | "only" | "never"
+// Devolve a mídia (ver m.media) com fromQuoted: true/false, ou null.
+//   accept:   (media) => boolean            filtro extra (ex.: ignorar documento que não é imagem/vídeo/áudio)
+function findMedia(msg, { types, families, quoted = "prefer", accept } = {}) {
+  const m = parse(msg)
+  const q = quoted === "never" ? null : m.quoted?.media || null
+  const own = quoted === "only" ? null : m.media
+  const ok = a => a && (!types || types.includes(a.type)) && (!families || families.includes(a.family)) && (!accept || accept(a))
+  if (ok(q)) return { ...q, fromQuoted: true }
+  if (ok(own)) return { ...own, fromQuoted: false }
+  return null
+}
+
+// atalho: só o texto (ou legenda) de uma mensagem
+const textOfMessage = msg => parse(msg).text
+
+module.exports = { parse, findMedia, unwrap, textOf: textOfMessage, toNumber, WRAPPERS, MEDIA_TYPES }

package/packages/message/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@morpho/message",
+  "version": "0.1.0",
+  "description": "Mensagem do WhatsApp em formato simples no Morpho: desembrulha (visualização única, temporária, editada...), descobre o tipo, texto/legenda, menções, mídia, resposta de botão/lista e a mensagem citada. Sem dependências. Junta o que no Morvyn estava espalhado em tipoMensagem.js, midia.js, global.js e handler.js.",
+  "main": "index.js",
+  "license": "MIT"
+}

package/packages/pool/README.md

@@ -0,0 +1,75 @@
+# morpho-socket/pool
+
+Runs **several WhatsApp numbers in one process**: connect, pair by code, reconnect with backoff, stop, reset. No business rules (plans, limits, who is the owner) — those plug in through events.
+
+```js
+const { MorphoPool } = require("morpho-socket/pool")
+const { initAuthCreds } = require("@whiskeysockets/baileys")
+
+const pool = new MorphoPool({ store, initCreds: initAuthCreds, maxAttemptsWithoutPairing: 8 })
+
+pool.on("socket", (id, sock, { listen }) => listen("messages.upsert", data => handle(id, sock, data)))
+pool.on("pairing-code", (id, code) => console.log(id, "→", code))
+pool.on("connect", (id, sock) => { /* socket is open */ })
+
+await pool.startAll(["client-a", { sessionId: "client-b", phoneNumber: "5511999999999" }], { intervalMs: 1500 })
+```
+
+## Pairing
+
+If a session has no saved credentials and you pass `phoneNumber`, the pool requests a pairing code and emits `pairing-code`. The code is requested only after WhatsApp answers the handshake (the `qr` event) — asking earlier makes the server reject the session. A session that started pairing but never finished is discarded on the next connect, so a failed attempt does not leave the number stuck in a 401 loop.
+
+## What happens when the connection drops
+
+| Code | Reason | What the pool does | Extra event |
+|---|---|---|---|
+| 401 | logged out | **stops** (always) | `logged-out` |
+| 440 | replaced: another instance opened the same session | **stops** (reconnecting would start a fight) | `replaced` |
+| 403 | forbidden: number restricted or banned | **stops** | `forbidden` |
+| 515 | restart required (normal right after pairing) | reconnects **immediately** (up to 3 in a row, then backoff) | — |
+| anything else | network drop, timeout… | reconnects with backoff (2 s … 60 s) | `reconnecting` |
+
+Every terminal stop also emits `stopped` with `{ reason }`, and rejects the pending `start()` if the session never opened. Override per code with `policy`:
+
+```js
+new MorphoPool({ store, initCreds, policy: { 440: "reconnect", 515: "immediate" } })  // "reconnect" | "immediate" | "stop"
+```
+
+## API
+
+**Constructor options**
+
+| Option | Meaning |
+|---|---|
+| `store`, `initCreds` | required — a [`MorphoAuthStore`](../core) and Baileys' `initAuthCreds` |
+| `socketConfig(sessionId, state)` | extra `makeWASocket` options (`getMessage`, `cachedGroupMetadata`, `browser`…) merged into the default factory |
+| `makeSocket({ sessionId, state, saveCreds })` | replace the socket factory entirely (also how you test without WhatsApp). `socketConfig` is only used by the default factory |
+| `backoff(attempt)` | milliseconds to wait; default exponential, capped at 60 s |
+| `policy` | per-close-code action (see above). 401 always stops |
+| `maxAttemptsWithoutPairing` | a number that was **never paired** gives up after N consecutive drops and emits `gave-up`. A paired session never gives up. Default `null` (try forever) |
+| `skipNetworkVersion`, `versionTimeoutMs` | the protocol version is fetched once and cached for 1 h, with a timeout; if the lookup fails the last good version (or Baileys' bundled one) is used and a warning is printed |
+
+**Methods**
+
+| | |
+|---|---|
+| `start(id, { phoneNumber })` | connects; resolves the first time the connection opens |
+| `startAll(items, { intervalMs })` | starts in sequence with a gap instead of opening every connection at once; does not wait for pairing. Items: `"id"`, `{ sessionId, phoneNumber }` or `{ sessionId, opts }` |
+| `stop(id)` | disconnects but **keeps** the saved session (`start()` again, no pairing) |
+| `reset(id)` | disconnects **and deletes** the saved session (next `start()` asks for pairing) |
+| `get(id)` | the current socket, or `null` |
+| `status(id)` / `info(id)` / `list()` | `"connecting" \| "open" \| "reconnecting" \| "stopped"` · `{ status, attempts, paired, stopReason }` · all sessions |
+
+**Events**
+
+| Event | Arguments |
+|---|---|
+| `socket` | `(id, sock, { listen })` — one per (re)connection. `listen` is `sock.ev.on` that ignores events from a replaced/stopped socket and routes listener errors (sync or async) to `error` |
+| `connect` | `(id, sock)` |
+| `pairing-code` | `(id, code)` |
+| `disconnect` | `(id, { code, message, loggedOut, reason, action })` |
+| `reconnecting` | `(id, { attempt, delayMs, reason, immediate })` |
+| `logged-out` · `replaced` · `forbidden` · `gave-up` · `stopped` | `(id, info)` |
+| `error` | `(id, error)` — without a listener the error is printed instead of crashing the process |
+
+Also exported: `STATUS`, `CLOSE_REASONS`, `DEFAULT_POLICY`.