@stone-wpp/ofc 1.0.5 → 1.0.7

package/lib/Socket/stone-calls.js

@@ -0,0 +1,311 @@
+import { EventEmitter } from 'node:events'
+import { buildGroupCallRejectStanza } from './stone-call-signaling.js'
+import { createStoneVoipBridge } from './stone-voip-bridge.js'
+import { prepareStoneGroupOffer } from './stone-voip-group.js'
+
+const ENDED_STATES = new Set(['reject', 'terminate', 'timeout'])
+const CALL_STATES = Object.freeze({
+  offer: 'incoming_ringing',
+  accept: 'signaled',
+  reject: 'ended',
+  terminate: 'ended',
+  timeout: 'ended'
+})
+
+const requiredText = (value, label) => {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new TypeError(`Informe ${label} válido`)
+  }
+  return value.trim()
+}
+
+/**
+ * Gerenciamento de eventos e operações de chamada já suportadas pelo socket
+ * nativo da Stone. Usa a MESMA conexão e credenciais do bot.
+ *
+ * Este gerenciador não cria uma sessão VoIP nem implementa codificação,
+ * criptografia SRTP ou transporte da mídia de chamadas.
+ */
+export function createStoneCalls(socket) {
+  if (!socket?.ev || typeof socket.ev.on !== 'function' ||
+      typeof socket.ev.off !== 'function' ||
+      typeof socket.rejectCall !== 'function' ||
+      typeof socket.createCallLink !== 'function') {
+    throw new TypeError('É necessário um socket Stone com eventos e operações de chamadas')
+  }
+
+  const emitter = new EventEmitter()
+  const tracked = new Map()
+  const MAX_TRACKED_CALLS = 128
+  let destroyed = false
+  let bridge = null
+  let initializing = null
+  let lastVoipError = null
+
+  const assertReady = () => {
+    if (destroyed) throw new Error('Gerenciador de chamadas encerrado')
+  }
+
+  const mediaUnavailable = (method) => {
+    assertReady()
+    const error = new Error(
+      `stone.calls.${method} ainda não está disponível no motor nativo. ` +
+      'A Stone já detecta chamadas e envia convites, mas atender, iniciar, ' +
+      'entrar em chamadas ou transmitir mídia exigem sinalização e transporte VoIP completos.'
+    )
+    error.code = 'STONE_CALL_MEDIA_NOT_IMPLEMENTED'
+    throw error
+  }
+
+  const onCall = (incoming) => {
+    if (destroyed || bridge) return
+    const batch = Array.isArray(incoming) ? incoming : [incoming]
+    for (const call of batch) {
+      if (!call?.id || typeof call.id !== 'string') continue
+
+      const previous = tracked.get(call.id)
+      const status = String(call.status || 'unknown')
+      const known = {
+        ...previous,
+        callId: call.id,
+        id: call.id,
+        chatId: call.chatId ?? previous?.chatId ?? null,
+        peerJid: call.from ?? previous?.peerJid ?? null,
+        from: call.from ?? previous?.from ?? null,
+        groupJid: call.groupJid ?? previous?.groupJid ?? null,
+        callerPn: call.callerPn ?? previous?.callerPn ?? null,
+        callCreator: call.callCreator ?? previous?.callCreator ?? null,
+        sourceJid: call.sourceJid ?? previous?.sourceJid ?? null,
+        stanzaId: call.stanzaId ?? previous?.stanzaId ?? null,
+        joinable: call.joinable ?? previous?.joinable ?? false,
+        reRing: call.reRing ?? false,
+        latencyMs: call.latencyMs ?? previous?.latencyMs ?? null,
+        isGroupCall: Boolean(call.isGroup ?? previous?.isGroupCall),
+        isVideo: Boolean(call.isVideo ?? previous?.isVideo),
+        status,
+        date: call.date ?? previous?.date ?? new Date(),
+        stateData: {
+          state: CALL_STATES[status] ?? previous?.stateData?.state ?? 'unknown',
+          ...(ENDED_STATES.has(status) ? { endReason: status } : {})
+        }
+      }
+
+      tracked.delete(call.id)
+      tracked.set(call.id, known)
+      if (tracked.size > MAX_TRACKED_CALLS) {
+        tracked.delete(tracked.keys().next().value)
+      }
+
+      const snapshot = { ...known, stateData: { ...known.stateData } }
+      emitter.emit('state', snapshot)
+      if (status === 'offer') emitter.emit('incoming', snapshot)
+      if (ENDED_STATES.has(status)) emitter.emit('ended', snapshot)
+    }
+  }
+
+  socket.ev.on('call', onCall)
+
+  const voipState = call => {
+    if (destroyed || !call?.callId) return
+    const state = String(call.stateData?.state || 'unknown')
+    const previous = tracked.get(call.callId)
+    // O motor emite tanto state quanto incoming/ended: não duplicar notificações.
+    const repeatedState = previous?.stateData?.state === state &&
+      (previous?.stateData?.endReason || null) === (call.stateData?.endReason || null)
+    const safe = {
+      ...previous,
+      id: call.callId, callId: call.callId,
+      from: call.peerJid || previous?.from || null,
+      peerJid: call.peerJid || previous?.peerJid || null,
+      callCreator: call.callCreator || previous?.callCreator || null,
+      groupJid: call.groupJid || previous?.groupJid || null,
+      isGroupCall: Boolean(call.isGroupCall),
+      isVideo: call.mediaType === 'video',
+      date: call.createdAt || previous?.date || new Date(),
+      status: state,
+      stateData: {
+        state,
+        ...(call.stateData?.endReason ? { endReason: call.stateData.endReason } : {})
+      }
+    }
+    tracked.delete(call.callId)
+    tracked.set(call.callId, safe)
+    if (tracked.size > MAX_TRACKED_CALLS) tracked.delete(tracked.keys().next().value)
+    if (repeatedState) return
+    const value = { ...safe, stateData: { ...safe.stateData } }
+    emitter.emit('state', value)
+    if (state === 'incoming_ringing') {
+      emitter.emit('incoming', value)
+      // Preserva os eventos legados consumidos pelos plugins do bot.
+      socket.ev.emit('call', [{
+        id: value.id, status: 'offer', from: value.from,
+        callCreator: value.callCreator, groupJid: value.groupJid,
+        isGroup: value.isGroupCall, isVideo: value.isVideo,
+        chatId: value.groupJid || value.from, date: value.date
+      }])
+    }
+    if (state === 'ended') emitter.emit('ended', value)
+  }
+
+  const onConnection = ({ connection } = {}) => {
+    if (connection === 'open' && process.env.STONE_VOIP_ENABLED === '1') {
+      void api.enableVoip().catch(error => {
+        lastVoipError = error
+        socket.ev.emit('stone.voip.error', { code: error.code || 'STONE_VOIP_FAILED', message: error.message })
+      })
+    }
+  }
+  socket.ev.on('connection.update', onConnection)
+
+  const api = {
+    on(event, handler) { assertReady(); emitter.on(event, handler); return api },
+    once(event, handler) { assertReady(); emitter.once(event, handler); return api },
+    off(event, handler) { emitter.off(event, handler); return api },
+
+    /** Inicializa a camada VoIP experimental na MESMA conexão Stone. */
+    async enableVoip(options = {}) {
+      assertReady()
+      if (bridge) return api.getCapabilities()
+      if (initializing) return initializing
+      initializing = (async () => {
+        const candidate = await createStoneVoipBridge(socket, options)
+        if (destroyed) { await candidate.dispose(); throw new Error('Socket encerrado antes do VoIP iniciar') }
+        bridge = candidate
+        candidate.events.on('voip_call_state', voipState)
+        candidate.events.on('voip_call_incoming', voipState)
+        candidate.events.on('voip_call_ended', voipState)
+        candidate.events.on('voip_call_error', error => {
+          lastVoipError = error
+          socket.ev.emit('stone.voip.error', { code: error?.code || 'STONE_VOIP_ERROR', message: error?.message || String(error) })
+        })
+        lastVoipError = null
+        return api.getCapabilities()
+      })().catch(error => {
+        lastVoipError = error
+        throw error
+      }).finally(() => { initializing = null })
+      return initializing
+    },
+
+    getVoipStatus() {
+      return { initialized: Boolean(bridge), initializing: Boolean(initializing),
+        transport: bridge?.transport || null,
+        transportFallback: Boolean(bridge?.transportFallback),
+        error: lastVoipError ? { code: lastVoipError.code || 'STONE_VOIP_ERROR', message: lastVoipError.message } : null }
+    },
+
+    /** Disponibilidade explícita de recursos, sem anunciar chamadas inexistentes. */
+    getCapabilities() {
+      return Object.freeze({
+        sharedSocket: true,
+        incomingEvents: true,
+        rejectIncomingCall: true,
+        groupCallReject: typeof socket.sendNode === 'function',
+        incomingMetadata: true,
+        callLinks: true,
+        groupCallInvites: typeof socket.sendGroupCallInvite === 'function',
+        // API presente, mas chamadas em grupo reais ainda rejeitadas (ACK 412/400).
+        // Não confundir funcionalidade exposta com conexão comprovada.
+        groupCallStartExperimental: Boolean(bridge),
+        groupCallConnectionVerified: false,
+        startCall: Boolean(bridge),
+        acceptCall: Boolean(bridge),
+        joinCall: Boolean(bridge),
+        liveAudio: Boolean(bridge),
+        audioFiles: Boolean(bridge?.audioFilesAvailable),
+        videoMedia: false,
+        transport: bridge?.transport || null
+      })
+    },
+
+    getCall(callId) {
+      assertReady()
+      const id = requiredText(callId, 'callId')
+      const value = tracked.get(id)
+      return value ? { ...value, stateData: { ...value.stateData } } : null
+    },
+
+    getCalls() {
+      assertReady()
+      return [...tracked.values()].map(value => ({
+        ...value, stateData: { ...value.stateData }
+      }))
+    },
+
+    /** Recusa uma oferta que o socket recebeu e ainda reconhece. */
+    async rejectCall(callId) {
+      assertReady()
+      const id = requiredText(callId, 'callId')
+      const call = tracked.get(id)
+      if (bridge) return bridge.coordinator.rejectCall(id)
+      if (!call || call.status !== 'offer' || !call.from) {
+        throw new Error('Chamada recebida não encontrada ou não disponível para recusa')
+      }
+      if (call.isGroupCall) {
+        if (typeof socket.sendNode !== 'function') {
+          throw new Error('Envio de sinalização para chamadas em grupo indisponível')
+        }
+        await socket.sendNode(buildGroupCallRejectStanza(id, call.callCreator || call.from))
+      } else {
+        await socket.rejectCall(id, call.from)
+      }
+      onCall([{ id, status: 'reject', from: call.from }])
+    },
+
+    async createCallLink(type = 'audio', event, timeoutMs) {
+      assertReady()
+      if (type !== 'audio' && type !== 'video') {
+        throw new TypeError('O tipo de chamada deve ser audio ou video')
+      }
+      return socket.createCallLink(type, event, timeoutMs)
+    },
+
+    async sendGroupCallInvite(groupJid, options = {}) {
+      assertReady()
+      if (typeof socket.sendGroupCallInvite !== 'function') {
+        throw new Error('O envio de convites não está disponível neste socket')
+      }
+      return socket.sendGroupCallInvite(groupJid, options)
+    },
+
+    startCall(options) {
+      if (!bridge) return mediaUnavailable('startCall')
+      if (!options?.groupJid) return bridge.coordinator.startCall(options)
+      // Mantém a exceção síncrona do contrato legado quando não há motor.
+      // Apenas chamadas em grupo aguardam a validação do roster e dos LIDs.
+      return (async () => {
+        const prepared = await prepareStoneGroupOffer(socket, options)
+        assertReady()
+        bridge.setSelfLid?.(prepared.selfLid)
+        return bridge.coordinator.startCall(prepared.options)
+      })()
+    },
+    startGroupCall(options) {
+      return api.startCall(options)
+    },
+    acceptCall(id) { return bridge ? bridge.coordinator.acceptCall(id) : mediaUnavailable('acceptCall') },
+    joinCall(id) { return bridge ? bridge.coordinator.joinCall(id) : mediaUnavailable('joinCall') },
+    leaveCall(id) { return bridge ? bridge.coordinator.leaveCall(id) : mediaUnavailable('leaveCall') },
+    endCall(id) { return bridge ? bridge.coordinator.endCall(id) : mediaUnavailable('endCall') },
+    loadAudio(id, file) { return bridge ? bridge.coordinator.loadAudio(id, file) : mediaUnavailable('loadAudio') },
+    playAudio() { return mediaUnavailable('playAudio') },
+    setExternalAudioMode(id, flag) { return bridge ? bridge.coordinator.setExternalAudioMode(id, flag) : mediaUnavailable('setExternalAudioMode') },
+    feedLiveAudio(id, chunk) { return bridge ? bridge.coordinator.feedLiveAudio(id, chunk) : mediaUnavailable('feedLiveAudio') },
+    getLiveBufferMs(id) { return bridge ? bridge.coordinator.getLiveBufferMs(id) : mediaUnavailable('getLiveBufferMs') },
+    getFeedWatermarksMs(id) { return bridge ? bridge.coordinator.getFeedWatermarksMs(id) : mediaUnavailable('getFeedWatermarksMs') },
+    setMute(id, flag) { return bridge ? bridge.coordinator.setMute(id, flag) : mediaUnavailable('setMute') },
+
+    /** Remove os listeners desta API sem encerrar a conexão principal. */
+    destroy() {
+      if (destroyed) return
+      destroyed = true
+      socket.ev.off('call', onCall)
+      socket.ev.off('connection.update', onConnection)
+      if (bridge) void bridge.dispose().catch(() => {})
+      emitter.removeAllListeners()
+      tracked.clear()
+    }
+  }
+
+  return api
+}

package/lib/Socket/stone-features.d.ts

@@ -2,6 +2,19 @@ import type { MiscMessageGenerationOptions, WAMessage, WAMessageKey } from '../T
 import type { Label } from '../Types/Label.js'
 
 export interface StoneAdditionalMethods {
+  /** Envia link de participação em chamada ao grupo; não inicia mídia/VoIP nem toca os celulares. */
+  sendGroupCallInvite(groupJid: string, options?: { type?: 'audio' | 'video'; text?: string }): Promise<{
+    groupJid: string;
+    type: 'audio' | 'video';
+    url: string;
+    message: WAMessage;
+  }>;
+  /** Resolve o vínculo PN/LID conhecido pela sessão. null significa não resolvido. */
+  resolveJidMapping(jid: string): Promise<{ input: string; pn: string | null; lid: string | null; resolved: boolean }>;
+  /** Consulta se existe uma sessão Signal para o JID sem alterar suas chaves. */
+  inspectSignalSession(jid: string): Promise<{ jid: string; exists: boolean }>;
+  /** Edita o texto de mensagem enviada pelo próprio bot; não edita mensagens de terceiros. */
+  editMessage(jid: string, messageKey: WAMessageKey, text: string): Promise<WAMessage | undefined>;
   /** Pesquisa username pelo USync. Não retorna números de telefone. */
   queryUsernameExists(username: string, pin?: string): Promise<{ username: string; jid: string; wid: string; exists: true } | null>;
   /** Cria ou altera uma nota da conta WhatsApp Business via app-state. */

package/lib/Socket/stone-features.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import { USyncQuery, USyncUser } from '../WAUSync/index.js'
+import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX } from '../Defaults/index.js'
 
 const PIX_KEY_TYPES = new Set(['CPF', 'CNPJ', 'PHONE', 'EMAIL', 'EVP'])
 
@@ -57,6 +58,90 @@ export function createStoneAdditionalMethods(socket) {
   })
 
   return {
+    /**
+     * Cria um link de chamada no WhatsApp e envia o convite ao grupo.
+     * Não inicia uma sessão de voz/vídeo e não faz os participantes tocarem.
+     */
+    async sendGroupCallInvite(groupJid, options = {}) {
+      if (typeof groupJid !== 'string' || !/^[^@\s]+@g\.us$/.test(groupJid)) {
+        throw new TypeError('Informe um JID de grupo válido')
+      }
+      if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new TypeError('Informe opções válidas para o convite')
+      }
+      const { type = 'audio', text } = options
+      if (type !== 'audio' && type !== 'video') {
+        throw new TypeError('Tipo de chamada deve ser audio ou video')
+      }
+      if (text !== undefined && (typeof text !== 'string' || !text.trim())) {
+        throw new TypeError('O texto do convite deve ser uma mensagem não vazia')
+      }
+      if (typeof socket.createCallLink !== 'function' || typeof socket.sendMessage !== 'function') {
+        throw new Error('Os recursos de convite não estão disponíveis neste socket')
+      }
+      const token = await socket.createCallLink(type)
+      if (typeof token !== 'string' || !/^[A-Za-z0-9_-]{6,256}$/.test(token)) {
+        throw new Error('O WhatsApp não retornou um token válido para a chamada')
+      }
+      const url = (type === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token
+      const title = text?.trim() || (type === 'audio' ? 'Convite para chamada de voz em grupo:' : 'Convite para chamada de vídeo em grupo:')
+      const message = await socket.sendMessage(groupJid, { text: `${title}\n${url}` })
+      if (!message?.key?.id) {
+        throw new Error('O socket não confirmou o envio do convite para o grupo')
+      }
+      return { groupJid, type, url, message }
+    },
+
+    /** Consulta o mapeamento PN/LID que a sessão conhece (sem inventar identidades). */
+    async resolveJidMapping(jid) {
+      requireJid(jid)
+      const mapping = socket.signalRepository?.lidMapping
+      if (!mapping) throw new Error('Mapeamento de identidades indisponível')
+      if (jid.endsWith('@lid') || jid.endsWith('@hosted.lid')) {
+        const pn = await mapping.getPNForLID(jid)
+        return { input: jid, pn: pn ?? null, lid: jid, resolved: Boolean(pn) }
+      }
+      if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@hosted')) {
+        const lid = await mapping.getLIDForPN(jid)
+        return { input: jid, pn: jid, lid: lid ?? null, resolved: Boolean(lid) }
+      }
+      throw new TypeError('Informe um JID de usuário PN ou LID')
+    },
+
+    /** Diagnóstico somente leitura: não recria nem substitui chaves Signal. */
+    async inspectSignalSession(jid) {
+      requireJid(jid)
+      if (!socket.signalRepository?.validateSession) {
+        throw new Error('Repositório de sessões indisponível')
+      }
+      const status = await socket.signalRepository.validateSession(jid)
+      return { jid, exists: Boolean(status?.exists) }
+    },
+
+    /**
+     * Edita uma mensagem enviada pela própria conta.
+     * A Stone já implementa MESSAGE_EDIT no sendMessage: aqui há um atalho
+     * com validação para não tentar falsificar mensagens de terceiros.
+     */
+    async editMessage(jid, messageKey, text) {
+      requireJid(jid)
+      if (!messageKey || typeof messageKey !== 'object' || !messageKey.id) {
+        throw new TypeError('Informe a chave (key) da mensagem enviada pelo bot')
+      }
+      if (messageKey.fromMe !== true) {
+        throw new TypeError('Só é possível editar mensagens enviadas pela própria conta')
+      }
+      if (messageKey.remoteJid && messageKey.remoteJid !== jid) {
+        throw new TypeError('A mensagem original não pertence a esta conversa')
+      }
+      if (typeof text !== 'string' || !text.trim()) {
+        throw new TypeError('Informe o novo texto da mensagem')
+      }
+      return socket.sendMessage(jid, {
+        text,
+        edit: { ...messageKey, remoteJid: jid, fromMe: true }
+      })
+    },
     /**
      * Consulta um @username pelo USync do WhatsApp, com PIN opcional.
      * Não revela nem infere o número de telefone.

package/lib/Socket/stone-pairing-state.js

@@ -0,0 +1,7 @@
+/**
+ * A phone JID is written into credentials while a pairing code is REQUESTED,
+ * so creds.me alone cannot identify a linked session. Only pair-success,
+ * validated against the WhatsApp account signature, supplies the account.
+ */
+export const hasCompletedStonePairing = (creds) =>
+    !!(creds?.me?.id && creds?.account);