@adatechnology/conversations-ui 0.1.0-rc.2 → 0.1.0-rc.21

package/src/preview/createPreviewWebhookClient.test.ts

@@ -0,0 +1,194 @@
+/**
+ * O risco aqui não é o cliente montar o payload errado — é o HMAC do WebCrypto divergir do que o
+ * servidor calcula com `node:crypto`. Uma divergência de um byte transforma todo envio do preview
+ * em 401, então o teste compara as duas implementações diretamente.
+ */
+
+import { createHmac } from 'node:crypto'
+import { describe, expect, it } from 'bun:test'
+import {
+  assertPreviewEnvironment,
+  createPreviewWebhookClient,
+  PreviewInProductionError,
+  PreviewMediaUploadRejectedError,
+  PreviewWebhookRejectedError,
+} from './createPreviewWebhookClient'
+import { PREVIEW_MEDIA_ID_PREFIX } from './createPreviewMediaUploader'
+
+const APP_SECRET = 'dev-app-secret'
+const FROM = '5511988887777'
+const WEBHOOK_URL = 'http://localhost:3000/v1/webhook/whatsapp'
+
+type CapturedRequest = {
+  body: string
+  signature: string
+}
+
+function createCapturingFetch(status = 200): { fetchImplementation: typeof fetch; captured: CapturedRequest[] } {
+  const captured: CapturedRequest[] = []
+
+  const fetchImplementation = (async (_url: string, init?: RequestInit) => {
+    const headers = init?.headers as Record<string, string>
+    captured.push({ body: String(init?.body), signature: headers['x-hub-signature-256'] ?? '' })
+    return { ok: status >= 200 && status < 300, status } as Response
+  }) as unknown as typeof fetch
+
+  return { fetchImplementation, captured }
+}
+
+describe('createPreviewWebhookClient', () => {
+  it('assina com o mesmo HMAC que o servidor calcula em node:crypto', async () => {
+    const { fetchImplementation, captured } = createCapturingFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await client.sendText('quero 2kg de arroz')
+
+    const request = captured[0]
+    const expected = `sha256=${createHmac('sha256', APP_SECRET)
+      .update(request?.body ?? '')
+      .digest('hex')}`
+    expect(request?.signature).toBe(expected)
+  })
+
+  it('envia exatamente os bytes que assinou', async () => {
+    const { fetchImplementation, captured } = createCapturingFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await client.sendButtonReply({ id: 'confirmar', title: 'Confirmar' })
+
+    const request = captured[0]
+    const reparsed = JSON.stringify(JSON.parse(request?.body ?? '{}'))
+    expect(request?.body).toBe(reparsed)
+  })
+
+  it('mensagens de texto idêntico produzem assinaturas distintas', async () => {
+    const { fetchImplementation, captured } = createCapturingFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await client.sendText('sim')
+    await client.sendText('sim')
+
+    expect(captured[0]?.signature).not.toBe(captured[1]?.signature)
+  })
+
+  it('propaga a recusa do webhook em vez de engolir', async () => {
+    const { fetchImplementation } = createCapturingFetch(401)
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await expect(client.sendText('oi')).rejects.toBeInstanceOf(PreviewWebhookRejectedError)
+  })
+})
+
+describe('assertPreviewEnvironment', () => {
+  it('recusa montar em produção', () => {
+    expect(() => assertPreviewEnvironment(true)).toThrow(PreviewInProductionError)
+    expect(() => assertPreviewEnvironment(false)).not.toThrow()
+  })
+})
+
+/**
+ * O microfone do simulador depende disto existir no cliente.
+ *
+ * Enquanto o upload era prop de quem montava a tela, um produto tinha gravador e o outro não — e a
+ * diferença não aparecia em teste nenhum, porque cada host montava o seu. Aqui a garantia é do
+ * pacote: cliente montado, upload assinado, id prefixado.
+ */
+describe('createPreviewWebhookClient.uploadMedia', () => {
+  function createUploadFetch(status = 201): {
+    fetchImplementation: typeof fetch
+    calls: Array<{ url: string; signature: string; body: string }>
+  } {
+    const calls: Array<{ url: string; signature: string; body: string }> = []
+
+    const fetchImplementation = (async (url: string, init?: RequestInit) => {
+      const headers = (init?.headers ?? {}) as Record<string, string>
+      calls.push({ url: String(url), signature: headers['x-preview-signature'] ?? '', body: String(init?.body) })
+      return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => ({ data: { uploadId: 'upl_123' } }),
+      } as Response
+    }) as unknown as typeof fetch
+
+    return { fetchImplementation, calls }
+  }
+
+  const audioFile = () => new File([new Uint8Array([1, 2, 3])], 'nota.ogg', { type: 'audio/ogg' })
+
+  it('sobe na mesma origem do webhook e devolve o id já prefixado', async () => {
+    const { fetchImplementation, calls } = createUploadFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    const uploaded = await client.uploadMedia(audioFile())
+
+    expect(calls[0]?.url).toBe('http://localhost:3000/v1/preview/media')
+    expect(uploaded.mediaId).toBe(`${PREVIEW_MEDIA_ID_PREFIX}upl_123`)
+    expect(uploaded.mimeType).toBe('audio/ogg')
+  })
+
+  it('assina o MIME com o mesmo HMAC que o servidor confere', async () => {
+    const { fetchImplementation, calls } = createUploadFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await client.uploadMedia(audioFile())
+
+    const expected = `sha256=${createHmac('sha256', APP_SECRET).update('audio/ogg').digest('hex')}`
+    expect(calls[0]?.signature).toBe(expected)
+  })
+
+  it('usa caminho relativo quando a URL do webhook não tem origem', async () => {
+    const { fetchImplementation, calls } = createUploadFetch()
+    const client = createPreviewWebhookClient({
+      webhookUrl: '/v1/webhook/whatsapp',
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await client.uploadMedia(audioFile())
+
+    expect(calls[0]?.url).toBe('/v1/preview/media')
+  })
+
+  it('avisa com erro próprio quando a rota de mídia recusa', async () => {
+    const { fetchImplementation } = createUploadFetch(404)
+    const client = createPreviewWebhookClient({
+      webhookUrl: WEBHOOK_URL,
+      appSecret: APP_SECRET,
+      from: FROM,
+      fetchImplementation,
+    })
+
+    await expect(client.uploadMedia(audioFile())).rejects.toBeInstanceOf(PreviewMediaUploadRejectedError)
+  })
+})

package/src/preview/createPreviewWebhookClient.ts

@@ -0,0 +1,222 @@
+/**
+ * Cliente que entrega mensagens do preview no webhook real, assinadas com HMAC — a mesma validação
+ * de staging e produção, sem rota alternativa e sem bypass. Do ponto de vista da API, este cliente
+ * é indistinguível da Meta; o que muda é apenas quem assina.
+ *
+ * Assina com WebCrypto porque `node:crypto` não existe no navegador. Os builders vêm dos contratos
+ * (isomórficos) justamente para que o mesmo payload seja montado nos dois runtimes.
+ *
+ * ⚠️ SOMENTE EXECUÇÃO LOCAL. Isto carrega o app secret no bundle, e bundle é público onde quer que
+ * seja servido — em qualquer ambiente com URL acessível (homologação inclusive) usar esta fábrica
+ * equivale a publicar o segredo, e quem o tiver forja webhooks válidos daquele app da Meta: injeta
+ * mensagem de qualquer número e dispara os fluxos. `assertPreviewEnvironment` barra produção, mas
+ * homologação passaria, então a barreira não basta.
+ *
+ * Para qualquer ambiente publicado use `createPreviewBridgeClient`: o navegador manda a intenção e
+ * o servidor assina com o segredo que ele já tem.
+ */
+
+import {
+  buildInboundAudioPayload,
+  buildInboundInteractivePayload,
+  buildInboundMediaPayload,
+  buildInboundTextPayload,
+  serializeWebhookPayload,
+  type InboundMediaType,
+  type InteractiveReplyOption,
+} from '@adatechnology/meta-whatsapp-contracts/testing'
+import { createPreviewMediaUploader, type PreviewUploadedMedia } from './createPreviewMediaUploader'
+
+export type PreviewWebhookClient = {
+  sendText(text: string): Promise<void>
+  sendButtonReply(reply: InteractiveReplyOption): Promise<void>
+  sendListReply(reply: InteractiveReplyOption): Promise<void>
+  sendAudio(mediaId: string): Promise<void>
+  sendMedia(params: SendPreviewMediaParams): Promise<void>
+  /**
+   * Guarda um arquivo gravado e devolve o `mediaId` já prefixado, pronto para `sendMedia`.
+   *
+   * Existe no cliente, e não como prop de quem monta a tela, porque isto é exatamente o que ele já
+   * sabe fazer: falar com ESTE host usando ESTE segredo. Enquanto era responsabilidade do produto,
+   * o resultado prático foi um produto com microfone no simulador e outro sem — não por decisão,
+   * por esquecimento. Cliente montado, microfone na tela.
+   *
+   * Opcional porque o cliente-ponte só consegue oferecer isto quando sabe a rota de mídia (ou quando
+   * o host injeta a função): sem destino, gravar áudio seria falar para o vazio, e aí a tela
+   * corretamente não desenha o gravador.
+   */
+  uploadMedia?(file: File): Promise<PreviewUploadedMedia>
+}
+
+export type SendPreviewMediaParams = {
+  readonly mediaType: InboundMediaType
+  /**
+   * Id que o host já usa para buscar o arquivo. Não é bytes: o webhook da Meta entrega mídia por
+   * referência, e o consumidor baixa depois — mandar base64 aqui simularia um payload que a Meta
+   * nunca produz, e o caminho testado deixaria de ser o de produção.
+   */
+  readonly mediaId: string
+  readonly mimeType?: string
+  readonly filename?: string
+  readonly caption?: string
+}
+
+export type CreatePreviewWebhookClientParams = {
+  readonly webhookUrl: string
+  readonly appSecret: string
+  readonly from: string
+  readonly phoneNumberId?: string
+  /**
+   * Rota que guarda o áudio gravado. Por padrão, `/v1/preview/media` na mesma origem do webhook.
+   *
+   * O padrão cobre o caso normal — as duas rotas são do mesmo servidor — e a prop existe para quem
+   * publica a API em outro host ou versiona o caminho.
+   */
+  readonly mediaUploadUrl?: string
+  // Escape hatch para teste; em runtime real é sempre o fetch global.
+  readonly fetchImplementation?: typeof fetch
+}
+
+/** Falha da rota de upload, separada da do webhook: os dois lados quebram por motivos diferentes. */
+export class PreviewMediaUploadRejectedError extends Error {
+  constructor(readonly status: number) {
+    super(`A rota de mídia do simulador recusou o upload (HTTP ${status}).`)
+    this.name = 'PreviewMediaUploadRejectedError'
+  }
+}
+
+export class PreviewInProductionError extends Error {
+  constructor() {
+    super('O preview de conversa carrega um app secret e não pode ser montado em produção.')
+    this.name = 'PreviewInProductionError'
+  }
+}
+
+export class PreviewWebhookRejectedError extends Error {
+  constructor(readonly status: number) {
+    super(`O webhook recusou a entrega do preview (HTTP ${status}).`)
+    this.name = 'PreviewWebhookRejectedError'
+  }
+}
+
+/**
+ * Falha alto em vez de degradar em silêncio: um preview que "quase funciona" em produção é pior
+ * que um que se recusa a montar.
+ */
+export function assertPreviewEnvironment(isProduction: boolean): void {
+  if (isProduction) throw new PreviewInProductionError()
+}
+
+/**
+ * Assina um texto qualquer com o app secret, no mesmo formato do header da Meta.
+ *
+ * Exportada porque o preview precisa provar identidade em MAIS de um lugar: além de entregar a
+ * mensagem no webhook, ele lê o transcript de volta — e ler pela API de admin exigia uma sessão que
+ * a aba do simulador não tem. Assinar a leitura com o segredo que ele já carrega resolve sem token
+ * de admin e sem rota aberta.
+ */
+export async function signPreviewPayload(params: { rawBody: string; appSecret: string }): Promise<string> {
+  const encoder = new TextEncoder()
+  const key = await globalThis.crypto.subtle.importKey(
+    'raw',
+    encoder.encode(params.appSecret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  )
+  const signature = await globalThis.crypto.subtle.sign('HMAC', key, encoder.encode(params.rawBody))
+
+  return `sha256=${[...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, '0')).join('')}`
+}
+
+const signWithWebCrypto = signPreviewPayload
+
+export const DEFAULT_MEDIA_UPLOAD_PATH = '/v1/preview/media'
+
+/**
+ * Mesma origem do webhook: as duas rotas são do mesmo servidor no caso normal.
+ *
+ * Quando `webhookUrl` é relativa — que é o que sai de um `VITE_API_URL` vazio, com o front servido
+ * pela própria API — não há origem para resolver contra, e o caminho relativo já aponta para o
+ * lugar certo. `new URL` com base relativa lançaria, e o microfone morreria no `createClient`.
+ */
+export function defaultMediaUploadUrl(webhookUrl: string): string {
+  try {
+    return new URL(DEFAULT_MEDIA_UPLOAD_PATH, webhookUrl).toString()
+  } catch {
+    return DEFAULT_MEDIA_UPLOAD_PATH
+  }
+}
+
+/**
+ * O POST de mídia, sem a parte de assinatura — para os dois clientes usarem o mesmo caminho.
+ *
+ * O cliente-ponte autentica por sessão e o de webhook por HMAC; o que não muda é a rota, o formato
+ * do corpo e a leitura do `uploadId`. Duas cópias disso é como o prefixo de mídia divergiu antes.
+ */
+export function createPreviewMediaPoster(params: {
+  readonly url: string
+  readonly headers?: (mimeType: string) => Promise<Readonly<Record<string, string>>>
+  readonly fetchImplementation?: typeof fetch
+}): (file: File) => Promise<PreviewUploadedMedia> {
+  return createPreviewMediaUploader({
+    upload: async (request) => {
+      const performRequest = params.fetchImplementation ?? fetch
+      const extraHeaders = (await params.headers?.(request.mimeType)) ?? {}
+
+      const response = await performRequest(params.url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...extraHeaders },
+        body: JSON.stringify(request),
+      })
+
+      if (!response.ok) throw new PreviewMediaUploadRejectedError(response.status)
+
+      const body = (await response.json()) as { data: { uploadId: string } }
+      return { uploadId: body.data.uploadId }
+    },
+  })
+}
+
+export function createPreviewWebhookClient(params: CreatePreviewWebhookClientParams): PreviewWebhookClient {
+  const sendPayload = async (payload: ReturnType<typeof buildInboundTextPayload>): Promise<void> => {
+    // Serializa uma vez só: assinar um texto e enviar outro (mesmo com o conteúdo igual) derruba a
+    // validação, porque o HMAC cobre os bytes exatos.
+    const rawBody = serializeWebhookPayload(payload)
+    const signature = await signWithWebCrypto({ rawBody, appSecret: params.appSecret })
+    const performRequest = params.fetchImplementation ?? fetch
+
+    const response = await performRequest(params.webhookUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-hub-signature-256': signature },
+      body: rawBody,
+    })
+
+    if (!response.ok) throw new PreviewWebhookRejectedError(response.status)
+  }
+
+  /**
+   * Assina o MIME, não o binário — mesmo contrato da rota.
+   *
+   * Passar megabytes de base64 pelo HMAC do navegador travaria a aba a cada nota de voz; o que a
+   * assinatura protege aqui é o acesso à rota, e o binário já tem teto de tamanho no servidor.
+   */
+  const uploadMedia = createPreviewMediaPoster({
+    url: params.mediaUploadUrl ?? defaultMediaUploadUrl(params.webhookUrl),
+    headers: async (mimeType) => ({
+      'x-preview-signature': await signWithWebCrypto({ rawBody: mimeType, appSecret: params.appSecret }),
+    }),
+    ...(params.fetchImplementation ? { fetchImplementation: params.fetchImplementation } : {}),
+  })
+
+  const envelope = { from: params.from, phoneNumberId: params.phoneNumberId }
+
+  return {
+    sendText: (text) => sendPayload(buildInboundTextPayload({ ...envelope, text })),
+    sendButtonReply: (reply) => sendPayload(buildInboundInteractivePayload({ ...envelope, buttonReply: reply })),
+    sendListReply: (reply) => sendPayload(buildInboundInteractivePayload({ ...envelope, listReply: reply })),
+    sendAudio: (mediaId) => sendPayload(buildInboundAudioPayload({ ...envelope, mediaId })),
+    sendMedia: (media) => sendPayload(buildInboundMediaPayload({ ...envelope, ...media })),
+    uploadMedia,
+  }
+}

package/src/preview/index.ts

@@ -0,0 +1,67 @@
+/**
+ * Export separado (`@adatechnology/conversations-ui/preview`) para que fixtures e mocks nunca
+ * entrem no bundle de produção de quem consome o pacote.
+ */
+
+export { createPreviewStore, conversationChannel, GLOBAL_CHANNEL } from './previewStore'
+export type {
+  PreviewStore,
+  CreatePreviewStoreParams,
+  PreviewEmission,
+  PreviewStoreListener,
+  AppendMessageParams,
+  SetModeParams,
+  ListConversationsFilters,
+} from './previewStore'
+
+export { createMockEventSource } from './mockEventSource'
+export type { MockEventSource } from './mockEventSource'
+
+export { createMockConversationsApi } from './createMockConversationsApi'
+export type { CreateMockConversationsApiParams } from './createMockConversationsApi'
+
+export { createMockSSEProvider } from './createMockSSEProvider'
+export type { CreateMockSSEProviderParams } from './createMockSSEProvider'
+
+export { PREVIEW_CONVERSATIONS, PREVIEW_MESSAGES, PREVIEW_DOCUMENTS } from './previewFixtures'
+
+export { ConversationPreview } from './ConversationPreview'
+export { mediaTypeOf } from './ConversationPreview'
+export type { ConversationPreviewProps, PreviewUploadedMedia } from './ConversationPreview'
+
+export { AudioRecorderButton, DEFAULT_AUDIO_RECORDER_BUTTON_LABELS } from '../AudioRecorderButton'
+export type { AudioRecorderButtonProps, AudioRecorderButtonLabels } from '../AudioRecorderButton'
+
+export {
+  createPreviewWebhookClient,
+  signPreviewPayload,
+  assertPreviewEnvironment,
+  PreviewInProductionError,
+  PreviewWebhookRejectedError,
+  PreviewMediaUploadRejectedError,
+  createPreviewMediaPoster,
+  DEFAULT_MEDIA_UPLOAD_PATH,
+} from './createPreviewWebhookClient'
+export type {
+  PreviewWebhookClient,
+  CreatePreviewWebhookClientParams,
+  SendPreviewMediaParams,
+} from './createPreviewWebhookClient'
+
+export { createPreviewBridgeClient, PreviewBridgeRejectedError } from './createPreviewBridgeClient'
+export type {
+  CreatePreviewBridgeClientParams,
+  PreviewInboundCommand,
+  SendPreviewInboundCommand,
+} from './createPreviewBridgeClient'
+
+export { startPreviewScript, DEFAULT_PREVIEW_SCRIPT } from './startPreviewScript'
+export type { PreviewScriptStep, StartPreviewScriptParams } from './startPreviewScript'
+export { PREVIEW_FILE_SAMPLES, resolvePreviewFileSample } from './previewFileSamples'
+export { createPreviewMediaResolver, previewFileUrl } from './previewMediaSource'
+export { previewFileBase64 } from './previewMediaSource'
+export { MediaTypesPreview, MEDIA_TYPES_CONVERSATION_ID } from './MediaTypesPreview'
+export type { MediaTypesPreviewProps } from './MediaTypesPreview'
+
+export { createPreviewMediaUploader, PREVIEW_MEDIA_ID_PREFIX } from './createPreviewMediaUploader'
+export type { CreatePreviewMediaUploaderParams, PreviewMediaUploadRequest } from './createPreviewMediaUploader'

package/src/preview/mediaTypeOf.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'bun:test'
+import { mediaTypeOf } from './ConversationPreview'
+
+describe('mediaTypeOf', () => {
+  it('deriva imagem, vídeo e áudio pelo prefixo do MIME', () => {
+    expect(mediaTypeOf('image/jpeg')).toBe('image')
+    expect(mediaTypeOf('video/mp4')).toBe('video')
+    expect(mediaTypeOf('audio/webm')).toBe('audio')
+  })
+
+  it('trata o resto como documento, inclusive MIME desconhecido', () => {
+    expect(mediaTypeOf('application/pdf')).toBe('document')
+    expect(mediaTypeOf('')).toBe('document')
+  })
+})

package/src/preview/mockDocumentsSearch.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Guarda a busca da biblioteca no mock — que é a implementação de referência da UI do SDK e tem de
+ * casar com o `companyDocumentSearch` do backend, senão o preview ensina um comportamento que a
+ * tela real não entrega.
+ */
+
+import { describe, expect, it } from 'bun:test'
+
+import { createMockConversationsApi } from './createMockConversationsApi'
+import { createPreviewStore } from './previewStore'
+import { PREVIEW_CONVERSATIONS, PREVIEW_MESSAGES } from './previewFixtures'
+
+function buildApi() {
+  const store = createPreviewStore({ conversations: PREVIEW_CONVERSATIONS, messages: PREVIEW_MESSAGES })
+  return createMockConversationsApi({ store })
+}
+
+async function search(term: string): Promise<{ total: number; conversations: string[] }> {
+  const page = await buildApi().getAllDocuments!({ search: term })
+  return { total: page.total, conversations: [...new Set(page.documents.map((document) => document.conversationId))] }
+}
+
+describe('busca da biblioteca no mock', () => {
+  it('acha por nome do arquivo', async () => {
+    const result = await search('contrato')
+
+    expect(result.total).toBe(1)
+  })
+
+  it('acha por telefone da conversa', async () => {
+    const porNumero = await search('94444')
+
+    expect(porNumero.conversations).toEqual(['5511944443333'])
+    expect(porNumero.total).toBeGreaterThan(0)
+    // Discrimina de verdade: 98888 é conversa que existe nas fixtures, mas sem arquivo — se o
+    // predicado do telefone não estivesse valendo, esta busca devolveria a biblioteca inteira.
+    expect((await search('98888')).total).toBe(0)
+  })
+
+  // O caso real: o atendente copia o número como a tela o mostra.
+  it('acha com o telefone formatado, como aparece na tela', async () => {
+    const cru = await search('5511944443333')
+    const formatado = await search('+55 (11) 94444-3333')
+
+    expect(formatado.total).toBe(cru.total)
+    expect(formatado.total).toBeGreaterThan(0)
+  })
+
+  it('não devolve nada para número de outra conversa', async () => {
+    expect((await search('99999999999')).total).toBe(0)
+  })
+
+  // Sem dígito, o predicado do telefone não existe — senão qualquer palavra casaria toda conversa.
+  it('termo sem dígito filtra só por nome', async () => {
+    expect((await search('zzz-inexistente')).total).toBe(0)
+  })
+})

package/src/preview/mockEventSource.ts

@@ -0,0 +1,53 @@
+/**
+ * `EventSource` só existe com um servidor HTTP do outro lado — é justamente o que falta quando se
+ * quer a inbox rodando com dados mockados. Este é o objeto mínimo que satisfaz
+ * `ConversationEventSource`: assina eventos nomeados, desassina e fecha.
+ *
+ * Não imita `EventSource` por completo de propósito: um fake "quase real" convida a depender de
+ * membros que o pacote não usa, e passa a quebrar a cada mudança de runtime.
+ */
+
+import type { ConversationEventSource } from '../providers/types'
+
+export type MockEventSource = ConversationEventSource & {
+  emit(event: string, payload: unknown): void
+  readonly closed: boolean
+}
+
+export function createMockEventSource(): MockEventSource {
+  const listeners = new Map<string, Set<(event: MessageEvent) => void>>()
+  let closed = false
+
+  return {
+    get closed(): boolean {
+      return closed
+    },
+
+    addEventListener(type: string, listener: (event: MessageEvent) => void): void {
+      const typeListeners = listeners.get(type) ?? new Set<(event: MessageEvent) => void>()
+      typeListeners.add(listener)
+      listeners.set(type, typeListeners)
+    },
+
+    removeEventListener(type: string, listener: (event: MessageEvent) => void): void {
+      listeners.get(type)?.delete(listener)
+    },
+
+    close(): void {
+      closed = true
+      listeners.clear()
+    },
+
+    emit(event: string, payload: unknown): void {
+      // Depois de fechado, emitir é no-op: o servidor real também não entrega em socket fechado, e
+      // silenciar aqui é o que faz vazamento de listener aparecer como bug de cleanup, não como
+      // evento fantasma na UI.
+      if (closed) return
+
+      // `data` é string no fio; entregar o objeto já parseado esconderia erro de serialização que
+      // aparece em produção.
+      const messageEvent = new MessageEvent(event, { data: JSON.stringify(payload) })
+      for (const listener of listeners.get(event) ?? []) listener(messageEvent)
+    },
+  }
+}