@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/connectors/telegram.ts

@@ -0,0 +1,221 @@
+import { Bot, InputFile } from 'grammy'
+import fs from 'fs'
+import path from 'path'
+import type { Connector } from '@/types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundMediaType } from './types'
+import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
+import { isNoMessage } from './manager'
+
+const telegram: PlatformConnector = {
+  async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
+    const bot = new Bot(botToken)
+
+    // Optional: restrict to specific chat IDs
+    const allowedChats = connector.config.chatIds
+      ? connector.config.chatIds.split(',').map((s) => s.trim()).filter(Boolean)
+      : null
+
+    // Log all errors
+    bot.catch((err) => {
+      console.error(`[telegram] Bot error:`, err.message || err)
+    })
+
+    // Delete any existing webhook so long polling works
+    await bot.api.deleteWebhook().catch((err) => {
+      console.error('[telegram] Failed to delete webhook:', err.message)
+    })
+
+    // Log all incoming updates for debugging
+    bot.use(async (ctx, next) => {
+      console.log(`[telegram] Update received: chat=${ctx.chat?.id}, from=${ctx.from?.first_name}, hasText=${!!ctx.message?.text}`)
+      await next()
+    })
+
+    // Handle /start command (required for new conversations)
+    bot.command('start', async (ctx) => {
+      console.log(`[telegram] /start from ${ctx.from?.first_name} (chat=${ctx.chat.id})`)
+      await ctx.reply('Hello! I\'m ready to chat. Send me a message.')
+    })
+
+    bot.on('message', async (ctx) => {
+      if (!ctx.message || !ctx.from || !ctx.chat) return
+      const chatId = String(ctx.chat.id)
+      const raw = ctx.message as any
+      const text = raw.text || raw.caption || ''
+      console.log(`[telegram] Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
+
+      // Filter by allowed chats if configured
+      if (allowedChats && !allowedChats.includes(chatId)) {
+        console.log(`[telegram] Skipping — chat ${chatId} not in allowed list: ${allowedChats.join(',')}`)
+        return
+      }
+
+      const media: NonNullable<InboundMessage['media']> = []
+      const mediaCandidates: Array<{ fileId: string; mimeType?: string; fileName?: string; type: InboundMediaType }> = []
+
+      if (Array.isArray(raw.photo) && raw.photo.length > 0) {
+        const largest = raw.photo[raw.photo.length - 1]
+        if (largest?.file_id) mediaCandidates.push({ fileId: largest.file_id, type: 'image' })
+      }
+      if (raw.video?.file_id) {
+        mediaCandidates.push({
+          fileId: raw.video.file_id,
+          type: 'video',
+          mimeType: raw.video.mime_type || undefined,
+          fileName: raw.video.file_name || undefined,
+        })
+      }
+      if (raw.audio?.file_id) {
+        mediaCandidates.push({
+          fileId: raw.audio.file_id,
+          type: 'audio',
+          mimeType: raw.audio.mime_type || undefined,
+          fileName: raw.audio.file_name || undefined,
+        })
+      }
+      if (raw.voice?.file_id) {
+        mediaCandidates.push({
+          fileId: raw.voice.file_id,
+          type: 'audio',
+          mimeType: raw.voice.mime_type || 'audio/ogg',
+          fileName: 'voice.ogg',
+        })
+      }
+      if (raw.document?.file_id) {
+        mediaCandidates.push({
+          fileId: raw.document.file_id,
+          type: inferInboundMediaType(raw.document.mime_type || undefined, raw.document.file_name || undefined, 'document'),
+          mimeType: raw.document.mime_type || undefined,
+          fileName: raw.document.file_name || undefined,
+        })
+      }
+      if (raw.animation?.file_id) {
+        mediaCandidates.push({
+          fileId: raw.animation.file_id,
+          type: 'video',
+          mimeType: raw.animation.mime_type || undefined,
+          fileName: raw.animation.file_name || undefined,
+        })
+      }
+
+      for (const m of mediaCandidates) {
+        try {
+          const file = await bot.api.getFile(m.fileId)
+          if (!file?.file_path) throw new Error('Missing Telegram file_path')
+          const sourceUrl = `https://api.telegram.org/file/bot${botToken}/${file.file_path}`
+          const stored = await downloadInboundMediaToUpload({
+            connectorId: connector.id,
+            mediaType: m.type,
+            url: sourceUrl,
+            fileName: m.fileName,
+            mimeType: m.mimeType,
+          })
+          if (stored) media.push(stored)
+        } catch (err: any) {
+          console.warn(`[telegram] Failed to fetch media ${m.fileId}:`, err?.message || String(err))
+          media.push({
+            type: m.type,
+            fileName: m.fileName,
+            mimeType: m.mimeType,
+          })
+        }
+      }
+
+      const inbound: InboundMessage = {
+        platform: 'telegram',
+        channelId: chatId,
+        channelName: ctx.chat.type === 'private'
+          ? `DM:${ctx.from.first_name}`
+          : ('title' in ctx.chat ? ctx.chat.title : chatId),
+        senderId: String(ctx.from.id),
+        senderName: ctx.from.first_name + (ctx.from.last_name ? ` ${ctx.from.last_name}` : ''),
+        text: text || (media.length > 0 ? '(media message)' : ''),
+        imageUrl: media.find((m) => m.type === 'image')?.url,
+        media,
+      }
+
+      try {
+        await ctx.api.sendChatAction(ctx.chat.id, 'typing')
+        const response = await onMessage(inbound)
+
+        if (isNoMessage(response)) return
+
+        // Telegram has a 4096 char limit
+        if (response.length <= 4096) {
+          await ctx.reply(response)
+        } else {
+          const chunks = response.match(/[\s\S]{1,4090}/g) || [response]
+          for (const chunk of chunks) {
+            await ctx.api.sendMessage(ctx.chat.id, chunk)
+          }
+        }
+      } catch (err: any) {
+        console.error(`[telegram] Error handling message:`, err.message)
+        try {
+          await ctx.reply('Sorry, I encountered an error processing your message.')
+        } catch { /* ignore */ }
+      }
+    })
+
+    // Start polling — not awaited (runs in background)
+    bot.start({
+      allowed_updates: ['message', 'edited_message'],
+      onStart: (botInfo) => {
+        console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
+      },
+    }).catch((err) => {
+      console.error(`[telegram] Polling stopped with error:`, err.message || err)
+    })
+
+    return {
+      connector,
+      async sendMessage(channelId, text, options) {
+        const chatId = channelId
+        const caption = options?.caption || text || undefined
+
+        // Local file
+        if (options?.mediaPath) {
+          if (!fs.existsSync(options.mediaPath)) throw new Error(`File not found: ${options.mediaPath}`)
+          const mime = options.mimeType || mimeFromPath(options.mediaPath)
+          const inputFile = new InputFile(options.mediaPath, options.fileName || path.basename(options.mediaPath))
+          if (isImageMime(mime)) {
+            const msg = await bot.api.sendPhoto(chatId, inputFile, { caption })
+            return { messageId: String(msg.message_id) }
+          } else {
+            const msg = await bot.api.sendDocument(chatId, inputFile, { caption })
+            return { messageId: String(msg.message_id) }
+          }
+        }
+        // URL-based image
+        if (options?.imageUrl) {
+          const msg = await bot.api.sendPhoto(chatId, options.imageUrl, { caption })
+          return { messageId: String(msg.message_id) }
+        }
+        // URL-based file
+        if (options?.fileUrl) {
+          const msg = await bot.api.sendDocument(chatId, options.fileUrl, { caption })
+          return { messageId: String(msg.message_id) }
+        }
+        // Text only
+        const payload = text || caption || ''
+        if (payload.length <= 4096) {
+          const msg = await bot.api.sendMessage(chatId, payload)
+          return { messageId: String(msg.message_id) }
+        }
+        const chunks = payload.match(/[\s\S]{1,4090}/g) || [payload]
+        let lastId: string | undefined
+        for (const chunk of chunks) {
+          const msg = await bot.api.sendMessage(chatId, chunk)
+          lastId = String(msg.message_id)
+        }
+        return { messageId: lastId }
+      },
+      async stop() {
+        await bot.stop()
+        console.log(`[telegram] Bot stopped`)
+      },
+    }
+  },
+}
+
+export default telegram

package/src/lib/server/connectors/types.ts

@@ -0,0 +1,62 @@
+import type { Connector } from '@/types'
+
+export type InboundMediaType = 'image' | 'video' | 'audio' | 'document' | 'file'
+
+export interface InboundMedia {
+  type: InboundMediaType
+  fileName?: string
+  mimeType?: string
+  sizeBytes?: number
+  /** Public URL when available (typically /api/uploads/...) */
+  url?: string
+  /** Absolute local path where media was persisted, if stored */
+  localPath?: string
+}
+
+/** Inbound message from a chat platform */
+export interface InboundMessage {
+  platform: string
+  channelId: string        // platform-specific channel/chat ID
+  channelName?: string     // human-readable name
+  senderId: string         // platform-specific user ID
+  senderName: string       // display name
+  text: string
+  imageUrl?: string
+  media?: InboundMedia[]
+  replyToMessageId?: string
+}
+
+/** A running connector instance */
+export interface ConnectorInstance {
+  connector: Connector
+  stop: () => Promise<void>
+  /** Optional outbound send support for proactive agent notifications */
+  sendMessage?: (
+    channelId: string,
+    text: string,
+    options?: {
+      imageUrl?: string
+      fileUrl?: string
+      /** Absolute local file path (e.g. screenshot saved to disk) */
+      mediaPath?: string
+      mimeType?: string
+      fileName?: string
+      caption?: string
+    },
+  ) => Promise<{ messageId?: string } | void>
+  /** Current QR code data URL (WhatsApp only, null when paired) */
+  qrDataUrl?: string | null
+  /** Whether the connector has successfully authenticated (WhatsApp only) */
+  authenticated?: boolean
+  /** Whether the connector has existing saved credentials (WhatsApp only) */
+  hasCredentials?: boolean
+}
+
+/** Platform-specific connector implementation */
+export interface PlatformConnector {
+  start(
+    connector: Connector,
+    botToken: string,
+    onMessage: (msg: InboundMessage) => Promise<string>,
+  ): Promise<ConnectorInstance>
+}

package/src/lib/server/connectors/whatsapp.ts

@@ -0,0 +1,349 @@
+import makeWASocket, {
+  useMultiFileAuthState,
+  DisconnectReason,
+  fetchLatestBaileysVersion,
+  normalizeMessageContent,
+  downloadMediaMessage,
+} from '@whiskeysockets/baileys'
+import QRCode from 'qrcode'
+import path from 'path'
+import fs from 'fs'
+import type { Connector } from '@/types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { saveInboundMediaBuffer, mimeFromPath, isImageMime } from './media'
+import { isNoMessage } from './manager'
+
+import { DATA_DIR } from '../data-dir'
+
+const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth')
+
+/** Normalize a phone number for JID matching — strip leading 0 or + */
+function normalizeNumber(num: string): string {
+  let n = num.replace(/[\s\-()]/g, '')
+  // UK local: 07xxx → 447xxx
+  if (n.startsWith('0') && n.length >= 10) {
+    n = '44' + n.slice(1)
+  }
+  // Strip leading +
+  if (n.startsWith('+')) n = n.slice(1)
+  return n
+}
+
+/** Check if auth directory has saved credentials */
+function hasStoredCreds(authDir: string): boolean {
+  try {
+    return fs.existsSync(path.join(authDir, 'creds.json'))
+  } catch { return false }
+}
+
+/** Clear auth directory to force fresh QR pairing */
+export function clearAuthDir(connectorId: string): void {
+  const authDir = path.join(AUTH_DIR, connectorId)
+  if (fs.existsSync(authDir)) {
+    fs.rmSync(authDir, { recursive: true, force: true })
+    console.log(`[whatsapp] Cleared auth state for connector ${connectorId}`)
+  }
+}
+
+const whatsapp: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    // Each connector gets its own auth directory
+    const authDir = path.join(AUTH_DIR, connector.id)
+    if (!fs.existsSync(authDir)) fs.mkdirSync(authDir, { recursive: true })
+
+    const { state, saveCreds } = await useMultiFileAuthState(authDir)
+    const { version } = await fetchLatestBaileysVersion()
+
+    let sock: ReturnType<typeof makeWASocket> | null = null
+    let stopped = false
+    let socketGen = 0 // Track socket generation to ignore stale events
+
+    const instance: ConnectorInstance = {
+      connector,
+      qrDataUrl: null,
+      authenticated: false,
+      hasCredentials: hasStoredCreds(authDir),
+      async sendMessage(channelId, text, options) {
+        if (!sock) throw new Error('WhatsApp connector is not connected')
+        // Local file path takes priority
+        if (options?.mediaPath) {
+          if (!fs.existsSync(options.mediaPath)) throw new Error(`File not found: ${options.mediaPath}`)
+          const buf = fs.readFileSync(options.mediaPath)
+          const mime = options.mimeType || mimeFromPath(options.mediaPath)
+          const caption = options.caption || text || undefined
+          const fName = options.fileName || path.basename(options.mediaPath)
+          let sent
+          if (isImageMime(mime)) {
+            sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
+          } else {
+            sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
+          }
+          if (sent?.key?.id) sentMessageIds.add(sent.key.id)
+          return { messageId: sent?.key?.id || undefined }
+        }
+        if (options?.imageUrl) {
+          const sent = await sock.sendMessage(channelId, {
+            image: { url: options.imageUrl },
+            caption: options.caption || text || undefined,
+          })
+          if (sent?.key?.id) sentMessageIds.add(sent.key.id)
+          return { messageId: sent?.key?.id || undefined }
+        }
+        if (options?.fileUrl) {
+          const sent = await sock.sendMessage(channelId, {
+            document: { url: options.fileUrl },
+            fileName: options.fileName || 'attachment',
+            mimetype: options.mimeType || 'application/octet-stream',
+            caption: options.caption || text || undefined,
+          })
+          if (sent?.key?.id) sentMessageIds.add(sent.key.id)
+          return { messageId: sent?.key?.id || undefined }
+        }
+
+        const payload = text || options?.caption || ''
+        const chunks = payload.length <= 4096 ? [payload] : (payload.match(/[\s\S]{1,4000}/g) || [payload])
+        let lastMessageId: string | undefined
+        for (const chunk of chunks) {
+          const sent = await sock.sendMessage(channelId, { text: chunk })
+          if (sent?.key?.id) {
+            lastMessageId = sent.key.id
+            sentMessageIds.add(sent.key.id)
+          }
+        }
+        return { messageId: lastMessageId }
+      },
+      async stop() {
+        stopped = true
+        try { sock?.end(undefined) } catch { /* ignore */ }
+        sock = null
+        console.log(`[whatsapp] Stopped connector: ${connector.name}`)
+      },
+    }
+
+    // Normalize allowed JIDs for matching
+    const allowedJids = connector.config.allowedJids
+      ? connector.config.allowedJids.split(',').map((s) => normalizeNumber(s.trim())).filter(Boolean)
+      : null
+
+    // Track message IDs sent by the bot to avoid infinite loops in self-chat
+    const sentMessageIds = new Set<string>()
+
+    if (allowedJids) {
+      console.log(`[whatsapp] Allowed JIDs (normalized): ${allowedJids.join(', ')}`)
+    }
+
+    const startSocket = () => {
+      // Close previous socket to prevent stale event handlers
+      if (sock) {
+        try { sock.ev.removeAllListeners('connection.update') } catch { /* ignore */ }
+        try { sock.ev.removeAllListeners('messages.upsert') } catch { /* ignore */ }
+        try { sock.ev.removeAllListeners('creds.update') } catch { /* ignore */ }
+        try { sock.end(undefined) } catch { /* ignore */ }
+        sock = null
+      }
+
+      const gen = ++socketGen // Capture generation for stale detection
+      console.log(`[whatsapp] Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
+
+      sock = makeWASocket({
+        version,
+        auth: state,
+        browser: ['SwarmClaw', 'Chrome', '120.0'],
+      })
+
+      sock.ev.on('creds.update', () => {
+        saveCreds()
+        // Update hasCredentials after first cred save
+        instance.hasCredentials = true
+      })
+
+      sock.ev.on('connection.update', async (update) => {
+        if (gen !== socketGen) return // Ignore events from stale sockets
+
+        const { connection, lastDisconnect, qr } = update
+        console.log(`[whatsapp] Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
+
+        if (qr) {
+          console.log(`[whatsapp] QR code generated for ${connector.name}`)
+          try {
+            instance.qrDataUrl = await QRCode.toDataURL(qr, {
+              width: 280,
+              margin: 2,
+              color: { dark: '#000000', light: '#ffffff' },
+            })
+          } catch (err) {
+            console.error('[whatsapp] Failed to generate QR data URL:', err)
+          }
+        }
+        if (connection === 'close') {
+          instance.qrDataUrl = null
+          const reason = (lastDisconnect?.error as any)?.output?.statusCode
+          console.log(`[whatsapp] Connection closed: reason=${reason} stopped=${stopped}`)
+
+          if (reason === DisconnectReason.loggedOut) {
+            // Session invalidated — clear auth and restart to get fresh QR
+            console.log(`[whatsapp] Logged out — clearing auth and restarting for fresh QR`)
+            instance.authenticated = false
+            instance.hasCredentials = false
+            clearAuthDir(connector.id)
+            if (!stopped) {
+              // Recreate auth dir and state for fresh start
+              fs.mkdirSync(authDir, { recursive: true })
+              setTimeout(startSocket, 1000)
+            }
+          } else if (reason === 440) {
+            // Conflict — another session replaced this one. Do NOT reconnect
+            // (reconnecting would create a ping-pong loop with the other session)
+            console.log(`[whatsapp] Session conflict (replaced by another connection) — stopping`)
+            instance.authenticated = false
+          } else if (!stopped) {
+            console.log(`[whatsapp] Reconnecting in 3s...`)
+            setTimeout(startSocket, 3000)
+          } else {
+            console.log(`[whatsapp] Disconnected permanently`)
+          }
+        } else if (connection === 'open') {
+          instance.authenticated = true
+          instance.hasCredentials = true
+          instance.qrDataUrl = null
+          console.log(`[whatsapp] Connected as ${sock?.user?.id}`)
+        }
+      })
+
+      sock.ev.on('messages.upsert', async (upsert) => {
+        const { messages, type } = upsert
+        console.log(`[whatsapp] messages.upsert gen=${gen}: type=${type}, count=${messages.length}`)
+
+        if (gen !== socketGen) {
+          console.log(`[whatsapp] Ignoring stale socket event (gen=${gen}, current=${socketGen})`)
+          return
+        }
+        if (type !== 'notify') {
+          console.log(`[whatsapp] Ignoring non-notify upsert type: ${type}`)
+          return
+        }
+
+        for (const msg of messages) {
+          console.log(`[whatsapp] Processing message: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, hasConversation=${!!msg.message?.conversation}, hasExtended=${!!msg.message?.extendedTextMessage}`)
+
+          if (msg.key.remoteJid === 'status@broadcast') continue
+
+          // Skip messages sent by the bot itself (tracked by ID to prevent infinite loops)
+          if (msg.key.id && sentMessageIds.has(msg.key.id)) {
+            console.log(`[whatsapp] Skipping own bot reply: ${msg.key.id}`)
+            sentMessageIds.delete(msg.key.id) // Clean up
+            continue
+          }
+
+          // Handle self-chat (same number messaging itself for testing)
+          // Self-chat JID can be phone format (447xxx@s.whatsapp.net) or LID format (185xxx@lid)
+          const remoteNum = msg.key.remoteJid?.split('@')[0] || ''
+          const remoteHost = msg.key.remoteJid?.split('@')[1] || ''
+          const myPhoneNum = sock?.user?.id?.split(':')[0] || ''
+          const myLid = sock?.user?.lid?.split(':')[0] || ''
+          const isSelfChat = (remoteNum === myPhoneNum) || (remoteHost === 'lid' && (myLid ? remoteNum === myLid : true))
+          console.log(`[whatsapp] Self-chat check: remote=${remoteNum}@${remoteHost}, myPhone=${myPhoneNum}, myLid=${myLid}, isSelf=${isSelfChat}`)
+          if (msg.key.fromMe && !isSelfChat) continue
+
+          const jid = msg.key.remoteJid || ''
+
+          // Match allowed JIDs using normalized numbers
+          // Self-chat always passes the filter (it's the bot's own account)
+          if (allowedJids && !isSelfChat) {
+            const jidNumber = jid.split('@')[0]
+            const matched = allowedJids.some((n) => jidNumber.includes(n) || n.includes(jidNumber))
+            console.log(`[whatsapp] JID filter: jidNumber=${jidNumber}, allowedJids=${allowedJids.join(',')}, matched=${matched}`)
+            if (!matched) {
+              console.log(`[whatsapp] Skipping message from non-allowed JID: ${jid}`)
+              continue
+            }
+          }
+
+          const content: any = normalizeMessageContent(msg.message as any) || msg.message || {}
+          const text = content?.conversation
+            || content?.extendedTextMessage?.text
+            || content?.imageMessage?.caption
+            || content?.videoMessage?.caption
+            || content?.documentMessage?.caption
+            || ''
+
+          const media: NonNullable<InboundMessage['media']> = []
+          const mediaCandidate:
+            | { kind: 'image' | 'video' | 'audio' | 'document' | 'file'; payload: any }
+            | null =
+            content?.imageMessage
+              ? { kind: 'image', payload: content.imageMessage }
+              : content?.videoMessage
+                ? { kind: 'video', payload: content.videoMessage }
+                : content?.audioMessage
+                  ? { kind: 'audio', payload: content.audioMessage }
+                  : content?.documentMessage
+                    ? { kind: 'document', payload: content.documentMessage }
+                    : content?.stickerMessage
+                      ? { kind: 'image', payload: content.stickerMessage }
+                      : null
+
+          if (mediaCandidate) {
+            try {
+              const buffer = await downloadMediaMessage(msg as any, 'buffer', {})
+              const saved = saveInboundMediaBuffer({
+                connectorId: connector.id,
+                buffer: buffer as Buffer,
+                mediaType: mediaCandidate.kind,
+                mimeType: mediaCandidate.payload?.mimetype || undefined,
+                fileName: mediaCandidate.payload?.fileName || undefined,
+              })
+              media.push(saved)
+            } catch (err: any) {
+              console.error(`[whatsapp] Failed to decode media: ${err?.message || String(err)}`)
+              media.push({
+                type: mediaCandidate.kind,
+                fileName: mediaCandidate.payload?.fileName || undefined,
+                mimeType: mediaCandidate.payload?.mimetype || undefined,
+              })
+            }
+          }
+
+          if (!text && media.length === 0) continue
+
+          const senderName = msg.pushName || jid.split('@')[0]
+          const isGroup = jid.endsWith('@g.us')
+
+          console.log(`[whatsapp] Message from ${senderName} (${jid}): ${text.slice(0, 80)}`)
+
+          const inbound: InboundMessage = {
+            platform: 'whatsapp',
+            channelId: jid,
+            channelName: isGroup ? jid : `DM:${senderName}`,
+            senderId: msg.key.participant || jid,
+            senderName,
+            text: text || '(media message)',
+            imageUrl: media.find((m) => m.type === 'image')?.url,
+            media,
+          }
+
+          try {
+            await sock!.sendPresenceUpdate('composing', jid)
+            const response = await onMessage(inbound)
+            await sock!.sendPresenceUpdate('paused', jid)
+
+            if (!isNoMessage(response)) {
+              await instance.sendMessage?.(jid, response)
+            }
+          } catch (err: any) {
+            console.error(`[whatsapp] Error handling message:`, err.message)
+            try {
+              await sock!.sendMessage(jid, { text: 'Sorry, I encountered an error processing your message.' })
+            } catch { /* ignore */ }
+          }
+        }
+      })
+    }
+
+    startSocket()
+
+    return instance
+  },
+}
+
+export default whatsapp