@lizzythelizard/whatsapp-mcp 0.1.3 → 0.1.5

package/src/index.ts

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import pkg from '../package.json' with { type: 'json' }
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { createStore, DataStore } from './store.js'
-import { createHandler } from './sync.js'
-import { promises as fsp } from 'fs'
-import { registerWhatsAppTools } from './tools.js'
-
-const dataDir = process.env.DATA_DIR ?? './data'
-
-async function readDataFromFile(): Promise<DataStore | undefined> {
-  const canAccess = await fsp.access(dataDir).then(() => true).catch(() => false)
-  if (!canAccess) return undefined
-  const chats = await fsp.readFile(`${dataDir}/chats.json`, 'utf-8')
-  const messages = await fsp.readFile(`${dataDir}/messages.json`, 'utf-8')
-  const contacts = await fsp.readFile(`${dataDir}/contacts.json`, 'utf-8')
-  const auth = await fsp.readFile(`${dataDir}/auth.json`, 'utf-8')
-  return { chats, messages, contacts, auth }
-}
-
-async function writeDataToFile(data: DataStore): Promise<void> {
-  await fsp.mkdir(dataDir, { recursive: true })
-  await fsp.writeFile(`${dataDir}/chats.json`, data.chats, 'utf-8')
-  await fsp.writeFile(`${dataDir}/messages.json`, data.messages, 'utf-8')
-  await fsp.writeFile(`${dataDir}/contacts.json`, data.contacts, 'utf-8')
-  await fsp.writeFile(`${dataDir}/auth.json`, data.auth, 'utf-8')
-}
-
-async function main() {
-  const server = new McpServer({ name: pkg.name, version: pkg.version })
-  const transport = new StdioServerTransport()
-  const inputData = await readDataFromFile()
-  const whatsappStore = createStore(writeDataToFile, inputData)
-  const whatsappSync = createHandler(whatsappStore)
-  registerWhatsAppTools(server, whatsappStore, whatsappSync)
-  await server.connect(transport)
-  console.info('whatsapp-mcp server running on stdio')
-}
-
-main().catch((error: unknown) => {
-  console.error('Server error:', error)
-  process.exit(1)
-})

package/src/store.test.ts

@@ -1,353 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { createStore, Emitter } from './store.js'
-import { createExportableAuth, ExportableAuthState } from './auth.js'
-import type { BaileysEventMap } from '@whiskeysockets/baileys'
-
-type EventHandler = (events: Partial<BaileysEventMap>) => void | Promise<void>
-
-function createMockEmitter(): (Emitter & { emit: (events: Partial<BaileysEventMap>) => void }) {
-  let handler: EventHandler | undefined
-  return {
-    process: vi.fn((h: EventHandler) => { handler = h }),
-    emit: (events: Partial<BaileysEventMap>) => { void handler?.(events) },
-  }
-}
-
-describe('createStore', () => {
-  it('starts with empty chats, contacts, messages', () => {
-    const store = createStore()
-    expect(store.getChats()).toEqual([])
-    expect(store.getContacts()).toEqual([])
-    expect(store.getMessages()).toEqual([])
-  })
-
-  it('loads initial data from DataStore', () => {
-    const store = createStore(undefined, {
-      chats: JSON.stringify([['c1', { id: 'c1', name: 'Chat' }]]),
-      contacts: JSON.stringify([['c1', { id: 'c1', name: 'Contact' }]]),
-      messages: JSON.stringify([['m1', { key: { id: 'm1', remoteJid: 'c1' }, message: { conversation: 'hi' } }]]),
-      auth: '',
-    })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getChat('c1')?.name).toBe('Chat')
-    expect(store.getContacts()).toHaveLength(1)
-    expect(store.getContact('c1')?.name).toBe('Contact')
-    expect(store.getMessages()).toHaveLength(1)
-    expect(store.getMessage('m1')?.message?.conversation).toBe('hi')
-  })
-
-  it('loads auth from initial data', () => {
-    const auth = createExportableAuth()
-    const store = createStore(undefined, {
-      chats: '', contacts: '', messages: '', auth: auth.toAuthState(),
-    })
-    expect(store.getAuth().creds.registrationId).toBe(auth.creds.registrationId)
-  })
-})
-
-describe('event processing', () => {
-  it('bind registers the process handler with ev.process', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    expect(ev.process).toHaveBeenCalledTimes(1)
-    expect(ev.process).toHaveBeenCalledWith(expect.any(Function))
-  })
-
-  it('processes messaging-history.set', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messaging-history.set': {
-        chats: [{ id: 'c1', name: 'Old Chat' }],
-        contacts: [{ id: 'c1', name: 'Old Contact' }],
-        messages: [{ key: { id: 'm1' }, message: { conversation: 'old' } }],
-      },
-    })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getContacts()).toHaveLength(1)
-    expect(store.getMessages()).toHaveLength(1)
-  })
-
-  it('processes chats.upsert — adds new chats', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'New Chat' }] })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getChat('c1')?.name).toBe('New Chat')
-  })
-
-  it('processes chats.upsert — merges into existing chats', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'First' }] })
-    ev.emit({ 'chats.upsert': [{ id: 'c1', archived: true }] })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getChat('c1')?.name).toBe('First')
-    expect(store.getChat('c1')?.archived).toBe(true)
-  })
-
-  it('processes chats.update — merges partial updates', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'Chat', archived: false }] })
-    ev.emit({ 'chats.update': [{ id: 'c1', archived: true }] })
-    expect(store.getChat('c1')?.archived).toBe(true)
-    expect(store.getChat('c1')?.name).toBe('Chat')
-  })
-
-  it('processes chats.delete — removes chats by id', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'One' }, { id: 'c2', name: 'Two' }] })
-    ev.emit({ 'chats.delete': ['c1'] })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getChat('c2')?.name).toBe('Two')
-  })
-
-  it('processes contacts.upsert — adds new contacts', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'contacts.upsert': [{ id: 'c1', name: 'Contact' }] })
-    expect(store.getContacts()).toHaveLength(1)
-    expect(store.getContact('c1')?.name).toBe('Contact')
-  })
-
-  it('processes contacts.update — merges partial updates', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'contacts.upsert': [{ id: 'c1', name: 'Old', status: 'away' }] })
-    ev.emit({ 'contacts.update': [{ id: 'c1', status: 'available' }] })
-    expect(store.getContact('c1')?.status).toBe('available')
-    expect(store.getContact('c1')?.name).toBe('Old')
-  })
-
-  it('processes messages.upsert — adds messages from .messages sub-property', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [{ key: { id: 'm1' }, message: { conversation: 'hello' } }],
-        type: 'notify',
-      },
-    })
-    expect(store.getMessages()).toHaveLength(1)
-    expect(store.getMessage('m1')?.message?.conversation).toBe('hello')
-  })
-
-  it('processes messages.update — merges the update wrapper (existing behavior)', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [{ key: { id: 'm1' }, message: { conversation: 'hi' } }],
-        type: 'notify',
-      },
-    })
-    ev.emit({
-      'messages.update': [{ key: { id: 'm1' }, update: { message: { conversation: 'updated' } } }],
-    })
-    const msg = store.getMessage('m1') as { message?: { conversation?: string }, update?: { message?: { conversation?: string } } }
-    expect(msg.message?.conversation).toBe('hi')
-    expect(msg.update?.message?.conversation).toBe('updated')
-  })
-
-  it('processes messages.delete with keys array', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [
-          { key: { id: 'm1' }, message: { conversation: 'a' } },
-          { key: { id: 'm2' }, message: { conversation: 'b' } },
-        ],
-        type: 'notify',
-      },
-    })
-    ev.emit({ 'messages.delete': { keys: [{ id: 'm1' }] } })
-    expect(store.getMessages()).toHaveLength(1)
-    expect(store.getMessage('m2')).toBeDefined()
-  })
-
-  it('processes messages.delete with jid', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [
-          { key: { id: 'm1', remoteJid: 'c1' } },
-          { key: { id: 'm2', remoteJid: 'c2' } },
-        ],
-        type: 'notify',
-      },
-    })
-    ev.emit({ 'messages.delete': { jid: 'c1', all: true } })
-    expect(store.getMessages()).toHaveLength(1)
-    expect(store.getMessage('m2')).toBeDefined()
-  })
-
-  it('skips chat without id in mergeChats', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ name: 'NoId' }] })
-    expect(store.getChats()).toHaveLength(0)
-  })
-
-  it('skips message without key.id in mergeMessages', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [{ key: { id: null }, message: { conversation: 'no key id' } }],
-        type: 'notify',
-      },
-    })
-    expect(store.getMessages()).toHaveLength(0)
-  })
-})
-
-describe('save callback', () => {
-  beforeEach(() => { vi.useFakeTimers() })
-  afterEach(() => { vi.useRealTimers() })
-
-  it('calls saveCb with serialized data after debounce', async () => {
-    const saveCb = vi.fn().mockResolvedValue(undefined)
-    const store = createStore(saveCb)
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'Chat' }] })
-    vi.advanceTimersByTime(1000)
-    await vi.waitFor(() => { expect(saveCb).toHaveBeenCalledTimes(1) })
-    const expected = expect.objectContaining({
-      chats: expect.any(String) as string,
-      contacts: expect.any(String) as string,
-      messages: expect.any(String) as string,
-      auth: expect.any(String) as string,
-    }) as Record<string, unknown>
-    expect(saveCb).toHaveBeenCalledWith(expected)
-  })
-
-  it('debounces multiple events into one save', async () => {
-    const saveCb = vi.fn().mockResolvedValue(undefined)
-    const store = createStore(saveCb)
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1', name: 'A' }] })
-    vi.advanceTimersByTime(500)
-    ev.emit({ 'chats.upsert': [{ id: 'c2', name: 'B' }] })
-    vi.advanceTimersByTime(1000)
-    await vi.waitFor(() => { expect(saveCb).toHaveBeenCalledTimes(1) })
-  })
-
-  it('error in saveCb is caught and does not throw', async () => {
-    const saveCb = vi.fn().mockRejectedValue(new Error('save failed'))
-    const store = createStore(saveCb)
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1' }] })
-    vi.advanceTimersByTime(1000)
-    await vi.waitFor(() => { expect(saveCb).toHaveBeenCalled() })
-  })
-})
-
-describe('getters', () => {
-  it('getChats returns all chats', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1' }, { id: 'c2' }] })
-    expect(store.getChats()).toHaveLength(2)
-  })
-
-  it('getChat returns undefined for missing id', () => {
-    expect(createStore().getChat('nonexistent')).toBeUndefined()
-  })
-
-  it('getContacts returns all contacts', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'contacts.upsert': [{ id: 'c1' }, { id: 'c2' }] })
-    expect(store.getContacts()).toHaveLength(2)
-  })
-
-  it('getContact returns undefined for missing id', () => {
-    expect(createStore().getContact('nonexistent')).toBeUndefined()
-  })
-
-  it('getMessages returns all messages', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messages.upsert': {
-        messages: [{ key: { id: 'm1' } }, { key: { id: 'm2' } }],
-        type: 'notify',
-      },
-    })
-    expect(store.getMessages()).toHaveLength(2)
-  })
-
-  it('getMessage returns undefined for missing id', () => {
-    expect(createStore().getMessage('nonexistent')).toBeUndefined()
-  })
-})
-
-describe('reset', () => {
-  it('clears all chats, contacts, messages', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({
-      'messaging-history.set': {
-        chats: [{ id: 'c1' }],
-        contacts: [{ id: 'c1' }],
-        messages: [{ key: { id: 'm1' } }],
-      },
-    })
-    store.reset()
-    expect(store.getChats()).toHaveLength(0)
-    expect(store.getContacts()).toHaveLength(0)
-    expect(store.getMessages()).toHaveLength(0)
-  })
-
-  it('resets auth to fresh state', () => {
-    const store = createStore()
-    store.reset()
-    expect(store.getAuth().creds).toBeDefined()
-  })
-
-  it('accepts new data after reset', () => {
-    const store = createStore()
-    const ev = createMockEmitter()
-    store.bind(ev)
-    ev.emit({ 'chats.upsert': [{ id: 'c1' }] })
-    store.reset()
-    ev.emit({ 'chats.upsert': [{ id: 'c2' }] })
-    expect(store.getChats()).toHaveLength(1)
-    expect(store.getChat('c2')).toBeDefined()
-  })
-})
-
-describe('getAuth', () => {
-  it('returns the internal auth state', () => {
-    const store = createStore()
-    const auth = store.getAuth() as ExportableAuthState
-    expect(auth.creds).toBeDefined()
-    expect(auth.keys).toBeDefined()
-    expect(typeof auth.toAuthState).toBe('function')
-  })
-})

package/src/store.ts

@@ -1,182 +0,0 @@
-import { AuthenticationState, BaileysEventMap, BufferJSON, Chat, Contact, WAMessage, WAMessageKey } from '@whiskeysockets/baileys'
-import { createExportableAuth } from './auth.js'
-
-export interface ChatWithId extends Chat {
-  id: string
-}
-
-export interface ContactWithId extends Contact {
-  id: string
-}
-
-export interface MessageWithId extends WAMessage {
-  key: WAMessageKey & { id: string }
-}
-
-export interface Emitter {
-  process: (processor: (e: Partial<BaileysEventMap>) => void) => void
-}
-
-export interface WhatsAppStore {
-  bind: (ev: Emitter) => void
-  getChats: () => ChatWithId[]
-  getChat: (id: string) => ChatWithId | undefined
-  getContacts: () => ContactWithId[]
-  getContact: (id: string) => ContactWithId | undefined
-  getMessages: () => MessageWithId[]
-  getMessage: (id: string) => MessageWithId | undefined
-  reset: () => void
-  getAuth: () => AuthenticationState
-}
-
-export interface DataStore {
-  chats: string
-  contacts: string
-  messages: string
-  auth: string
-}
-
-function fromString<T>(data: string | undefined): Map<string, T> {
-  if (!data) return new Map<string, T>()
-  const parsed = JSON.parse(data) as [string, T][]
-  return new Map<string, T>(parsed)
-}
-
-function toString<T>(map: Map<string, T>): string {
-  return JSON.stringify(map, BufferJSON.replacer)
-}
-
-export function createStore(saveCb?: (data: DataStore) => Promise<void>, initialData?: DataStore): WhatsAppStore {
-  // TODO: Load initial states from somewhere
-  const chats = fromString<ChatWithId>(initialData?.chats)
-  const contacts = fromString<ContactWithId>(initialData?.contacts)
-  const messages = fromString<MessageWithId>(initialData?.messages)
-  let auth = createExportableAuth(initialData?.auth)
-  let saveTimeout: NodeJS.Timeout | undefined = undefined
-
-  function mergeChats(newChats: Partial<Chat>[]) {
-    for (const c of newChats) {
-      if (!c.id) continue
-      const existing = chats.get(c.id) ?? {}
-      const merged = { ...existing, ...c } as ChatWithId
-      chats.set(c.id, merged)
-    }
-  }
-
-  function deleteChats(ids: string[]) {
-    for (const id of ids) {
-      chats.delete(id)
-    }
-  }
-
-  function mergeContacts(newContacts: Partial<Contact>[]) {
-    for (const c of newContacts) {
-      if (!c.id) continue
-      const existing = contacts.get(c.id) ?? {}
-      const merged = { ...existing, ...c } as ContactWithId
-      contacts.set(c.id, merged)
-    }
-  }
-
-  function mergeMessages(newMessages: Partial<WAMessage>[]) {
-    for (const m of newMessages) {
-      if (!m.key?.id) continue
-      const existing = messages.get(m.key.id) ?? {}
-      const merged = { ...existing, ...m } as MessageWithId
-      messages.set(m.key.id, merged)
-    }
-  }
-
-  function deleteMessages(keys: WAMessageKey[]) {
-    for (const key of keys) {
-      if (!key.id) continue
-      messages.delete(key.id)
-    }
-  }
-
-  function deleteMessage(jid: string) {
-    for (const [id, m] of messages.entries()) {
-      if (m.key.remoteJid === jid) {
-        messages.delete(id)
-      }
-    }
-  }
-
-  function save() {
-    if (!saveCb) return
-    const data: DataStore = {
-      chats: toString(chats),
-      contacts: toString(contacts),
-      messages: toString(messages),
-      auth: auth.toAuthState(),
-    }
-    void saveCb(data).catch((error: unknown) => {
-      console.error('Error saving WhatsApp store data:', error)
-    })
-  }
-
-  function process(e: Partial<BaileysEventMap>) {
-    // Store data if no new events come in for 1 second
-    if (saveTimeout) clearTimeout(saveTimeout)
-    if (saveCb) saveTimeout = setTimeout(save, 1000)
-    for (const key of Object.keys(e) as (keyof BaileysEventMap)[]) {
-      try {
-        switch (key) {
-          case 'messaging-history.set':
-            mergeChats(e[key]?.chats ?? [])
-            mergeContacts(e[key]?.contacts ?? [])
-            mergeMessages(e[key]?.messages ?? [])
-            break
-          case 'chats.delete':
-            deleteChats(e[key] ?? [])
-            break
-          case 'chats.update':
-          case 'chats.upsert':
-            mergeChats(e[key] ?? [])
-            break
-          case 'contacts.update':
-          case 'contacts.upsert':
-            mergeContacts(e[key] ?? [])
-            break
-          case 'messages.delete':
-            if (!e[key]) break
-            if ('keys' in e[key])
-              deleteMessages(e[key].keys)
-            else
-              deleteMessage(e[key].jid)
-            break
-          case 'messages.update':
-            mergeMessages(e[key] ?? [])
-            break
-          case 'messages.upsert':
-            mergeMessages(e[key]?.messages ?? [])
-            break
-        }
-      }
-      catch (error) {
-        handleError(error)
-      }
-    }
-  }
-
-  function handleError(error: unknown) {
-    console.error(`Error processing WhatsApp store event: ${error instanceof Error ? error.message : String(error)}`)
-  }
-
-  return {
-    bind: (ev) => { ev.process(process) },
-    getChats: () => Array.from(chats.values()),
-    getChat: id => chats.get(id),
-    getContacts: () => Array.from(contacts.values()),
-    getContact: id => contacts.get(id),
-    getMessages: () => Array.from(messages.values()),
-    getMessage: id => messages.get(id),
-    reset: () => {
-      chats.clear()
-      contacts.clear()
-      messages.clear()
-      auth = createExportableAuth(undefined)
-    },
-    getAuth: () => auth,
-  }
-}