whatsapp-pi 1.0.40 → 1.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatsapp-pi",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "type": "module",
   "description": "WhatsApp integration extension for Pi",
   "main": "whatsapp-pi.ts",

package/src/models/whatsapp.types.ts

@@ -73,6 +73,28 @@ export interface RecentConversationSummary {
     isAllowed: boolean;
 }
 
+export interface SelectedMessageContext {
+    messageId: string;
+    senderNumber: string;
+    senderName?: string;
+    text: string;
+    direction: MessageDirection;
+    timestamp: number;
+}
+
+export interface ReplyDraft {
+    text: string;
+    targetMessageId: string;
+    targetConversation: string;
+}
+
+export interface ReplySendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    attempts: number;
+}
+
 export interface RecentsStore {
     conversations: RecentConversationSummary[];
     messagesBySender: Record<string, RecentConversationMessage[]>;

package/src/services/message.sender.ts

@@ -39,7 +39,7 @@ export class MessageSender {
     public async send(request: MessageRequest): Promise<MessageResult> {
         const maxRetries = request.options?.maxRetries ?? 3;
         let attempts = 0;
-        let lastError: any = null;
+        let lastError: unknown = null;
 
         while (attempts < maxRetries) {
             attempts++;
@@ -61,15 +61,15 @@ export class MessageSender {
 
                 return {
                     success: true,
-                    messageId: response.key.id,
+                    messageId: response?.key?.id,
                     attempts
                 };
-            } catch (error: any) {
+            } catch (error: unknown) {
                 lastError = error;
-                console.error(`[MessageSender] Attempt ${attempts} failed for ${request.recipientJid}: ${error.message}`);
+                console.error(`[MessageSender] Attempt ${attempts} failed for ${request.recipientJid}: ${error instanceof Error ? error.message : String(error)}`);
                 
                 // Specific handling for non-retryable errors
-                if (error.code === 'TIMEOUT') {
+                if (error instanceof WhatsAppError && error.code === 'TIMEOUT') {
                     break;
                 }
 
@@ -86,7 +86,7 @@ export class MessageSender {
 
         return {
             success: false,
-            error: lastError?.message || 'Unknown error',
+            error: lastError instanceof Error ? lastError.message : 'Unknown error',
             attempts
         };
     }

package/src/services/recents.service.ts

@@ -93,24 +93,38 @@ export class RecentsService {
         const summaries = new Map<string, RecentConversationSummary>();
 
         for (const [senderNumber, messages] of Object.entries(this.store.messagesBySender)) {
-            if (messages.length === 0) continue;
-            const lastMessage = messages[messages.length - 1];
+            const latestMessage = this.getLatestConversationMessage(messages);
+            if (!latestMessage) continue;
+
             summaries.set(senderNumber, {
                 senderNumber,
                 senderName: previousNames.get(senderNumber),
-                lastMessagePreview: this.buildPreview(lastMessage.text),
-                lastMessageTime: lastMessage.timestamp,
-                lastMessageDirection: lastMessage.direction,
+                lastMessagePreview: this.buildPreview(latestMessage.text),
+                lastMessageTime: latestMessage.timestamp,
+                lastMessageDirection: latestMessage.direction,
                 messageCount: messages.length,
                 isAllowed: this.sessionManager.isAllowed(senderNumber)
             });
         }
 
-        this.store.conversations = Array.from(summaries.values())
-            .sort((left, right) => right.lastMessageTime - left.lastMessageTime)
+        this.store.conversations = this.sortConversationsByLatestMessage(Array.from(summaries.values()))
             .slice(0, 20);
     }
 
+    private getLatestConversationMessage(messages: RecentConversationMessage[]): RecentConversationMessage | undefined {
+        return messages[messages.length - 1];
+    }
+
+    private sortConversationsByLatestMessage(conversations: RecentConversationSummary[]): RecentConversationSummary[] {
+        return [...conversations].sort((left, right) => {
+            if (right.lastMessageTime !== left.lastMessageTime) {
+                return right.lastMessageTime - left.lastMessageTime;
+            }
+
+            return left.senderNumber.localeCompare(right.senderNumber);
+        });
+    }
+
     private buildPreview(text: string): string {
         const normalized = text.trim().replace(/\s+/g, ' ');
         if (normalized.length <= 80) return normalized;
@@ -172,12 +186,10 @@ export class RecentsService {
             isAllowed: this.sessionManager.isAllowed(senderNumber)
         };
 
-        this.store.conversations = [
+        this.store.conversations = this.sortConversationsByLatestMessage([
             summary,
             ...this.store.conversations.filter(item => item.senderNumber !== senderNumber)
-        ]
-            .sort((left, right) => right.lastMessageTime - left.lastMessageTime)
-            .slice(0, 20);
+        ]).slice(0, 20);
 
         await this.persistStore();
     }

package/src/services/whatsapp-pi.logger.ts

@@ -5,6 +5,10 @@ export class WhatsAppPiLogger {
         this.verbose = verbose;
     }
 
+    info(message: string, ...args: unknown[]) {
+        console.log(message, ...args);
+    }
+
     log(message: string, ...args: unknown[]) {
         if (this.verbose) {
             console.log(message, ...args);

package/src/services/whatsapp.service.ts

@@ -1,14 +1,12 @@
-import { 
+import {
     makeWASocket,
-    DisconnectReason, 
-    useMultiFileAuthState, 
+    DisconnectReason,
     fetchLatestBaileysVersion,
     makeCacheableSignalKeyStore
 } from '@whiskeysockets/baileys';
 import P from 'pino';
-import { Boom } from '@hapi/boom';
 import { SessionManager } from './session.manager.js';
-import { IncomingMessage, WhatsAppSession, SessionStatus } from '../models/whatsapp.types.js';
+import { IncomingMessage, SessionStatus } from '../models/whatsapp.types.js';
 import { MessageSender } from './message.sender.js';
 import { installBaileysConsoleFilter } from './baileys-console-filter.js';
 
@@ -16,8 +14,65 @@ export interface WhatsAppStartOptions {
     allowPairingOnAuthFailure?: boolean;
 }
 
+interface DisconnectPayload {
+    error?: unknown;
+}
+
+interface ConnectionUpdateEvent {
+    connection?: 'close' | 'open' | string;
+    lastDisconnect?: DisconnectPayload;
+    qr?: string;
+}
+
+interface IncomingMessageKey {
+    id?: string;
+    remoteJid?: string;
+    fromMe?: boolean;
+}
+
+interface IncomingMessageContent {
+    conversation?: string;
+    extendedTextMessage?: { text?: string };
+}
+
+interface IncomingMessageLike {
+    key: IncomingMessageKey;
+    message?: IncomingMessageContent;
+    pushName?: string;
+    messageTimestamp?: number | string;
+}
+
+interface MessagesUpsertEvent {
+    messages?: IncomingMessageLike[];
+}
+
+interface WhatsAppSocketLike {
+    ev: {
+        on(event: 'connection.update', handler: (update: ConnectionUpdateEvent) => void | Promise<void>): void;
+        on(event: 'creds.update', handler: () => void | Promise<void>): void;
+        on(event: 'messages.upsert', handler: (payload: MessagesUpsertEvent) => void | Promise<void>): void;
+        removeAllListeners(event: 'connection.update' | 'creds.update' | 'messages.upsert'): void;
+    };
+    end(reason?: unknown): void;
+    logout(): Promise<void>;
+    sendMessage(jid: string, content: { text: string }): Promise<{ key?: { id?: string } } | undefined>;
+    sendPresenceUpdate(presence: 'composing' | 'recording' | 'paused', jid: string): Promise<void>;
+    readMessages(messages: Array<{ remoteJid: string; id: string; fromMe: boolean }>): Promise<void>;
+}
+
+interface LastDisconnectLike {
+    error?: unknown;
+}
+
+interface BoomLikeError {
+    output?: {
+        statusCode?: number;
+    };
+    message?: string;
+}
+
 export class WhatsAppService {
-    private socket: any;
+    private socket?: WhatsAppSocketLike;
     private sessionManager: SessionManager;
     private messageSender: MessageSender;
     private isReconnecting = false;
@@ -25,6 +80,11 @@ export class WhatsAppService {
     private onIncomingMessageRecorded?: (message: IncomingMessage) => void | Promise<void>;
     private saveCreds?: () => Promise<void>;
     private restoreBaileysConsoleFilter?: () => void;
+    private reconnectTimeout?: ReturnType<typeof setTimeout>;
+    private onQRCode?: (qr: string) => void;
+    private onMessage?: (m: unknown) => void;
+    private onStatusUpdate?: (status: string) => void;
+    private lastRemoteJid: string | null = null;
 
     constructor(sessionManager: SessionManager) {
         this.sessionManager = sessionManager;
@@ -48,7 +108,7 @@ export class WhatsAppService {
         this.onIncomingMessageRecorded = callback;
     }
 
-    public getSocket(): any {
+    public getSocket(): WhatsAppSocketLike | undefined {
         return this.socket;
     }
 
@@ -76,196 +136,311 @@ export class WhatsAppService {
         return value;
     }
 
-    async start(options: WhatsAppStartOptions = {}) {
-        const allowPairingOnAuthFailure = options.allowPairingOnAuthFailure ?? true;
-        if (this.isReconnecting) return;
-        this.onStatusUpdate?.('| WhatsApp: Connecting...');
+    private normalizeRecipientJid(jid: string): string {
+        if (jid.includes('@')) return jid;
+        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
+        return `${digits}@s.whatsapp.net`;
+    }
+
+    private getDisconnectStatusCode(error: unknown): number | undefined {
+        if (!error || typeof error !== 'object') {
+            return undefined;
+        }
 
+        const candidate = error as BoomLikeError;
+        return candidate.output?.statusCode;
+    }
+
+    private getErrorMessage(error: unknown): string {
+        if (error instanceof Error) {
+            return error.message;
+        }
+
+        if (typeof error === 'object' && error !== null && 'message' in error) {
+            const candidate = error as { message?: unknown };
+            return typeof candidate.message === 'string' ? candidate.message : '';
+        }
+
+        return '';
+    }
+
+    private clearReconnectTimeout() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
+    }
+
+    private cleanupSocket() {
+        this.clearReconnectTimeout();
+
+        if (!this.socket) {
+            return;
+        }
+
+        this.restoreBaileysConsoleFilter?.();
+        this.restoreBaileysConsoleFilter = undefined;
+        this.socket.ev.removeAllListeners('connection.update');
+        this.socket.ev.removeAllListeners('creds.update');
+        this.socket.ev.removeAllListeners('messages.upsert');
+
+        try {
+            this.socket.end(undefined);
+        } catch {
+            // Best-effort cleanup
+        }
+
+        this.socket = undefined;
+    }
+
+    private setSocket(socket: WhatsAppSocketLike) {
+        this.socket = socket;
+    }
+
+    private registerSocketListeners(socket: WhatsAppSocketLike, options: WhatsAppStartOptions, saveCreds: () => Promise<void>) {
+        socket.ev.on('creds.update', async () => {
+            await saveCreds();
+            await this.sessionManager.markAuthStateAvailable();
+        });
+
+        socket.ev.on('connection.update', async (update) => {
+            await this.handleConnectionUpdate(update, options);
+        });
+
+        socket.ev.on('messages.upsert', (payload) => {
+            void this.handleIncomingMessages(payload);
+        });
+    }
+
+    private async createSocket(): Promise<WhatsAppSocketLike> {
         const { state, saveCreds } = await this.sessionManager.getAuthState();
         this.saveCreds = saveCreds;
         const { version } = await fetchLatestBaileysVersion();
 
-        // Cleanup existing socket if any
-        if (this.socket) {
-            this.restoreBaileysConsoleFilter?.();
-            this.restoreBaileysConsoleFilter = undefined;
-            this.socket.ev.removeAllListeners('connection.update');
-            this.socket.ev.removeAllListeners('creds.update');
-            this.socket.ev.removeAllListeners('messages.upsert');
-            try {
-                this.socket.end(undefined);
-            } catch (e) {}
-        }
-
         const logger = P({ level: this.verboseMode ? 'trace' : 'silent' });
-        
-        // Suppress Baileys console output during initialization
+
+        const socket = makeWASocket({
+            version,
+            printQRInTerminal: false,
+            auth: {
+                creds: state.creds,
+                keys: makeCacheableSignalKeyStore(state.keys, logger)
+            },
+            syncFullHistory: false,
+            logger
+        }) as WhatsAppSocketLike;
+
+        return socket;
+    }
+
+    async start(options: WhatsAppStartOptions = {}) {
+        if (this.isReconnecting) return;
+        this.onStatusUpdate?.('| WhatsApp: Connecting...');
+
+        this.cleanupSocket();
+
         const originalConsoleLog = console.log;
         const originalConsoleWarn = console.warn;
         const originalConsoleError = console.error;
-        
+        let socketInitialized = false;
+
         if (!this.verboseMode) {
             console.log = () => {};
             console.warn = () => {};
             console.error = () => {};
         }
-        
+
         try {
-            this.socket = makeWASocket({
-                version,
-                printQRInTerminal: false,
-                auth: {
-                    creds: state.creds,
-                    keys: makeCacheableSignalKeyStore(state.keys, logger),
-                },
-                syncFullHistory: false,
-                logger,
-            });
+            const socket = await this.createSocket();
+            this.setSocket(socket);
+            this.registerSocketListeners(socket, options, this.saveCreds ?? (async () => {}));
+            socketInitialized = true;
         } catch (error) {
-            // Restore console methods even if socket creation fails
             if (!this.verboseMode) {
                 console.log = originalConsoleLog;
                 console.warn = originalConsoleWarn;
                 console.error = originalConsoleError;
             }
             throw error;
+        } finally {
+            if (!this.verboseMode) {
+                console.log = originalConsoleLog;
+                console.warn = originalConsoleWarn;
+                console.error = originalConsoleError;
+                if (socketInitialized) {
+                    this.restoreBaileysConsoleFilter = installBaileysConsoleFilter(this.verboseMode);
+                }
+            }
         }
+    }
 
-        this.socket.ev.on('creds.update', async () => {
-            await saveCreds();
-            await this.sessionManager.markAuthStateAvailable();
-        });
+    private async handleConnectionUpdate(update: ConnectionUpdateEvent, options: WhatsAppStartOptions) {
+        const { connection, lastDisconnect, qr } = update;
+        const allowPairingOnAuthFailure = options.allowPairingOnAuthFailure ?? true;
 
-        this.socket.ev.on('connection.update', async (update: any) => {
-            const { connection, lastDisconnect, qr } = update;
-            
-            if (qr) {
-                this.sessionManager.setStatus('pairing');
-                this.onQRCode?.(qr);
-                this.onStatusUpdate?.('| WhatsApp: type /whatsapp to connect');
-            }
+        if (qr) {
+            await this.handlePairingQr(qr);
+        }
 
-            if (connection === 'close') {
-                const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
-                const errorMessage = lastDisconnect?.error?.message || '';
-                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
-                const isBadMac = errorMessage.includes('Bad MAC');
-                const isAuthRejected =
-                    errorMessage.includes('bad-request') ||
-                    statusCode === 400 ||
-                    statusCode === 401 ||
-                    statusCode === DisconnectReason.loggedOut ||
-                    statusCode === DisconnectReason.badSession;
-                const shouldTreatAsLoggedOut = isBadMac || isAuthRejected;
+        if (connection === 'close') {
+            await this.handleConnectionClosed(lastDisconnect, allowPairingOnAuthFailure, options);
+            return;
+        }
 
-                if (this.verboseMode) {
-                    console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
-                }
+        if (connection === 'open') {
+            await this.handleConnectionOpen();
+        }
+    }
 
-                if (shouldTreatAsLoggedOut) {
-                    if (isAuthRejected && !isBadMac && allowPairingOnAuthFailure) {
-                        if (this.verboseMode) {
-                            console.error(`Session rejected [${statusCode}] - clearing auth state and starting pairing`);
-                        }
-                        await this.sessionManager.deleteAuthState();
-                        this.socket.ev.removeAllListeners('connection.update');
-                        this.socket.ev.removeAllListeners('creds.update');
-                        this.socket.ev.removeAllListeners('messages.upsert');
-                        try {
-                            this.socket.end(undefined);
-                        } catch (e) {}
-                        this.socket = undefined;
-                        await this.start({ allowPairingOnAuthFailure: false });
-                        return;
-                    }
-
-                    if (this.verboseMode) {
-                        console.error(`Session invalid or logged out [${statusCode}] - preserving auth state and requiring re-auth`);
-                    }
-                    if (isBadMac) {
-                        if (this.verboseMode) {
-                            console.error('[WhatsApp-Pi] Bad MAC error detected. Your session keys are corrupted.');
-                            console.error('[WhatsApp-Pi] Run /whatsapp-logout to clear auth state, then reconnect with /whatsapp-connect');
-                        }
-                        this.onStatusUpdate?.('| WhatsApp: Session Error (Bad MAC)');
-                    }
-                    this.sessionManager.setStatus('logged-out');
-                    if (!isBadMac) {
-                        this.onStatusUpdate?.('| WhatsApp: Logged out');
-                    }
-                    return;
-                }
+    private async handlePairingQr(qr: string) {
+        this.sessionManager.setStatus('pairing');
+        this.onQRCode?.(qr);
+        this.onStatusUpdate?.('| WhatsApp: type /whatsapp to connect');
+    }
 
-                if (statusCode === DisconnectReason.connectionReplaced) {
-                    if (this.verboseMode) {
-                        console.error('Connection replaced - another instance connected');
-                    }
-                    this.onStatusUpdate?.('| WhatsApp: Conflict (Another Instance)');
-                    return;
-                }
-                
-                if (shouldReconnect && !this.isReconnecting) {
-                    this.isReconnecting = true;
-                    this.onStatusUpdate?.('| WhatsApp: Reconnecting...');
-                    setTimeout(() => {
-                        this.isReconnecting = false;
-                        this.start(options);
-                    }, 3000);
-                } else if (!shouldReconnect) {
-                    this.sessionManager.setStatus('logged-out');
-                    this.onStatusUpdate?.('| WhatsApp: Disconnected');
-                }
-            } else if (connection === 'open') {
+    private async handleConnectionOpen() {
+        if (this.verboseMode) {
+            console.log('WhatsApp connection successfully opened');
+        }
+
+        this.isReconnecting = false;
+        this.clearReconnectTimeout();
+        await this.saveCreds?.();
+        await this.sessionManager.markAuthStateAvailable();
+        this.sessionManager.setStatus('connected');
+        this.onStatusUpdate?.('| WhatsApp: Connected');
+    }
+
+    private isBadMacError(errorMessage: string): boolean {
+        return errorMessage.includes('Bad MAC');
+    }
+
+    private isAuthRejected(statusCode: number | undefined, errorMessage: string): boolean {
+        return errorMessage.includes('bad-request')
+            || statusCode === 400
+            || statusCode === 401
+            || statusCode === DisconnectReason.loggedOut
+            || statusCode === DisconnectReason.badSession;
+    }
+
+    private async handleConnectionClosed(
+        lastDisconnect: LastDisconnectLike | undefined,
+        allowPairingOnAuthFailure: boolean,
+        options: WhatsAppStartOptions
+    ) {
+        const statusCode = this.getDisconnectStatusCode(lastDisconnect?.error);
+        const errorMessage = this.getErrorMessage(lastDisconnect?.error);
+        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+        const isBadMac = this.isBadMacError(errorMessage);
+        const isAuthRejected = this.isAuthRejected(statusCode, errorMessage);
+        const shouldTreatAsLoggedOut = isBadMac || isAuthRejected;
+
+        if (this.verboseMode) {
+            console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
+        }
+
+        if (shouldTreatAsLoggedOut) {
+            if (isAuthRejected && !isBadMac && allowPairingOnAuthFailure) {
                 if (this.verboseMode) {
-                    console.log('WhatsApp connection successfully opened');
+                    console.error(`Session rejected [${statusCode}] - clearing auth state and starting pairing`);
                 }
+                await this.sessionManager.deleteAuthState();
+                this.cleanupSocket();
+                this.socket = undefined;
                 this.isReconnecting = false;
-                await this.saveCreds?.();
-                await this.sessionManager.markAuthStateAvailable();
-                this.sessionManager.setStatus('connected');
-                this.onStatusUpdate?.('| WhatsApp: Connected');
+                await this.start({ allowPairingOnAuthFailure: false });
+                return;
             }
-        });
 
-        this.socket.ev.on('messages.upsert', (m: any) => this.handleIncomingMessages(m));
+            if (this.verboseMode) {
+                console.error(`Session invalid or logged out [${statusCode}] - preserving auth state and requiring re-auth`);
+            }
+            if (isBadMac) {
+                if (this.verboseMode) {
+                    console.error('[WhatsApp-Pi] Bad MAC error detected. Your session keys are corrupted.');
+                    console.error('[WhatsApp-Pi] Run /whatsapp-logout to clear auth state, then reconnect with /whatsapp-connect');
+                }
+                this.onStatusUpdate?.('| WhatsApp: Session Error (Bad MAC)');
+            }
+            this.sessionManager.setStatus('logged-out');
+            if (!isBadMac) {
+                this.onStatusUpdate?.('| WhatsApp: Logged out');
+            }
+            return;
+        }
 
-        // Restore console methods after socket creation
-        if (!this.verboseMode) {
-            console.log = originalConsoleLog;
-            console.warn = originalConsoleWarn;
-            console.error = originalConsoleError;
-            this.restoreBaileysConsoleFilter = installBaileysConsoleFilter(this.verboseMode);
+        if (statusCode === DisconnectReason.connectionReplaced) {
+            if (this.verboseMode) {
+                console.error('Connection replaced - another instance connected');
+            }
+            this.onStatusUpdate?.('| WhatsApp: Conflict (Another Instance)');
+            return;
+        }
+
+        if (shouldReconnect && !this.isReconnecting) {
+            this.isReconnecting = true;
+            this.onStatusUpdate?.('| WhatsApp: Reconnecting...');
+            this.clearReconnectTimeout();
+            this.reconnectTimeout = setTimeout(() => {
+                this.isReconnecting = false;
+                void this.start(options);
+            }, 3000);
+        } else if (!shouldReconnect) {
+            this.sessionManager.setStatus('logged-out');
+            this.onStatusUpdate?.('| WhatsApp: Disconnected');
         }
     }
 
-    public async handleIncomingMessages(m: any) {
-        if (this.sessionManager.getStatus() !== 'connected') return;
-        const msg = m.messages[0];
+    private extractText(message: IncomingMessageContent | undefined): string {
+        return message?.conversation || message?.extendedTextMessage?.text || '';
+    }
 
-        // msg.key.fromMe is always allowed
-        if (!msg || !msg.key.remoteJid) return;
+    private isPiGeneratedMessage(text: string): boolean {
+        return text.endsWith('π');
+    }
 
-        // Ignore messages sent by Pi (marked with π)
-        const text = msg.message?.conversation || msg.message?.extendedTextMessage?.text || "";
-        if (text.endsWith('π')) return;
+    private getIncomingTimestamp(timestamp: number | string | undefined): number {
+        if (typeof timestamp === 'number') {
+            return timestamp;
+        }
 
-        const remoteJid = msg.key.remoteJid;
-        if (remoteJid.endsWith('@g.us')) return;
+        if (typeof timestamp === 'string') {
+            const parsed = Number(timestamp);
+            return Number.isFinite(parsed) ? parsed : Date.now();
+        }
 
-        const senderJid = this.normalizeContactNumber(remoteJid.split('@')[0]);
+        return Date.now();
+    }
 
+    private async recordIncomingMessage(message: IncomingMessageLike, remoteJid: string, text: string) {
         void Promise.resolve(this.onIncomingMessageRecorded?.({
-            id: msg.key.id,
+            id: message.key.id ?? remoteJid,
             remoteJid,
-            pushName: msg.pushName || undefined,
+            pushName: message.pushName || undefined,
             text,
-            timestamp: typeof msg.messageTimestamp === 'number' ? Number(msg.messageTimestamp) : Date.now()
+            timestamp: this.getIncomingTimestamp(message.messageTimestamp)
         })).catch(error => {
             if (this.verboseMode) {
                 console.error('Failed to record recent message:', error);
             }
         });
-        
+    }
+
+    public async handleIncomingMessages(payload: MessagesUpsertEvent) {
+        if (this.sessionManager.getStatus() !== 'connected') return;
+
+        const message = payload.messages?.[0];
+        if (!message || !message.key.remoteJid) return;
+
+        const text = this.extractText(message.message);
+        if (this.isPiGeneratedMessage(text)) return;
+
+        const remoteJid = message.key.remoteJid;
+        if (remoteJid.endsWith('@g.us')) return;
+
+        const senderJid = this.normalizeContactNumber(remoteJid.split('@')[0]);
+        void this.recordIncomingMessage(message, remoteJid, text);
+
         if (this.sessionManager.isBlocked(senderJid)) {
             if (this.isVerbose()) {
                 console.log(`Ignoring message from ${senderJid} (explicitly blocked)`);
@@ -277,26 +452,20 @@ export class WhatsAppService {
             if (this.isVerbose()) {
                 console.log(`Ignoring message from ${senderJid} (not in allow list)`);
             }
-            // Track this number as ignored so user can allow it later
-            const pushName = msg.pushName || undefined;
+            const pushName = message.pushName || undefined;
             await this.sessionManager.trackIgnoredNumber(senderJid, pushName);
             return;
         }
 
-        this.lastRemoteJid = msg.key.remoteJid;
-        this.onMessage?.(m);
+        this.lastRemoteJid = remoteJid;
+        this.onMessage?.(payload);
     }
 
-    private onQRCode?: (qr: string) => void;
-    private onMessage?: (m: any) => void;
-    private onStatusUpdate?: (status: string) => void;
-    private lastRemoteJid: string | null = null;
-
     setQRCodeCallback(callback: (qr: string) => void) {
         this.onQRCode = callback;
     }
 
-    setMessageCallback(callback: (m: any) => void) {
+    setMessageCallback(callback: (m: unknown) => void) {
         this.onMessage = callback;
     }
 
@@ -308,6 +477,14 @@ export class WhatsAppService {
         return this.lastRemoteJid;
     }
 
+    private getActiveSocket(): WhatsAppSocketLike | null {
+        if (!this.socket || this.getStatus() !== 'connected') {
+            return null;
+        }
+
+        return this.socket;
+    }
+
     async sendMessage(jid: string, text: string) {
         // Ensure we show the typing indicator before sending
         await this.sendPresence(jid, 'composing');
@@ -323,20 +500,15 @@ export class WhatsAppService {
         if (!result.success) {
             console.error(`Failed to send message to ${jid}: ${result.error}`);
         }
-        
-        return result;
-    }
 
-    private normalizeRecipientJid(jid: string): string {
-        if (jid.includes('@')) return jid;
-        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
-        return `${digits}@s.whatsapp.net`;
+        return result;
     }
 
     async sendMenuMessage(jid: string, text: string) {
         const normalizedJid = this.normalizeRecipientJid(jid);
+        const socket = this.getActiveSocket();
 
-        if (!this.socket || this.getStatus() !== 'connected') {
+        if (!socket) {
             return {
                 success: false,
                 error: 'WhatsApp is not connected',
@@ -346,7 +518,7 @@ export class WhatsAppService {
 
         try {
             await this.sendPresence(normalizedJid, 'composing');
-            const response = await this.socket.sendMessage(normalizedJid, { text });
+            const response = await socket.sendMessage(normalizedJid, { text });
             await this.sendPresence(normalizedJid, 'paused');
 
             return {
@@ -354,21 +526,22 @@ export class WhatsAppService {
                 messageId: response?.key?.id,
                 attempts: 1
             };
-        } catch (error: any) {
+        } catch (error: unknown) {
             await this.sendPresence(normalizedJid, 'paused');
             console.error(`Failed to send menu message to ${normalizedJid}:`, error);
             return {
                 success: false,
-                error: error?.message || 'Unknown error',
+                error: error instanceof Error ? error.message : 'Unknown error',
                 attempts: 1
             };
         }
     }
 
     async sendPresence(jid: string, presence: 'composing' | 'recording' | 'paused') {
-        if (!this.socket || this.getStatus() !== 'connected') return;
+        const socket = this.getActiveSocket();
+        if (!socket) return;
         try {
-            await this.socket.sendPresenceUpdate(presence, jid);
+            await socket.sendPresenceUpdate(presence, jid);
         } catch (error) {
             if (this.verboseMode) {
                 console.error(`Failed to send presence update to ${jid}:`, error);
@@ -377,9 +550,10 @@ export class WhatsAppService {
     }
 
     async markRead(jid: string, messageId: string, fromMe: boolean = false) {
-        if (!this.socket || this.getStatus() !== 'connected') return;
+        const socket = this.getActiveSocket();
+        if (!socket) return;
         try {
-            await this.socket.readMessages([{ remoteJid: jid, id: messageId, fromMe }]);
+            await socket.readMessages([{ remoteJid: jid, id: messageId, fromMe }]);
         } catch (error) {
             if (this.verboseMode) {
                 console.error(`Failed to mark message as read:`, error);
@@ -401,18 +575,8 @@ export class WhatsAppService {
             }
         }
 
-        if (this.socket) {
-            this.restoreBaileysConsoleFilter?.();
-            this.restoreBaileysConsoleFilter = undefined;
-            this.socket.ev.removeAllListeners('connection.update');
-            this.socket.ev.removeAllListeners('creds.update');
-            this.socket.ev.removeAllListeners('messages.upsert');
-            try {
-                this.socket.end(undefined);
-            } catch (e) {}
-            this.socket = undefined;
-            this.isReconnecting = false;
-        }
+        this.cleanupSocket();
+        this.isReconnecting = false;
         await this.sessionManager.setStatus('disconnected');
         this.onStatusUpdate?.('| WhatsApp: Disconnected');
     }

package/src/ui/menu.handler.ts

@@ -1,10 +1,17 @@
 import { WhatsAppService } from '../services/whatsapp.service.js';
 import { SessionManager, type Contact } from '../services/session.manager.js';
-import { validatePhoneNumber, type RecentConversationSummary } from '../models/whatsapp.types.js';
+import { validatePhoneNumber, type RecentConversationMessage, type RecentConversationSummary } from '../models/whatsapp.types.js';
 import { RecentsService } from '../services/recents.service.js';
+import { showMessageDetailView } from './message-detail.view.js';
+import { showMessageReplyView } from './message-reply.view.js';
 import * as qrcode from 'qrcode-terminal';
 import type { ExtensionCommandContext } from '@mariozechner/pi-coding-agent';
 
+interface HistoryOptionEntry {
+    label: string;
+    message: RecentConversationMessage;
+}
+
 export class MenuHandler {
     private readonly printedAllowedNumbers: string[] = [];
 
@@ -109,7 +116,7 @@ export class MenuHandler {
 
     private async manageAllowedContact(ctx: ExtensionCommandContext, contact: Contact) {
         const displayName = this.formatAllowedContactOption(contact);
-        const options = ['Send Message', 'Print Number', 'History'];
+        const options = ['History', 'Send Message', 'Print Number'];
         if (contact.name) {
             options.push('Remove Alias');
         } else {
@@ -175,11 +182,18 @@ export class MenuHandler {
 
     private printAllowedNumber(ctx: ExtensionCommandContext, number: string) {
         this.printedAllowedNumbers.push(number);
+        const output = this.printedAllowedNumbers
+            .map((entry) => `  • ${entry}`)
+            .join('\n');
+        console.log([
+            '[WhatsApp-Pi] Allowed numbers',
+            output
+        ].join('\n'));
         ctx.ui.notify(this.printedAllowedNumbers.join('\n'), 'info');
     }
 
     private async manageBlockList(ctx: ExtensionCommandContext) {
-        const list = [...this.sessionManager.getIgnoredNumbers()].reverse();
+        const list = [...this.sessionManager.getBlockList()].reverse();
 
         if (list.length === 0) {
             ctx.ui.notify('No blocked numbers', 'info');
@@ -203,16 +217,14 @@ export class MenuHandler {
         if (action === 'Allow') {
             const ok = await ctx.ui.confirm('Allow', `Move ${number} to Allowed Numbers?`);
             if (ok) {
-                const list = this.sessionManager.getIgnoredNumbers();
-                const contact = list.find(c => c.number === number);
-                await this.sessionManager.addNumber(number, contact?.name);
+                await this.sessionManager.unblockAndAllow(number);
                 ctx.ui.notify(`${number} moved to Allowed List`, 'info');
             }
             await this.manageBlockList(ctx);
         } else if (action === 'Delete') {
             const ok = await ctx.ui.confirm('Delete', `Remove ${number} from Block List?`);
             if (ok) {
-                await this.sessionManager.removeIgnoredNumber(number);
+                await this.sessionManager.unblockNumber(number);
                 ctx.ui.notify(`${number} removed from Block List`, 'info');
             }
             await this.manageBlockList(ctx);
@@ -256,13 +268,13 @@ export class MenuHandler {
     private async manageRecentConversation(ctx: ExtensionCommandContext, conversation: RecentConversationSummary) {
         const displayName = this.getConversationDisplayName(conversation);
         const allowedContact = this.sessionManager.getAllowedContact(conversation.senderNumber);
-        const options: string[] = [];
+        const options: string[] = ['History'];
 
         if (!allowedContact) {
             options.push('Allow Number');
         }
 
-        options.push('History', 'Send Message');
+        options.push('Send Message');
 
         if (allowedContact?.name) {
             options.push('Remove Alias');
@@ -364,10 +376,20 @@ export class MenuHandler {
     }
 
     private async showConversationHistory(ctx: ExtensionCommandContext, conversation: RecentConversationSummary) {
-        await this.showConversationHistoryForNumber(ctx, conversation.senderNumber, this.getConversationDisplayName(conversation));
+        await this.showConversationHistoryForNumber(
+            ctx,
+            conversation.senderNumber,
+            this.getConversationDisplayName(conversation),
+            conversation.senderName
+        );
     }
 
-    private async showConversationHistoryForNumber(ctx: ExtensionCommandContext, senderNumber: string, displayName: string) {
+    private async showConversationHistoryForNumber(
+        ctx: ExtensionCommandContext,
+        senderNumber: string,
+        displayName: string,
+        senderName?: string
+    ) {
         const history = await this.recentsService.getConversationHistory(senderNumber);
 
         if (history.length === 0) {
@@ -375,16 +397,56 @@ export class MenuHandler {
             return;
         }
 
-        const options = [
-            ...this.sortHistoryByMostRecent(history)
-                .map(message => this.formatHistoryOption(message.timestamp, message.direction, message.text)),
+        const historyOptions = this.buildHistoryOptions(this.sortHistoryByMostRecent(history));
+        const choice = await ctx.ui.select(`History • ${displayName}`, [
+            ...historyOptions.map(option => option.label),
             'Back'
-        ];
+        ]);
 
-        const choice = await ctx.ui.select(`History • ${displayName}`, options);
-        if (choice === 'Back' || !choice) {
+        if (!choice || choice === 'Back') {
             return;
         }
+
+        const selectedMessage = this.resolveHistorySelection(choice, historyOptions);
+        if (!selectedMessage) {
+            return;
+        }
+
+        const detailAction = await showMessageDetailView(ctx, {
+            title: `Message • ${displayName}`,
+            messageId: selectedMessage.messageId,
+            senderNumber: selectedMessage.senderNumber,
+            senderName,
+            text: selectedMessage.text,
+            direction: selectedMessage.direction,
+            timestamp: selectedMessage.timestamp
+        });
+
+        if (detailAction === 'reply') {
+            await showMessageReplyView(ctx, {
+                selectedMessage: {
+                    messageId: selectedMessage.messageId,
+                    senderNumber: selectedMessage.senderNumber,
+                    senderName,
+                    text: selectedMessage.text,
+                    direction: selectedMessage.direction,
+                    timestamp: selectedMessage.timestamp
+                },
+                whatsappService: this.whatsappService,
+                recentsService: this.recentsService
+            });
+        }
+    }
+
+    private buildHistoryOptions(history: RecentConversationMessage[]): HistoryOptionEntry[] {
+        return history.map(message => ({
+            label: this.formatHistoryOption(message.timestamp, message.direction, message.text),
+            message
+        }));
+    }
+
+    private resolveHistorySelection(choice: string, options: HistoryOptionEntry[]): RecentConversationMessage | undefined {
+        return options.find(option => option.label === choice)?.message;
     }
 
     private formatRecentConversationOption(conversation: RecentConversationSummary): string {

package/src/ui/message-detail.view.ts

@@ -0,0 +1,119 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi, visibleWidth } from '@mariozechner/pi-tui';
+import type { SelectedMessageContext } from '../models/whatsapp.types.js';
+
+export interface MessageDetailViewProps extends SelectedMessageContext {
+    title: string;
+    onClose: () => void;
+    onReply?: () => void | Promise<void>;
+}
+
+export class MessageDetailView {
+    constructor(private readonly props: MessageDetailViewProps) {}
+
+    handleInput(data: string): void {
+        const normalized = data.toLowerCase();
+
+        if (normalized === 'r' || matchesKey(data, 'r')) {
+            void this.props.onReply?.();
+            return;
+        }
+
+        if (
+            data === 'enter' ||
+            data === 'return' ||
+            data === 'escape' ||
+            data === 'esc' ||
+            matchesKey(data, 'enter') ||
+            matchesKey(data, 'escape') ||
+            matchesKey(data, 'backspace')
+        ) {
+            this.props.onClose();
+        }
+    }
+
+    render(width: number): string[] {
+        const title = this.props.title.trim() || 'Message Details';
+        const bodyText = this.props.text.length > 0 ? this.props.text : '[No readable text available]';
+
+        const availableWidth = Math.max(20, width - 4);
+        const rawHeaderLines = [
+            `Message ID: ${this.props.messageId}`,
+            `From: ${this.formatSender()}`,
+            `Direction: ${this.formatDirection()} • Time: ${this.formatTimestamp(this.props.timestamp)}`
+        ];
+
+        const contentWidth = Math.min(
+            availableWidth,
+            Math.max(
+                visibleWidth('Press Enter or Esc to return'),
+                ...rawHeaderLines.map(line => visibleWidth(line)),
+                ...wrapTextWithAnsi(bodyText, availableWidth).map(line => visibleWidth(line))
+            )
+        );
+
+        const wrapWidth = Math.max(1, contentWidth);
+        const boxWidth = wrapWidth + 4;
+        const padLine = (line: string) => `│ ${truncateToWidth(line, wrapWidth).padEnd(wrapWidth, ' ')} │`;
+        const centerLine = (line: string) => {
+            const content = truncateToWidth(line, wrapWidth);
+            const visible = visibleWidth(content);
+            const leftPadding = Math.max(0, Math.floor((wrapWidth - visible) / 2));
+            const rightPadding = Math.max(0, wrapWidth - visible - leftPadding);
+            return `│ ${' '.repeat(leftPadding)}${content}${' '.repeat(rightPadding)} │`;
+        };
+        const topBorder = `╭${'─'.repeat(boxWidth - 2)}╮`;
+        const separator = `├${'─'.repeat(boxWidth - 2)}┤`;
+        const bottomBorder = `╰${'─'.repeat(boxWidth - 2)}╯`;
+        const bodyLines = wrapTextWithAnsi(bodyText, wrapWidth).filter(line => line.length > 0 || bodyText.length === 0);
+        const exitHint = this.props.onReply
+            ? `\x1b[90mPress R to reply • Enter or Esc to return\x1b[39m`
+            : `\x1b[90mPress Enter or Esc to return\x1b[39m`;
+
+        return [
+            topBorder,
+            ...rawHeaderLines.map(padLine),
+            separator,
+            ...bodyLines.map(padLine),
+            separator,
+            centerLine(exitHint),
+            bottomBorder
+        ];
+    }
+
+    invalidate(): void {}
+
+    private formatSender(): string {
+        return this.props.senderName
+            ? `${this.props.senderName} (${this.props.senderNumber})`
+            : this.props.senderNumber;
+    }
+
+    private formatDirection(): string {
+        return this.props.direction === 'outgoing' ? 'Sent' : 'Received';
+    }
+
+    private formatTimestamp(timestamp: number): string {
+        return new Intl.DateTimeFormat(undefined, {
+            dateStyle: 'short',
+            timeStyle: 'medium'
+        }).format(new Date(timestamp));
+    }
+}
+
+export async function showMessageDetailView(
+    ctx: {
+        ui: {
+            custom: <T>(factory: (_tui: unknown, _theme: unknown, _keybindings: unknown, done: (value: T | undefined) => void) => MessageDetailView, options?: { overlay?: boolean }) => Promise<T | undefined>;
+        }
+    },
+    props: Omit<MessageDetailViewProps, 'onClose'>
+): Promise<'reply' | undefined> {
+    return await ctx.ui.custom<'reply' | undefined>(
+        (_tui, _theme, _keybindings, done) => new MessageDetailView({
+            ...props,
+            onClose: () => done(undefined),
+            onReply: () => done('reply')
+        }),
+        { overlay: true }
+    );
+}

package/src/ui/message-reply.view.ts

@@ -0,0 +1,105 @@
+import type { ReplyDraft, ReplySendResult, SelectedMessageContext } from '../models/whatsapp.types.js';
+import { truncateToWidth } from '@mariozechner/pi-tui';
+import type { WhatsAppService } from '../services/whatsapp.service.js';
+import type { RecentsService } from '../services/recents.service.js';
+
+export interface MessageReplyViewProps {
+    selectedMessage: SelectedMessageContext;
+    whatsappService: WhatsAppService;
+    recentsService: RecentsService;
+}
+
+interface MessageReplyContextUi {
+    editor(title: string, prefilled?: string): Promise<string | undefined>;
+    notify(message: string, level: 'info' | 'warning' | 'error'): void;
+    setWidget(name: string, widget?: string[] | ((tui: unknown, theme: { fg: (tone: string, text: string) => string }) => { render(width: number): string[]; invalidate(): void }) , options?: { placement?: 'belowEditor' }): void;
+}
+
+interface MessageReplyContext {
+    ui: MessageReplyContextUi;
+}
+
+const buildPreview = (text: string): string => {
+    const normalized = text.trim().replace(/\s+/g, ' ');
+    if (!normalized) {
+        return '[No readable text available]';
+    }
+
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+};
+
+const buildReplyWidget = (selectedMessage: SelectedMessageContext): string[] => {
+    const sender = selectedMessage.senderName
+        ? `${selectedMessage.senderName} (${selectedMessage.senderNumber})`
+        : selectedMessage.senderNumber;
+
+    return [
+        `Replying to: ${sender}`,
+        `Message ID: ${selectedMessage.messageId}`,
+        `Original: ${buildPreview(selectedMessage.text)}`
+    ];
+};
+
+const buildReplyTitle = (selectedMessage: SelectedMessageContext): string => {
+    const sender = selectedMessage.senderName
+        ? `${selectedMessage.senderName} (${selectedMessage.senderNumber})`
+        : selectedMessage.senderNumber;
+
+    return truncateToWidth(`Reply to ${sender}`, 120);
+};
+
+export async function showMessageReplyView(
+    ctx: MessageReplyContext,
+    props: MessageReplyViewProps
+): Promise<void> {
+    const widgetName = 'message-reply-context';
+    ctx.ui.setWidget(widgetName, buildReplyWidget(props.selectedMessage), { placement: 'belowEditor' });
+
+    try {
+        while (true) {
+            const replyText = await ctx.ui.editor(buildReplyTitle(props.selectedMessage));
+
+            if (replyText === undefined) {
+                return;
+            }
+
+            const text = replyText.trim();
+            if (!text) {
+                ctx.ui.notify('Please enter a message before sending.', 'error');
+                continue;
+            }
+
+            const draft: ReplyDraft = {
+                text,
+                targetMessageId: props.selectedMessage.messageId,
+                targetConversation: props.selectedMessage.senderNumber
+            };
+
+            const result: ReplySendResult = await props.whatsappService.sendMenuMessage(
+                props.selectedMessage.senderNumber,
+                draft.text
+            );
+
+            if (result.success) {
+                await props.recentsService.recordMessage({
+                    messageId: result.messageId ?? `${Date.now()}`,
+                    senderNumber: props.selectedMessage.senderNumber,
+                    senderName: props.selectedMessage.senderName,
+                    text: draft.text,
+                    direction: 'outgoing',
+                    timestamp: Date.now()
+                });
+                ctx.ui.notify(`Sent reply to ${buildPreview(props.selectedMessage.text)}`, 'info');
+            } else {
+                ctx.ui.notify(
+                    `Failed to send reply: ${result.error ?? 'Unknown error'}`,
+                    'error'
+                );
+            }
+
+            return;
+        }
+    } finally {
+        ctx.ui.setWidget(widgetName, undefined);
+    }
+}

package/whatsapp-pi.ts

@@ -240,6 +240,18 @@ export default function (pi: ExtensionAPI) {
                 };
             }
 
+            const formattedMessage = params.message
+                .split('\n')
+                .map((line) => `    ${line}`)
+                .join('\n');
+
+            console.log([
+                '[WhatsApp-Pi] Outgoing WhatsApp message',
+                `  To: ${params.jid}`,
+                '  Message:',
+                formattedMessage
+            ].join('\n'));
+
             const result = await whatsappService.sendMessage(params.jid, params.message);
 
             if (result.success) {
@@ -250,6 +262,19 @@ export default function (pi: ExtensionAPI) {
                     direction: 'outgoing',
                     timestamp: Date.now()
                 });
+                console.log([
+                    '[WhatsApp-Pi] Outgoing WhatsApp message result',
+                    `  To: ${params.jid}`,
+                    '  Status: sent',
+                    `  MessageId: ${result.messageId ?? 'unknown'}`
+                ].join('\n'));
+            } else {
+                console.log([
+                    '[WhatsApp-Pi] Outgoing WhatsApp message result',
+                    `  To: ${params.jid}`,
+                    '  Status: failed',
+                    `  Error: ${result.error ?? 'unknown error'}`
+                ].join('\n'));
             }
 
             return {