whatsapp-pi 1.0.23 → 1.0.25

package/README.md

@@ -79,7 +79,7 @@ pi -e whatsapp-pi.ts --verbose
 - `/whatsapp` - Open the WhatsApp management menu
 
 ### Main Menu Options
-- **Connect WhatsApp** - Start WhatsApp connection (shows QR code for first-time setup)
+- **Connect / Reconnect WhatsApp** - Start WhatsApp connection using saved credentials when available; QR code appears only if pairing is required
 - **Disconnect WhatsApp** - Stop WhatsApp connection
 - **Logoff (Delete Session)** - Remove all credentials and session data
 - **Allowed Numbers** - Manage contacts that can interact with Pi
@@ -87,8 +87,7 @@ pi -e whatsapp-pi.ts --verbose
 
 ### Allowed Numbers Management
 - **Add Number** - Add a new contact to the allow list (format: +5511999999999)
-- **Remove [Number]** - Remove a specific contact from the allow list
-- **Clear All** - Remove all allowed numbers
+- **Select a contact** - Open a submenu with **Send Message**, **Remove Number**, and **Back**
 - **Back** - Return to main menu
 
 ### Blocked Numbers Management

package/package.json

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

package/src/models/whatsapp.types.ts

@@ -52,3 +52,29 @@ export interface DocumentMetadata {
     savedPath: string;
     timestamp: number;
 }
+
+export type MessageDirection = 'incoming' | 'outgoing';
+
+export interface RecentConversationMessage {
+    messageId: string;
+    senderNumber: string;
+    text: string;
+    direction: MessageDirection;
+    timestamp: number;
+}
+
+export interface RecentConversationSummary {
+    senderNumber: string;
+    senderName?: string;
+    lastMessagePreview: string;
+    lastMessageTime: number;
+    lastMessageDirection: MessageDirection;
+    messageCount: number;
+    isAllowed: boolean;
+}
+
+export interface RecentsStore {
+    conversations: RecentConversationSummary[];
+    messagesBySender: Record<string, RecentConversationMessage[]>;
+    updatedAt: number;
+}

package/src/services/recents.service.ts

@@ -0,0 +1,203 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import type {
+    MessageDirection,
+    RecentConversationMessage,
+    RecentConversationSummary,
+    RecentsStore
+} from '../models/whatsapp.types.js';
+import { SessionManager } from './session.manager.js';
+
+export interface RecentsMessageInput {
+    messageId: string;
+    senderNumber: string;
+    senderName?: string;
+    text: string;
+    direction: MessageDirection;
+    timestamp: number;
+}
+
+export class RecentsService {
+    private readonly baseDir = join(homedir(), '.pi', 'whatsapp-pi');
+    private readonly dataDir = join(this.baseDir, 'recents');
+    private readonly storePath = join(this.dataDir, 'recents.json');
+    private store: RecentsStore = {
+        conversations: [],
+        messagesBySender: {},
+        updatedAt: Date.now()
+    };
+
+    constructor(private readonly sessionManager: SessionManager) {}
+
+    async ensureInitialized() {
+        await mkdir(this.dataDir, { recursive: true });
+        await this.loadStore();
+    }
+
+    private async loadStore() {
+        try {
+            const content = await readFile(this.storePath, 'utf-8');
+            const parsed = JSON.parse(content) as Partial<RecentsStore>;
+
+            this.store = {
+                conversations: Array.isArray(parsed.conversations) ? parsed.conversations.slice(0, 20) : [],
+                messagesBySender: parsed.messagesBySender && typeof parsed.messagesBySender === 'object'
+                    ? this.normalizeMessagesMap(parsed.messagesBySender)
+                    : {},
+                updatedAt: typeof parsed.updatedAt === 'number' ? parsed.updatedAt : Date.now()
+            };
+
+            this.rebuildConversationState();
+        } catch {
+            this.store = {
+                conversations: [],
+                messagesBySender: {},
+                updatedAt: Date.now()
+            };
+        }
+    }
+
+    private normalizeMessagesMap(messagesBySender: RecentsStore['messagesBySender']): RecentsStore['messagesBySender'] {
+        const normalized: RecentsStore['messagesBySender'] = {};
+
+        for (const [senderNumber, messages] of Object.entries(messagesBySender)) {
+            if (!Array.isArray(messages)) continue;
+            normalized[senderNumber] = messages
+                .filter((message): message is RecentConversationMessage => this.isValidMessage(message))
+                .map(message => ({ ...message, timestamp: this.normalizeTimestamp(message.timestamp) }))
+                .sort((left, right) => left.timestamp - right.timestamp)
+                .slice(-20);
+        }
+
+        return normalized;
+    }
+
+    private isValidMessage(message: unknown): message is RecentConversationMessage {
+        return Boolean(
+            message &&
+            typeof message === 'object' &&
+            typeof (message as RecentConversationMessage).messageId === 'string' &&
+            typeof (message as RecentConversationMessage).senderNumber === 'string' &&
+            typeof (message as RecentConversationMessage).text === 'string' &&
+            (message as RecentConversationMessage).text.trim().length > 0 &&
+            ((message as RecentConversationMessage).direction === 'incoming' || (message as RecentConversationMessage).direction === 'outgoing') &&
+            typeof (message as RecentConversationMessage).timestamp === 'number'
+        );
+    }
+
+    private rebuildConversationState() {
+        const previousNames = new Map(
+            this.store.conversations.map(conversation => [conversation.senderNumber, conversation.senderName] as const)
+        );
+        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];
+            summaries.set(senderNumber, {
+                senderNumber,
+                senderName: previousNames.get(senderNumber),
+                lastMessagePreview: this.buildPreview(lastMessage.text),
+                lastMessageTime: lastMessage.timestamp,
+                lastMessageDirection: lastMessage.direction,
+                messageCount: messages.length,
+                isAllowed: this.sessionManager.isAllowed(senderNumber)
+            });
+        }
+
+        this.store.conversations = Array.from(summaries.values())
+            .sort((left, right) => right.lastMessageTime - left.lastMessageTime)
+            .slice(0, 20);
+    }
+
+    private buildPreview(text: string): string {
+        const normalized = text.trim().replace(/\s+/g, ' ');
+        if (normalized.length <= 80) return normalized;
+        return `${normalized.slice(0, 77)}...`;
+    }
+
+    private async persistStore() {
+        this.store.updatedAt = Date.now();
+        await writeFile(this.storePath, JSON.stringify(this.store, null, 2));
+    }
+
+    private normalizeNumber(input: string): string {
+        const cleaned = input.replace(/@s\.whatsapp\.net$/, '');
+        if (cleaned.startsWith('+')) {
+            return cleaned;
+        }
+        if (/^\d+$/.test(cleaned)) {
+            return `+${cleaned}`;
+        }
+        return cleaned;
+    }
+
+    private normalizeTimestamp(timestamp: number): number {
+        return timestamp < 1_000_000_000_000 ? timestamp * 1000 : timestamp;
+    }
+
+    async recordMessage(input: RecentsMessageInput) {
+        const senderNumber = this.normalizeNumber(input.senderNumber);
+        if (!senderNumber) return;
+
+        const normalizedTimestamp = this.normalizeTimestamp(input.timestamp);
+        const normalizedText = input.text.trim().replace(/\s+/g, ' ');
+        if (!normalizedText) return;
+
+        const existing = this.store.messagesBySender[senderNumber] ?? [];
+        const nextMessage: RecentConversationMessage = {
+            messageId: input.messageId,
+            senderNumber,
+            text: normalizedText,
+            direction: input.direction,
+            timestamp: normalizedTimestamp
+        };
+
+        const filtered = existing.filter(message => message.messageId !== nextMessage.messageId);
+        filtered.push(nextMessage);
+
+        this.store.messagesBySender[senderNumber] = filtered
+            .sort((left, right) => left.timestamp - right.timestamp)
+            .slice(-20);
+
+        const existingConversation = this.store.conversations.find(conversation => conversation.senderNumber === senderNumber);
+        const summary: RecentConversationSummary = {
+            senderNumber,
+            senderName: input.senderName ?? existingConversation?.senderName,
+            lastMessagePreview: this.buildPreview(input.text),
+            lastMessageTime: normalizedTimestamp,
+            lastMessageDirection: input.direction,
+            messageCount: this.store.messagesBySender[senderNumber].length,
+            isAllowed: this.sessionManager.isAllowed(senderNumber)
+        };
+
+        this.store.conversations = [
+            summary,
+            ...this.store.conversations.filter(item => item.senderNumber !== senderNumber)
+        ]
+            .sort((left, right) => right.lastMessageTime - left.lastMessageTime)
+            .slice(0, 20);
+
+        await this.persistStore();
+    }
+
+    async getRecentConversations(): Promise<RecentConversationSummary[]> {
+        this.rebuildConversationState();
+        return [...this.store.conversations];
+    }
+
+    async getConversationHistory(senderNumber: string): Promise<RecentConversationMessage[]> {
+        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);
+    }
+
+    async hasRecentConversations(): Promise<boolean> {
+        const conversations = await this.getRecentConversations();
+        return conversations.length > 0;
+    }
+}

package/src/services/session.manager.ts

@@ -1,6 +1,6 @@
 import { useMultiFileAuthState } from '@whiskeysockets/baileys';
 import { join } from 'path';
-import { readFile, writeFile, mkdir, rm } from 'fs/promises';
+import { readFile, writeFile, mkdir, rm, readdir } from 'fs/promises';
 import { homedir } from 'os';
 import { SessionStatus } from '../models/whatsapp.types.js';
 
@@ -12,21 +12,27 @@ export interface Contact {
 export class SessionManager {
     // Data is stored in the user's home directory to persist across updates
     private readonly baseDir = join(homedir(), '.pi', 'whatsapp-pi');
-    private readonly authDir = join(this.baseDir, 'auth');
+    private readonly authStateDir = join(this.baseDir, 'auth');
     private readonly configPath = join(this.baseDir, 'config.json');
 
     private status: SessionStatus = 'logged-out';
     private allowList: Contact[] = [];
     private blockList: Contact[] = [];
     private ignoredNumbers: Contact[] = [];
+    private hasAuthState = false;
     private openaiKey: string = '';
     private visionModel: string = 'gpt-4o';
 
+    private async ensureStorageDirectories() {
+        await mkdir(this.baseDir, { recursive: true });
+        await mkdir(this.authStateDir, { recursive: true });
+    }
+
     public async ensureInitialized() {
         try {
-            await mkdir(this.baseDir, { recursive: true });
-            await mkdir(this.authDir, { recursive: true });
+            await this.ensureStorageDirectories();
             await this.loadConfig();
+            await this.syncAuthStateFromDisk();
         } catch (error) {}
     }
 
@@ -54,6 +60,7 @@ export class SessionManager {
             this.blockList = (config.blockList || []).map(cleanContact).filter(Boolean) as Contact[];
             this.ignoredNumbers = (config.ignoredNumbers || []).map(cleanContact).filter(Boolean) as Contact[];
             this.status = config.status || 'logged-out';
+            this.hasAuthState = Boolean(config.hasAuthState);
             this.openaiKey = config.openaiKey || '';
             this.visionModel = config.visionModel || 'gpt-4o';
         } catch (error) {
@@ -68,6 +75,7 @@ export class SessionManager {
                 blockList: this.blockList,
                 ignoredNumbers: this.ignoredNumbers,
                 status: this.status,
+                hasAuthState: this.hasAuthState,
                 openaiKey: this.openaiKey,
                 visionModel: this.visionModel
             };
@@ -81,6 +89,10 @@ export class SessionManager {
         return this.allowList;
     }
 
+    getAllowedContact(number: string): Contact | undefined {
+        return this.allowList.find(c => c.number === number);
+    }
+
     getBlockList(): Contact[] {
         return this.blockList;
     }
@@ -106,12 +118,19 @@ export class SessionManager {
             return;
         }
 
-        if (!this.allowList.find(c => c.number === cleanNumber)) {
+        const existing = this.allowList.find(c => c.number === cleanNumber);
+        if (!existing) {
             this.allowList.push({ number: cleanNumber, name });
             // Remove from blockList and ignoredNumbers if it was there
             this.blockList = this.blockList.filter(c => c.number !== cleanNumber);
             this.ignoredNumbers = this.ignoredNumbers.filter(c => c.number !== cleanNumber);
             await this.saveConfig();
+            return;
+        }
+
+        if (name && !existing.name) {
+            existing.name = name;
+            await this.saveConfig();
         }
     }
 
@@ -120,8 +139,28 @@ export class SessionManager {
         await this.saveConfig();
     }
 
-    async clearAllowList() {
-        this.allowList = [];
+    async setAllowedContactAlias(number: string, alias: string) {
+        const trimmedAlias = alias.trim();
+        if (!trimmedAlias) {
+            return;
+        }
+
+        const contact = this.getAllowedContact(number);
+        if (!contact) {
+            return;
+        }
+
+        contact.name = trimmedAlias;
+        await this.saveConfig();
+    }
+
+    async removeAllowedContactAlias(number: string) {
+        const contact = this.getAllowedContact(number);
+        if (!contact || !contact.name) {
+            return;
+        }
+
+        delete contact.name;
         await this.saveConfig();
     }
 
@@ -168,25 +207,51 @@ export class SessionManager {
 
     public async isRegistered(): Promise<boolean> {
         try {
-            const credsPah = join(this.authDir, 'creds.json');
+            const credsPah = join(this.authStateDir, 'creds.json');
             await readFile(credsPah);
+            this.hasAuthState = true;
             return true;
         } catch {
-            return false;
+            await this.syncAuthStateFromDisk();
+            return this.hasAuthState;
+        }
+    }
+
+    async markAuthStateAvailable() {
+        if (!this.hasAuthState) {
+            this.hasAuthState = true;
+            await this.saveConfig();
         }
     }
 
     async getAuthState() {
-        return await useMultiFileAuthState(this.authDir);
+        await this.ensureStorageDirectories();
+        return await useMultiFileAuthState(this.authStateDir);
+    }
+
+    private async syncAuthStateFromDisk() {
+        try {
+            const entries = await readdir(this.authStateDir);
+            if (entries.length > 0) {
+                if (!this.hasAuthState) {
+                    this.hasAuthState = true;
+                    await this.saveConfig();
+                }
+            }
+        } catch {
+            // Ignore missing directory / empty auth state
+        }
     }
 
-    async clearSession() {
+    async deleteAuthState() {
         try {
-            await rm(this.authDir, { recursive: true, force: true });
+            await rm(this.authStateDir, { recursive: true, force: true });
+            await mkdir(this.authStateDir, { recursive: true });
             this.status = 'logged-out';
+            this.hasAuthState = false;
             await this.saveConfig();
         } catch (error) {
-            console.error('Failed to clear session:', error);
+            console.error('Failed to delete auth state:', error);
         }
     }
 
@@ -217,7 +282,7 @@ export class SessionManager {
         await this.saveConfig();
     }
 
-    getAuthDir(): string {
-        return this.authDir;
+    getAuthStateDir(): string {
+        return this.authStateDir;
     }
 }