whatsapp-pi 1.0.44 → 1.0.46

package/README.md

@@ -46,10 +46,10 @@ pi install npm:whatsapp-pi
 pi
 ```
 
-To automatically connect to WhatsApp on startup (if you are already authenticated):
-```bash
-pi --whatsapp-pi-online
-```
+After connecting WhatsApp once from the menu and scanning the QR code, you can start Pi with auto-connect enabled:
+```bash
+pi --whatsapp-pi-online
+```
 
 3. Use the menu to connect WhatsApp and manage allowed/blocked numbers
 
@@ -69,10 +69,15 @@ npm install
 pi -e whatsapp-pi.ts
 ```
 
-For verbose mode (shows Baileys trace logs for debugging):
-```bash
-pi -e whatsapp-pi.ts --verbose
-```
+For verbose mode (shows Baileys trace logs for debugging):
+```bash
+pi -e whatsapp-pi.ts --verbose
+```
+
+To test startup auto-connect locally after you have already paired WhatsApp:
+```bash
+pi -e whatsapp-pi.ts --whatsapp-pi-online
+```
 
 ## Commands
 

package/package.json

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

package/src/models/whatsapp.types.ts

@@ -18,9 +18,12 @@ export interface IncomingMessage {
     timestamp: number;
 }
 
+export type MessageOrigin = 'agent' | 'menu';
+
 export interface MessageRequest {
     recipientJid: string;
     text: string;
+    origin?: MessageOrigin;
     options?: {
         maxRetries?: number;
         priority?: 'high' | 'normal';

package/src/services/message.sender.ts

@@ -54,9 +54,9 @@ export class MessageSender {
                 }
 
                 // 3. Send the message
-                // Note: Branding π is applied here to ensure consistency
-                const response = await socket.sendMessage(request.recipientJid, { 
-                    text: `${request.text} π` 
+                const shouldAppendPi = request.origin !== 'menu';
+                const response = await socket.sendMessage(request.recipientJid, {
+                    text: shouldAppendPi ? `${request.text} π` : request.text
                 });
 
                 return {

package/src/services/session.manager.ts

@@ -136,10 +136,11 @@ export class SessionManager {
     public async saveConfig() {
         const tempPath = `${this.configPath}.${process.pid}.${Date.now()}.tmp`;
         try {
+            this.hasAuthState = this.hasAuthState || await this.hasCredentialsFile();
             const config = {
                 allowList: this.allowList,
-                blockList: this.blockList,
-                ignoredNumbers: this.ignoredNumbers,
+                blockList: this.blockList,
+                ignoredNumbers: this.ignoredNumbers,
                 status: this.status,
                 hasAuthState: this.hasAuthState,
                 openaiKey: this.openaiKey,

package/src/services/whatsapp.service.ts

@@ -72,10 +72,14 @@ interface BoomLikeError {
 }
 
 export class WhatsAppService {
+    private static readonly INITIAL_RECONNECT_DELAY_MS = 5_000;
+    private static readonly MAX_RECONNECT_DELAY_MS = 120_000;
+
     private socket?: WhatsAppSocketLike;
     private sessionManager: SessionManager;
     private messageSender: MessageSender;
     private isReconnecting = false;
+    private reconnectAttempts = 0;
     private verboseMode = false;
     private onIncomingMessageRecorded?: (message: IncomingMessage) => void | Promise<void>;
     private saveCreds?: () => Promise<void>;
@@ -171,6 +175,11 @@ export class WhatsAppService {
         }
     }
 
+    private getReconnectDelayMs(): number {
+        const delay = WhatsAppService.INITIAL_RECONNECT_DELAY_MS * (2 ** Math.max(0, this.reconnectAttempts - 1));
+        return Math.min(delay, WhatsAppService.MAX_RECONNECT_DELAY_MS);
+    }
+
     private cleanupSocket() {
         this.clearReconnectTimeout();
 
@@ -295,7 +304,7 @@ export class WhatsAppService {
     private async handlePairingQr(qr: string) {
         this.sessionManager.setStatus('pairing');
         this.onQRCode?.(qr);
-        this.onStatusUpdate?.('| WhatsApp: Disconnected');
+        this.onStatusUpdate?.('| WhatsApp: Disconnected');
     }
 
     private async handleConnectionOpen() {
@@ -304,6 +313,7 @@ export class WhatsAppService {
         }
 
         this.isReconnecting = false;
+        this.reconnectAttempts = 0;
         this.clearReconnectTimeout();
         await this.saveCreds?.();
         await this.sessionManager.markAuthStateAvailable();
@@ -339,45 +349,55 @@ export class WhatsAppService {
             console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
         }
 
-        if (shouldTreatAsLoggedOut) {
-            if (this.verboseMode) {
-                console.error(`Session rejected [${statusCode}] - preserving auth state`);
-            }
-            if (isBadMac) {
-                if (this.verboseMode) {
-                    console.error('[WhatsApp-Pi] Bad MAC error detected. Your session keys are corrupted.');
-                    console.error('[WhatsApp-Pi] Use Logoff (Delete Session) only if reconnect keeps failing.');
-                }
-                this.onStatusUpdate?.('| WhatsApp: Session Error (Bad MAC)');
-            } else if (isAuthRejected && allowPairingOnAuthFailure) {
-                this.onStatusUpdate?.('| WhatsApp: Session Preserved (Reconnect Failed)');
-            }
-            this.cleanupSocket();
-            this.isReconnecting = false;
-            await this.sessionManager.setStatus('disconnected');
-            if (!isBadMac) {
-                this.onStatusUpdate?.('| WhatsApp: Disconnected');
-            }
-            return;
-        }
+        if (shouldTreatAsLoggedOut) {
+            if (this.verboseMode) {
+                console.error(`Session rejected [${statusCode}] - preserving auth state`);
+            }
+            if (isBadMac) {
+                if (this.verboseMode) {
+                    console.error('[WhatsApp-Pi] Bad MAC error detected. Your session keys are corrupted.');
+                    console.error('[WhatsApp-Pi] Use Logoff (Delete Session) only if reconnect keeps failing.');
+                }
+                this.onStatusUpdate?.('| WhatsApp: Session Error (Bad MAC)');
+            } else if (isAuthRejected && allowPairingOnAuthFailure) {
+                this.onStatusUpdate?.('| WhatsApp: Session Preserved (Reconnect Failed)');
+            }
+            this.cleanupSocket();
+            this.isReconnecting = false;
+            this.reconnectAttempts = 0;
+            await this.sessionManager.setStatus('disconnected');
+            if (!isBadMac) {
+                this.onStatusUpdate?.('| WhatsApp: Disconnected');
+            }
+            return;
+        }
 
         if (statusCode === DisconnectReason.connectionReplaced) {
             if (this.verboseMode) {
                 console.error('Connection replaced - another instance connected');
             }
+            this.cleanupSocket();
+            this.isReconnecting = false;
+            this.reconnectAttempts = 0;
+            await this.sessionManager.setStatus('disconnected');
             this.onStatusUpdate?.('| WhatsApp: Conflict (Another Instance)');
             return;
         }
 
         if (shouldReconnect && !this.isReconnecting) {
             this.isReconnecting = true;
+            this.reconnectAttempts++;
+            const reconnectDelayMs = this.getReconnectDelayMs();
             this.onStatusUpdate?.('| WhatsApp: Reconnecting...');
             this.clearReconnectTimeout();
+            await this.saveCreds?.();
+            this.cleanupSocket();
             this.reconnectTimeout = setTimeout(() => {
                 this.isReconnecting = false;
                 void this.start(options);
-            }, 3000);
+            }, reconnectDelayMs);
         } else if (!shouldReconnect) {
+            this.reconnectAttempts = 0;
             this.sessionManager.setStatus('logged-out');
             this.onStatusUpdate?.('| WhatsApp: Disconnected');
         }
@@ -477,13 +497,14 @@ export class WhatsAppService {
         return this.socket;
     }
 
-    async sendMessage(jid: string, text: string) {
+    async sendMessage(jid: string, text: string, origin: 'agent' | 'menu' = 'agent') {
         // Ensure we show the typing indicator before sending
         await this.sendPresence(jid, 'composing');
 
         const result = await this.messageSender.send({
             recipientJid: jid,
-            text: text
+            text,
+            origin
         });
 
         // After sending, we can stop the typing indicator
@@ -498,35 +519,7 @@ export class WhatsAppService {
 
     async sendMenuMessage(jid: string, text: string) {
         const normalizedJid = this.normalizeRecipientJid(jid);
-        const socket = this.getActiveSocket();
-
-        if (!socket) {
-            return {
-                success: false,
-                error: 'WhatsApp is not connected',
-                attempts: 0
-            };
-        }
-
-        try {
-            await this.sendPresence(normalizedJid, 'composing');
-            const response = await socket.sendMessage(normalizedJid, { text });
-            await this.sendPresence(normalizedJid, 'paused');
-
-            return {
-                success: true,
-                messageId: response?.key?.id,
-                attempts: 1
-            };
-        } catch (error: unknown) {
-            await this.sendPresence(normalizedJid, 'paused');
-            console.error(`Failed to send menu message to ${normalizedJid}:`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-                attempts: 1
-            };
-        }
+        return this.sendMessage(normalizedJid, text, 'menu');
     }
 
     async sendPresence(jid: string, presence: 'composing' | 'recording' | 'paused') {

package/src/ui/menu.handler.ts

@@ -63,14 +63,14 @@ export class MenuHandler {
                 await this.whatsappService.stop();
                 ctx.ui.notify('WhatsApp Agent Disconnected', 'warning');
                 break;
-            case 'Logoff (Delete Session)': {
-                const confirmLogoff = await ctx.ui.confirm('Logoff', 'Delete all credentials?');
-                if (confirmLogoff) {
-                    await this.whatsappService.logout();
-                    ctx.ui.notify('Logged off and credentials deleted', 'info');
-                }
-                break;
-            }
+            case 'Logoff (Delete Session)': {
+                const confirmLogoff = await ctx.ui.confirm('Logoff', 'Delete all credentials?');
+                if (confirmLogoff) {
+                    await this.whatsappService.logout();
+                    ctx.ui.notify('Logged off and credentials deleted', 'info');
+                }
+                break;
+            }
             case 'Allowed Numbers':
                 await this.manageAllowList(ctx);
                 break;
@@ -325,8 +325,7 @@ export class MenuHandler {
         await this.sendPromptedMenuMessage(ctx, {
             displayName: this.getConversationDisplayName(conversation),
             senderNumber: conversation.senderNumber,
-            senderName: conversation.senderName,
-            appendPiSuffix: false
+            senderName: conversation.senderName
         });
     }
 
@@ -334,8 +333,7 @@ export class MenuHandler {
         await this.sendPromptedMenuMessage(ctx, {
             displayName: this.formatAllowedContactOption(contact),
             senderNumber: contact.number,
-            senderName: contact.name,
-            appendPiSuffix: true
+            senderName: contact.name
         });
     }
 
@@ -345,10 +343,9 @@ export class MenuHandler {
             displayName: string;
             senderNumber: string;
             senderName?: string;
-            appendPiSuffix: boolean;
         }
     ) {
-        const { displayName, senderNumber, senderName, appendPiSuffix } = options;
+        const { displayName, senderNumber, senderName } = options;
         for (let attempt = 0; attempt < 2; attempt++) {
             const inputText = (await ctx.ui.input(`Send a message to ${displayName}:`))?.trim() || '';
 
@@ -357,14 +354,13 @@ export class MenuHandler {
                 continue;
             }
 
-            const messageText = appendPiSuffix ? `${inputText} π` : inputText;
-            const result = await this.whatsappService.sendMenuMessage(this.toJid(senderNumber), messageText);
+            const result = await this.whatsappService.sendMenuMessage(this.toJid(senderNumber), inputText);
             if (result.success) {
                 await this.recentsService.recordMessage({
                     messageId: result.messageId ?? `${Date.now()}`,
                     senderNumber,
                     senderName,
-                    text: messageText,
+                    text: inputText,
                     direction: 'outgoing',
                     timestamp: Date.now()
                 });

package/whatsapp-pi.ts

@@ -60,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");
@@ -86,10 +86,10 @@ export default function (pi: ExtensionAPI) {
                 await whatsappService.stop();
             }
         };
-        whatsappService.setIncomingMessageRecorder(async (message) => {
-            await recentsService.recordMessage({
-                messageId: message.id,
-                senderNumber: `+${message.remoteJid.split('@')[0]}`,
+        whatsappService.setIncomingMessageRecorder(async (message) => {
+            await recentsService.recordMessage({
+                messageId: message.id,
+                senderNumber: `+${message.remoteJid.split('@')[0]}`,
                 senderName: message.pushName,
                 text: message.text || '',
                 direction: 'incoming',
@@ -97,20 +97,20 @@ export default function (pi: ExtensionAPI) {
             });
         });
 
-        const savedStateEntry = [...ctx.sessionManager.getEntries()]
-            .reverse()
-            .find(entry => entry.type === "custom" && entry.customType === "whatsapp-state");
-        const isWhatsappPiOn = pi.getFlag("whatsapp-pi-online") === true;
-        const registered = await sessionManager.isRegistered();
-
-        if (savedStateEntry) {
-            const data = (savedStateEntry as { data?: any }).data;
-            if (data.status) {
-                const restoredStatus = data.status === 'connected' && !(isWhatsappPiOn && registered)
-                    ? 'disconnected'
-                    : data.status;
-                await sessionManager.setStatus(restoredStatus);
-            }
+        const savedStateEntry = [...ctx.sessionManager.getEntries()]
+            .reverse()
+            .find(entry => entry.type === "custom" && entry.customType === "whatsapp-state");
+        const isWhatsappPiOn = pi.getFlag("whatsapp-pi-online") === true;
+        const registered = await sessionManager.isRegistered();
+
+        if (savedStateEntry) {
+            const data = (savedStateEntry as { data?: any }).data;
+            if (data.status) {
+                const restoredStatus = data.status === 'connected' && !(isWhatsappPiOn && registered)
+                    ? '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;
@@ -118,10 +118,10 @@ export default function (pi: ExtensionAPI) {
                     await sessionManager.addNumber(num, name);
                 }
             }
-        }
-
-        if (isWhatsappPiOn && registered) {
-            ctx.ui.setStatus('whatsapp', '| WhatsApp: Auto-connecting...');
+        }
+
+        if (isWhatsappPiOn && registered) {
+            ctx.ui.setStatus('whatsapp', '| WhatsApp: Auto-connecting...');
 
             // Retry logic (max 3 attempts, 3s delay)
             let attempts = 0;
@@ -131,7 +131,7 @@ export default function (pi: ExtensionAPI) {
                 attempts++;
                 try {
                     await whatsappService.start({ allowPairingOnAuthFailure: false });
-                } catch {
+                } catch {
                     if (attempts < maxAttempts) {
                         ctx.ui.notify(`WhatsApp: Connection attempt ${attempts} failed. Retrying...`, 'warning');
                         setTimeout(tryConnect, 3000);
@@ -143,11 +143,11 @@ export default function (pi: ExtensionAPI) {
             };
 
             await tryConnect();
-        } else if (isWhatsappPiOn) {
-            ctx.ui.notify('WhatsApp: Auto-connect requested, but no saved WhatsApp credentials were found. Use Connect WhatsApp once to scan the QR code.', 'warning');
-        } else {
-            ctx.ui.notify('WhatsApp: Use Connect / Reconnect WhatsApp. QR code will appear only if pairing is needed.', 'info');
-        }
+        } else if (isWhatsappPiOn) {
+            ctx.ui.notify('WhatsApp: Auto-connect requested, but no saved WhatsApp credentials were found. Use Connect WhatsApp once to scan the QR code.', 'warning');
+        } else {
+            ctx.ui.notify('WhatsApp: Use Connect / Reconnect WhatsApp. QR code will appear only if pairing is needed.', 'info');
+        }
 
         ctx.ui.notify('WhatsApp: Session reset via /new is now fully supported.', 'info');
 
@@ -157,7 +157,7 @@ export default function (pi: ExtensionAPI) {
             if (code !== 0 && code !== 99) { // 99 is a common exit code for -v in some versions
                 throw new Error(`pdftotext returned code ${code}`);
             }
-        } catch {
+        } catch {
             ctx.ui.notify('WhatsApp: pdftotext not found. PDF document support will be limited to storage only.', 'warning');
             logger.warn('[WhatsApp-Pi] Warning: pdftotext not found in system PATH.');
         }
@@ -333,7 +333,7 @@ export default function (pi: ExtensionAPI) {
                     } else {
                         ctx.ui.notify(`Failed to send WhatsApp reply`, 'error');
                     }
-                } catch {
+                } catch {
                     ctx.ui.notify(`Failed to send WhatsApp reply`, 'error');
                 }
             }