@lizzythelizard/whatsapp-mcp 0.1.3 → 0.1.5

package/src/sync.test.ts

@@ -1,304 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-
-const mockMakeWASocket = vi.hoisted(() => vi.fn())
-
-vi.mock('@whiskeysockets/baileys', async (importOriginal) => {
-  const actual: object = await importOriginal()
-  return { ...actual, default: mockMakeWASocket, makeWASocket: mockMakeWASocket }
-})
-
-import { createHandler } from './sync.js'
-import { createStore } from './store.js'
-
-function createStoreMockEmitter() {
-  return { process: vi.fn() }
-}
-
-function newMockSocket() {
-  return {
-    ev: {
-      on: vi.fn(),
-      process: vi.fn(),
-    },
-    end: vi.fn().mockResolvedValue(undefined),
-    sendMessage: vi.fn().mockResolvedValue({ key: { id: 'mock', remoteJid: 'test' }, message: { conversation: 'ok' } }),
-    chatModify: vi.fn().mockResolvedValue(undefined),
-  }
-}
-
-function getConnectionUpdateHandler(socket: ReturnType<typeof newMockSocket>): ((update: Record<string, unknown>) => void) | undefined {
-  const call = (socket.ev.on.mock.calls as [string, (update: Record<string, unknown>) => void][])
-    .find(([name]) => name === 'connection.update')
-  return call?.[1]
-}
-
-function emitConnectionUpdate(update: Record<string, unknown>) {
-  const results = mockMakeWASocket.mock.results as { value: ReturnType<typeof newMockSocket>, type: string }[]
-  if (results.length === 0) return
-  const socket = results[results.length - 1].value
-  const handler = getConnectionUpdateHandler(socket)
-  if (handler) handler(update)
-}
-
-function getLatestSocket(): ReturnType<typeof newMockSocket> {
-  const results = mockMakeWASocket.mock.results as { value: ReturnType<typeof newMockSocket>, type: string }[]
-  return results[results.length - 1].value
-}
-
-beforeEach(() => {
-  mockMakeWASocket.mockReset()
-  mockMakeWASocket.mockReturnValue(newMockSocket())
-})
-
-describe('createHandler', () => {
-  it('initial state is connecting', () => {
-    const handler = createHandler(createStore())
-    expect(handler.getStatus()).toEqual({ type: 'connecting' })
-  })
-
-  it('transitions to needAuth on QR', () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ qr: 'base64qr===' })
-    expect(handler.getStatus()).toEqual({ type: 'needAuth', qr: 'base64qr===' })
-  })
-
-  it('transitions to ready on connection open', () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'open' })
-    expect(handler.getStatus()).toEqual({ type: 'ready' })
-  })
-
-  it('transitions to closed on connection close without error', () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'close' })
-    expect(handler.getStatus()).toEqual({ type: 'closed' })
-  })
-
-  it('transitions to closed with error on connection close with error', () => {
-    const handler = createHandler(createStore())
-    const error = new Error('generic failure')
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(handler.getStatus()).toEqual({ type: 'closed', error })
-  })
-
-  it('ignores intermediate connection updates', () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'connecting' })
-    expect(handler.getStatus()).toEqual({ type: 'connecting' })
-  })
-})
-
-describe('error handling', () => {
-  it('handles 401 error by resetting store and restarting', () => {
-    const store = createStore()
-    const handler = createHandler(store)
-    const error = Object.assign(new Error('auth failed'), { output: { statusCode: 401 } })
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(handler.getStatus()).toEqual({ type: 'connecting' })
-    expect(mockMakeWASocket).toHaveBeenCalledTimes(2)
-  })
-
-  it('handles 515 error by resetting store and restarting with re-login', () => {
-    const store = createStore()
-    const handler = createHandler(store)
-    const error = Object.assign(new Error('reconnect needed'), { output: { statusCode: 515 } })
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(handler.getStatus()).toEqual({ type: 'connecting' })
-    expect(mockMakeWASocket).toHaveBeenCalledTimes(2)
-  })
-
-  it('non-401/515 error stays closed with error', () => {
-    const handler = createHandler(createStore())
-    const error = Object.assign(new Error('other error'), { output: { statusCode: 500 } })
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(handler.getStatus()).toEqual({ type: 'closed', error })
-  })
-
-  it('plain Error without output does not trigger reconnection', () => {
-    const handler = createHandler(createStore())
-    const error = new Error('no output property')
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(handler.getStatus()).toEqual({ type: 'closed', error })
-  })
-
-  it('non-Error value falls through to closed with the value as error', () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error: 'string error' } })
-    expect(handler.getStatus().type).toBe('closed')
-    expect(handler.getStatus()).toHaveProperty('error', 'string error')
-  })
-
-  it('401 error resets store data', () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    createHandler(store)
-    ev.process.mockClear()
-    const error = Object.assign(new Error('auth'), { output: { statusCode: 401 } })
-    emitConnectionUpdate({ connection: 'close', lastDisconnect: { error } })
-    expect(store.getChats()).toHaveLength(0)
-  })
-})
-
-describe('getStatus', () => {
-  it('returns the current state', () => {
-    const store = createStore()
-    const handler = createHandler(store)
-    expect(handler.getStatus().type).toBe('connecting')
-    emitConnectionUpdate({ connection: 'open' })
-    expect(handler.getStatus().type).toBe('ready')
-  })
-})
-
-describe('sendMessage', () => {
-  it('throws when state is connecting', async () => {
-    const handler = createHandler(createStore())
-    await expect(handler.sendMessage('test@s.whatsapp.net', 'hello')).rejects.toThrow('Server still connecting')
-  })
-
-  it('throws when state is closed', async () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'close' })
-    await expect(handler.sendMessage('test@s.whatsapp.net', 'hello')).rejects.toThrow('Connection closed')
-  })
-
-  it('throws when state is needAuth', async () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ qr: 'qr' })
-    await expect(handler.sendMessage('test@s.whatsapp.net', 'hello')).rejects.toThrow('Authentication needed')
-  })
-
-  it('calls sock.sendMessage when ready', async () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'open' })
-    const socket = getLatestSocket()
-    const result = await handler.sendMessage('test@s.whatsapp.net', 'Hello!')
-    expect(socket.sendMessage).toHaveBeenCalledWith('test@s.whatsapp.net', { text: 'Hello!' })
-    expect(result).toBeDefined()
-  })
-
-  it('throws when sock.sendMessage returns null', async () => {
-    const handler = createHandler(createStore())
-    getLatestSocket().sendMessage.mockResolvedValue(null)
-    emitConnectionUpdate({ connection: 'open' })
-    await expect(handler.sendMessage('test@s.whatsapp.net', 'hi')).rejects.toThrow('Failed to send message')
-  })
-})
-
-describe('setArchived', () => {
-  it('throws when state is connecting', async () => {
-    const handler = createHandler(createStore())
-    await expect(handler.setArchived('test@s.whatsapp.net', true)).rejects.toThrow('Server still connecting')
-  })
-
-  it('throws when chat is not found', async () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'open' })
-    await expect(handler.setArchived('unknown@s.whatsapp.net', true)).rejects.toThrow('No chat found')
-  })
-
-  it('calls chatModify with empty lastMessages when chat has no last message', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net' })
-    const socket = getLatestSocket()
-    await handler.setArchived('test@s.whatsapp.net', true)
-    expect(socket.chatModify).toHaveBeenCalledWith(
-      { archive: true, lastMessages: [] },
-      'test@s.whatsapp.net',
-    )
-  })
-
-  it('throws when last message has no key', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net', messages: [{ message: {} }] })
-    await expect(handler.setArchived('test@s.whatsapp.net', true)).rejects.toThrow('has no key')
-  })
-
-  it('calls chatModify with archive and last message when valid', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    const lastMsg = { key: { id: 'last', remoteJid: 'test@s.whatsapp.net' }, message: { conversation: 'bye' } }
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net', messages: [{ message: lastMsg }] })
-    const socket = getLatestSocket()
-    await handler.setArchived('test@s.whatsapp.net', true)
-    expect(socket.chatModify).toHaveBeenCalledWith(
-      { archive: true, lastMessages: [lastMsg] },
-      'test@s.whatsapp.net',
-    )
-  })
-})
-
-describe('setRead', () => {
-  it('throws when state is connecting', async () => {
-    const handler = createHandler(createStore())
-    await expect(handler.setRead('test@s.whatsapp.net', true)).rejects.toThrow('Server still connecting')
-  })
-
-  it('throws when chat is not found', async () => {
-    const handler = createHandler(createStore())
-    emitConnectionUpdate({ connection: 'open' })
-    await expect(handler.setRead('unknown@s.whatsapp.net', true)).rejects.toThrow('No chat found')
-  })
-
-  it('calls chatModify with empty lastMessages when chat has no last message', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net' })
-    const socket = getLatestSocket()
-    await handler.setRead('test@s.whatsapp.net', true)
-    expect(socket.chatModify).toHaveBeenCalledWith(
-      { markRead: true, lastMessages: [] },
-      'test@s.whatsapp.net',
-    )
-  })
-
-  it('throws when last message has no key', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net', messages: [{ message: {} }] })
-    await expect(handler.setRead('test@s.whatsapp.net', true)).rejects.toThrow('has no key')
-  })
-
-  it('calls chatModify with markRead and last message when valid', async () => {
-    const store = createStore()
-    const ev = createStoreMockEmitter()
-    store.bind(ev)
-    const handler = createHandler(store)
-    emitConnectionUpdate({ connection: 'open' })
-    const lastMsg = { key: { id: 'last', remoteJid: 'test@s.whatsapp.net' }, message: { conversation: 'hi' } }
-    store.getChat = vi.fn().mockReturnValue({ id: 'test@s.whatsapp.net', messages: [{ message: lastMsg }] })
-    const socket = getLatestSocket()
-    await handler.setRead('test@s.whatsapp.net', true)
-    expect(socket.chatModify).toHaveBeenCalledWith(
-      { markRead: true, lastMessages: [lastMsg] },
-      'test@s.whatsapp.net',
-    )
-  })
-})
-
-describe('close', () => {
-  it('sets state to closed and calls sock.end', () => {
-    const handler = createHandler(createStore())
-    const socket = getLatestSocket()
-    handler.close()
-    expect(socket.end).toHaveBeenCalled()
-    expect(handler.getStatus()).toEqual({ type: 'closed' })
-  })
-})

package/src/sync.ts

@@ -1,170 +0,0 @@
-import makeWASocket, { WABrowserDescription, ConnectionState, WAMessage, proto } from '@whiskeysockets/baileys'
-import { createStore } from './store.js'
-
-export type SyncStatus = { type: 'connecting' } | { type: 'needAuth', qr: string } | { type: 'ready' } | { type: 'closed', error?: Error }
-
-export interface WhatsAppHandler {
-  close: () => void
-  getStatus: () => SyncStatus
-  sendMessage: (jid: string, text: string) => Promise<WAMessage>
-  setRead: (jid: string, read: boolean) => Promise<void>
-  setArchived: (jid: string, archived: boolean) => Promise<void>
-}
-
-export function createHandler(store: ReturnType<typeof createStore>): WhatsAppHandler {
-  let state: SyncStatus = { type: 'connecting' }
-  let sock: ReturnType<typeof makeWASocket> | undefined
-  const browser = ['Gutschi.site', 'Desktop', '1.0.0'] as WABrowserDescription
-
-  function onError(error: unknown): void {
-    const arg = error instanceof Error ? error : new Error(String(error))
-    console.error(`Closing WhatsApp sync due to error ${arg}`)
-    close(arg)
-  }
-
-  function close(error?: Error): void {
-    if (sock) {
-      const sockCpy = sock
-      sock = undefined
-      sockCpy.end(error).catch(onClosed)
-    }
-    state = { type: 'closed', error }
-  }
-
-  function onClosed(error?: Error): void {
-    if (!error) {
-      console.log(`WhatsApp sync connection closed without error`)
-      state = { type: 'closed' }
-      return
-    }
-    if (isInvalidAuthError(error)) {
-      console.warn(`WhatsApp sync requires re-authentication due to invalid auth state`)
-      store.reset()
-      start()
-      return
-    }
-    if (isRequiredReconnectError(error)) {
-      console.log(`WhatsApp sync connection closed due to required reconnect`)
-      store.reset()
-      startAgainAfterLogin()
-      return
-    }
-    state = { type: 'closed', error }
-  }
-
-  function start() {
-    sock = makeWASocket({ auth: store.getAuth(), browser, logger: baileysLogger, markOnlineOnConnect: false, syncFullHistory: true, emitOwnEvents: true })
-    sock.ev.on('connection.update', (update) => {
-      connectionUpdate(update, onClosed,
-        qr => state = { type: 'needAuth', qr },
-        () => state = { type: 'ready' })
-    },
-    )
-    store.bind(sock.ev)
-  }
-
-  function startAgainAfterLogin() {
-    sock = makeWASocket({ auth: store.getAuth(), browser, logger: baileysLogger, markOnlineOnConnect: false, syncFullHistory: true, emitOwnEvents: true })
-    sock.ev.on('connection.update', (update) => { connectionUpdateAfterLogin(update, onClosed, onError) })
-    // wait untill no new messages are received for 2 seconds, then set state to ready
-    let timeout = setTimeout(() => state = { type: 'ready' }, 2000)
-    sock.ev.process(() => {
-      clearTimeout(timeout)
-      timeout = setTimeout(() => state = { type: 'ready' }, 2000)
-    })
-    store.bind(sock.ev)
-  }
-
-  async function sendMessage(jid: string, message: string): Promise<WAMessage> {
-    if (state.type === 'connecting') throw new Error('Server still connecting, please wait')
-    if (state.type === 'closed') throw new Error('Connection closed, please restart server')
-    if (state.type === 'needAuth') throw new Error('Authentication needed, please authenticate yourself first')
-    if (sock === undefined) throw new Error(`No Socket defined but state is ${state.type}. This is invalid, please restart server`)
-    const result = await sock.sendMessage(jid, { text: message })
-    if (!result) throw new Error(`Failed to send message to ${jid}`)
-    return result
-  }
-
-  async function setArchived(jid: string, archived: boolean): Promise<void> {
-    if (state.type === 'connecting') throw new Error('Server still connecting, please wait')
-    if (state.type === 'closed') throw new Error('Connection closed, please restart server')
-    if (state.type === 'needAuth') throw new Error('Authentication needed, please authenticate yourself first')
-    if (sock === undefined) throw new Error(`No Socket defined but state is ${state.type}. This is invalid, please restart server`)
-    const chat = store.getChat(jid)
-    if (!chat) throw new Error(`No chat found for ${jid}`)
-    const lastMessage = chat.messages?.[0].message
-    if (!lastMessage) {
-      await sock.chatModify({ archive: archived, lastMessages: [] }, jid)
-      return
-    }
-    if (!lastMessage.key) throw new Error(`Last message for ${jid} has no key, cannot archive chat`)
-    await sock.chatModify({ archive: archived, lastMessages: [lastMessage as proto.IWebMessageInfo & { key: typeof lastMessage.key }] }, jid)
-  }
-
-  async function setRead(jid: string, read: boolean): Promise<void> {
-    if (state.type === 'connecting') throw new Error('Server still connecting, please wait')
-    if (state.type === 'closed') throw new Error('Connection closed, please restart server')
-    if (state.type === 'needAuth') throw new Error('Authentication needed, please authenticate yourself first')
-    if (sock === undefined) throw new Error(`No Socket defined but state is ${state.type}. This is invalid, please restart server`)
-    const chat = store.getChat(jid)
-    if (!chat) throw new Error(`No chat found for ${jid}`)
-    const lastMessage = chat.messages?.[0].message
-    if (!lastMessage) {
-      await sock.chatModify({ markRead: read, lastMessages: [] }, jid)
-      return
-    }
-    if (!lastMessage.key) throw new Error(`Last message for ${jid} has no key, cannot mark chat as unread`)
-    await sock.chatModify({ markRead: read, lastMessages: [lastMessage as proto.IWebMessageInfo & { key: typeof lastMessage.key }] }, jid)
-  }
-  start()
-
-  return {
-    getStatus: () => state,
-    sendMessage: sendMessage,
-    setArchived: setArchived,
-    setRead: setRead,
-    close: close,
-  }
-}
-
-const baileysLogger = {
-  level: 'error',
-  child: () => baileysLogger,
-  trace: () => { /* empty */ },
-  debug: () => { /* empty */ },
-  info: () => { /* empty */ },
-  warn: () => { /* empty */ },
-  error: () => { /* empty */ },
-}
-
-function connectionUpdate(update: Partial<ConnectionState>, onClose: (error?: Error) => void, onQr?: (qr: string) => void, onReady?: () => void): void {
-  if (update.qr) onQr?.(update.qr)
-  else if (update.connection === 'open') onReady?.()
-  else if (update.connection !== 'close') { /* do nothing, wait for next update */ }
-  else onClose(update.lastDisconnect?.error)
-}
-
-function isInvalidAuthError(error: unknown): boolean {
-  if (!(error instanceof Error)) return false
-  if (!('output' in error)) return false
-  if (typeof error.output !== 'object' || error.output === null) return false
-  if (!('statusCode' in error.output)) return false
-  if (error.output.statusCode !== 401) return false
-  return true
-}
-
-function isRequiredReconnectError(error: unknown): boolean {
-  if (!(error instanceof Error)) return false
-  if (!('output' in error)) return false
-  if (typeof error.output !== 'object' || error.output === null) return false
-  if (!('statusCode' in error.output)) return false
-  if (error.output.statusCode !== 515) return false
-  return true
-}
-
-function connectionUpdateAfterLogin(update: Partial<ConnectionState>, onClose: (error?: Error) => void, onErr: (error: Error) => void): void {
-  if (update.qr) onErr(new Error('Received QR code update during WhatsApp sync after login'))
-  else if (update.connection === 'open') { /* do nothing, wait for next update */ }
-  else if (update.connection !== 'close') { /* do nothing, wait for next update */ }
-  else onClose(update.lastDisconnect?.error)
-}