whatsapp-pi 1.0.35 → 1.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatsapp-pi",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "type": "module",
   "description": "WhatsApp integration extension for Pi",
   "main": "whatsapp-pi.ts",
@@ -39,6 +39,7 @@
     "@mariozechner/pi-coding-agent": "latest",
     "@types/node": "^20.11.0",
     "@types/qrcode-terminal": "^0.12.2",
+    "@vitest/coverage-v8": "^1.6.1",
     "ts-node": "^10.9.2",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",
@@ -50,4 +51,4 @@
     ],
     "image": "https://upload.wikimedia.org/wikipedia/commons/thumb/6/6b/WhatsApp.svg/512px-WhatsApp.svg.png"
   }
-}
+}

package/src/services/baileys-console-filter.ts

@@ -0,0 +1,66 @@
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error';
+
+const noisyBaileysPatterns = [
+    'Failed to decrypt message with any known session',
+    'Session error:',
+    'Bad MAC',
+    'Closing open session in favor of incoming prekey bundle',
+    'Closing session:'
+];
+
+const stringifyConsolePart = (part: unknown): string => {
+    if (part instanceof Error) {
+        return `${part.name}: ${part.message}\n${part.stack ?? ''}`;
+    }
+
+    if (typeof part === 'string') {
+        return part;
+    }
+
+    try {
+        return JSON.stringify(part);
+    } catch {
+        return String(part);
+    }
+};
+
+export const shouldSuppressBaileysConsoleMessage = (args: unknown[]): boolean => {
+    const message = args.map(stringifyConsolePart).join(' ');
+    return noisyBaileysPatterns.some(pattern => message.includes(pattern));
+};
+
+export const installBaileysConsoleFilter = (verbose: boolean): (() => void) => {
+    if (verbose) {
+        return () => {};
+    }
+
+    const methods: ConsoleMethod[] = ['log', 'info', 'warn', 'error'];
+    const originals = new Map<ConsoleMethod, (...args: any[]) => void>();
+    const patched = new Map<ConsoleMethod, (...args: any[]) => void>();
+
+    for (const method of methods) {
+        const original = console[method].bind(console);
+        originals.set(method, original);
+
+        const replacement = (...args: unknown[]) => {
+            if (shouldSuppressBaileysConsoleMessage(args)) {
+                return;
+            }
+
+            original(...args);
+        };
+
+        patched.set(method, replacement);
+        console[method] = replacement as typeof console[typeof method];
+    }
+
+    return () => {
+        for (const method of methods) {
+            const replacement = patched.get(method);
+            const original = originals.get(method);
+            if (replacement && original && console[method] === replacement) {
+                console[method] = original as typeof console[typeof method];
+            }
+        }
+    };
+};

package/src/services/incoming-media.service.ts

@@ -0,0 +1,123 @@
+import { downloadContentFromMessage } from '@whiskeysockets/baileys';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { AudioService } from './audio.service.js';
+import type { IncomingResolution } from './incoming-message.resolver.js';
+import { WhatsAppPiLogger } from './whatsapp-pi.logger.js';
+
+export interface ProcessedIncomingContent {
+    text: string;
+    imageBuffer?: Buffer;
+    imageMimeType?: string;
+}
+
+export class IncomingMediaService {
+    constructor(
+        private readonly audioService: AudioService,
+        private readonly logger = new WhatsAppPiLogger(false)
+    ) {}
+
+    async process(resolved: IncomingResolution, pushName: string): Promise<ProcessedIncomingContent> {
+        if (resolved.kind === 'audio') {
+            return this.processAudio(resolved.audioMessage, pushName);
+        }
+
+        if (resolved.kind === 'image') {
+            return this.processImage(resolved.imageMessage, resolved.text, pushName);
+        }
+
+        if (resolved.kind === 'document') {
+            return this.processDocument(resolved.documentMessage, pushName);
+        }
+
+        return { text: resolved.text };
+    }
+
+    private async processAudio(audioMessage: any, pushName: string): Promise<ProcessedIncomingContent> {
+        this.logger.log(`[WhatsApp-Pi] Transcribing audio from ${pushName}...`);
+        const transcription = await this.audioService.transcribe(audioMessage);
+        return { text: `[Transcribed Audio]: ${transcription}` };
+    }
+
+    private async processImage(imageMessage: any, fallbackText: string, pushName: string): Promise<ProcessedIncomingContent> {
+        this.logger.log(`[WhatsApp-Pi] Downloading image from ${pushName}...`);
+
+        try {
+            const imageBuffer = await this.downloadMessage(imageMessage, 'image');
+            const rawMime = imageMessage.mimetype || 'image/jpeg';
+            let imageMimeType = rawMime.toLowerCase().split(';')[0].trim();
+            if (imageMimeType === 'image/jpg') imageMimeType = 'image/jpeg';
+
+            this.logger.log(`[WhatsApp-Pi] Image downloaded. MIME: ${imageMimeType} (original: ${rawMime}), Size: ${imageBuffer.length} bytes`);
+
+            return {
+                text: fallbackText || '[Image]',
+                imageBuffer,
+                imageMimeType
+            };
+        } catch (error) {
+            this.logger.error('[WhatsApp-Pi] Failed to download image:', error);
+            return { text: '[Image (download failed)]' };
+        }
+    }
+
+    private async processDocument(documentMessage: any, pushName: string): Promise<ProcessedIncomingContent> {
+        const fileName = documentMessage.fileName || 'unnamed_document';
+        const mimeType = documentMessage.mimetype || 'application/octet-stream';
+        const fileSize = documentMessage.fileLength ? Number(documentMessage.fileLength) : 0;
+
+        this.logger.log(`[WhatsApp-Pi] Downloading document from ${pushName}: ${fileName}...`);
+
+        try {
+            const buffer = await this.downloadMessage(documentMessage, 'document');
+            const relativePath = await this.saveDocument(fileName, buffer);
+
+            this.logger.log(`[WhatsApp-Pi] Document saved to ${relativePath} (${buffer.length} bytes)`);
+
+            let text = `[Document Received: ${fileName}]\n`
+                + `MIME Type: ${mimeType}\n`
+                + `Size: ${this.formatFileSize(fileSize)}\n`
+                + `Location: ${relativePath}`;
+
+            if (documentMessage.caption) {
+                text += `\n\nDescription: ${documentMessage.caption}`;
+            }
+
+            return { text };
+        } catch (error) {
+            this.logger.error('[WhatsApp-Pi] Failed to download document:', error);
+            return { text: `[Document: ${fileName} (download failed)]` };
+        }
+    }
+
+    private async downloadMessage(message: any, type: 'image' | 'document'): Promise<Buffer> {
+        const stream = await downloadContentFromMessage(message, type);
+        let buffer = Buffer.from([]);
+
+        for await (const chunk of stream) {
+            buffer = Buffer.concat([buffer, chunk]);
+        }
+
+        return buffer;
+    }
+
+    private async saveDocument(fileName: string, buffer: Buffer): Promise<string> {
+        const sanitized = fileName.replace(/[^a-z0-9\._-]/gi, '_');
+        const savedFileName = `${Date.now()}_${sanitized}`;
+        const documentDir = join(process.cwd(), '.pi-data', 'whatsapp', 'documents');
+        const absolutePath = join(documentDir, savedFileName);
+
+        await mkdir(documentDir, { recursive: true });
+        await writeFile(absolutePath, buffer);
+
+        return `./.pi-data/whatsapp/documents/${savedFileName}`;
+    }
+
+    private formatFileSize(fileSize: number): string {
+        if (fileSize > 1024 * 1024) {
+            return `${(fileSize / (1024 * 1024)).toFixed(1)} MB`;
+        }
+
+        return `${(fileSize / 1024).toFixed(1)} KB`;
+    }
+}

package/src/services/incoming-message.resolver.ts

@@ -0,0 +1,129 @@
+import { extractMessageContent } from '@whiskeysockets/baileys';
+
+export type IncomingResolution =
+    | { kind: 'text'; text: string }
+    | { kind: 'audio'; text: string; audioMessage: any }
+    | { kind: 'image'; text: string; imageMessage: any }
+    | { kind: 'document'; text: string; documentMessage: any }
+    | { kind: 'contact'; text: string }
+    | { kind: 'location'; text: string }
+    | { kind: 'system'; text: string }
+    | { kind: 'unsupported'; text: string };
+
+const protocolTypes: Record<number, string> = {
+    0: 'Message Deleted',
+    3: 'Disappearing Messages Updated',
+    4: 'Disappearing Message Sync Response',
+    5: 'History Sync Notification',
+    6: 'App State Sync Key Share',
+    7: 'App State Sync Key Request',
+    8: 'Message Backfill Request',
+    9: 'Security Notification Sync',
+    10: 'Fatal App State Sync Notification',
+    11: 'Phone Number Shared',
+    14: 'Message Edited',
+    16: 'Peer Data Request',
+    17: 'Peer Data Response',
+    18: 'Welcome Message Request',
+    19: 'Bot Feedback',
+    20: 'Media Notification'
+};
+
+const unwrapMessageContent = (content: any): any => extractMessageContent(content) ?? content;
+
+const getTypeName = (payload: any): string => {
+    if (!payload || typeof payload !== 'object') return 'unknown';
+    return Object.keys(payload)[0] || 'unknown';
+};
+
+const formatProtocolMessage = (protocolMessage: any): string => {
+    const typeLabel = protocolTypes[Number(protocolMessage?.type)] || 'System Update';
+    const editedText = protocolMessage?.editedMessage?.conversation
+        || protocolMessage?.editedMessage?.extendedTextMessage?.text;
+
+    if (editedText) {
+        return `[${typeLabel}: ${editedText}]`;
+    }
+
+    return `[${typeLabel}]`;
+};
+
+export const extractIncomingText = (message: any): IncomingResolution => {
+    const content = unwrapMessageContent(message);
+    const inner = content?.ephemeralMessage?.message
+        || content?.viewOnceMessage?.message
+        || content?.viewOnceMessageV2?.message
+        || content?.viewOnceMessageV2Extension?.message
+        || content?.message;
+
+    const resolved = inner ? unwrapMessageContent(inner) : content;
+    const typeName = getTypeName(resolved);
+    const protocolMessage = resolved?.protocolMessage
+        || (typeName === 'protocolMessage' ? resolved : undefined)
+        || content?.protocolMessage;
+
+    if (protocolMessage) {
+        return { kind: 'system', text: formatProtocolMessage(protocolMessage) };
+    }
+
+    if (resolved?.conversation) {
+        return { kind: 'text', text: resolved.conversation };
+    }
+
+    if (resolved?.extendedTextMessage?.text) {
+        return { kind: 'text', text: resolved.extendedTextMessage.text };
+    }
+
+    if (resolved?.imageMessage) {
+        return {
+            kind: 'image',
+            text: resolved.imageMessage.caption || '[Image]',
+            imageMessage: resolved.imageMessage
+        };
+    }
+
+    if (resolved?.videoMessage) {
+        return {
+            kind: 'text',
+            text: resolved.videoMessage.caption || '[Video]'
+        };
+    }
+
+    if (resolved?.audioMessage) {
+        return {
+            kind: 'audio',
+            text: '[Audio Message]',
+            audioMessage: resolved.audioMessage
+        };
+    }
+
+    if (resolved?.documentMessage) {
+        return {
+            kind: 'document',
+            text: resolved.documentMessage.caption || '[Document]',
+            documentMessage: resolved.documentMessage
+        };
+    }
+
+    if (resolved?.contactMessage || resolved?.contactsArrayMessage) {
+        return { kind: 'contact', text: '[Contact]' };
+    }
+
+    if (resolved?.locationMessage) {
+        return { kind: 'location', text: '[Location]' };
+    }
+
+    if (resolved?.buttonsResponseMessage?.selectedDisplayText) {
+        return { kind: 'text', text: resolved.buttonsResponseMessage.selectedDisplayText };
+    }
+
+    if (resolved?.listResponseMessage?.title) {
+        return { kind: 'text', text: resolved.listResponseMessage.title };
+    }
+
+    if (resolved?.templateButtonReplyMessage?.selectedDisplayText) {
+        return { kind: 'text', text: resolved.templateButtonReplyMessage.selectedDisplayText };
+    }
+
+    return { kind: 'unsupported', text: `[Unsupported Message Type: ${typeName}]` };
+};

package/src/services/recents.service.ts

@@ -191,7 +191,6 @@ export class RecentsService {
         const normalizedNumber = this.normalizeNumber(senderNumber);
         const messages = this.store.messagesBySender[normalizedNumber] ?? [];
         return [...messages]
-            .map(message => ({ ...message, timestamp: this.normalizeTimestamp(message.timestamp) }))
             .sort((left, right) => left.timestamp - right.timestamp)
             .slice(-20);
     }

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

@@ -0,0 +1,25 @@
+export class WhatsAppPiLogger {
+    constructor(private verbose = false) {}
+
+    setVerbose(verbose: boolean) {
+        this.verbose = verbose;
+    }
+
+    log(message: string, ...args: unknown[]) {
+        if (this.verbose) {
+            console.log(message, ...args);
+        }
+    }
+
+    warn(message: string, ...args: unknown[]) {
+        if (this.verbose) {
+            console.warn(message, ...args);
+        }
+    }
+
+    error(message: string, ...args: unknown[]) {
+        if (this.verbose) {
+            console.error(message, ...args);
+        }
+    }
+}

package/src/services/whatsapp.service.ts

@@ -10,6 +10,11 @@ import { Boom } from '@hapi/boom';
 import { SessionManager } from './session.manager.js';
 import { IncomingMessage, WhatsAppSession, SessionStatus } from '../models/whatsapp.types.js';
 import { MessageSender } from './message.sender.js';
+import { installBaileysConsoleFilter } from './baileys-console-filter.js';
+
+export interface WhatsAppStartOptions {
+    allowPairingOnAuthFailure?: boolean;
+}
 
 export class WhatsAppService {
     private socket: any;
@@ -19,6 +24,7 @@ export class WhatsAppService {
     private verboseMode = false;
     private onIncomingMessageRecorded?: (message: IncomingMessage) => void | Promise<void>;
     private saveCreds?: () => Promise<void>;
+    private restoreBaileysConsoleFilter?: () => void;
 
     constructor(sessionManager: SessionManager) {
         this.sessionManager = sessionManager;
@@ -29,6 +35,15 @@ export class WhatsAppService {
         return this.sessionManager.getStatus();
     }
 
+    public getEffectiveStatus(): SessionStatus {
+        const status = this.sessionManager.getStatus();
+        if (status === 'connected' && !this.socket) {
+            return 'disconnected';
+        }
+
+        return status;
+    }
+
     public setIncomingMessageRecorder(callback: (message: IncomingMessage) => void | Promise<void>) {
         this.onIncomingMessageRecorded = callback;
     }
@@ -43,6 +58,10 @@ export class WhatsAppService {
 
     public setVerboseMode(verbose: boolean) {
         this.verboseMode = verbose;
+        if (verbose) {
+            this.restoreBaileysConsoleFilter?.();
+            this.restoreBaileysConsoleFilter = undefined;
+        }
     }
 
     private normalizeContactNumber(value: string): string {
@@ -57,7 +76,8 @@ export class WhatsAppService {
         return value;
     }
 
-    async start() {
+    async start(options: WhatsAppStartOptions = {}) {
+        const allowPairingOnAuthFailure = options.allowPairingOnAuthFailure ?? true;
         if (this.isReconnecting) return;
         this.onStatusUpdate?.('| WhatsApp: Connecting...');
 
@@ -67,6 +87,8 @@ export class WhatsAppService {
 
         // 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');
@@ -127,32 +149,57 @@ export class WhatsAppService {
                 const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
                 const errorMessage = lastDisconnect?.error?.message || '';
                 const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
-                const shouldTreatAsLoggedOut =
+                const isBadMac = errorMessage.includes('Bad MAC');
+                const isAuthRejected =
                     errorMessage.includes('bad-request') ||
-                    errorMessage.includes('Bad MAC') ||
                     statusCode === 400 ||
                     statusCode === 401 ||
                     statusCode === DisconnectReason.loggedOut ||
                     statusCode === DisconnectReason.badSession;
+                const shouldTreatAsLoggedOut = isBadMac || isAuthRejected;
 
-                console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
+                if (this.verboseMode) {
+                    console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
+                }
 
                 if (shouldTreatAsLoggedOut) {
-                    console.error(`Session invalid or logged out [${statusCode}] - preserving auth state and requiring re-auth`);
-                    if (errorMessage.includes('Bad MAC')) {
-                        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');
+                    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 (!errorMessage.includes('Bad MAC')) {
+                    if (!isBadMac) {
                         this.onStatusUpdate?.('| WhatsApp: Logged out');
                     }
                     return;
                 }
 
                 if (statusCode === DisconnectReason.connectionReplaced) {
-                    console.error('Connection replaced - another instance connected');
+                    if (this.verboseMode) {
+                        console.error('Connection replaced - another instance connected');
+                    }
                     this.onStatusUpdate?.('| WhatsApp: Conflict (Another Instance)');
                     return;
                 }
@@ -162,7 +209,7 @@ export class WhatsAppService {
                     this.onStatusUpdate?.('| WhatsApp: Reconnecting...');
                     setTimeout(() => {
                         this.isReconnecting = false;
-                        this.start();
+                        this.start(options);
                     }, 3000);
                 } else if (!shouldReconnect) {
                     this.sessionManager.setStatus('logged-out');
@@ -187,6 +234,7 @@ export class WhatsAppService {
             console.log = originalConsoleLog;
             console.warn = originalConsoleWarn;
             console.error = originalConsoleError;
+            this.restoreBaileysConsoleFilter = installBaileysConsoleFilter(this.verboseMode);
         }
     }
 
@@ -354,6 +402,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');

package/src/ui/menu.handler.ts

@@ -13,7 +13,7 @@ export class MenuHandler {
     ) {}
 
     async handleCommand(ctx: ExtensionCommandContext) {
-        const status = this.sessionManager.getStatus();
+        const status = this.whatsappService.getEffectiveStatus();
         const registered = await this.sessionManager.isRegistered();
         const options: string[] = [];
 
@@ -178,12 +178,7 @@ export class MenuHandler {
         const choice = await ctx.ui.select('Blocked Numbers (Select to Manage)', options);
 
         if (choice && choice !== 'Back') {
-            let num = choice;
-            if (num.includes('(')) {
-                const match = num.match(/\((.*?)\)/);
-                if (match) num = match[1];
-            }
-            await this.manageBlockedNumber(ctx, num);
+            await this.manageBlockedNumber(ctx, this.parseContactNumberOption(choice));
         } else {
             await this.handleCommand(ctx);
         }
@@ -301,36 +296,33 @@ export class MenuHandler {
     }
 
     private async sendMessageFromRecents(ctx: ExtensionCommandContext, conversation: RecentConversationSummary) {
-        const displayName = this.getConversationDisplayName(conversation);
-        for (let attempt = 0; attempt < 2; attempt++) {
-            const text = await ctx.ui.input(`Send a message to ${displayName}:`);
-            const trimmed = text?.trim() || '';
-
-            if (!trimmed) {
-                ctx.ui.notify('Please enter a message before sending.', 'error');
-                continue;
-            }
-
-            const result = await this.whatsappService.sendMenuMessage(this.toJid(conversation.senderNumber), trimmed);
-            if (result.success) {
-                await this.recentsService.recordMessage({
-                    messageId: result.messageId ?? `${Date.now()}`,
-                    senderNumber: conversation.senderNumber,
-                    senderName: conversation.senderName,
-                    text: trimmed,
-                    direction: 'outgoing',
-                    timestamp: Date.now()
-                });
-                ctx.ui.notify(`Sent message to ${displayName}`, 'info');
-            } else {
-                ctx.ui.notify(`Failed to send message to ${displayName}: ${result.error ?? 'Unknown error'}`, 'error');
-            }
-            return;
-        }
+        await this.sendPromptedMenuMessage(ctx, {
+            displayName: this.getConversationDisplayName(conversation),
+            senderNumber: conversation.senderNumber,
+            senderName: conversation.senderName,
+            appendPiSuffix: false
+        });
     }
 
     private async sendMessageToAllowedNumber(ctx: ExtensionCommandContext, contact: Contact) {
-        const displayName = contact.name ? `${contact.name} (${contact.number})` : contact.number;
+        await this.sendPromptedMenuMessage(ctx, {
+            displayName: this.formatAllowedContactOption(contact),
+            senderNumber: contact.number,
+            senderName: contact.name,
+            appendPiSuffix: true
+        });
+    }
+
+    private async sendPromptedMenuMessage(
+        ctx: ExtensionCommandContext,
+        options: {
+            displayName: string;
+            senderNumber: string;
+            senderName?: string;
+            appendPiSuffix: boolean;
+        }
+    ) {
+        const { displayName, senderNumber, senderName, appendPiSuffix } = options;
         for (let attempt = 0; attempt < 2; attempt++) {
             const inputText = (await ctx.ui.input(`Send a message to ${displayName}:`))?.trim() || '';
 
@@ -339,15 +331,14 @@ export class MenuHandler {
                 continue;
             }
 
-            const inputTextWithPiSuffix = inputText + ' π';
-
-            const result = await this.whatsappService.sendMenuMessage(this.toJid(contact.number), inputTextWithPiSuffix);
+            const messageText = appendPiSuffix ? `${inputText} π` : inputText;
+            const result = await this.whatsappService.sendMenuMessage(this.toJid(senderNumber), messageText);
             if (result.success) {
                 await this.recentsService.recordMessage({
                     messageId: result.messageId ?? `${Date.now()}`,
-                    senderNumber: contact.number,
-                    senderName: contact.name,
-                    text: inputTextWithPiSuffix,
+                    senderNumber,
+                    senderName,
+                    text: messageText,
                     direction: 'outgoing',
                     timestamp: Date.now()
                 });
@@ -372,7 +363,8 @@ export class MenuHandler {
         }
 
         const options = [
-            ...history.slice().reverse().map(message => this.formatHistoryOption(message.timestamp, message.direction, message.text)),
+            ...this.sortHistoryByMostRecent(history)
+                .map(message => this.formatHistoryOption(message.timestamp, message.direction, message.text)),
             'Back'
         ];
 
@@ -404,6 +396,39 @@ export class MenuHandler {
         return contact.name ? `${contact.name} ${contact.number}` : contact.number;
     }
 
+    private parseContactNumberOption(choice: string): string {
+        if (!choice.includes('(')) {
+            return choice;
+        }
+
+        const match = choice.match(/\((.*?)\)/);
+        return match?.[1] ?? choice;
+    }
+
+    private sortHistoryByMostRecent<T extends { timestamp: number }>(history: T[]): T[] {
+        return [...history].sort((left, right) => {
+            const dayComparison = this.getDayStart(right.timestamp) - this.getDayStart(left.timestamp);
+            if (dayComparison !== 0) {
+                return dayComparison;
+            }
+
+            return this.getTimeOfDay(right.timestamp) - this.getTimeOfDay(left.timestamp);
+        });
+    }
+
+    private getTimeOfDay(timestamp: number): number {
+        const date = new Date(timestamp);
+        return date.getHours() * 60 * 60 * 1000
+            + date.getMinutes() * 60 * 1000
+            + date.getSeconds() * 1000
+            + date.getMilliseconds();
+    }
+
+    private getDayStart(timestamp: number): number {
+        const date = new Date(timestamp);
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+    }
+
     private formatHistoryOption(timestamp: number, direction: string, text: string): string {
         const marker = direction === 'outgoing' ? 'Sent' : 'Received';
         const displayText = this.truncate(text, 60) || '[No text]';

package/whatsapp-pi.ts

@@ -1,15 +1,13 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { extractMessageContent } from '@whiskeysockets/baileys';
 import { SessionManager } from './src/services/session.manager.js';
 import { WhatsAppService } from './src/services/whatsapp.service.js';
 import { MenuHandler } from './src/ui/menu.handler.js';
 import { RecentsService } from './src/services/recents.service.js';
 import { AudioService } from './src/services/audio.service.js';
-import { join } from 'node:path';
-import { writeFile, mkdir } from 'node:fs/promises';
-
-console.log("[WhatsApp-Pi] Extension file loaded by Pi...");
+import { extractIncomingText } from './src/services/incoming-message.resolver.js';
+import { IncomingMediaService } from './src/services/incoming-media.service.js';
+import { WhatsAppPiLogger } from './src/services/whatsapp-pi.logger.js';
 
 const shutdownState = globalThis as typeof globalThis & {
     __whatsappPiShutdown?: {
@@ -36,6 +34,8 @@ export default function (pi: ExtensionAPI) {
     const whatsappService = new WhatsAppService(sessionManager);
     const recentsService = new RecentsService(sessionManager);
     const audioService = new AudioService();
+    const logger = new WhatsAppPiLogger(false);
+    const incomingMediaService = new IncomingMediaService(audioService, logger);
     const menuHandler = new MenuHandler(whatsappService, sessionManager, recentsService);
     let _ctx: ExtensionContext | undefined;
 
@@ -46,11 +46,12 @@ export default function (pi: ExtensionAPI) {
         }
 
         shutdownState.__whatsappPiShutdown.installed = true;
+        
         const shutdown = async (reason: string) => {
             try {
                 await shutdownState.__whatsappPiShutdown?.stop?.();
             } catch (error) {
-                console.error(`[WhatsApp-Pi] Graceful shutdown failed during ${reason}:`, error);
+                logger.error(`[WhatsApp-Pi] Graceful shutdown failed during ${reason}:`, error);
             }
         };
 
@@ -59,7 +60,7 @@ export default function (pi: ExtensionAPI) {
     };
 
     // Initial status setup
-    pi.on("session_start", async (_event, ctx) => {
+    pi.on("session_start", async (event, ctx) => {
         _ctx = ctx;
         // Check verbose mode
         const isVerboseFlagSet = process.argv.includes("--verbose");
@@ -67,9 +68,10 @@ export default function (pi: ExtensionAPI) {
         const isVerbose = isVerboseFlagSet;
 
         whatsappService.setVerboseMode(isVerbose);
+        logger.setVerbose(isVerbose);
 
         if (isVerbose) {
-            console.log('[WhatsApp-Pi] Verbose mode enabled - Baileys trace logs will be shown');
+            logger.log('[WhatsApp-Pi] Verbose mode enabled - Baileys trace logs will be shown');
         }
         ctx.ui.setStatus('whatsapp', '| WhatsApp: Disconnected');
         whatsappService.setStatusCallback((status) => {
@@ -98,10 +100,16 @@ export default function (pi: ExtensionAPI) {
         const savedStateEntry = [...ctx.sessionManager.getEntries()]
             .reverse()
             .find(entry => entry.type === "custom" && entry.customType === "whatsapp-state");
+        const isWhatsappPiOn = event.reason === "startup" && pi.getFlag("whatsapp-pi-online") === true;
 
         if (savedStateEntry) {
             const data = (savedStateEntry as { data?: any }).data;
-            if (data.status) await sessionManager.setStatus(data.status);
+            if (data.status) {
+                const restoredStatus = data.status === 'connected' && !isWhatsappPiOn
+                    ? 'disconnected'
+                    : data.status;
+                await sessionManager.setStatus(restoredStatus);
+            }
             if (Array.isArray(data.allowList)) {
                 for (const n of data.allowList) {
                     const num = typeof n === "string" ? n : n.number;
@@ -111,12 +119,11 @@ export default function (pi: ExtensionAPI) {
             }
         }
 
-        // Check whatsapp flag
-        const isWhatsappPiOn = process.argv.includes("--whatsapp-pi-online");
+        // Check whatsapp flag — only auto-connect on initial startup, not reloads/new sessions
         const registered = await sessionManager.isRegistered();
 
-        if (registered || isWhatsappPiOn) {
-            ctx.ui.setStatus('whatsapp', registered ? '| WhatsApp: Reconnecting...' : '| WhatsApp: Auto-connecting...');
+        if (isWhatsappPiOn && registered) {
+            ctx.ui.setStatus('whatsapp', '| WhatsApp: Auto-connecting...');
 
             // Retry logic (max 3 attempts, 3s delay)
             let attempts = 0;
@@ -125,7 +132,7 @@ export default function (pi: ExtensionAPI) {
             const tryConnect = async () => {
                 attempts++;
                 try {
-                    await whatsappService.start();
+                    await whatsappService.start({ allowPairingOnAuthFailure: false });
                 } catch (error) {
                     if (attempts < maxAttempts) {
                         ctx.ui.notify(`WhatsApp: Connection attempt ${attempts} failed. Retrying...`, 'warning');
@@ -152,141 +159,10 @@ export default function (pi: ExtensionAPI) {
             }
         } catch (e) {
             ctx.ui.notify('WhatsApp: pdftotext not found. PDF document support will be limited to storage only.', 'warning');
-            console.warn('[WhatsApp-Pi] Warning: pdftotext not found in system PATH.');
+            logger.warn('[WhatsApp-Pi] Warning: pdftotext not found in system PATH.');
         }
     });
 
-
-
-    type IncomingResolution =
-        | { kind: 'text'; text: string }
-        | { kind: 'audio'; text: string; audioMessage: any }
-        | { kind: 'image'; text: string; imageMessage: any }
-        | { kind: 'document'; text: string; documentMessage: any }
-        | { kind: 'contact'; text: string }
-        | { kind: 'location'; text: string }
-        | { kind: 'system'; text: string }
-        | { kind: 'unsupported'; text: string };
-
-    const extractIncomingText = (message: any, pushName: string): IncomingResolution => {
-        const unwrap = (content: any): any => extractMessageContent(content) ?? content;
-        const content = unwrap(message);
-
-        const getTypeName = (payload: any): string => {
-            if (!payload || typeof payload !== 'object') return 'unknown';
-            const keys = Object.keys(payload);
-            return keys[0] || 'unknown';
-        };
-
-        const formatProtocolMessage = (protocolMessage: any): string => {
-            const protocolTypes: Record<number, string> = {
-                0: 'Message Deleted',
-                3: 'Disappearing Messages Updated',
-                4: 'Disappearing Message Sync Response',
-                5: 'History Sync Notification',
-                6: 'App State Sync Key Share',
-                7: 'App State Sync Key Request',
-                8: 'Message Backfill Request',
-                9: 'Security Notification Sync',
-                10: 'Fatal App State Sync Notification',
-                11: 'Phone Number Shared',
-                14: 'Message Edited',
-                16: 'Peer Data Request',
-                17: 'Peer Data Response',
-                18: 'Welcome Message Request',
-                19: 'Bot Feedback',
-                20: 'Media Notification'
-            };
-
-            const typeLabel = protocolTypes[Number(protocolMessage?.type)] || 'System Update';
-            if (protocolMessage?.editedMessage?.conversation || protocolMessage?.editedMessage?.extendedTextMessage?.text) {
-                const editedText = protocolMessage.editedMessage.conversation
-                    || protocolMessage.editedMessage.extendedTextMessage?.text
-                    || '[Edited message]';
-                return `[${typeLabel}: ${editedText}]`;
-            }
-
-            return `[${typeLabel}]`;
-        };
-
-        const inner = content?.ephemeralMessage?.message
-            || content?.viewOnceMessage?.message
-            || content?.viewOnceMessageV2?.message
-            || content?.viewOnceMessageV2Extension?.message
-            || content?.message;
-
-        const resolved = inner ? unwrap(inner) : content;
-        const typeName = getTypeName(resolved);
-        const protocolMessage = resolved?.protocolMessage
-            || (typeName === 'protocolMessage' ? resolved : undefined)
-            || content?.protocolMessage;
-
-        if (protocolMessage) {
-            return { kind: 'system', text: formatProtocolMessage(protocolMessage) };
-        }
-
-        if (resolved?.conversation) {
-            return { kind: 'text', text: resolved.conversation };
-        }
-
-        if (resolved?.extendedTextMessage?.text) {
-            return { kind: 'text', text: resolved.extendedTextMessage.text };
-        }
-
-        if (resolved?.imageMessage) {
-            return {
-                kind: 'image',
-                text: resolved.imageMessage.caption || '[Image]',
-                imageMessage: resolved.imageMessage
-            };
-        }
-
-        if (resolved?.videoMessage) {
-            return {
-                kind: 'text',
-                text: resolved.videoMessage.caption || '[Video]'
-            };
-        }
-
-        if (resolved?.audioMessage) {
-            return {
-                kind: 'audio',
-                text: '[Audio Message]',
-                audioMessage: resolved.audioMessage
-            };
-        }
-
-        if (resolved?.documentMessage) {
-            return {
-                kind: 'document',
-                text: resolved.documentMessage.caption || '[Document]',
-                documentMessage: resolved.documentMessage
-            };
-        }
-
-        if (resolved?.contactMessage || resolved?.contactsArrayMessage) {
-            return { kind: 'contact', text: '[Contact]' };
-        }
-
-        if (resolved?.locationMessage) {
-            return { kind: 'location', text: '[Location]' };
-        }
-
-        if (resolved?.buttonsResponseMessage?.selectedDisplayText) {
-            return { kind: 'text', text: resolved.buttonsResponseMessage.selectedDisplayText };
-        }
-
-        if (resolved?.listResponseMessage?.title) {
-            return { kind: 'text', text: resolved.listResponseMessage.title };
-        }
-
-        if (resolved?.templateButtonReplyMessage?.selectedDisplayText) {
-            return { kind: 'text', text: resolved.templateButtonReplyMessage.selectedDisplayText };
-        }
-
-        return { kind: 'unsupported', text: `[Unsupported Message Type: ${typeName}]` };
-    };
-
     // Handle incoming messages by injecting them as user prompts
     whatsappService.setMessageCallback(async (m) => {
         const msg = m.messages[0];
@@ -302,99 +178,15 @@ export default function (pi: ExtensionAPI) {
             whatsappService.sendPresence(remoteJid, 'composing');
         }
 
-        const resolved = extractIncomingText(msg.message, pushName);
+        const resolved = extractIncomingText(msg.message);
         if (resolved.kind === 'system') {
-            console.log(`[WhatsApp-Pi] ${pushName} (${sender}): ${resolved.text}`);
+            logger.log(`[WhatsApp-Pi] ${pushName} (${sender}): ${resolved.text}`);
             return;
         }
 
-        let text = resolved.text;
-
-        // Handle media types
-        let imageBuffer: Buffer | undefined;
-        let imageMimeType: string | undefined;
-
-        if (resolved.kind === 'audio') {
-            console.log(`[WhatsApp-Pi] Transcribing audio from ${pushName}...`);
-            const transcription = await audioService.transcribe(resolved.audioMessage);
-            text = `[Transcribed Audio]: ${transcription}`;
-        } else if (resolved.kind === 'image') {
-            console.log(`[WhatsApp-Pi] Downloading image from ${pushName}...`);
-            try {
-                const { downloadContentFromMessage } = await import('@whiskeysockets/baileys');
-                const stream = await downloadContentFromMessage(resolved.imageMessage, 'image');
-                let buffer = Buffer.from([]);
-                for await (const chunk of stream) {
-                    buffer = Buffer.concat([buffer, chunk]);
-                }
-                imageBuffer = buffer;
-
-                // Normalize mime type for Cloud Code Assist / Gemini
-                let rawMime = resolved.imageMessage.mimetype || 'image/jpeg';
-                imageMimeType = rawMime.toLowerCase().split(';')[0].trim();
-                if (imageMimeType === 'image/jpg') imageMimeType = 'image/jpeg';
-
-                console.log(`[WhatsApp-Pi] Image downloaded. MIME: ${imageMimeType} (original: ${rawMime}), Size: ${imageBuffer.length} bytes`);
-
-                text = resolved.text || "[Image]";
-            } catch (e) {
-                console.error(`[WhatsApp-Pi] Failed to download image:`, e);
-                text = "[Image (download failed)]";
-            }
-        } else if (resolved.kind === 'document') {
-            const doc = resolved.documentMessage;
-            const fileName = doc.fileName || 'unnamed_document';
-            const mimeType = doc.mimetype || 'application/octet-stream';
-            const fileSize = doc.fileLength ? Number(doc.fileLength) : 0;
-
-            console.log(`[WhatsApp-Pi] Downloading document from ${pushName}: ${fileName}...`);
-
-            try {
-                const { downloadContentFromMessage } = await import('@whiskeysockets/baileys');
-                const stream = await downloadContentFromMessage(doc, 'document');
-                let buffer = Buffer.from([]);
-                for await (const chunk of stream) {
-                    buffer = Buffer.concat([buffer, chunk]);
-                }
-
-                // Sanitize filename
-                const sanitized = fileName.replace(/[^a-z0-9\._-]/gi, '_');
-                const savedFileName = `${Date.now()}_${sanitized}`;
-                const relativePath = `./.pi-data/whatsapp/documents/${savedFileName}`;
-                const absolutePath = join(process.cwd(), '.pi-data', 'whatsapp', 'documents', savedFileName);
-
-                // Ensure directory exists (T001 handles it at startup, but let's be safe)
-                await mkdir(join(process.cwd(), '.pi-data', 'whatsapp', 'documents'), { recursive: true });
-                await writeFile(absolutePath, buffer);
-
-                console.log(`[WhatsApp-Pi] Document saved to ${relativePath} (${buffer.length} bytes)`);
-
-                const sizeFormatted = fileSize > 1024 * 1024
-                    ? `${(fileSize / (1024 * 1024)).toFixed(1)} MB`
-                    : `${(fileSize / 1024).toFixed(1)} KB`;
-
-                text = `[Document Received: ${fileName}]\n` +
-                    `MIME Type: ${mimeType}\n` +
-                    `Size: ${sizeFormatted}\n` +
-                    `Location: ${relativePath}`;
-
-                if (doc.caption) {
-                    text += `\n\nDescription: ${doc.caption}`;
-                }
-            } catch (e) {
-                console.error(`[WhatsApp-Pi] Failed to download document:`, e);
-                text = `[Document: ${fileName} (download failed)]`;
-            }
-        } else if (resolved.kind === 'contact') {
-            text = resolved.text;
-        } else if (resolved.kind === 'location') {
-            text = resolved.text;
-        } else if (resolved.kind === 'unsupported') {
-            text = resolved.text;
-        }
+        const { text, imageBuffer, imageMimeType } = await incomingMediaService.process(resolved, pushName);
 
-        // Always log to console so it appears in the TUI log pane
-        console.log(`[WhatsApp-Pi] ${pushName} (${sender}): ${text}`);
+        logger.log(`[WhatsApp-Pi] ${pushName} (${sender}): ${text}`);
 
         // Use a standard delivery for ALL messages to ensure TUI consistency
         if (imageBuffer && imageMimeType) {
@@ -408,7 +200,7 @@ export default function (pi: ExtensionAPI) {
 
         // Handle commands
         if (text.trim().toLowerCase().startsWith('/compact')) {
-            console.log(`[WhatsApp-Pi] Session compact requested by ${pushName}.`);
+            logger.log(`[WhatsApp-Pi] Session compact requested by ${pushName}.`);
 
             if (_ctx) {
                 _ctx.compact();
@@ -418,7 +210,7 @@ export default function (pi: ExtensionAPI) {
         }
 
         if (text.trim().toLowerCase().startsWith('/abort')) {
-            console.log(`[WhatsApp-Pi] Abort requested by ${pushName}.`);
+            logger.log(`[WhatsApp-Pi] Abort requested by ${pushName}.`);
             if (_ctx) {
                 _ctx.abort();
                 await whatsappService.sendMessage(remoteJid!, "Aborted! ✅");
@@ -524,7 +316,7 @@ export default function (pi: ExtensionAPI) {
     });
 
     pi.on("session_shutdown", async () => {
-        console.log("[WhatsApp-Pi] Session shutdown detected. Stopping WhatsApp service...");
+        logger.log("[WhatsApp-Pi] Session shutdown detected. Stopping WhatsApp service...");
         await whatsappService.stop();
     });
 }