@lizzythelizard/whatsapp-mcp 0.1.3 → 0.1.5

package/src/tools.test.ts

@@ -1,254 +0,0 @@
-import { describe, it, expect, vi, Mock } from 'vitest'
-import { z } from 'zod'
-import { registerWhatsAppTools } from './tools.js'
-import type { WhatsAppStore } from './store.js'
-import type { WhatsAppHandler } from './sync.js'
-import type { CallToolResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types'
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp'
-
-function createMockServer(): McpServer & { registerResource: Mock, registerTool: Mock } {
-  return {
-    registerResource: vi.fn(),
-    registerTool: vi.fn(),
-  } as McpServer & { registerResource: Mock, registerTool: Mock }
-}
-
-function createMockStore(): WhatsAppStore {
-  return {
-    bind: vi.fn(),
-    getChats: vi.fn().mockReturnValue([]),
-    getChat: vi.fn().mockReturnValue(undefined),
-    getContacts: vi.fn().mockReturnValue([]),
-    getContact: vi.fn().mockReturnValue(undefined),
-    getMessages: vi.fn().mockReturnValue([]),
-    getMessage: vi.fn().mockReturnValue(undefined),
-    reset: vi.fn(),
-    getAuth: vi.fn(),
-  }
-}
-
-function createMockSync(): WhatsAppHandler {
-  return {
-    close: vi.fn(),
-    getStatus: vi.fn(),
-    sendMessage: vi.fn(),
-    setArchived: vi.fn(),
-    setRead: vi.fn(),
-  }
-}
-
-describe('registerWhatsAppTools', () => {
-  it('registers resources and tools on the server', () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    registerWhatsAppTools(server, store, sync)
-    expect(server.registerResource).toHaveBeenCalled()
-    expect(server.registerTool).toHaveBeenCalled()
-  })
-
-  it('registers 5 resources (chats, chat, contacts, contact, messages, message)', () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    registerWhatsAppTools(server, store, sync)
-    expect(server.registerResource).toHaveBeenCalledTimes(6)
-  })
-
-  it('registers 3 tools (send_message, set_chat_archived, set_chat_read)', () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    registerWhatsAppTools(server, store, sync)
-    expect(server.registerTool).toHaveBeenCalledTimes(3)
-  })
-})
-
-describe('send_message handler', () => {
-  it('calls sync.sendMessage with jid and message', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(sync.sendMessage).mockResolvedValue({
-      key: { id: 'm1', remoteJid: 'user@s.whatsapp.net' },
-      message: { conversation: 'Hello!' },
-    })
-
-    registerWhatsAppTools(server, store, sync)
-    const sendMessageTool = server.registerTool.mock.calls.find((c: string[]) => c[0] === 'send_message')
-    const handler = sendMessageTool?.[2] as (input: { jid: string, message: string }) => Promise<CallToolResult>
-
-    const result: CallToolResult = await handler({ jid: 'user@s.whatsapp.net', message: 'Hello!' })
-    expect(sync.sendMessage).toHaveBeenCalledWith('user@s.whatsapp.net', 'Hello!')
-    expect(result.isError).toBe(false)
-    expect(result.content[0]).toEqual({ text: 'Message sent to user@s.whatsapp.net: "Hello!"', type: 'text' })
-  })
-
-  it('returns error result when sync.sendMessage fails', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(sync.sendMessage).mockRejectedValue(new Error('connection lost'))
-
-    registerWhatsAppTools(server, store, sync)
-    const sendMessageTool = server.registerTool.mock.calls.find((c: string[]) => c[0] === 'send_message')
-    const handler = sendMessageTool?.[2] as (input: { jid: string, message: string }) => Promise<CallToolResult>
-
-    const result: CallToolResult = await handler({ jid: 'user@s.whatsapp.net', message: 'Hello!' })
-    expect(result.isError).toBe(true)
-    expect(result.content[0]).toEqual({ text: 'Error: connection lost', type: 'text' })
-  })
-})
-
-describe('set_chat_archived handler', () => {
-  it('calls sync.setArchived with jid and archived', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(sync.setArchived).mockResolvedValue(undefined)
-
-    registerWhatsAppTools(server, store, sync)
-    const tool = server.registerTool.mock.calls.find((c: string[]) => c[0] === 'set_chat_archived')
-    const handler = tool?.[2] as (input: { jid: string, archived: boolean }) => Promise<CallToolResult>
-
-    const result: CallToolResult = await handler({ jid: 'user@s.whatsapp.net', archived: true })
-    expect(sync.setArchived).toHaveBeenCalledWith('user@s.whatsapp.net', true)
-    expect(result.isError).toBe(false)
-  })
-
-  it('returns error when sync.setArchived fails', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(sync.setArchived).mockRejectedValue(new Error('no chat'))
-
-    registerWhatsAppTools(server, store, sync)
-    const tool = server.registerTool.mock.calls.find((c: string[]) => c[0] === 'set_chat_archived')
-    const handler = tool?.[2] as (input: { jid: string, archived: boolean }) => Promise<CallToolResult>
-
-    const result: CallToolResult = await handler({ jid: 'user@s.whatsapp.net', archived: false })
-    expect(result.isError).toBe(true)
-    expect(result.content[0]).toEqual({ text: 'Error: no chat', type: 'text' })
-  })
-})
-
-describe('set_chat_read handler', () => {
-  it('calls sync.setRead with jid and read', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(sync.setRead).mockResolvedValue(undefined)
-
-    registerWhatsAppTools(server, store, sync)
-    const tool = server.registerTool.mock.calls.find((c: string[]) => c[0] === 'set_chat_read')
-    const handler = tool?.[2] as (input: { jid: string, read: boolean }) => Promise<CallToolResult>
-
-    const result: CallToolResult = await handler({ jid: 'user@s.whatsapp.net', read: true })
-    expect(sync.setRead).toHaveBeenCalledWith('user@s.whatsapp.net', true)
-    expect(result.isError).toBe(false)
-  })
-})
-
-describe('resource handlers', () => {
-  it('chats resource handler returns store.getChats() as content', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getChats).mockReturnValue([{ id: 'c1', name: 'Chat1' }])
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'chats')
-    const handler = call?.[3] as () => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler()
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('chats://app/c1')
-  })
-
-  it('single chat resource handler returns store.getChat(chatId)', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getChat).mockReturnValue({ id: 'c1', name: 'Found' })
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'chat')
-    const handler = call?.[3] as (input: undefined, params: { chatId: string }) => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler(undefined, { chatId: 'c1' })
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('chats://app/c1')
-  })
-
-  it('contacts resource handler returns store.getContacts()', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getContacts).mockReturnValue([{ id: 'c1', name: 'Contact1' }])
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'contacts')
-    const handler = call?.[3] as () => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler()
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('contacts://app/c1')
-  })
-
-  it('single contact resource handler returns store.getContact(contactId)', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getContact).mockReturnValue({ id: 'c1', name: 'Found' })
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'contact')
-    const handler = call?.[3] as (input: undefined, params: { contactId: string }) => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler(undefined, { contactId: 'c1' })
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('contacts://app/c1')
-  })
-
-  it('messages resource handler returns store.getMessages()', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getMessages).mockReturnValue([{ key: { id: 'm1' }, message: { conversation: 'hi' } }])
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'messages')
-    const handler = call?.[3] as () => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler()
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('messages://app/m1')
-  })
-
-  it('single message resource handler returns store.getMessage(messageId)', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-    const sync = createMockSync()
-    vi.mocked(store.getMessage).mockReturnValue({ key: { id: 'm1' }, message: { conversation: 'found' } })
-
-    registerWhatsAppTools(server, store, sync)
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'message')
-    const handler = call?.[3] as (input: undefined, params: { messageId: string }) => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler(undefined, { messageId: 'm1' })
-    expect(result.contents).toHaveLength(1)
-    expect(result.contents[0].uri).toBe('messages://app/m1')
-  })
-
-  it('resource returns empty array when no data exists', async () => {
-    const server = createMockServer()
-    const store = createMockStore()
-
-    registerWhatsAppTools(server, store, createMockSync())
-    const call = server.registerResource.mock.calls.find((c: string[]) => c[0] === 'chats')
-    const handler = call?.[3] as () => Promise<ReadResourceResult>
-
-    const result: ReadResourceResult = await handler()
-    expect(result.contents).toEqual([])
-  })
-})

package/src/tools.ts

@@ -1,132 +0,0 @@
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp'
-import { ChatWithId, ContactWithId, MessageWithId, WhatsAppStore } from './store.js'
-import { WhatsAppHandler } from './sync.js'
-import { CallToolResult, ListResourcesResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types'
-import z from 'zod'
-import { WAMessage } from '@whiskeysockets/baileys'
-
-export function registerWhatsAppTools(server: McpServer, store: WhatsAppStore, sync: WhatsAppHandler) {
-  registerChatsResources(server, store)
-  registerContactsResources(server, store)
-  registerMessagesResources(server, store)
-  registerMessageTools(server, sync)
-  registerChatTools(server, sync)
-}
-
-function registerChatsResources(server: McpServer, store: WhatsAppStore) {
-  server.registerResource(
-    'chats',
-    'chats://app',
-    { title: 'All WhatsApp Chats', description: 'List WhatsApp chats', mimeType: 'application/json' },
-    () => toReadResource(store.getChats().flatMap(chatToReadResource)))
-  server.registerResource(
-    'chat',
-    new ResourceTemplate('chats://app/{chatId}', { list: () => toListResource(store.getChats().flatMap(chatToListResource)) }),
-    { title: 'A single WhatsApp Chat', description: 'Details of a single WhatsApp chat', mimeType: 'application/json' },
-    (_, { chatId }) => toReadResource(chatToReadResource(store.getChat(chatId as string))))
-}
-
-const chatToReadResource = (chat: ChatWithId | undefined) => chat
-  ? [{ uri: `chats://app/${chat.id}`, mimeType: 'application/json', text: JSON.stringify(chat) }]
-  : []
-
-const chatToListResource = (chat: ChatWithId | undefined) => chat
-  ? [{ uri: `chats://app/${chat.id}`, name: chat.name ?? chat.id }]
-  : []
-
-function registerContactsResources(server: McpServer, store: WhatsAppStore) {
-  server.registerResource(
-    'contacts',
-    'contacts://app',
-    { title: 'All WhatsApp Contacts', description: 'List WhatsApp contacts', mimeType: 'application/json' },
-    () => toReadResource(store.getContacts().flatMap(contactToReadResource)))
-  server.registerResource(
-    'contact',
-    new ResourceTemplate('contacts://app/{contactId}', { list: () => toListResource(store.getContacts().flatMap(contactToListResource)) }),
-    { title: 'A single WhatsApp Contact', description: 'Details of a single WhatsApp contact', mimeType: 'application/json' },
-    (_, { contactId }) => toReadResource(contactToReadResource(store.getContact(contactId as string))))
-}
-
-const contactToReadResource = (contact: ContactWithId | undefined) => contact
-  ? [{ uri: `contacts://app/${contact.id}`, mimeType: 'application/json', text: JSON.stringify(contact) }]
-  : []
-
-const contactToListResource = (contact: ContactWithId | undefined) => contact
-  ? [{ uri: `contacts://app/${contact.id}`, name: contact.name ?? contact.id }]
-  : []
-
-function registerMessagesResources(server: McpServer, store: WhatsAppStore) {
-  server.registerResource(
-    'messages',
-    'messages://app',
-    { title: 'All WhatsApp Messages', description: 'List WhatsApp messages', mimeType: 'application/json' },
-    () => toReadResource(store.getMessages().flatMap(messageToReadResource)))
-  server.registerResource(
-    'message',
-    new ResourceTemplate('messages://app/{messageId}', { list: () => toListResource(store.getMessages().flatMap(messageToListResource)) }),
-    { title: 'A single WhatsApp Message', description: 'Details of a single WhatsApp message', mimeType: 'application/json' },
-    (_, { messageId }) => toReadResource(messageToReadResource(store.getMessage(messageId as string))))
-}
-
-const messageToReadResource = (message: MessageWithId | undefined) => message
-  ? [{ uri: `messages://app/${message.key.id}`, mimeType: 'application/json', text: JSON.stringify(message) }]
-  : []
-
-const messageToListResource = (message: MessageWithId | undefined) => message
-  ? [{ uri: `messages://app/${message.key.id}`, name: message.key.id }]
-  : []
-
-const toReadResource = (t: ReadResourceResult['contents']) => ({ contents: t })
-const toListResource = (t: ListResourcesResult['resources']) => ({ resources: t })
-
-function registerMessageTools(server: McpServer, sync: WhatsAppHandler) {
-  server.registerTool(
-    'send_message',
-    { description: 'Send a WhatsApp-Message to a given JID.', inputSchema: SendMessageSchema },
-    args => sync.sendMessage(args.jid, args.message).then(messageToText).then(toCallResult).catch(toCallError),
-  )
-}
-
-const messageToText = (message: WAMessage): string => {
-  return `Message sent to ${message.key.remoteJid ?? 'unknown'}: "${message.message?.conversation ?? 'unknown'}"`
-}
-
-function registerChatTools(server: McpServer, sync: WhatsAppHandler) {
-  server.registerTool(
-    'set_chat_archived',
-    { description: 'Set a WhatsApp chat as archived or unarchived.', inputSchema: ArchiveChatSchema },
-    args => sync.setArchived(args.jid, args.archived).then(() => `Chat ${args.jid} archived status set to ${args.archived.toString()}`).then(toCallResult).catch(toCallError),
-  )
-  server.registerTool(
-    'set_chat_read',
-    { description: 'Set a WhatsApp chat as read or unread.', inputSchema: ReadChatSchema },
-    args => sync.setRead(args.jid, args.read).then(() => `Chat ${args.jid} read status set to ${args.read.toString()}`).then(toCallResult).catch(toCallError),
-  )
-}
-
-const JidSchema = z.union([
-  z.string().min(1, 'JID is required').endsWith('@s.whatsapp.net', 'JID not a valid WhatsApp JID)'),
-  z.string().min(1, 'JID is required').endsWith('@g.us', 'JID not a valid WhatsApp JID)'),
-]).describe('The JID of the recipient or chat. For example 41791234567@s.whatsapp.net for an individual or 1234567890-1234567890@g.us for a group')
-
-const SendMessageSchema = z.object({
-  jid: JidSchema,
-  message: z.string()
-    .min(1, 'Message body is required')
-    .describe('The body of the message to be sent. Can contain unicode characters like emojis.'),
-})
-
-const ArchiveChatSchema = z.object({
-  jid: JidSchema,
-  archived: z.boolean()
-    .describe('Whether the chat should be archived (true) or unarchived (false).'),
-})
-
-const ReadChatSchema = z.object({
-  jid: JidSchema,
-  read: z.boolean()
-    .describe('Whether the chat should be marked as read (true) or unread (false).'),
-})
-
-const toCallResult = (t: string): CallToolResult => ({ content: [{ type: 'text', text: t }], isError: false })
-const toCallError = (error: Error): CallToolResult => ({ content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true })

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
-}

package/tsconfig.test.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": ["src/**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    include: ['src/**/*.test.ts'],
-  },
-})