From b6ad9b53d499fcbba31195b8e36f0cb18db90edb Mon Sep 17 00:00:00 2001
From: RenoXF <renoxf11@gmail.com>
Date: Tue, 4 Aug 2026 16:46:18 +0700
Subject: [PATCH] Refactor WhatsApp session management and database queries

- Improved SSE handling in `src/server/sse/index.ts` by adding cleanup logic for unsubscribing and clearing intervals.
- Removed obsolete message handling in `src/shutdown.ts` and `src/whatsapp/db-migration.ts`, including dropping unused tables.
- Introduced `message-store.ts` to manage sent messages per device, optimizing memory usage.
- Consolidated group-related queries into `src/whatsapp/queries/groups.ts` and removed unused message and media queries.
- Updated `src/whatsapp/whatsapp-session.ts` to utilize the new message store and removed legacy media handling.
- Enhanced code readability and maintainability by restructuring functions and improving error handling.
---
 src/server/client/client.css     |  40 -------
 src/server/client/index.html     |  89 +-------------
 src/server/connections/index.ts  |  10 +-
 src/server/contacts/index.ts     |  82 ++++++-------
 src/server/index.ts              |   7 +-
 src/server/messages/index.ts     |  15 ++-
 src/server/messages/manage.ts    | 197 ++++++++++++++++++++++---------
 src/server/messages/media.ts     |  26 ----
 src/server/messages/send.ts      |  88 +++++---------
 src/server/sse/index.ts          |  40 ++++---
 src/shutdown.ts                  |   1 -
 src/whatsapp/db-migration.ts     |  38 +-----
 src/whatsapp/index.ts            |   2 +-
 src/whatsapp/message-store.ts    | 181 ++++++++++++++++++++++++++++
 src/whatsapp/queries/contacts.ts |  15 ++-
 src/whatsapp/queries/groups.ts   |  40 +++++++
 src/whatsapp/queries/index.ts    |  48 ++++----
 src/whatsapp/queries/media.ts    |  34 ------
 src/whatsapp/queries/messages.ts | 153 ------------------------
 src/whatsapp/queries/status.ts   |  66 -----------
 src/whatsapp/session-media.ts    |  69 -----------
 src/whatsapp/whatsapp-session.ts | 142 +++++++---------------
 22 files changed, 557 insertions(+), 826 deletions(-)
 delete mode 100644 src/server/messages/media.ts
 create mode 100644 src/whatsapp/message-store.ts
 create mode 100644 src/whatsapp/queries/groups.ts
 delete mode 100644 src/whatsapp/queries/media.ts
 delete mode 100644 src/whatsapp/queries/messages.ts
 delete mode 100644 src/whatsapp/queries/status.ts
 delete mode 100644 src/whatsapp/session-media.ts

diff --git a/src/server/client/client.css b/src/server/client/client.css
index f13b416..a7173f5 100644
--- a/src/server/client/client.css
+++ b/src/server/client/client.css
@@ -18,7 +18,6 @@
   --active: #2a3942;
   --accent: #00a884;
   --danger: #ef5350;
-  --unread: #00a884;
   --shadow: rgba(0,0,0,.4);
 }
 html, body {
@@ -79,13 +78,6 @@ html, body {
 .chat-meta { display: flex; justify-content: space-between; align-items: baseline; }
 .chat-preview { font-size: 13px; color: var(--text-secondary); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .chat-time { font-size: 11px; color: var(--text-secondary); white-space: nowrap; }
-.chat-unread {
-  background: var(--unread); color: #fff;
-  border-radius: 50%; min-width: 20px; height: 20px;
-  display: flex; align-items: center; justify-content: center;
-  font-size: 11px; font-weight: 600;
-  position: absolute; top: -4px; right: -4px;
-}
 
 /* ── Device Actions on Hover ── */
 .device-actions {
@@ -157,19 +149,6 @@ html, body {
 .msg.incoming .msg-footer { justify-content: flex-start; }
 .msg-check { color: #53bdeb; }
 .msg-check.delivered { color: var(--text-secondary); }
-.msg-image { max-width: 260px; max-height: 260px; border-radius: 6px; display: block; cursor: pointer; object-fit: cover; }
-.msg-audio { width: 100%; }
-.msg-video { max-width: 260px; max-height: 260px; border-radius: 6px; }
-.msg-document {
-  display: flex; align-items: center; gap: 10px;
-  padding: 8px; background: rgba(255,255,255,.05); border-radius: 6px;
-  cursor: pointer;
-}
-.msg-document i { font-size: 28px; color: var(--accent); }
-.msg-doc-info { flex: 1; min-width: 0; }
-.msg-doc-name { font-size: 13px; font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.msg-doc-size { font-size: 11px; color: var(--text-secondary); }
-.msg-sticker { width: 160px; border-radius: 8px; }
 
 /* ── Load More ── */
 .load-more {
@@ -246,25 +225,6 @@ html, body {
 .icon-btn:hover { background: var(--hover); color: var(--text); }
 .icon-btn.primary { color: var(--accent); }
 
-/* ── Attachment Menu ── */
-.attach-menu {
-  position: absolute; bottom: 68px; left: 16px;
-  display: flex; gap: 12px; padding: 12px;
-  background: var(--panel-bg); border-radius: 10px;
-  box-shadow: 0 4px 12px var(--shadow);
-  z-index: 10;
-}
-.attach-item {
-  display: flex; flex-direction: column;
-  align-items: center; gap: 4px; cursor: pointer;
-}
-.attach-item i {
-  width: 48px; height: 48px; border-radius: 50%;
-  display: flex; align-items: center; justify-content: center;
-  font-size: 22px; color: #fff;
-}
-.attach-item span { font-size: 11px; color: var(--text-secondary); }
-
 /* ── Device Dashboard ── */
 .device-cards { display: flex; flex-wrap: wrap; gap: 16px; padding: 24px; }
 .device-card {
diff --git a/src/server/client/index.html b/src/server/client/index.html
index 9444694..cf0dc19 100644
--- a/src/server/client/index.html
+++ b/src/server/client/index.html
@@ -46,16 +46,8 @@
         <span class="reply-close" onclick="cancelReply()">&times;</span>
       </div>
       <div class="input-area" style="position:relative">
-        <button class="icon-btn" onclick="toggleAttachMenu()"><i class="bi bi-paperclip"></i></button>
         <input id="msgInput" placeholder="Type a message" onkeydown="if(event.key==='Enter')sendMsg()">
         <button class="icon-btn primary" onclick="sendMsg()"><i class="bi bi-send"></i></button>
-        <div class="attach-menu" id="attachMenu" style="display:none">
-          <div class="attach-item" onclick="pickFile('image/*')"><i style="background:#ef5350"><i class="bi bi-image"></i></i><span>Image</span></div>
-          <div class="attach-item" onclick="pickFile('audio/*')"><i style="background:#ff9800"><i class="bi bi-music-note"></i></i><span>Audio</span></div>
-          <div class="attach-item" onclick="pickFile('video/*')"><i style="background:#4caf50"><i class="bi bi-camera-reels"></i></i><span>Video</span></div>
-          <div class="attach-item" onclick="pickFile('*/*')"><i style="background:#2196f3"><i class="bi bi-file-earmark"></i></i><span>Document</span></div>
-        </div>
-        <input type="file" id="fileInput" style="display:none" onchange="sendMedia(event)">
       </div>
     </div>
     <div class="empty-state" id="emptyState">
@@ -65,10 +57,7 @@
   </main>
 </div>
 <div class="toast-container" id="toastContainer"></div>
-<div id="imageModal" style="display:none;position:fixed;inset:0;z-index:999;background:rgba(0,0,0,.85);cursor:zoom-out;align-items:center;justify-content:center" onclick="this.style.display='none'">
-  <img id="modalImage" style="max-width:90vw;max-height:90vh;border-radius:8px;object-fit:contain">
-</div>
-    <div id="addDeviceModal" style="display:none;position:fixed;inset:0;z-index:1000;background:rgba(0,0,0,.7);align-items:center;justify-content:center" onclick="if(event.target===this)this.style.display='none'">
+<div id="addDeviceModal" style="display:none;position:fixed;inset:0;z-index:1000;background:rgba(0,0,0,.7);align-items:center;justify-content:center" onclick="if(event.target===this)this.style.display='none'">
   <div style="background:var(--panel-bg);border-radius:12px;padding:24px;width:420px;max-width:90vw;box-shadow:0 8px 32px rgba(0,0,0,.5)">
     <h3 style="margin-bottom:16px;font-weight:600">Tambah Device Baru</h3>
     <input id="newDeviceName" placeholder="Nama device (contoh: HP Sales)" style="width:100%;padding:10px 14px;border:none;border-radius:8px;background:var(--input-bg);color:var(--text);font-size:14px;outline:none;margin-bottom:10px">
@@ -110,17 +99,6 @@ <h3 style="margin-bottom:16px;font-weight:600"><i class="bi bi-info-circle"></i>
   $('toastContainer').appendChild(t);
   setTimeout(() => t.remove(), 3000);
 }
-function showImage(src) {
-  $('modalImage').src = src;
-  $('imageModal').style.display = 'flex';
-}
-function mediaError(el) {
-  el.style.display = 'none';
-  const div = document.createElement('div');
-  div.style.cssText = 'padding:8px;color:var(--text-secondary);font-style:italic;font-size:12px';
-  div.textContent = 'Media tidak tersedia';
-  el.parentElement.appendChild(div);
-}
 
 // ── Add Device Modal ──
 function showAddDeviceModal() {
@@ -537,10 +515,9 @@ <h3 style="margin-bottom:16px;font-weight:600"><i class="bi bi-info-circle"></i>
     </div>
   </div>`;
   html += chats.map(c => {
-    const uc = c.unreadCount || 0;
     const name = bestName(c);
     return `<div class="chat-item${c.jid === currentJid ? ' active' : ''}" data-jid="${esc(c.jid)}" data-name="${esc(name.toLowerCase())}" onclick="selectChat('${c.jid}')">
-      <div class="chat-avatar">${esc(name[0] || '?')}${uc > 0 ? `<span class="chat-unread">${uc > 99 ? '99+' : uc}</span>` : ''}</div>
+      <div class="chat-avatar">${esc(name[0] || '?')}</div>
       <div class="chat-info">
         <div class="chat-meta">
           <div class="chat-name">${esc(name)}</div>
@@ -651,33 +628,8 @@ <h3 style="margin-bottom:16px;font-weight:600"><i class="bi bi-info-circle"></i>
     if (isFwd) {
       html += '<div class="msg-forwarded"><i class="bi bi-forward"></i> Forwarded</div>';
     }
-    // media content
-    if (content.type === 'image') {
-      const key = getMsgRemoteJid(m) + '-' + getMsgId(m);
-      html += `<img class="msg-image" src="/messages/media/${currentDevice}/${encodeURIComponent(key)}" alt="image" onerror="mediaError(this)" onclick="showImage(this.src)">`;
-      if (content.text && !content.text.startsWith('📷')) html += `<div class="msg-text">${esc(content.text)}</div>`;
-    } else if (content.type === 'video') {
-      const key = getMsgRemoteJid(m) + '-' + getMsgId(m);
-      html += `<video class="msg-video" src="/messages/media/${currentDevice}/${encodeURIComponent(key)}" controls onerror="mediaError(this)"></video>`;
-      if (content.text && !content.text.startsWith('🎬')) html += `<div class="msg-text">${esc(content.text)}</div>`;
-    } else if (content.type === 'audio') {
-      const key = getMsgRemoteJid(m) + '-' + getMsgId(m);
-      html += `<audio class="msg-audio" src="/messages/media/${currentDevice}/${encodeURIComponent(key)}" controls onerror="mediaError(this)"></audio>`;
-    } else if (content.type === 'document') {
-      const key = getMsgRemoteJid(m) + '-' + getMsgId(m);
-      html += `<div class="msg-document" onclick="window.open('/messages/media/${currentDevice}/${encodeURIComponent(key)}')">
-        <i class="bi bi-file-earmark"></i>
-        <div class="msg-doc-info">
-          <div class="msg-doc-name">${esc(content.obj?.fileName || 'Document')}</div>
-          <div class="msg-doc-size">${content.obj?.fileSize ? Math.round(content.obj.fileSize / 1024) + ' KB' : ''}</div>
-        </div>
-      </div>`;
-    } else if (content.type === 'sticker') {
-      const key = getMsgRemoteJid(m) + '-' + getMsgId(m);
-      html += `<img class="msg-sticker" src="/messages/media/${currentDevice}/${encodeURIComponent(key)}" alt="sticker" onerror="this.style.display='none'">`;
-    } else {
-      html += `<div class="msg-text">${esc(content.text)}</div>`;
-    }
+    // message content (media no longer supported)
+    html += `<div class="msg-text">${esc(content.text)}</div>`;
     // footer
     html += '<div class="msg-footer">';
     html += `<span>${time}</span>`;
@@ -756,39 +708,6 @@ <h3 style="margin-bottom:16px;font-weight:600"><i class="bi bi-info-circle"></i>
   $('replyPreview').style.display = 'none';
 }
 
-// ── Send Media ──
-function pickFile(accept) {
-  $('attachMenu').style.display = 'none';
-  const input = $('fileInput');
-  input.accept = accept;
-  input.click();
-}
-
-async function sendMedia(event) {
-  const file = event.target.files[0];
-  if (!file || !currentDevice || !currentJid) return;
-
-  const fd = new FormData();
-  fd.append('deviceId', currentDevice);
-  fd.append('recipient', currentJid);
-  fd.append('file', file);
-  if (replyTarget) fd.append('replyId', replyTarget.id);
-
-  try {
-    await api('/messages/send-media', { method: 'POST', body: fd });
-    cancelReply();
-    toast('Media sent');
-    fetchMessages();
-    loadChats();
-  } catch (e) { toast('Send media failed: ' + e.message, 'error'); }
-  event.target.value = '';
-}
-
-function toggleAttachMenu() {
-  const el = $('attachMenu');
-  el.style.display = el.style.display === 'none' ? 'flex' : 'none';
-}
-
 // ── SSE Live ──
 let typingTimers = {};
 
diff --git a/src/server/connections/index.ts b/src/server/connections/index.ts
index ae41616..af2ea35 100644
--- a/src/server/connections/index.ts
+++ b/src/server/connections/index.ts
@@ -1,10 +1,10 @@
+import { DB_PATH } from '@/config';
 import { logger } from '@/logger';
 import { SessionManager } from '@/whatsapp/session-manager';
-import { DB_PATH } from '@/config';
 import { Elysia, t } from 'elysia';
-import { stringify } from 'qs';
-import { readdirSync, statSync, existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { stringify } from 'qs';
 
 const sessionManager = SessionManager.getInstance();
 const refreshGroupsRateLimit = new Map<string, number>();
@@ -19,7 +19,9 @@ function getDirSize(dir: string): number {
       const full = join(dir, entry.name);
       if (entry.isDirectory()) size += getDirSize(full);
       else if (entry.isFile()) {
-        try { size += statSync(full).size; } catch {}
+        try {
+          size += statSync(full).size;
+        } catch {}
       }
     }
   } catch {}
diff --git a/src/server/contacts/index.ts b/src/server/contacts/index.ts
index 7bb8873..a8406cd 100644
--- a/src/server/contacts/index.ts
+++ b/src/server/contacts/index.ts
@@ -1,11 +1,12 @@
-import { SessionManager } from '@/whatsapp';
+import { SessionManager, messageStore } from '@/whatsapp';
 import { Elysia, t } from 'elysia';
 
 const manager = SessionManager.getInstance();
 
 const getWA = (deviceId: string) => {
   const whatsapp = manager.getSession(deviceId);
-  if (!whatsapp) throw new Error(`Device ${deviceId} not found, please connect first`);
+  if (!whatsapp)
+    throw new Error(`Device ${deviceId} not found, please connect first`);
   return whatsapp;
 };
 
@@ -15,48 +16,43 @@ export const contacts = new Elysia({
     tags: ['Contacts'],
     description: 'Endpoints to get contact information',
   },
-})
-  .get(
-    '/:deviceId',
-    ({ params: { deviceId }, set }) => {
-      try {
-        const whatsapp = getWA(deviceId);
-        const dbQueries = whatsapp.getDbQueries();
+}).get(
+  '/:deviceId',
+  ({ params: { deviceId }, set }) => {
+    try {
+      const whatsapp = getWA(deviceId);
+      const dbQueries = whatsapp.getDbQueries();
 
-        if (!dbQueries) {
-          set.status = 400;
-          return { success: false, message: 'Database not initialized' };
-        }
+      const chats = messageStore.listChatJids(deviceId);
 
-        const chats = dbQueries.listChatJids();
-        const unreads = dbQueries.getAllUnreadCounts();
+      const contacts = chats.map((chat) => {
+        const contact = dbQueries?.getContact(chat.chatJid);
+        return {
+          jid: chat.chatJid,
+          name: contact?.name ?? chat.chatJid.split('@')[0],
+          photo_url: contact?.photo_url ?? null,
+          lastMessage: chat.lastMessage,
+          lastTimestamp: chat.lastTimestamp,
+          messageCount: chat.count,
+        };
+      });
 
-        const contacts = chats.map((chat) => {
-          const contact = dbQueries.getContact(chat.chatJid);
-          return {
-            jid: chat.chatJid,
-            name: contact?.name ?? chat.chatJid.split('@')[0],
-            photo_url: contact?.photo_url ?? null,
-            lastMessage: chat.lastMessage,
-            lastTimestamp: chat.lastTimestamp,
-            messageCount: chat.count,
-            unreadCount: unreads[chat.chatJid] ?? 0,
-          };
-        });
-
-        return { success: true, data: contacts };
-      } catch (error) {
-        set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : String(error) };
-      }
-    },
-    {
-      params: t.Object({
-        deviceId: t.String(),
-      }),
-      detail: {
-        summary: 'List Contacts',
-        description: 'Get all contacts with last message and unread count.',
-      },
+      return { success: true, data: contacts };
+    } catch (error) {
+      set.status = 400;
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+  {
+    params: t.Object({
+      deviceId: t.String(),
+    }),
+    detail: {
+      summary: 'List Contacts',
+      description: 'Get all contacts with last message.',
     },
-  );
+  },
+);
diff --git a/src/server/index.ts b/src/server/index.ts
index 51a61be..80a5750 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -1,7 +1,9 @@
 import { logger } from '@/logger';
+import { SessionManager } from '@/whatsapp';
 import { openapi } from '@elysiajs/openapi';
 import { file } from 'bun';
 import { Elysia, t } from 'elysia';
+import { cpus, freemem, hostname, uptime as osUptime, totalmem } from 'node:os';
 import { version } from 'package.json';
 import { stringify } from 'qs';
 import icon from '../../assets/icon.ico' with { type: 'file' };
@@ -13,8 +15,6 @@ import { contacts } from './contacts';
 import { logs } from './logs';
 import { messages } from './messages';
 import { liveSse } from './sse';
-import { SessionManager } from '@/whatsapp';
-import { totalmem, freemem, hostname, cpus, uptime as osUptime } from 'node:os';
 
 const startTime = Date.now();
 
@@ -177,7 +177,8 @@ const app = new Elysia()
           },
           sessions: {
             active: sessions.length,
-            total_in_db: SessionManager.getInstance().getAllSessionsFromDB().length,
+            total_in_db:
+              SessionManager.getInstance().getAllSessionsFromDB().length,
           },
         },
       };
diff --git a/src/server/messages/index.ts b/src/server/messages/index.ts
index 3464726..46e7c87 100644
--- a/src/server/messages/index.ts
+++ b/src/server/messages/index.ts
@@ -1,15 +1,15 @@
 import { SessionManager } from '@/whatsapp';
 import { isJidGroup, isLidUser, isPnUser } from 'baileys';
 import { Elysia } from 'elysia';
-import { sendRoutes } from './send';
 import { manageRoutes } from './manage';
-import { mediaRoutes } from './media';
+import { sendRoutes } from './send';
 
 const manager = SessionManager.getInstance();
 
 export const getWA = (deviceId: string) => {
   const whatsapp = manager.getSession(deviceId);
-  if (!whatsapp) throw new Error(`Device ${deviceId} not found, please connect first`);
+  if (!whatsapp)
+    throw new Error(`Device ${deviceId} not found, please connect first`);
   return whatsapp;
 };
 
@@ -24,8 +24,11 @@ export const validateJid = (jid: string) => {
 
 export const messages = new Elysia({
   prefix: '/messages',
-  detail: { tags: ['Messages'], summary: 'Messages', description: 'Endpoints to manage and send messages.' },
+  detail: {
+    tags: ['Messages'],
+    summary: 'Messages',
+    description: 'Endpoints to manage and send messages.',
+  },
 })
   .use(sendRoutes)
-  .use(manageRoutes)
-  .use(mediaRoutes);
+  .use(manageRoutes);
diff --git a/src/server/messages/manage.ts b/src/server/messages/manage.ts
index c204ae9..4c9d690 100644
--- a/src/server/messages/manage.ts
+++ b/src/server/messages/manage.ts
@@ -1,6 +1,6 @@
+import { SessionManager, messageStore } from '@/whatsapp';
 import { Elysia, sse, t } from 'elysia';
-import { SessionManager, readMessages } from '@/whatsapp';
-import { getWA, validateJid } from './index';
+import { getWA } from './index';
 
 const manager = SessionManager.getInstance();
 
@@ -10,17 +10,27 @@ export const manageRoutes = new Elysia()
     ({ params: { deviceId }, set }) => {
       try {
         const whatsapp = getWA(deviceId);
-        const dbQueries = whatsapp.getDbQueries();
-        if (!dbQueries) { set.status = 400; return { success: false, message: 'Database not initialized' }; }
-        return { success: true, data: dbQueries.listChatJids() };
+        return { success: true, data: messageStore.listChatJids(deviceId) };
       } catch (error) {
         set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : 'Failed to list chats' };
+        return {
+          success: false,
+          message:
+            error instanceof Error ? error.message : 'Failed to list chats',
+        };
       }
     },
     {
-      params: t.Object({ deviceId: t.String({ minLength: 1, pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$' }) }),
-      detail: { summary: 'List Chat JIDs', description: 'Get all unique chat JIDs with last message.' },
+      params: t.Object({
+        deviceId: t.String({
+          minLength: 1,
+          pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$',
+        }),
+      }),
+      detail: {
+        summary: 'List Chat JIDs',
+        description: 'Get all unique chat JIDs with last message.',
+      },
     },
   )
   .get(
@@ -28,80 +38,129 @@ export const manageRoutes = new Elysia()
     ({ params: { deviceId, chatJid }, query, set }) => {
       try {
         const whatsapp = getWA(deviceId);
-        const dbQueries = whatsapp.getDbQueries();
-        if (!dbQueries) { set.status = 400; return { success: false, message: 'Database not initialized' }; }
-        const messages = dbQueries.listMessages(chatJid, query.limit ?? 50, query.offset ?? 0);
+        const messages = messageStore.listMessages(
+          deviceId,
+          chatJid,
+          query.limit ?? 50,
+          query.offset ?? 0,
+        );
         return { success: true, data: messages };
       } catch (error) {
         set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : 'Failed to list messages' };
+        return {
+          success: false,
+          message:
+            error instanceof Error ? error.message : 'Failed to list messages',
+        };
       }
     },
     {
       params: t.Object({
-        deviceId: t.String({ minLength: 1, pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$' }),
+        deviceId: t.String({
+          minLength: 1,
+          pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$',
+        }),
         chatJid: t.String({ minLength: 1 }),
       }),
-      query: t.Object({ limit: t.Optional(t.Number({ default: 50, maximum: 200 })), offset: t.Optional(t.Number({ default: 0 })) }),
-      detail: { summary: 'List Messages', description: 'Get messages for a specific chat JID.' },
+      query: t.Object({
+        limit: t.Optional(t.Number({ default: 50, maximum: 200 })),
+        offset: t.Optional(t.Number({ default: 0 })),
+      }),
+      detail: {
+        summary: 'List Messages',
+        description: 'Get messages for a specific chat JID.',
+      },
     },
   )
   .get(
     '/sse/:deviceId/:chatJid',
     async function* ({ params: { deviceId, chatJid }, set }) {
       const whatsapp = manager.getSession(deviceId);
-      if (!whatsapp) { set.status = 404; yield sse(JSON.stringify({ error: 'Session not found' })); return; }
-      const dbQueries = whatsapp.getDbQueries();
-      if (!dbQueries) { set.status = 400; yield sse(JSON.stringify({ error: 'Database not initialized' })); return; }
-
+      if (!whatsapp) {
+        set.status = 404;
+        yield sse(JSON.stringify({ error: 'Session not found' }));
+        return;
+      }
       let lastCount = 0;
-      yield sse(JSON.stringify({ type: 'connected', sessionId: deviceId, chatJid }));
+      yield sse(
+        JSON.stringify({ type: 'connected', sessionId: deviceId, chatJid }),
+      );
       while (true) {
         try {
-          const messages = dbQueries.listMessages(chatJid, 200, 0);
-          if (messages.length !== lastCount) { lastCount = messages.length; yield sse(JSON.stringify({ type: 'messages_update', data: messages })); }
-        } catch { yield sse(JSON.stringify({ type: 'error', message: 'Failed to fetch messages' })); }
+          const messages = messageStore.listMessages(deviceId, chatJid, 200, 0);
+          if (messages.length !== lastCount) {
+            lastCount = messages.length;
+            yield sse(
+              JSON.stringify({ type: 'messages_update', data: messages }),
+            );
+          }
+        } catch {
+          yield sse(
+            JSON.stringify({
+              type: 'error',
+              message: 'Failed to fetch messages',
+            }),
+          );
+        }
         await new Promise((r) => setTimeout(r, 2000));
       }
     },
     {
-      params: t.Object({ deviceId: t.String({ minLength: 1, pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$' }), chatJid: t.String({ minLength: 1 }) }),
-      detail: { summary: 'Per-Chat SSE', description: 'Real-time message updates per chat.' },
+      params: t.Object({
+        deviceId: t.String({
+          minLength: 1,
+          pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$',
+        }),
+        chatJid: t.String({ minLength: 1 }),
+      }),
+      detail: {
+        summary: 'Per-Chat SSE',
+        description: 'Real-time message updates per chat.',
+      },
     },
   )
   .get(
     '/sse/:deviceId',
     async function* ({ params: { deviceId }, set }) {
       const whatsapp = manager.getSession(deviceId);
-      if (!whatsapp) { set.status = 404; yield sse(JSON.stringify({ error: 'Session not found' })); return; }
-      const dbQueries = whatsapp.getDbQueries();
-      if (!dbQueries) { set.status = 400; yield sse(JSON.stringify({ error: 'Database not initialized' })); return; }
+      if (!whatsapp) {
+        set.status = 404;
+        yield sse(JSON.stringify({ error: 'Session not found' }));
+        return;
+      }
 
       let lastCount = 0;
       yield sse(JSON.stringify({ type: 'connected', sessionId: deviceId }));
       while (true) {
         try {
-          const chats = dbQueries.listChatJids();
+          const chats = messageStore.listChatJids(deviceId);
           const count = chats.reduce((s, c) => s + c.count, 0);
-          if (count !== lastCount) { lastCount = count; yield sse(JSON.stringify({ type: 'messages_update', data: chats })); }
-        } catch { yield sse(JSON.stringify({ type: 'error', message: 'Failed to fetch messages' })); }
+          if (count !== lastCount) {
+            lastCount = count;
+            yield sse(JSON.stringify({ type: 'messages_update', data: chats }));
+          }
+        } catch {
+          yield sse(
+            JSON.stringify({
+              type: 'error',
+              message: 'Failed to fetch messages',
+            }),
+          );
+        }
         await new Promise((r) => setTimeout(r, 2000));
       }
     },
     {
-      params: t.Object({ deviceId: t.String({ minLength: 1, pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$' }) }),
-      detail: { summary: 'Session SSE', description: 'Real-time message updates for a session.' },
-    },
-  )
-  .post(
-    '/read/:deviceId/:chatJid',
-    async ({ params: { deviceId, chatJid } }) => {
-      const whatsapp = getWA(deviceId);
-      return { success: await readMessages(whatsapp, chatJid) };
-    },
-    {
-      params: t.Object({ deviceId: t.String(), chatJid: t.String() }),
-      detail: { summary: 'Mark as Read', description: 'Mark all messages as read.' },
+      params: t.Object({
+        deviceId: t.String({
+          minLength: 1,
+          pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$',
+        }),
+      }),
+      detail: {
+        summary: 'Session SSE',
+        description: 'Real-time message updates for a session.',
+      },
     },
   )
   .post(
@@ -110,17 +169,32 @@ export const manageRoutes = new Elysia()
       try {
         const whatsapp = getWA(deviceId);
         const socket = whatsapp.getSocket();
-        if (!socket) { set.status = 400; return { success: false, message: 'Socket not connected' }; }
-        await socket.sendMessage(body.jid, { delete: { id: body.messageId, remoteJid: body.jid, fromMe: true } as any });
+        if (!socket) {
+          set.status = 400;
+          return { success: false, message: 'Socket not connected' };
+        }
+        await socket.sendMessage(body.jid, {
+          delete: {
+            id: body.messageId,
+            remoteJid: body.jid,
+            fromMe: true,
+          } as any,
+        });
         return { success: true };
       } catch (error) {
         set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : String(error) };
+        return {
+          success: false,
+          message: error instanceof Error ? error.message : String(error),
+        };
       }
     },
     {
       body: t.Object({ jid: t.String(), messageId: t.String() }),
-      detail: { summary: 'Delete Message', description: 'Delete for everyone.' },
+      detail: {
+        summary: 'Delete Message',
+        description: 'Delete for everyone.',
+      },
     },
   )
   .post(
@@ -128,19 +202,32 @@ export const manageRoutes = new Elysia()
     async ({ params: { deviceId }, body, set }) => {
       try {
         const whatsapp = getWA(deviceId);
-        const dbQueries = whatsapp.getDbQueries();
-        if (!dbQueries) { set.status = 400; return { success: false, message: 'DB not ready' }; }
-        const raw = dbQueries.getMessage(body.messageKey) as any;
-        if (!raw?.message) { set.status = 404; return { success: false, message: 'Message not found' }; }
-        await whatsapp.sendMessage(Bun.randomUUIDv7(), body.targetJid, { forward: raw } as any, undefined, false);
+        const raw = messageStore.get(deviceId, body.messageKey) as any;
+        if (!raw?.message) {
+          set.status = 404;
+          return { success: false, message: 'Message not found' };
+        }
+        await whatsapp.sendMessage(
+          Bun.randomUUIDv7(),
+          body.targetJid,
+          { forward: raw } as any,
+          undefined,
+          false,
+        );
         return { success: true };
       } catch (error) {
         set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : String(error) };
+        return {
+          success: false,
+          message: error instanceof Error ? error.message : String(error),
+        };
       }
     },
     {
       body: t.Object({ targetJid: t.String(), messageKey: t.String() }),
-      detail: { summary: 'Forward Message', description: 'Forward a message to another chat.' },
+      detail: {
+        summary: 'Forward Message',
+        description: 'Forward a message to another chat.',
+      },
     },
   );
diff --git a/src/server/messages/media.ts b/src/server/messages/media.ts
deleted file mode 100644
index 0efa6eb..0000000
--- a/src/server/messages/media.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Elysia, t } from 'elysia';
-import { getWA } from './index';
-import { downloadMedia } from '@/whatsapp';
-
-export const mediaRoutes = new Elysia()
-  .get(
-    '/media/:deviceId/:messageKey',
-    async ({ params: { deviceId, messageKey }, set }) => {
-      try {
-        const whatsapp = getWA(deviceId);
-        const result = await downloadMedia(whatsapp, messageKey);
-        if (!result) { set.status = 404; return { success: false, message: 'Media not found' }; }
-        const file = Bun.file(result.filePath);
-        set.headers['content-type'] = result.mimeType;
-        set.headers['cache-control'] = 'public, max-age=86400';
-        return file;
-      } catch (error) {
-        set.status = 400;
-        return { success: false, message: error instanceof Error ? error.message : String(error) };
-      }
-    },
-    {
-      params: t.Object({ deviceId: t.String(), messageKey: t.String() }),
-      detail: { summary: 'Download Media', description: 'Download cached media from a message.' },
-    },
-  );
diff --git a/src/server/messages/send.ts b/src/server/messages/send.ts
index c218915..64eb8c7 100644
--- a/src/server/messages/send.ts
+++ b/src/server/messages/send.ts
@@ -1,5 +1,5 @@
+import { messageStore } from '@/whatsapp';
 import { Elysia, t } from 'elysia';
-import { proto } from 'baileys';
 import { getWA, validateJid } from './index';
 
 export const sendRoutes = new Elysia()
@@ -22,9 +22,15 @@ export const sendRoutes = new Elysia()
       return { success: true };
     },
     {
-      detail: { summary: 'Send Text Message', description: 'Send a text message via the specified session.' },
+      detail: {
+        summary: 'Send Text Message',
+        description: 'Send a text message via the specified session.',
+      },
       body: t.Object({
-        deviceId: t.String({ minLength: 1, pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$' }),
+        deviceId: t.String({
+          minLength: 1,
+          pattern: '^[a-zA-Z0-9_\\-:@\\.\\|\\!]+$',
+        }),
         id: t.Optional(t.Nullable(t.String())),
         delay: t.Optional(t.Number({ minimum: 0, maximum: 300 })),
         sendPresence: t.Optional(t.Boolean()),
@@ -34,57 +40,6 @@ export const sendRoutes = new Elysia()
       }),
     },
   )
-  .post(
-    '/send-media',
-    async ({ request }) => {
-      const formData = await request.formData().catch(() => null);
-      if (!formData) return { success: false, message: 'Invalid form data' };
-
-      const deviceId = formData.get('deviceId') as string;
-      const recipient = formData.get('recipient') as string;
-      const caption = formData.get('caption') as string | null;
-      const replyId = formData.get('replyId') as string | null;
-
-      try {
-        const whatsapp = getWA(deviceId);
-        const dbQueries = whatsapp.getDbQueries();
-        const jid = recipient;
-        validateJid(jid);
-
-        const file = formData.get('file') as File | null;
-        if (!file) return { success: false, message: 'No file provided' };
-
-        const buffer = Buffer.from(await file.arrayBuffer());
-        const mime = file.type || 'application/octet-stream';
-
-        let messageContent: any;
-        if (mime.startsWith('image/')) messageContent = { image: buffer, caption: caption || '', mimetype: mime };
-        else if (mime.startsWith('audio/')) messageContent = { audio: buffer, mimetype: mime };
-        else if (mime.startsWith('video/')) messageContent = { video: buffer, caption: caption || '', mimetype: mime };
-        else if (mime === 'image/webp') messageContent = { sticker: buffer, mimetype: mime };
-        else messageContent = { document: buffer, fileName: file.name || 'file', mimetype: mime, caption: caption || '' };
-
-        const quotedOption = replyId
-          ? { quoted: (() => {
-              if (dbQueries && replyId.includes('-')) {
-                const raw = dbQueries.getMessage(replyId) as any;
-                if (raw) return raw;
-              }
-              return { key: { id: replyId, remoteJid: jid, fromMe: false } as proto.IMessageKey, message: { conversation: '' } };
-            })() }
-          : undefined;
-
-        await whatsapp.sendMessage(Bun.randomUUIDv7(), jid, messageContent, quotedOption, false);
-        return { success: true };
-      } catch (error) {
-        return { success: false, message: error instanceof Error ? error.message : String(error) };
-      }
-    },
-    {
-      detail: { summary: 'Send Media Message', description: 'Send image/audio/video/document/sticker.' },
-      body: t.Optional(t.Any()),
-    },
-  )
   .post(
     '/send-reply',
     async ({ body: { deviceId, recipient, message, replyMessageKey } }) => {
@@ -92,21 +47,32 @@ export const sendRoutes = new Elysia()
       const jid = recipient;
       validateJid(jid);
 
-      const dbQueries = whatsapp.getDbQueries();
       let quotedMsg = replyMessageKey;
-      if (typeof replyMessageKey === 'string' && dbQueries) {
-        const raw = dbQueries.getMessage(replyMessageKey) as any;
+      if (typeof replyMessageKey === 'string') {
+        const raw = messageStore.get(deviceId, replyMessageKey) as any;
         if (raw) quotedMsg = raw;
       }
 
-      await whatsapp.sendMessage(Bun.randomUUIDv7(), jid, { text: message }, { quoted: quotedMsg } as any, true);
+      await whatsapp.sendMessage(
+        Bun.randomUUIDv7(),
+        jid,
+        { text: message },
+        { quoted: quotedMsg } as any,
+        true,
+      );
       return { success: true };
     },
     {
-      detail: { summary: 'Send Reply', description: 'Send a reply to a quoted message.' },
+      detail: {
+        summary: 'Send Reply',
+        description: 'Send a reply to a quoted message.',
+      },
       body: t.Object({
-        deviceId: t.String(), recipient: t.String(), message: t.String(),
-        replyMessageKey: t.Any(), sendPresence: t.Optional(t.Boolean()),
+        deviceId: t.String(),
+        recipient: t.String(),
+        message: t.String(),
+        replyMessageKey: t.Any(),
+        sendPresence: t.Optional(t.Boolean()),
       }),
     },
   );
diff --git a/src/server/sse/index.ts b/src/server/sse/index.ts
index 16558e2..0547868 100644
--- a/src/server/sse/index.ts
+++ b/src/server/sse/index.ts
@@ -11,31 +11,37 @@ export const liveSse = new Elysia({
   '/:deviceId/live',
   ({ params: { deviceId }, request }) => {
     let closed = false;
+    let unsubscribe: (() => void) | null = null;
+    let keepalive: ReturnType<typeof setInterval> | null = null;
+
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      unsubscribe?.();
+      if (keepalive) clearInterval(keepalive);
+    };
 
     const stream = new ReadableStream({
       start(controller) {
-        const unsubscribe = WhatsAppSession.subscribeSse(deviceId, (data: string) => {
-          if (!closed) {
-            try {
-              controller.enqueue(new TextEncoder().encode(`data: ${data}\n\n`));
-            } catch {}
-          }
+        unsubscribe = WhatsAppSession.subscribeSse(deviceId, (data: string) => {
+          if (closed) return;
+          if (controller.desiredSize !== null && controller.desiredSize <= 0)
+            return;
+          try {
+            controller.enqueue(new TextEncoder().encode(`data: ${data}\n\n`));
+          } catch {}
         });
 
-        const keepalive = setInterval(() => {
-          if (!closed) {
-            try {
-              controller.enqueue(new TextEncoder().encode(':\n\n'));
-            } catch {}
-          }
+        keepalive = setInterval(() => {
+          if (closed) return;
+          try {
+            controller.enqueue(new TextEncoder().encode(':\n\n'));
+          } catch {}
         }, 30000);
 
-        request.signal.addEventListener('abort', () => {
-          closed = true;
-          unsubscribe();
-          clearInterval(keepalive);
-        });
+        request.signal.addEventListener('abort', cleanup);
       },
+      cancel: cleanup,
     });
 
     return new Response(stream, {
diff --git a/src/shutdown.ts b/src/shutdown.ts
index f3706d8..e85a8b0 100644
--- a/src/shutdown.ts
+++ b/src/shutdown.ts
@@ -7,7 +7,6 @@ const shutdown = async (signal: NodeJS.Signals) => {
   const sessions = SessionManager.getInstance().getAllSessions();
   for (const session of sessions) {
     logger.info(`Closing session ${session.sessionId}...`);
-    session.pruneOldMessages();
     await session.disconnect();
     logger.info(`Session ${session.sessionId} closed.`);
   }
diff --git a/src/whatsapp/db-migration.ts b/src/whatsapp/db-migration.ts
index c4eb185..fabea17 100644
--- a/src/whatsapp/db-migration.ts
+++ b/src/whatsapp/db-migration.ts
@@ -7,6 +7,7 @@ export const startDbMigration = (db: Database) => {
   db.run('PRAGMA temp_store = MEMORY;');
   db.run('PRAGMA mmap_size = 33554432;');
   db.run('PRAGMA auto_vacuum = INCREMENTAL;');
+  db.run('PRAGMA busy_timeout = 5000;');
 
   if (Bun.env.NODE_ENV === 'production') {
     db.run('PRAGMA locking_mode = EXCLUSIVE;'); // Exclusive locking for single-writer scenarios
@@ -20,31 +21,12 @@ export const startDbMigration = (db: Database) => {
     created_at INTEGER NOT NULL DEFAULT (unixepoch())
   )`);
 
-  db.run(`CREATE TABLE IF NOT EXISTS messages (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL,
-    created_at INTEGER NOT NULL DEFAULT (unixepoch())
-  )`);
-
   db.run(`CREATE TABLE IF NOT EXISTS groups (
     key TEXT PRIMARY KEY,
     value TEXT NOT NULL,
     created_at INTEGER NOT NULL DEFAULT (unixepoch())
   )`);
 
-  db.run(
-    `CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);`,
-  );
-  db.run(
-    `CREATE INDEX IF NOT EXISTS idx_messages_key ON messages(key);`,
-  );
-  db.run(
-    `CREATE INDEX IF NOT EXISTS idx_messages_chatjid ON messages(substr(key, 1, instr(key, '-') - 1), created_at DESC);`,
-  );
-  db.run(
-    `CREATE INDEX IF NOT EXISTS idx_groups_created_at ON groups(created_at);`,
-  );
-
   db.run(`CREATE TABLE IF NOT EXISTS contacts (
     jid TEXT PRIMARY KEY,
     name TEXT,
@@ -53,18 +35,8 @@ export const startDbMigration = (db: Database) => {
     last_seen INTEGER
   )`);
 
-  db.run(`CREATE TABLE IF NOT EXISTS chat_status (
-    chat_jid TEXT PRIMARY KEY,
-    last_read_message_key TEXT,
-    unread_count INTEGER DEFAULT 0,
-    updated_at INTEGER
-  )`);
-
-  db.run(`CREATE TABLE IF NOT EXISTS media_cache (
-    message_key TEXT PRIMARY KEY,
-    file_path TEXT,
-    mime_type TEXT,
-    file_size INTEGER,
-    downloaded_at INTEGER
-  )`);
+  // Legacy tables from when messages were persisted — no longer used
+  db.run(`DROP TABLE IF EXISTS messages`);
+  db.run(`DROP TABLE IF EXISTS media_cache`);
+  db.run(`DROP TABLE IF EXISTS chat_status`);
 };
diff --git a/src/whatsapp/index.ts b/src/whatsapp/index.ts
index 094dfba..7af0bb9 100644
--- a/src/whatsapp/index.ts
+++ b/src/whatsapp/index.ts
@@ -1,4 +1,4 @@
+export { messageStore } from './message-store';
 export { SessionManager } from './session-manager';
 export { validatePhoneNumber } from './validate-phone-number';
 export { WhatsAppSession } from './whatsapp-session';
-export { downloadMedia, readMessages } from './session-media';
diff --git a/src/whatsapp/message-store.ts b/src/whatsapp/message-store.ts
new file mode 100644
index 0000000..de4ceb6
--- /dev/null
+++ b/src/whatsapp/message-store.ts
@@ -0,0 +1,181 @@
+const MAX_PER_DEVICE = Number(Bun.env.SENT_MESSAGES_PER_DEVICE ?? 50);
+
+interface ChatIndex {
+  lastKey: string;
+  lastMessage: unknown;
+  count: number;
+  lastTimestamp: number;
+}
+
+export interface ChatSummary {
+  chatJid: string;
+  lastMessage: unknown;
+  count: number;
+  lastTimestamp: number;
+}
+
+/**
+ * Per-device store of the most recent SENT messages (fromMe only).
+ * Incoming messages and media are intentionally not stored to keep memory
+ * and CPU low. Each device is capped at MAX_PER_DEVICE messages; the oldest
+ * sent message is evicted when the cap is exceeded.
+ */
+class MessageStore {
+  private devices = new Map<string, Map<string, unknown>>();
+  private chats = new Map<string, Map<string, ChatIndex>>();
+
+  private device(deviceId: string): Map<string, unknown> {
+    let m = this.devices.get(deviceId);
+    if (!m) {
+      m = new Map();
+      this.devices.set(deviceId, m);
+    }
+    return m;
+  }
+
+  private chatIndex(deviceId: string): Map<string, ChatIndex> {
+    let m = this.chats.get(deviceId);
+    if (!m) {
+      m = new Map();
+      this.chats.set(deviceId, m);
+    }
+    return m;
+  }
+
+  upsert(deviceId: string, msg: any): void {
+    if (!msg?.key?.id || !msg?.key?.remoteJid) return;
+    if (!msg.key.fromMe) return;
+
+    const key = `${msg.key.remoteJid}-${msg.key.id}`;
+    const dev = this.device(deviceId);
+    const existing = dev.get(key);
+    const isNew = !existing;
+
+    if (existing) {
+      Object.assign(existing, msg);
+    } else {
+      dev.set(key, msg);
+      this.updateChatIndex(deviceId, msg, key, true);
+      this.evict(deviceId);
+      return;
+    }
+    this.updateChatIndex(deviceId, msg, key, false);
+  }
+
+  get(deviceId: string, msgKey: string): unknown {
+    return this.device(deviceId).get(msgKey);
+  }
+
+  listMessages(
+    deviceId: string,
+    chatJid: string,
+    limit = 50,
+    offset = 0,
+  ): unknown[] {
+    const dev = this.device(deviceId);
+    const prefix = `${chatJid}-`;
+    const out: unknown[] = [];
+    for (const [k, v] of dev) {
+      if (k.startsWith(prefix)) out.push(v);
+    }
+    out.reverse();
+    return out.slice(offset, offset + limit);
+  }
+
+  listChatJids(deviceId: string): ChatSummary[] {
+    const idx = this.chatIndex(deviceId);
+    const dev = this.device(deviceId);
+    const out: ChatSummary[] = [];
+    for (const [jid, chat] of idx) {
+      let lastMessage = chat.lastMessage;
+      if (lastMessage && !dev.has(chat.lastKey)) {
+        lastMessage = null;
+      }
+      if (lastMessage === null) {
+        lastMessage = this.recomputeLastMessage(dev, jid);
+        const best = lastMessage as any;
+        if (best?.key?.id && best.key.remoteJid === jid) {
+          chat.lastKey = `${jid}-${best.key.id}`;
+        }
+      }
+      out.push({
+        chatJid: jid,
+        lastMessage,
+        count: chat.count,
+        lastTimestamp: chat.lastTimestamp,
+      });
+    }
+    out.sort((a, b) => b.lastTimestamp - a.lastTimestamp);
+    return out;
+  }
+
+  private recomputeLastMessage(
+    dev: Map<string, unknown>,
+    jid: string,
+  ): unknown {
+    let best: unknown = null;
+    let bestTs = 0;
+    for (const [k, v] of dev) {
+      if (!k.startsWith(`${jid}-`)) continue;
+      const msg = v as any;
+      const ts = Number(msg.messageTimestamp ?? 0);
+      if (ts >= bestTs) {
+        best = v;
+        bestTs = ts;
+      }
+    }
+    return best;
+  }
+
+  private updateChatIndex(
+    deviceId: string,
+    msg: any,
+    key: string,
+    isNew: boolean,
+  ): void {
+    const jid = msg.key.remoteJid;
+    const ts = Number(msg.messageTimestamp ?? 0);
+    const idx = this.chatIndex(deviceId);
+    const chat = idx.get(jid);
+    if (!chat) {
+      idx.set(jid, {
+        lastKey: key,
+        lastMessage: msg,
+        count: 1,
+        lastTimestamp: ts,
+      });
+      return;
+    }
+    if (isNew) chat.count++;
+    if (ts >= chat.lastTimestamp) {
+      chat.lastKey = key;
+      chat.lastMessage = msg;
+      chat.lastTimestamp = ts;
+    }
+  }
+
+  private evict(deviceId: string): void {
+    const dev = this.device(deviceId);
+    while (dev.size > MAX_PER_DEVICE) {
+      const first = dev.entries().next().value as [string, unknown] | undefined;
+      if (!first) break;
+      const [key] = first;
+      dev.delete(key);
+      this.onEvict(deviceId, key);
+    }
+  }
+
+  private onEvict(deviceId: string, key: string): void {
+    const dash = key.indexOf('-');
+    if (dash < 0) return;
+    const jid = key.slice(0, dash);
+    const idx = this.chatIndex(deviceId);
+    const chat = idx.get(jid);
+    if (!chat) return;
+    chat.count--;
+    if (chat.lastKey === key) chat.lastMessage = null;
+    if (chat.count <= 0) idx.delete(jid);
+  }
+}
+
+export const messageStore = new MessageStore();
diff --git a/src/whatsapp/queries/contacts.ts b/src/whatsapp/queries/contacts.ts
index 6df3995..43572e1 100644
--- a/src/whatsapp/queries/contacts.ts
+++ b/src/whatsapp/queries/contacts.ts
@@ -4,7 +4,11 @@ import { Database } from 'bun:sqlite';
 export class ContactsQueries {
   constructor(private db: Database) {}
 
-  upsertContact(jid: string, name?: string | null, photoUrl?: string | null): void {
+  upsertContact(
+    jid: string,
+    name?: string | null,
+    photoUrl?: string | null,
+  ): void {
     let query;
     try {
       query = this.db.query(
@@ -19,10 +23,15 @@ export class ContactsQueries {
     }
   }
 
-  getContact(jid: string): { jid: string; name: string | null; photo_url: string | null } | undefined {
+  getContact(
+    jid: string,
+  ):
+    { jid: string; name: string | null; photo_url: string | null } | undefined {
     let query;
     try {
-      query = this.db.query('SELECT jid, name, photo_url FROM contacts WHERE jid = $jid');
+      query = this.db.query(
+        'SELECT jid, name, photo_url FROM contacts WHERE jid = $jid',
+      );
       return query.get({ $jid: jid }) as any;
     } catch {
       return undefined;
diff --git a/src/whatsapp/queries/groups.ts b/src/whatsapp/queries/groups.ts
new file mode 100644
index 0000000..3bfc92c
--- /dev/null
+++ b/src/whatsapp/queries/groups.ts
@@ -0,0 +1,40 @@
+import { logger } from '@/logger';
+import { BufferJSON } from 'baileys';
+import { Database } from 'bun:sqlite';
+
+export class GroupsQueries {
+  constructor(private db: Database) {}
+
+  getGroup(key: string): unknown {
+    let query;
+    try {
+      query = this.db.query(
+        'SELECT value FROM groups WHERE key = $key LIMIT 1',
+      );
+      const row = query.get({ $key: key }) as { value: string } | undefined;
+      if (row?.value) return JSON.parse(row.value, BufferJSON.reviver);
+      return undefined;
+    } catch (error) {
+      logger.error({ error, key }, '[GroupsQueries] Error getting group');
+      throw error;
+    } finally {
+      query?.finalize();
+    }
+  }
+
+  upsertGroup(key: string, value: unknown): void {
+    let query;
+    try {
+      const serialized = JSON.stringify(value, BufferJSON.replacer);
+      query = this.db.query(
+        `INSERT INTO groups (key, value) VALUES ($key, $value) ON CONFLICT(key) DO UPDATE SET value = $value`,
+      );
+      query.run({ $key: key, $value: serialized });
+    } catch (error) {
+      logger.error({ error, key }, '[GroupsQueries] Error upserting group');
+      throw error;
+    } finally {
+      query?.finalize();
+    }
+  }
+}
diff --git a/src/whatsapp/queries/index.ts b/src/whatsapp/queries/index.ts
index eb05985..aaeff04 100644
--- a/src/whatsapp/queries/index.ts
+++ b/src/whatsapp/queries/index.ts
@@ -1,39 +1,35 @@
 import { Database } from 'bun:sqlite';
-import { proto } from 'baileys';
-import { MessagesQueries } from './messages';
 import { ContactsQueries } from './contacts';
-import { StatusQueries } from './status';
-import { MediaQueries } from './media';
+import { GroupsQueries } from './groups';
 
 export class DatabaseQueries {
-  messages: MessagesQueries;
+  groups: GroupsQueries;
   contacts: ContactsQueries;
-  status: StatusQueries;
-  media: MediaQueries;
 
   constructor(private db: Database) {
-    this.messages = new MessagesQueries(db);
+    this.groups = new GroupsQueries(db);
     this.contacts = new ContactsQueries(db);
-    this.status = new StatusQueries(db);
-    this.media = new MediaQueries(db);
   }
 
   // ── Proxies (backward compat, callers keep using dbQueries.getGroup()) ──
 
-  getGroup(key: string): unknown { return this.messages.getGroup(key); }
-  getMessage(key: string): unknown { return this.messages.getMessage(key); }
-  upsertMessage(key: string, value: unknown): void { return this.messages.upsertMessage(key, value); }
-  upsertGroup(key: string, value: unknown): void { return this.messages.upsertGroup(key, value); }
-  deleteOldMessages(cutoffSeconds: number): number { return this.messages.deleteOldMessages(cutoffSeconds); }
-  listChatJids(): Array<{ chatJid: string; lastMessage: unknown; count: number; lastTimestamp: number }> { return this.messages.listChatJids(); }
-  listMessages(chatJid: string, limit?: number, offset?: number): unknown[] { return this.messages.listMessages(chatJid, limit, offset); }
-  getUnreadMessageKeys(jid: string): proto.IMessageKey[] { return this.messages.getUnreadMessageKeys(jid); }
-  upsertContact(jid: string, name?: string | null, photoUrl?: string | null): void { return this.contacts.upsertContact(jid, name, photoUrl); }
-  getContact(jid: string): { jid: string; name: string | null; photo_url: string | null } | undefined { return this.contacts.getContact(jid); }
-  incrementUnread(chatJid: string): void { return this.status.incrementUnread(chatJid); }
-  resetUnread(chatJid: string): void { return this.status.resetUnread(chatJid); }
-  getUnreadCount(chatJid: string): number { return this.status.getUnreadCount(chatJid); }
-  getAllUnreadCounts(): Record<string, number> { return this.status.getAllUnreadCounts(); }
-  cacheMedia(key: string, filePath: string, mimeType: string, fileSize: number): void { return this.media.cacheMedia(key, filePath, mimeType, fileSize); }
-  getCachedMedia(key: string): { file_path: string; mime_type: string; file_size: number } | undefined { return this.media.getCachedMedia(key); }
+  getGroup(key: string): unknown {
+    return this.groups.getGroup(key);
+  }
+  upsertGroup(key: string, value: unknown): void {
+    return this.groups.upsertGroup(key, value);
+  }
+  upsertContact(
+    jid: string,
+    name?: string | null,
+    photoUrl?: string | null,
+  ): void {
+    return this.contacts.upsertContact(jid, name, photoUrl);
+  }
+  getContact(
+    jid: string,
+  ):
+    { jid: string; name: string | null; photo_url: string | null } | undefined {
+    return this.contacts.getContact(jid);
+  }
 }
diff --git a/src/whatsapp/queries/media.ts b/src/whatsapp/queries/media.ts
deleted file mode 100644
index 26a63a4..0000000
--- a/src/whatsapp/queries/media.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { logger } from '@/logger';
-import { Database } from 'bun:sqlite';
-
-export class MediaQueries {
-  constructor(private db: Database) {}
-
-  cacheMedia(key: string, filePath: string, mimeType: string, fileSize: number): void {
-    let query;
-    try {
-      query = this.db.query(
-        `INSERT INTO media_cache (message_key, file_path, mime_type, file_size, downloaded_at)
-         VALUES ($key, $path, $mime, $size, unixepoch())
-         ON CONFLICT(message_key) DO UPDATE SET downloaded_at = unixepoch()`,
-      );
-      query.run({ $key: key, $path: filePath, $mime: mimeType, $size: fileSize });
-    } catch (error) {
-      logger.error({ error, key }, '[DatabaseQueries] Error caching media');
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  getCachedMedia(key: string): { file_path: string; mime_type: string; file_size: number } | undefined {
-    let query;
-    try {
-      query = this.db.query('SELECT file_path, mime_type, file_size FROM media_cache WHERE message_key = $key');
-      return query.get({ $key: key }) as any;
-    } catch {
-      return undefined;
-    } finally {
-      query?.finalize();
-    }
-  }
-}
diff --git a/src/whatsapp/queries/messages.ts b/src/whatsapp/queries/messages.ts
deleted file mode 100644
index 6b8f898..0000000
--- a/src/whatsapp/queries/messages.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { logger } from '@/logger';
-import { BufferJSON, proto } from 'baileys';
-import { Database } from 'bun:sqlite';
-
-export class MessagesQueries {
-  constructor(private db: Database) {}
-
-  getGroup(key: string): unknown {
-    let query;
-    try {
-      query = this.db.query('SELECT value FROM groups WHERE key = $key LIMIT 1');
-      const row = query.get({ $key: key }) as { value: string } | undefined;
-      if (row?.value) return JSON.parse(row.value, BufferJSON.reviver);
-      return undefined;
-    } catch (error) {
-      logger.error({ error, key }, '[DatabaseQueries] Error getting group');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  getMessage(key: string): unknown {
-    let query;
-    try {
-      query = this.db.query('SELECT value FROM messages WHERE key = $key LIMIT 1');
-      const row = query.get({ $key: key }) as { value: string } | undefined;
-      if (row?.value) return JSON.parse(row.value, BufferJSON.reviver);
-      return undefined;
-    } catch (error) {
-      logger.error({ error, key }, '[DatabaseQueries] Error getting message');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  upsertMessage(key: string, value: unknown): void {
-    let query;
-    try {
-      const serialized = JSON.stringify(value, BufferJSON.replacer);
-      query = this.db.query(
-        `INSERT INTO messages (key, value) VALUES ($key, $value) ON CONFLICT(key) DO UPDATE SET value = json_patch(messages.value, EXCLUDED.value)`,
-      );
-      query.run({ $key: key, $value: serialized });
-    } catch (error) {
-      logger.error({ error, key }, '[DatabaseQueries] Error upserting message');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  upsertGroup(key: string, value: unknown): void {
-    let query;
-    try {
-      const serialized = JSON.stringify(value, BufferJSON.replacer);
-      query = this.db.query(
-        `INSERT INTO groups (key, value) VALUES ($key, $value) ON CONFLICT(key) DO UPDATE SET value = json_patch(groups.value, EXCLUDED.value)`,
-      );
-      query.run({ $key: key, $value: serialized });
-    } catch (error) {
-      logger.error({ error, key }, '[DatabaseQueries] Error upserting group');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  deleteOldMessages(cutoffSeconds: number): number {
-    let query;
-    try {
-      query = this.db.query('DELETE FROM messages WHERE created_at < $cutoff');
-      const result = query.run({ $cutoff: cutoffSeconds });
-      if (result.changes > 0) {
-        logger.info(`[DatabaseQueries] ${result.changes} messages deleted. Optimizing DB...`);
-        this.db.run('PRAGMA wal_checkpoint(TRUNCATE);');
-        this.db.run('PRAGMA incremental_vacuum;');
-        logger.info('[DatabaseQueries] Optimization complete.');
-      }
-      return result.changes;
-    } catch (error) {
-      logger.error({ error }, '[DatabaseQueries] Error deleting old messages');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  listChatJids(): Array<{ chatJid: string; lastMessage: unknown; count: number; lastTimestamp: number }> {
-    let query;
-    try {
-      // Single query: get stats + last message per chat using window function
-      query = this.db.query(`
-        SELECT
-          substr(key, 1, instr(key, '-') - 1) as chatJid,
-          MAX(created_at) as lastTimestamp,
-          COUNT(*) as count,
-          (SELECT value FROM messages m2
-           WHERE substr(m2.key, 1, instr(m2.key, '-') - 1) = substr(messages.key, 1, instr(messages.key, '-') - 1)
-           ORDER BY m2.created_at DESC LIMIT 1) as lastMessage
-        FROM messages
-        GROUP BY chatJid
-        ORDER BY lastTimestamp DESC`);
-      const rows = query.all() as Array<{ chatJid: string; lastTimestamp: number; count: number; lastMessage: string | null }>;
-      return rows.map((row) => ({
-        chatJid: row.chatJid,
-        lastMessage: row.lastMessage ? JSON.parse(row.lastMessage, BufferJSON.reviver) : null,
-        count: row.count,
-        lastTimestamp: row.lastTimestamp,
-      }));
-    } catch (error) {
-      logger.error({ error }, '[DatabaseQueries] Error listing chat JIDs');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  listMessages(chatJid: string, limit = 50, offset = 0): unknown[] {
-    let query;
-    try {
-      query = this.db.query('SELECT value FROM messages WHERE key LIKE $pattern ORDER BY created_at DESC LIMIT $limit OFFSET $offset');
-      const rows = query.all({ $pattern: `${chatJid}-%`, $limit: limit, $offset: offset }) as Array<{ value: string }>;
-      return rows.map((row) => JSON.parse(row.value, BufferJSON.reviver));
-    } catch (error) {
-      logger.error({ error, chatJid }, '[DatabaseQueries] Error listing messages');
-      throw error;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  getUnreadMessageKeys(jid: string): proto.IMessageKey[] {
-    const keys: proto.IMessageKey[] = [];
-    let query;
-    try {
-      query = this.db.query('SELECT value FROM messages WHERE key LIKE $pattern ORDER BY created_at ASC');
-      const rows = query.all({ $pattern: `${jid}-%` }) as Array<{ value: string }>;
-      for (const row of rows) {
-        const msg = JSON.parse(row.value, BufferJSON.reviver) as any;
-        if (msg.key && !msg.key.fromMe) {
-          keys.push({ remoteJid: jid, id: msg.key.id, fromMe: false });
-        }
-      }
-    } catch (error) {
-      logger.error({ error, jid }, '[DatabaseQueries] Error getting unread message keys');
-    } finally {
-      query?.finalize();
-    }
-    return keys;
-  }
-}
diff --git a/src/whatsapp/queries/status.ts b/src/whatsapp/queries/status.ts
deleted file mode 100644
index 95b89d3..0000000
--- a/src/whatsapp/queries/status.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { logger } from '@/logger';
-import { Database } from 'bun:sqlite';
-
-export class StatusQueries {
-  constructor(private db: Database) {}
-
-  incrementUnread(chatJid: string): void {
-    let query;
-    try {
-      query = this.db.query(
-        `INSERT INTO chat_status (chat_jid, unread_count, updated_at)
-         VALUES ($jid, 1, unixepoch())
-         ON CONFLICT(chat_jid) DO UPDATE SET unread_count = chat_status.unread_count + 1, updated_at = unixepoch()`,
-      );
-      query.run({ $jid: chatJid });
-    } catch (error) {
-      logger.error({ error, chatJid }, '[DatabaseQueries] Error incrementing unread');
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  resetUnread(chatJid: string): void {
-    let query;
-    try {
-      query = this.db.query(
-        `INSERT INTO chat_status (chat_jid, unread_count, updated_at)
-         VALUES ($jid, 0, unixepoch())
-         ON CONFLICT(chat_jid) DO UPDATE SET unread_count = 0, updated_at = unixepoch()`,
-      );
-      query.run({ $jid: chatJid });
-    } catch (error) {
-      logger.error({ error, chatJid }, '[DatabaseQueries] Error resetting unread');
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  getUnreadCount(chatJid: string): number {
-    let query;
-    try {
-      query = this.db.query('SELECT unread_count FROM chat_status WHERE chat_jid = $jid');
-      const row = query.get({ $jid: chatJid }) as { unread_count: number } | undefined;
-      return row?.unread_count ?? 0;
-    } catch {
-      return 0;
-    } finally {
-      query?.finalize();
-    }
-  }
-
-  getAllUnreadCounts(): Record<string, number> {
-    let query;
-    try {
-      query = this.db.query('SELECT chat_jid, unread_count FROM chat_status WHERE unread_count > 0');
-      const rows = query.all() as Array<{ chat_jid: string; unread_count: number }>;
-      const map: Record<string, number> = {};
-      for (const r of rows) map[r.chat_jid] = r.unread_count;
-      return map;
-    } catch {
-      return {};
-    } finally {
-      query?.finalize();
-    }
-  }
-}
diff --git a/src/whatsapp/session-media.ts b/src/whatsapp/session-media.ts
deleted file mode 100644
index e41a423..0000000
--- a/src/whatsapp/session-media.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
-import { downloadContentFromMessage } from 'baileys/lib/Utils/messages-media';
-import { proto } from 'baileys';
-import type { WhatsAppSession } from './whatsapp-session';
-
-export async function downloadMedia(session: WhatsAppSession, messageKey: string) {
-  const dbQueries = session.getDbQueries();
-  if (!dbQueries) return null;
-
-  const cached = dbQueries.media.getCachedMedia(messageKey);
-  if (cached) return { filePath: cached.file_path, mimeType: cached.mime_type };
-
-  const msg = dbQueries.messages.getMessage(messageKey) as any;
-  if (!msg?.message) return null;
-
-  const msgKeys = Object.keys(msg.message);
-  if (msgKeys.length === 0) return null;
-
-  const msgType = msgKeys[0]!;
-  const mediaContent = msg.message[msgType];
-  if (!mediaContent) return null;
-
-  const typeMap: Record<string, string> = { imageMessage: 'image', videoMessage: 'video', audioMessage: 'audio', documentMessage: 'document', stickerMessage: 'sticker' };
-  const mediaType = typeMap[msgType];
-  if (!mediaType) return null;
-
-  if (!mediaContent.mediaKey && !mediaContent.fileSha256 && !mediaContent.url) return null;
-
-  const ext = msgType === 'imageMessage' ? 'jpg'
-    : msgType === 'videoMessage' ? 'mp4'
-    : msgType === 'audioMessage' ? (mediaContent.mimetype?.includes('ogg') ? 'ogg' : 'mp3')
-    : msgType === 'stickerMessage' ? 'webp'
-    : 'bin';
-
-  const mediaDir = `${session.mediaDir}/${mediaType}`;
-  await mkdir(mediaDir, { recursive: true });
-  const filePath = `${mediaDir}/${messageKey}.${ext}`;
-
-  try {
-    const stream = await downloadContentFromMessage(mediaContent, mediaType as any);
-    const writeStream = createWriteStream(filePath);
-    for await (const chunk of stream as AsyncIterable<Buffer>) writeStream.write(chunk);
-    await new Promise<void>((r) => writeStream.end(r));
-  } catch (err) {
-    try { await import('node:fs/promises').then((m) => m.unlink(filePath)); } catch {}
-    return null;
-  }
-
-  const mimeType = mediaContent.mimetype ?? `image/${ext}`;
-  const stats = await import('node:fs/promises').then((m) => m.stat(filePath));
-  dbQueries.media.cacheMedia(messageKey, filePath, mimeType, stats.size);
-  return { filePath, mimeType };
-}
-
-export async function readMessages(session: WhatsAppSession, jid: string): Promise<boolean> {
-  const socket = (session as any).socket;
-  const dbQueries = session.getDbQueries();
-  if (!socket || !dbQueries) return false;
-
-  try {
-    const keys = dbQueries.messages.getUnreadMessageKeys(jid);
-    if (keys.length > 0) await socket.readMessages(keys);
-    dbQueries.status.resetUnread(jid);
-    return true;
-  } catch {
-    return false;
-  }
-}
diff --git a/src/whatsapp/whatsapp-session.ts b/src/whatsapp/whatsapp-session.ts
index 966dde6..5b3fa84 100644
--- a/src/whatsapp/whatsapp-session.ts
+++ b/src/whatsapp/whatsapp-session.ts
@@ -17,20 +17,18 @@ import {
   type WASocket,
 } from 'baileys';
 import { Database } from 'bun:sqlite';
-import { Cron } from 'croner';
 import { randomInt } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { createWriteStream } from 'node:fs';
 import { mkdir, rm } from 'node:fs/promises';
 import PQueue from 'p-queue';
 import P from 'pino';
 import { stringify } from 'qs';
 import { startDbMigration } from './db-migration';
+import { messageStore } from './message-store';
 import { DatabaseQueries } from './queries';
 import { useSqliteAuthState } from './sqlite-auth-state';
 import { validatePhoneNumber } from './validate-phone-number';
 import { createWhatsAppLogger } from './whatsapp-logger';
-import { downloadContentFromMessage } from 'baileys/lib/Utils/messages-media';
 
 /**
  * Event map for WhatsAppSession
@@ -56,12 +54,21 @@ interface WhatsAppSessionEvents {
  */
 export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
   private static sseClients = new Map<string, Set<(data: string) => void>>();
+  private static readonly SSE_CLIENTS_PER_DEVICE = 50;
 
-  static subscribeSse(deviceId: string, callback: (data: string) => void): () => void {
+  static subscribeSse(
+    deviceId: string,
+    callback: (data: string) => void,
+  ): () => void {
     if (!this.sseClients.has(deviceId)) {
       this.sseClients.set(deviceId, new Set());
     }
-    this.sseClients.get(deviceId)!.add(callback);
+    const clients = this.sseClients.get(deviceId)!;
+    if (clients.size >= this.SSE_CLIENTS_PER_DEVICE) {
+      const oldest = clients.values().next().value;
+      if (oldest) clients.delete(oldest);
+    }
+    clients.add(callback);
     return () => this.sseClients.get(deviceId)?.delete(callback);
   }
 
@@ -69,7 +76,9 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
     const clients = this.sseClients.get(deviceId);
     if (clients) {
       for (const cb of clients) {
-        try { cb(data); } catch {}
+        try {
+          cb(data);
+        } catch {}
       }
     }
   }
@@ -82,7 +91,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
   private db: Database | null = null;
   private dbQueries: DatabaseQueries | null = null;
   private dbDirectory: string;
-  public mediaDir: string;
   private DEFAULT_TIMEOUT = 0;
 
   private socket: WASocket | null = null;
@@ -96,9 +104,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
   private readonly MAX_RETRIES = 3;
   private readonly RETRY_DELAY = 5_000;
   private webhookMutex = new Mutex();
-  private pruneJob: Cron | null = null;
-  private onlineTimer: NodeJS.Timeout | null = null;
-
   private dailyMessageCount: number = 0;
   private dailyMessageDate: string = '';
   private dailyMessageLimit: number = 0;
@@ -130,7 +135,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
     }
 
     this.dbDirectory = `${DB_PATH}/${this.sessionId}`;
-    this.mediaDir = `${this.dbDirectory}/media`;
     this.webhookUrl = webhookUrl;
   }
 
@@ -201,24 +205,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
     };
   }
 
-  private async setOnline(): Promise<void> {
-    if (!this.socket) return;
-    clearTimeout(this.onlineTimer!);
-    try {
-      await this.socket.sendPresenceUpdate('available');
-    } catch {}
-  }
-
-  private scheduleOffline(): void {
-    clearTimeout(this.onlineTimer!);
-    this.onlineTimer = setTimeout(async () => {
-      try {
-        await this.socket?.sendPresenceUpdate('unavailable');
-      } catch {}
-      this.onlineTimer = null;
-    }, 10000);
-  }
-
   /**
    * Connect to WhatsApp
    * @returns Promise that resolves when connection is established
@@ -285,7 +271,7 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           },
           browser: ['Windows', 'Edge', '120.0.0'],
           generateHighQualityLinkPreview: true,
-          markOnlineOnConnect: false,
+          markOnlineOnConnect: true,
           syncFullHistory: false,
           shouldIgnoreJid: (jid) => {
             return (
@@ -310,7 +296,10 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
               'Fetching cached message',
             );
 
-            const obj = dbQueries.getMessage(`${key.remoteJid}-${key.id}`);
+            const obj = messageStore.get(
+              this.sessionId,
+              `${key.remoteJid}-${key.id}`,
+            );
             if (obj && typeof obj === 'object' && 'message' in obj) {
               return proto.Message.create(obj.message as any);
             }
@@ -332,39 +321,8 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           );
 
           for (const msg of upsert.messages) {
-            if (msg.key.id && msg.key.remoteJid) {
-              const messageKey = `${msg.key.remoteJid}-${msg.key.id}`;
-              dbQueries.upsertMessage(messageKey, msg);
-
-              if (!msg.key.fromMe) {
-                dbQueries.incrementUnread(msg.key.remoteJid);
-                // incoming message → set online, reset offline timer
-                this.setOnline();
-                this.scheduleOffline();
-              }
-
-              WhatsAppSession.emitToSse(
-                this.sessionId,
-                JSON.stringify({ type: 'new_message', data: msg }),
-              );
-            }
-          }
-        });
-
-        sock.ev.on('messages.update', (updates) => {
-          this.logger.info({ count: updates.length }, 'Messages update event');
-
-          for (const msg of updates) {
-            if (msg.key.id && msg.key.remoteJid) {
-              dbQueries.upsertMessage(
-                `${msg.key.remoteJid}-${msg.key.id}`,
-                msg,
-              );
-
-              WhatsAppSession.emitToSse(
-                this.sessionId,
-                JSON.stringify({ type: 'message_update', data: msg }),
-              );
+            if (msg.key.id && msg.key.remoteJid && msg.key.fromMe) {
+              messageStore.upsert(this.sessionId, msg);
             }
           }
         });
@@ -372,7 +330,11 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
         sock.ev.on('contacts.upsert', (contacts) => {
           for (const c of contacts) {
             if (c.id) {
-              dbQueries.upsertContact(c.id, (c as any).name ?? (c as any).notify, (c as any).imgUrl);
+              dbQueries.upsertContact(
+                c.id,
+                (c as any).name ?? (c as any).notify,
+                (c as any).imgUrl,
+              );
             }
           }
         });
@@ -433,7 +395,9 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           );
 
           for (const msg of messages) {
-            dbQueries.upsertMessage(`${msg.key.remoteJid}-${msg.key.id}`, msg);
+            if (msg.key?.fromMe) {
+              messageStore.upsert(this.sessionId, msg);
+            }
           }
         });
 
@@ -701,9 +665,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
             this.emit('authenticated', sock);
             this.sendWebhook('ready', {});
 
-            this.pruneJob = new Cron('0 0 * * *', () => {
-              this.pruneOldMessages(30);
-            });
             if (this._isNewSession) {
               sock.groupFetchAllParticipating().catch((err) => {
                 this.logger.error(
@@ -802,8 +763,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
     // this.db?.close();
     // this.db = null;
     this.dbQueries = null;
-    this.pruneJob?.stop();
-    this.pruneJob = null;
     this.messageQueue.clear();
     this._connectionState = 'close';
     clearInterval(this.heartbeatInterval);
@@ -924,7 +883,8 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           );
         await Bun.sleep(randomInt(10, 15) * 100);
       } else {
-        const jitter = (base: number) => Math.max(0, Math.round(base * 1000 + (Math.random() - 0.5) * 30000));
+        const jitter = (base: number) =>
+          Math.max(0, Math.round(base * 1000 + (Math.random() - 0.5) * 30000));
         await Bun.sleep(jitter(delay));
       }
 
@@ -937,16 +897,16 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           throw new Error(`[${this.sessionId}] sendMessage error: ${r}`);
         });
 
-      await Bun.sleep(Math.max(0, Math.round(delay * 1000 + (Math.random() - 0.5) * 30000)));
+      await Bun.sleep(
+        Math.max(0, Math.round(delay * 1000 + (Math.random() - 0.5) * 30000)),
+      );
     };
 
     const sendWithRetry = async () => {
       let lastError: Error | null = null;
-      await this.setOnline();
       for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
         try {
           await send();
-          this.scheduleOffline();
           return;
         } catch (err) {
           lastError = err instanceof Error ? err : new Error(String(err));
@@ -959,10 +919,16 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
           }
         }
       }
-      this.scheduleOffline();
       throw lastError;
     };
 
+    const MAX_QUEUED = Number(Bun.env.SEND_QUEUE_MAX ?? 500);
+    if (this.messageQueue.size >= MAX_QUEUED) {
+      throw new Error(
+        `[${this.sessionId}] Send queue full (${MAX_QUEUED}), try again later`,
+      );
+    }
+
     this.messageQueue
       .add(sendWithRetry)
       .then(() => {
@@ -991,30 +957,6 @@ export class WhatsAppSession extends EventEmitter<WhatsAppSessionEvents> {
       });
   }
 
-  /**
-   * Prune old messages from the database
-   * @param olderThanDays Number of days to keep messages. Messages older than this will be deleted. Default is 30 days.
-   */
-  pruneOldMessages(olderThanDays: number = 30): void {
-    if (!this.dbQueries) {
-      this.logger.warn('Database not initialized, cannot prune messages');
-      return;
-    }
-
-    const cutoffTimestamp = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
-    const cutoffSeconds = Math.floor(cutoffTimestamp / 1000);
-
-    const deletedCount = this.dbQueries.deleteOldMessages(cutoffSeconds);
-
-    this.logger.info(
-      {
-        deletedCount,
-        olderThanDays,
-      },
-      'Pruned old messages',
-    );
-  }
-
   /**
    * Send webhook notification
    *