@stone-wpp/ofc 1.0.6 → 1.0.7

package/lib/Socket/stone-call-signaling.js

@@ -0,0 +1,127 @@
+import { randomBytes } from 'node:crypto'
+
+/**
+ * Normaliza metadados públicos de uma sinalização recebida sem reter nem
+ * expor os nós que carregam chaves E2EE, tokens ou credenciais de relay.
+ * Não é um decodificador de mídia nem um implementador de chamadas VoIP.
+ */
+export function parseStoneCallStanza(node, status) {
+  const attrs = node?.attrs ?? {}
+  const inner = Array.isArray(node?.content) ? node.content.find(child => child?.tag && child?.attrs) : null
+  const fields = inner?.attrs
+  if (!fields || typeof fields['call-id'] !== 'string' || !fields['call-id']) return null
+
+  const children = Array.isArray(inner.content) ? inner.content : []
+  const groupJid = fields['group-jid'] || fields.group_jid || null
+  const callCreator = fields['call-creator'] || fields.from || null
+  const timestamp = Number(attrs.t)
+  const date = Number.isFinite(timestamp) && timestamp > 0 ? new Date(timestamp * 1000) : new Date()
+  const value = {
+    id: fields['call-id'],
+    chatId: attrs.from ?? null,
+    from: fields.from || callCreator,
+    callCreator,
+    sourceJid: attrs.from ?? null,
+    stanzaId: attrs.id ?? null,
+    callerPn: fields.caller_pn ?? fields['caller_pn'] ?? null,
+    date,
+    offline: attrs.offline === '1' || attrs.offline === 'true' || attrs.offline === true,
+    status: typeof status === 'string' && status ? status : inner.tag
+  }
+  if (value.status === 'offer') {
+    value.isGroup = fields.type === 'group' || Boolean(groupJid) || String(attrs.from || '').endsWith('@call')
+    value.groupJid = groupJid
+    value.isVideo = children.some(child => child?.tag === 'video')
+    value.joinable = fields.joinable === '1' || fields.joinable === 'true'
+    value.reRing = fields['re-ring'] === '1'
+  }
+  if (value.status === 'relaylatency') {
+    const latency = fields.latency ?? fields.latency_ms ?? fields['latency-ms']
+    if (latency !== undefined && latency !== '') {
+      const ms = Number(latency)
+      if (Number.isFinite(ms) && ms >= 0) value.latencyMs = ms
+    }
+  }
+  return value
+}
+
+
+/**
+ * Primitivas de sinalização da Stone WPP.
+ * Apenas montam nós binários e não iniciam nenhuma ligação nem transportam mídia.
+ */
+export function createStoneCallStanza({ to, tag, callId, callCreator, attrs = {}, content }, random = randomBytes) {
+  if (typeof to !== 'string' || !/^[^@\s]+@[^@\s]+$/.test(to)) {
+    throw new TypeError('Destino da sinalização inválido')
+  }
+  if (!['offer', 'preaccept', 'accept', 'terminate', 'reject'].includes(tag)) {
+    throw new TypeError('Tipo da sinalização inválido')
+  }
+  if (typeof callId !== 'string' || !/^[A-Za-z0-9_-]{1,256}$/.test(callId)) {
+    throw new TypeError('Identificador da chamada inválido')
+  }
+  if (typeof callCreator !== 'string' || !/^[^@\s]+@[^@\s]+$/.test(callCreator)) {
+    throw new TypeError('Criador da chamada inválido')
+  }
+  if (!attrs || typeof attrs !== 'object' || Array.isArray(attrs) ||
+      Object.keys(attrs).some(key => key === 'call-id' || key === 'call-creator' ||
+        typeof attrs[key] !== 'string')) {
+    throw new TypeError('Atributos da sinalização inválidos')
+  }
+  if (content !== undefined && (!Array.isArray(content) || content.some(x => !x || typeof x.tag !== 'string'))) {
+    throw new TypeError('Conteúdo da sinalização inválido')
+  }
+  const bytes = Buffer.from(random(16))
+  if (bytes.length !== 16) throw new Error('Gerador de identificadores inválido')
+  const child = { tag, attrs: { 'call-id': callId, 'call-creator': callCreator, ...attrs } }
+  if (content !== undefined) child.content = content
+  return {
+    tag: 'call',
+    attrs: { to, id: bytes.toString('hex').toUpperCase() },
+    content: [child]
+  }
+}
+
+/**
+ * Formato de mídia anunciado no protocolo (não cria codec nem transmite áudio).
+ * A camada de mídia ainda precisa negociar transporte e chaves antes de uso real.
+ */
+export function createStoneCallMediaDescription(isVideo = false) {
+  const nodes = [
+    { tag: 'audio', attrs: { enc: 'opus', rate: '8000' } },
+    { tag: 'audio', attrs: { enc: 'opus', rate: '16000' } }
+  ]
+  if (isVideo) {
+    nodes.push({
+      tag: 'video',
+      attrs: {
+        enc: 'h.264', dec: 'H264',
+        screen_width: '1920', screen_height: '1080',
+        device_orientation: '0'
+      }
+    })
+  }
+  nodes.push({ tag: 'net', attrs: { medium: '3' } })
+  return nodes
+}
+
+/** Extrai o ID de um destino de grupo @call, sem expor o payload da oferta. */
+export function parseStoneCallServerJid(jid) {
+  if (typeof jid !== 'string' || !jid.endsWith('@call')) return null
+  const id = jid.slice(0, -'@call'.length)
+  return /^[A-Za-z0-9_-]{1,256}$/.test(id) ? id : null
+}
+
+/** Grupo: a recusa pertence à chamada e vai para <call-id>@call. */
+export function buildGroupCallRejectStanza(callId, callCreator, random = randomBytes) {
+  if (typeof callId !== 'string' || !/^[A-Za-z0-9_-]{1,256}$/.test(callId)) {
+    throw new TypeError('Identificador da chamada inválido')
+  }
+  if (typeof callCreator !== 'string' || !/^[^@\s]+@[^@\s]+$/.test(callCreator)) {
+    throw new TypeError('Criador da chamada inválido')
+  }
+  return createStoneCallStanza({
+    to: `${callId}@call`, tag: 'reject', callId, callCreator,
+    attrs: { count: '0' }
+  }, random)
+}

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

@@ -0,0 +1,76 @@
+export type StoneCallEvent = 'incoming' | 'state' | 'ended'
+export interface StoneCallInfo {
+  callId: string
+  id: string
+  status: string
+  chatId: string | null
+  peerJid: string | null
+  from: string | null
+  groupJid: string | null
+  callerPn: string | null
+  callCreator: string | null
+  sourceJid: string | null
+  stanzaId: string | null
+  joinable: boolean
+  reRing: boolean
+  latencyMs: number | null
+  isGroupCall: boolean
+  isVideo: boolean
+  date: Date
+  stateData: { state: string; endReason?: string }
+}
+export interface StoneCallCapabilities {
+  sharedSocket: true
+  incomingEvents: true
+  rejectIncomingCall: true
+  groupCallReject: boolean
+  incomingMetadata: true
+  callLinks: true
+  groupCallInvites: boolean
+  startCall: boolean
+  acceptCall: boolean
+  joinCall: boolean
+  liveAudio: boolean
+  audioFiles: boolean
+  videoMedia: boolean
+}
+export interface StoneCalls {
+  on(event: StoneCallEvent, handler: (call: StoneCallInfo) => void): StoneCalls
+  once(event: StoneCallEvent, handler: (call: StoneCallInfo) => void): StoneCalls
+  off(event: StoneCallEvent, handler: (call: StoneCallInfo) => void): StoneCalls
+  enableVoip(options?: { maxConcurrentCalls?: number; useRawUdpTransport?: boolean; logLevel?: string }): Promise<StoneCallCapabilities>
+  getVoipStatus(): { initialized: boolean; initializing: boolean; error: { code: string; message: string } | null }
+  getCapabilities(): StoneCallCapabilities
+  getCall(callId: string): StoneCallInfo | null
+  getCalls(): StoneCallInfo[]
+  rejectCall(callId: string): Promise<void>
+  createCallLink(type?: 'audio' | 'video', event?: { startTime: number }, timeoutMs?: number): Promise<string | undefined>
+  sendGroupCallInvite(groupJid: string, options?: { type?: 'audio' | 'video'; text?: string }): Promise<{
+    groupJid: string
+    type: 'audio' | 'video'
+    url: string
+    message: import('../Types/index.js').WAMessage
+  }>
+  /** Disponíveis SOMENTE depois de enableVoip() concluir com o motor de mídia carregado. */
+  startCall(options: { peerJid?: string; groupJid?: string; participants?: Array<{ jid: string; devices?: string[] }>; isVideo?: boolean; audioFile?: string }): Promise<string>
+  startGroupCall(options: { groupJid: string; participants: Array<{ jid: string; devices?: string[] }>; isVideo?: boolean; audioFile?: string }): Promise<string>
+  acceptCall(callId: string): Promise<void>
+  joinCall(callId: string): Promise<void>
+  leaveCall(callId: string): Promise<void>
+  endCall(callId: string): Promise<void>
+  loadAudio(callId: string, file: string): Promise<void>
+  playAudio(...args: any[]): never
+  setExternalAudioMode(callId: string, enabled: boolean): void
+  feedLiveAudio(callId: string, samples: Float32Array): number
+  getLiveBufferMs(callId: string): number
+  getFeedWatermarksMs(callId: string): unknown
+  setMute(callId: string, muted: boolean): void
+  destroy(): void
+}
+export declare function createStoneCalls(socket: {
+  ev: { on(event: string, handler: (event: any) => void): any; off(event: string, handler: (event: any) => void): any }
+  rejectCall(callId: string, from: string): Promise<void>
+  sendNode?: (node: any) => Promise<void>
+  createCallLink(type: 'audio' | 'video', event?: { startTime: number }, timeoutMs?: number): Promise<string | undefined>
+  sendGroupCallInvite?: (jid: string, options?: { type?: 'audio' | 'video'; text?: string }) => Promise<any>
+}): StoneCalls

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,17 @@ 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. */

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,66 @@ 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

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);