whatsapp-pi 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+# WhatsApp-Pi
+
+WhatsApp integration for Pi coding agent with message filtering, blocking, and reliable message delivery.
+
+## Features
+
+- **Manual WhatsApp Connection**: QR code-based authentication with session persistence
+- **Allow List**: Control which numbers can interact with Pi
+  - Add contacts with optional names for easy identification
+  - View ignored numbers (not in allow list) and add them when needed
+- **Reliable Messaging**: Queue-based message sending with retry logic
+- **TUI Integration**: Menu-driven interface for managing connections and contacts
+
+## Quick Start
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Run the extension:
+```bash
+pi -e whatsapp-pi.ts
+```
+
+For verbose mode (shows Baileys trace logs for debugging):
+```bash
+pi -e whatsapp-pi.ts -v
+# or
+pi -e whatsapp-pi.ts --verbose
+```
+
+3. Use the menu to connect WhatsApp and manage allowed/blocked numbers
+
+## Commands
+
+- `/whatsapp` - Open the WhatsApp management menu
+  - **Allow Numbers**: Manage contacts that can interact with Pi
+  - **Blocked Numbers**: View ignored numbers (not in allow list) and add them to allow list
+
+## Important Configuration
+
+### Using Your Own WhatsApp Number
+
+If you're using your **own WhatsApp number** (not a separate bot number), you need to modify the message filtering in `src/services/whatsapp.service.ts`:
+
+**Remove this line from `handleIncomingMessages()`:**
+```typescript
+// Ignore messages sent by the bot itself
+if (msg.key.fromMe) return;
+```
+
+**Why?** When using your own number:
+- Pi sends messages from your account (marked with `π` symbol)
+- The `fromMe` filter blocks ALL your outgoing messages, including Pi's responses
+- The `π` symbol check is sufficient to prevent message loops
+
+**Keep this check:**
+```typescript
+// Ignore messages sent by Pi (marked with π)
+const text = msg.message?.conversation || msg.message?.extendedTextMessage?.text || "";
+if (text.endsWith('π')) return;
+```
+
+This ensures Pi doesn't process its own sent messages while still receiving messages from others.
+
+## Project Structure
+
+```
+src/
+├── models/          # Type definitions
+├── services/        # Core services (WhatsApp, Session, MessageSender)
+└── ui/              # Menu handlers
+
+specs/               # Feature specifications
+tests/               # Unit and integration tests
+```
+
+## Documentation
+
+See `specs/` directory for detailed feature documentation:
+- `001-whatsapp-tui-integration/` - TUI menu system
+- `002-manual-whatsapp-connection/` - Connection management
+- `003-whatsapp-messaging-refactor/` - Reliable messaging
+- `004-blocked-numbers-management/` - Block list feature
+
+## Development
+
+Run tests:
+```bash
+npm test
+```
+
+Lint:
+```bash
+npm run lint
+```

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "whatsapp-pi",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "WhatsApp integration extension for Pi",
+  "main": "whatsapp-pi.ts",
+  "files": [
+    "whatsapp-pi.ts",
+    "src"
+  ],
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "whatsapp",
+    "baileys",
+    "agent"
+  ],
+  "author": "Rapha",
+  "license": "MIT",
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.11.0",
+    "pino": "^10.3.1",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-coding-agent": "latest",
+    "@types/node": "^20.11.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  },
+  "pi": {
+    "extensions": [
+      "./whatsapp-pi.ts"
+    ]
+  }
+}

package/src/models/whatsapp.types.ts

@@ -0,0 +1,46 @@
+export type SessionStatus = 'logged-out' | 'pairing' | 'connected' | 'disconnected';
+
+export interface WhatsAppSession {
+    id: string;
+    status: SessionStatus;
+    credentialsPath: string;
+}
+
+export interface AllowList {
+    numbers: string[];
+}
+
+export interface IncomingMessage {
+    id: string;
+    remoteJid: string;
+    pushName?: string;
+    text?: string;
+    timestamp: number;
+}
+
+export interface MessageRequest {
+    recipientJid: string;
+    text: string;
+    options?: {
+        maxRetries?: number;
+        priority?: 'high' | 'normal';
+    };
+}
+
+export interface MessageResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    attempts: number;
+}
+
+export class WhatsAppError extends Error {
+    constructor(public code: string, message: string) {
+        super(message);
+        this.name = 'WhatsAppError';
+    }
+}
+
+export function validatePhoneNumber(number: string): boolean {
+    return /^\+[1-9]\d{1,14}$/.test(number);
+}

package/src/services/audio.service.ts

@@ -0,0 +1,53 @@
+import { downloadContentFromMessage } from '@whiskeysockets/baileys';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+const execAsync = promisify(exec);
+
+export class AudioService {
+    private readonly mediaDir = '/home/opc/.pi/whatsapp-medias';
+    private readonly whisperPath = '/home/opc/.local/bin/whisper';
+
+    constructor() {
+        if (!existsSync(this.mediaDir)) {
+            mkdir(this.mediaDir, { recursive: true }).catch(() => {});
+        }
+    }
+
+    async transcribe(audioMessage: any): Promise<string> {
+        try {
+            const filename = `audio_${Date.now()}`;
+            const inputPath = join(this.mediaDir, `${filename}.ogg`);
+
+            // Download audio content
+            const stream = await downloadContentFromMessage(audioMessage, 'audio');
+            let buffer = Buffer.from([]);
+            for await (const chunk of stream) {
+                buffer = Buffer.concat([buffer, chunk]);
+            }
+
+            await writeFile(inputPath, buffer);
+
+            // Transcribe using Whisper
+            // Using small model for better accuracy
+            const command = `${this.whisperPath} "${inputPath}" --model small --language pt --output_format txt --output_dir "${this.mediaDir}" --fp16 False`;
+            
+            await execAsync(command);
+
+            const txtPath = join(this.mediaDir, `${filename}.txt`);
+            if (existsSync(txtPath)) {
+                const fs = await import('node:fs/promises');
+                const text = await fs.readFile(txtPath, 'utf8');
+                return text.trim();
+            }
+
+            return '[Transcrição vazia]';
+        } catch (error) {
+            console.error('[AudioService] Transcription error:', error);
+            return `[Erro na transcrição: ${error instanceof Error ? error.message : String(error)}]`;
+        }
+    }
+}

package/src/services/message.sender.ts

@@ -0,0 +1,93 @@
+import { WhatsAppService } from './whatsapp.service.js';
+import { MessageRequest, MessageResult, WhatsAppError } from '../models/whatsapp.types.js';
+
+export class MessageSender {
+    private whatsappService: WhatsAppService;
+
+    constructor(whatsappService: WhatsAppService) {
+        this.whatsappService = whatsappService;
+    }
+
+    /**
+     * Pauses execution for the specified time.
+     * @param ms Milliseconds to sleep.
+     */
+    private async sleep(ms: number) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Waits for the WhatsApp connection to be active.
+     * @param timeoutMs Maximum time to wait in milliseconds.
+     * @throws {WhatsAppError} If connection is not established within timeout.
+     */
+    private async waitIfOffline(timeoutMs: number = 30000): Promise<void> {
+        const start = Date.now();
+        while (this.whatsappService.getStatus() !== 'connected') {
+            if (Date.now() - start > timeoutMs) {
+                throw new WhatsAppError('TIMEOUT', 'Timed out waiting for WhatsApp connection');
+            }
+            await this.sleep(1000);
+        }
+    }
+
+    /**
+     * Sends a message with retry logic and connection awareness.
+     * @param request The message recipient and content.
+     * @returns Promise resolving to a result object indicating success or failure.
+     */
+    public async send(request: MessageRequest): Promise<MessageResult> {
+        const maxRetries = request.options?.maxRetries ?? 3;
+        let attempts = 0;
+        let lastError: any = null;
+
+        while (attempts < maxRetries) {
+            attempts++;
+            try {
+                // 1. Ensure we are online
+                await this.waitIfOffline();
+                
+                // 2. Get active socket
+                const socket = this.whatsappService.getSocket();
+                if (!socket) {
+                    throw new WhatsAppError('SOCKET_NOT_INIT', 'WhatsApp socket not initialized');
+                }
+
+                // 3. Send the message
+                // Note: Branding π is applied here to ensure consistency
+                const response = await socket.sendMessage(request.recipientJid, { 
+                    text: `${request.text} π` 
+                });
+
+                return {
+                    success: true,
+                    messageId: response.key.id,
+                    attempts
+                };
+            } catch (error: any) {
+                lastError = error;
+                console.error(`[MessageSender] Attempt ${attempts} failed for ${request.recipientJid}: ${error.message}`);
+                
+                // Specific handling for non-retryable errors
+                if (error.code === 'TIMEOUT') {
+                    break;
+                }
+
+                // 4. Backoff before retry
+                if (attempts < maxRetries) {
+                    const backoff = Math.pow(2, attempts) * 1000;
+                    if (this.whatsappService.isVerbose()) {
+                        console.log(`[MessageSender] Retrying in ${backoff}ms...`);
+                    }
+                    await this.sleep(backoff);
+                }
+            }
+        }
+
+        return {
+            success: false,
+            error: lastError?.message || 'Unknown error',
+            attempts
+        };
+    }
+}

package/src/services/session.manager.ts

@@ -0,0 +1,191 @@
+import { useMultiFileAuthState } from '@whiskeysockets/baileys';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { rm, readFile, writeFile, mkdir } from 'fs/promises';
+import { SessionStatus } from '../models/whatsapp.types.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export interface Contact {
+    number: string;
+    name?: string;
+}
+
+export class SessionManager {
+    // Data is stored in a fixed folder inside the extension project
+    private readonly baseDir = join(__dirname, '..', '..', '.pi-data');
+    private readonly authDir = 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[] = [];
+
+    public async ensureInitialized() {
+        try {
+            await mkdir(this.baseDir, { recursive: true });
+            await mkdir(this.authDir, { recursive: true });
+            await this.loadConfig();
+        } catch (error) {}
+    }
+
+    private async loadConfig() {
+        try {
+            const data = await readFile(this.configPath, 'utf-8');
+            const config = JSON.parse(data);
+            
+            const cleanContact = (item: any): Contact | null => {
+                if (typeof item === 'string') return { number: item };
+                if (item && typeof item === 'object') {
+                    let num = item.number;
+                    // Unroll nested objects if any
+                    while (num && typeof num === 'object' && num.number) {
+                        num = num.number;
+                    }
+                    if (typeof num === 'string') {
+                        return { number: num, name: item.name };
+                    }
+                }
+                return null;
+            };
+
+            this.allowList = (config.allowList || []).map(cleanContact).filter(Boolean) as Contact[];
+            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';
+        } catch (error) {
+            // File not found is fine
+        }
+    }
+
+    public async saveConfig() {
+        try {
+            const config = {
+                allowList: this.allowList,
+                blockList: this.blockList,
+                ignoredNumbers: this.ignoredNumbers,
+                status: this.status
+            };
+            await writeFile(this.configPath, JSON.stringify(config, null, 2));
+        } catch (error) {
+            console.error('Failed to save config:', error);
+        }
+    }
+
+    getAllowList(): Contact[] {
+        return this.allowList;
+    }
+
+    getBlockList(): Contact[] {
+        return this.blockList;
+    }
+
+    getIgnoredNumbers(): Contact[] {
+        return this.ignoredNumbers;
+    }
+
+    async addNumber(number: any, name?: string) {
+        // Handle potential nested objects from legacy bugs
+        let cleanNumber = number;
+        while (cleanNumber && typeof cleanNumber === 'object' && cleanNumber.number) {
+            cleanNumber = cleanNumber.number;
+        }
+
+        if (typeof cleanNumber !== 'string') {
+            console.warn('[SessionManager] Attempted to add invalid number:', cleanNumber);
+            return;
+        }
+
+        if (!this.allowList.find(c => c.number === cleanNumber)) {
+            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();
+        }
+    }
+
+    async removeNumber(number: string) {
+        this.allowList = this.allowList.filter(c => c.number !== number);
+        await this.saveConfig();
+    }
+
+    async blockNumber(number: string, name?: string) {
+        if (!this.blockList.find(c => c.number === number)) {
+            this.blockList.push({ number, name });
+            // Remove from allowList if it was there
+            this.allowList = this.allowList.filter(c => c.number !== number);
+            await this.saveConfig();
+        }
+    }
+
+    async unblockNumber(number: string) {
+        this.blockList = this.blockList.filter(c => c.number !== number);
+        await this.saveConfig();
+    }
+
+    async unblockAndAllow(number: string) {
+        const blocked = this.blockList.find(c => c.number === number);
+        this.blockList = this.blockList.filter(c => c.number !== number);
+        if (!this.allowList.find(c => c.number === number)) {
+            this.allowList.push({ number, name: blocked?.name });
+        }
+        await this.saveConfig();
+    }
+
+    isAllowed(number: string): boolean {
+        return this.allowList.some(c => c.number === number);
+    }
+
+    isBlocked(number: string): boolean {
+        return this.blockList.some(c => c.number === number);
+    }
+
+    async trackIgnoredNumber(number: string, name?: string) {
+        // Only track if not already in allow list, block list, or ignored list
+        if (!this.allowList.find(c => c.number === number) &&
+            !this.blockList.find(c => c.number === number) &&
+            !this.ignoredNumbers.find(c => c.number === number)) {
+            this.ignoredNumbers.push({ number, name });
+            await this.saveConfig();
+        }
+    }
+
+    public async isRegistered(): Promise<boolean> {
+        try {
+            const credsPah = join(this.authDir, 'creds.json');
+            await readFile(credsPah);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async getAuthState() {
+        return await useMultiFileAuthState(this.authDir);
+    }
+
+    async clearSession() {
+        try {
+            await rm(this.authDir, { recursive: true, force: true });
+            this.status = 'logged-out';
+            await this.saveConfig();
+        } catch (error) {
+            console.error('Failed to clear session:', error);
+        }
+    }
+
+    getStatus(): SessionStatus {
+        return this.status;
+    }
+
+    async setStatus(status: SessionStatus) {
+        this.status = status;
+        await this.saveConfig();
+    }
+
+    getAuthDir(): string {
+        return this.authDir;
+    }
+}

package/src/services/whatsapp.service.ts

@@ -0,0 +1,245 @@
+import { 
+    makeWASocket,
+    DisconnectReason, 
+    useMultiFileAuthState, 
+    fetchLatestBaileysVersion,
+    makeCacheableSignalKeyStore
+} from '@whiskeysockets/baileys';
+import P from 'pino';
+import { Boom } from '@hapi/boom';
+import { SessionManager } from './session.manager.js';
+import { WhatsAppSession, SessionStatus } from '../models/whatsapp.types.js';
+import { MessageSender } from './message.sender.js';
+
+export class WhatsAppService {
+    private socket: any;
+    private sessionManager: SessionManager;
+    private messageSender: MessageSender;
+    private isReconnecting = false;
+    private verboseMode = false;
+
+    constructor(sessionManager: SessionManager) {
+        this.sessionManager = sessionManager;
+        this.messageSender = new MessageSender(this);
+    }
+
+    public getStatus(): SessionStatus {
+        return this.sessionManager.getStatus();
+    }
+
+    public getSocket(): any {
+        return this.socket;
+    }
+
+    public isVerbose(): boolean {
+        return this.verboseMode;
+    }
+
+    public setVerboseMode(verbose: boolean) {
+        this.verboseMode = verbose;
+    }
+
+    async start() {
+        if (this.isReconnecting) return;
+        this.onStatusUpdate?.('| WhatsApp: Connecting...');
+
+        const { state, saveCreds } = await this.sessionManager.getAuthState();
+        const { version } = await fetchLatestBaileysVersion();
+
+        // Cleanup existing socket if any
+        if (this.socket) {
+            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' });
+        
+        this.socket = makeWASocket({
+            version,
+            printQRInTerminal: false,
+            auth: {
+                creds: state.creds,
+                keys: makeCacheableSignalKeyStore(state.keys, logger),
+            },
+            logger,
+        });
+
+        this.socket.ev.on('creds.update', saveCreds);
+
+        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: Pairing...');
+            }
+
+            if (connection === 'close') {
+                const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode;
+                const errorMessage = lastDisconnect?.error?.message || '';
+                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+                
+                console.error(`Connection closed [${statusCode}]. Reconnecting: ${shouldReconnect}`);
+                
+                if (errorMessage.includes('bad-request') || statusCode === 400) {
+                    console.error('Bad request error detected - clearing session and forcing re-auth');
+                    await this.sessionManager.clearSession();
+                    this.sessionManager.setStatus('logged-out');
+                    this.onStatusUpdate?.('| WhatsApp: Logged out');
+                    return;
+                }
+
+                if (statusCode === DisconnectReason.connectionReplaced) {
+                    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();
+                    }, 3000);
+                } else if (!shouldReconnect) {
+                    this.sessionManager.setStatus('logged-out');
+                    this.onStatusUpdate?.('| WhatsApp: Disconnected');
+                }
+            } else if (connection === 'open') {
+                if (this.verboseMode) {
+                    console.log('WhatsApp connection successfully opened');
+                }
+                this.isReconnecting = false;
+                this.sessionManager.setStatus('connected');
+                this.onStatusUpdate?.('| WhatsApp: Connected');
+            }
+        });
+
+        this.socket.ev.on('messages.upsert', (m: any) => this.handleIncomingMessages(m));
+    }
+
+    public async handleIncomingMessages(m: any) {
+        if (this.sessionManager.getStatus() !== 'connected') return;
+        const msg = m.messages[0];
+        if (!msg || !msg.key.remoteJid) return;
+
+        // KEEP IT COMMENTED
+        // if (msg.key.fromMe) return;
+
+        // Ignore messages sent by Pi (marked with π)
+        const text = msg.message?.conversation || msg.message?.extendedTextMessage?.text || "";
+        if (text.endsWith('π')) return;
+        
+
+        const sender = msg.key.remoteJid.split('@')[0];
+        const fullNumber = '+' + sender; 
+        
+        if (this.sessionManager.isBlocked(fullNumber)) {
+            if (this.isVerbose()) {
+                console.log(`Ignoring message from ${fullNumber} (explicitly blocked)`);
+            }
+            return;
+        }
+
+        if (!this.sessionManager.isAllowed(fullNumber)) {
+            if (this.isVerbose()) {
+                console.log(`Ignoring message from ${fullNumber} (not in allow list)`);
+            }
+            // Track this number as ignored so user can allow it later
+            const pushName = msg.pushName || undefined;
+            await this.sessionManager.trackIgnoredNumber(fullNumber, pushName);
+            return;
+        }
+
+        this.lastRemoteJid = msg.key.remoteJid;
+        this.onMessage?.(m);
+    }
+
+    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) {
+        this.onMessage = callback;
+    }
+
+    setStatusCallback(callback: (status: string) => void) {
+        this.onStatusUpdate = callback;
+    }
+
+    public getLastRemoteJid(): string | null {
+        return this.lastRemoteJid;
+    }
+
+    async sendMessage(jid: string, text: string) {
+        // Ensure we show the typing indicator before sending
+        await this.sendPresence(jid, 'composing');
+
+        const result = await this.messageSender.send({
+            recipientJid: jid,
+            text: text
+        });
+
+        // After sending, we can stop the typing indicator
+        await this.sendPresence(jid, 'paused');
+
+        if (!result.success) {
+            console.error(`Failed to send message to ${jid}: ${result.error}`);
+        }
+        
+        return result;
+    }
+
+    async sendPresence(jid: string, presence: 'composing' | 'recording' | 'paused') {
+        if (!this.socket || this.getStatus() !== 'connected') return;
+        try {
+            await this.socket.sendPresenceUpdate(presence, jid);
+        } catch (error) {
+            if (this.verboseMode) {
+                console.error(`Failed to send presence update to ${jid}:`, error);
+            }
+        }
+    }
+
+    async markRead(jid: string, messageId: string, fromMe: boolean = false) {
+        if (!this.socket || this.getStatus() !== 'connected') return;
+        try {
+            await this.socket.readMessages([{ remoteJid: jid, id: messageId, fromMe }]);
+        } catch (error) {
+            if (this.verboseMode) {
+                console.error(`Failed to mark message as read:`, error);
+            }
+        }
+    }
+
+    async logout() {
+        await this.socket?.logout();
+        await this.sessionManager.clearSession();
+    }
+
+    async stop() {
+        if (this.socket) {
+            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;
+        }
+        await this.sessionManager.setStatus('disconnected');
+        this.onStatusUpdate?.('| WhatsApp: Disconnected');
+    }
+}

package/src/ui/menu.handler.ts

@@ -0,0 +1,138 @@
+import { WhatsAppService } from '../services/whatsapp.service.js';
+import { SessionManager } from '../services/session.manager.js';
+import { validatePhoneNumber } from '../models/whatsapp.types.js';
+import * as qrcode from 'qrcode-terminal';
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+export class MenuHandler {
+    private whatsappService: WhatsAppService;
+    private sessionManager: SessionManager;
+
+    constructor(whatsappService: WhatsAppService, sessionManager: SessionManager) {
+        this.whatsappService = whatsappService;
+        this.sessionManager = sessionManager;
+    }
+
+    async handleCommand(ctx: ExtensionCommandContext) {
+        const status = this.sessionManager.getStatus();
+        const registered = await this.sessionManager.isRegistered();
+        const options: string[] = [];
+
+        if (status === 'connected') {
+            options.push('Disconnect WhatsApp');
+        } else {
+            options.push('Connect WhatsApp');
+        }
+
+        if (registered) options.push('Logoff (Delete Session)');
+        
+        options.push('Allow Numbers');
+        options.push('Blocked Numbers');
+        options.push('Back');
+
+        const choice = await ctx.ui.select(`WhatsApp (Status: ${status})`, options);
+
+        switch (choice) {
+            case 'Connect WhatsApp':
+                this.whatsappService.setQRCodeCallback((qr) => {
+                    ctx.ui.notify('Scan the QR code in the terminal', 'info');
+                    qrcode.generate(qr, { small: true });
+                });
+                await this.whatsappService.start();
+                ctx.ui.notify('WhatsApp Connection Started', 'info');
+                break;
+            case 'Disconnect WhatsApp':
+                await this.whatsappService.stop();
+                ctx.ui.notify('WhatsApp Agent Disconnected', 'warning');
+                break;
+            case 'Logoff (Delete Session)':
+                const confirm = await ctx.ui.confirm('Logoff', 'Delete all credentials?');
+                if (confirm) {
+                    await this.whatsappService.logout();
+                    ctx.ui.notify('Logged off and credentials deleted', 'info');
+                }
+                break;
+            case 'Allow Numbers':
+                await this.manageAllowList(ctx);
+                break;
+            case 'Blocked Numbers':
+                await this.manageBlockList(ctx);
+                break;
+        }
+    }
+
+    private async manageAllowList(ctx: ExtensionCommandContext) {
+        const list = this.sessionManager.getAllowList();
+        // Exibe o nome se existir, senão apenas o número
+        const options = [...list.map(c => `Remove ${c.name ? c.name + ' (' + c.number + ')' : c.number}`), 'Add Number', 'Back'];
+        
+        const choice = await ctx.ui.select('Allowed Numbers', options);
+
+        if (choice === 'Add Number') {
+            const num = await ctx.ui.input('Enter number (e.g. +5511999999999):');
+            if (num && validatePhoneNumber(num)) {
+                await this.sessionManager.addNumber(num);
+                ctx.ui.notify(`Added ${num}`, 'info');
+            } else {
+                ctx.ui.notify('Invalid number format', 'error');
+            }
+            await this.manageAllowList(ctx);
+        } else if (choice?.startsWith('Remove ')) {
+            // Extrai o número entre parênteses ou o que sobrar depois de "Remove "
+            let num = choice.replace('Remove ', '');
+            if (num.includes('(')) {
+                const match = num.match(/\((.*?)\)/);
+                if (match) num = match[1];
+            }
+            await this.sessionManager.removeNumber(num);
+            ctx.ui.notify(`Removed ${num}`, 'info');
+            await this.manageAllowList(ctx);
+        }
+    }
+
+    private async manageBlockList(ctx: ExtensionCommandContext) {
+        const list = this.sessionManager.getBlockList();
+        
+        if (list.length === 0) {
+            ctx.ui.notify('No blocked numbers', 'info');
+            await this.handleCommand(ctx);
+            return;
+        }
+
+        const options = [...list.map(c => c.name ? `${c.name} (${c.number})` : c.number), 'Back'];
+        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);
+        } else {
+            await this.handleCommand(ctx);
+        }
+    }
+
+    private async manageBlockedNumber(ctx: ExtensionCommandContext, number: string) {
+        const action = await ctx.ui.select(`Manage ${number}`, ['Unblock and Allow', 'Delete', 'Back']);
+
+        if (action === 'Unblock and Allow') {
+            const ok = await ctx.ui.confirm('Unblock', `Move ${number} to Allowed Numbers?`);
+            if (ok) {
+                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.unblockNumber(number);
+                ctx.ui.notify(`${number} removed from Block List`, 'info');
+            }
+            await this.manageBlockList(ctx);
+        } else {
+            await this.manageBlockList(ctx);
+        }
+    }
+}

package/whatsapp-pi.ts

@@ -0,0 +1,211 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+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 { AudioService } from './src/services/audio.service.js';
+
+console.log("[WhatsApp-Pi] Extension file loaded by Pi...");
+export default function(pi: ExtensionAPI) {
+    // Register verbose flag
+    pi.registerFlag("v", {
+        description: "Enable verbose mode (show Baileys trace logs)",
+        type: "boolean",
+        default: false
+    });
+    pi.registerFlag("verbose", {
+        description: "Enable verbose mode (show Baileys trace logs)",
+        type: "boolean",
+        default: false
+    });
+    
+    // Register whatsapp flags
+    pi.registerFlag("w", {
+        description: "Auto-connect to WhatsApp on startup",
+        type: "boolean",
+        default: false
+    });
+    pi.registerFlag("whatsapp", {
+        description: "Auto-connect to WhatsApp on startup",
+        type: "boolean",
+        default: false
+    });
+
+    const sessionManager = new SessionManager();
+    const whatsappService = new WhatsAppService(sessionManager);
+    const audioService = new AudioService();
+    const menuHandler = new MenuHandler(whatsappService, sessionManager);
+
+    // Initial status setup
+    pi.on("session_start", async (_event, ctx) => {
+        // Check verbose mode
+        const isVerboseFlagSet = pi.getFlag("v") === true || pi.getFlag("verbose") === true || process.argv.includes("-v") || process.argv.includes("--verbose");
+        
+        const isVerbose = isVerboseFlagSet;
+        
+        whatsappService.setVerboseMode(isVerbose);
+        
+        if (isVerbose) {
+            console.log('[WhatsApp-Pi] Verbose mode enabled - Baileys trace logs will be shown');
+        }
+        ctx.ui.setStatus('whatsapp', '|  WhatsApp: Disconnected');
+        whatsappService.setStatusCallback((status) => {
+            ctx.ui.setStatus('whatsapp', status);
+        });
+        await sessionManager.ensureInitialized();
+        
+        for (const entry of ctx.sessionManager.getEntries()) {
+            if (entry.type === "custom" && entry.customType === "whatsapp-state") {
+                const data = entry.data as any;
+                if (data.status) await sessionManager.setStatus(data.status);
+                if (data.allowList) {
+                    for (const n of data.allowList) {
+                        const num = typeof n === "string" ? n : n.number;
+                        const name = typeof n === "string" ? undefined : n.name;
+                        await sessionManager.addNumber(num, name);
+                    }
+                }
+            }
+        }
+
+        // Check whatsapp flag
+        const isConnectFlagSet = pi.getFlag("w") === true || pi.getFlag("whatsapp") === true || process.argv.includes("-w") || process.argv.includes("--whatsapp");
+        
+        // Auto-connect removed to avoid socket conflicts
+        if (await sessionManager.isRegistered()) {
+            const shouldConnect = isConnectFlagSet;
+
+            if (shouldConnect) {
+                ctx.ui.setStatus('whatsapp', '|  WhatsApp: Auto-connecting...');
+                
+                // Retry logic (max 3 attempts, 3s delay)
+                let attempts = 0;
+                const maxAttempts = 4; // Initial + 3 retries
+                
+                const tryConnect = async () => {
+                    attempts++;
+                    try {
+                        await whatsappService.start();
+                    } catch (error) {
+                        if (attempts < maxAttempts) {
+                            ctx.ui.notify(`WhatsApp: Connection attempt ${attempts} failed. Retrying...`, 'warning');
+                            setTimeout(tryConnect, 3000);
+                        } else {
+                            ctx.ui.notify('WhatsApp: Auto-connect failed after multiple attempts.', 'error');
+                            ctx.ui.setStatus('whatsapp', '|  WhatsApp: Connection Failed');
+                        }
+                    }
+                };
+
+                await tryConnect();
+            } else {
+                // We just ensure state is loaded, but do NOT call whatsappService.start()
+                await sessionManager.setStatus('disconnected');
+            }
+        } else if (isConnectFlagSet) {
+            ctx.ui.notify('WhatsApp: Auto-connect skipped. Manual login required.', 'info');
+        }
+    });
+
+    // Handle incoming messages by injecting them as user prompts
+    whatsappService.setMessageCallback(async (m) => {
+        const msg = m.messages[0];
+        if (!msg.message) return;
+
+        let text = msg.message?.conversation || msg.message?.extendedTextMessage?.text || "";
+        
+        const sender = msg.key.remoteJid?.split('@')[0] || "unknown";
+        const pushName = msg.pushName || "WhatsApp User";
+
+        // Mark as read and start typing indicator immediately
+        const remoteJid = msg.key.remoteJid;
+        if (remoteJid && msg.key.id) {
+            whatsappService.markRead(remoteJid, msg.key.id, msg.key.fromMe);
+            whatsappService.sendPresence(remoteJid, 'composing');
+        }
+
+        // Handle media types
+        if (msg.message.audioMessage) {
+            console.log(`[WhatsApp-Pi] Transcribing audio from ${pushName}...`);
+            const transcription = await audioService.transcribe(msg.message.audioMessage);
+            text = `[Áudio Transcrito]: ${transcription}`;
+        } else if (!text) {
+            if (msg.message.imageMessage) text = "[Image]";
+            else if (msg.message.videoMessage) text = "[Video]";
+            else if (msg.message.stickerMessage) text = "[Sticker]";
+            else if (msg.message.documentMessage) text = "[Document]";
+            else if (msg.message.contactMessage || msg.message.contactsArrayMessage) text = "[Contact]";
+            else if (msg.message.locationMessage) text = "[Location]";
+            else text = "[Unsupported Message Type]";
+        }
+
+        // Always log to console so it appears in the TUI log pane
+        console.log(`[WhatsApp-Pi] ${pushName} (+${sender}): ${text}`);
+
+        // Handle commands
+        const cmd = text.trim().toLowerCase();
+        if (cmd === '/new') {
+            console.log(`[WhatsApp-Pi] Session reset requested by ${pushName}. Terminating process to clear context...`);
+            
+            await whatsappService.sendMessage(remoteJid!, "Iniciando nova sessão... 🆕\nO contexto anterior foi limpo e o serviço será reiniciado.");
+            
+            // Give time for the message to be sent
+            setTimeout(() => {
+                // Exit process. The OS/Service Manager should restart it.
+                // When it restarts, it starts a new session by default
+                process.exit(0);
+            }, 2000);
+            return;
+        }
+
+        // Use a standard delivery to see if it improves TUI visibility
+        pi.sendUserMessage(`Mensagem de ${pushName} (+${sender}): ${text}`);
+    });
+
+    // Register commands
+    pi.registerCommand("whatsapp", {
+        description: "Manage WhatsApp integration",
+        handler: async (args, ctx) => {
+            await menuHandler.handleCommand(ctx);
+            
+            // Persist state after changes
+            pi.appendEntry("whatsapp-state", {
+                status: sessionManager.getStatus(),
+                allowList: sessionManager.getAllowList()
+            });
+        }
+    });
+
+    // Handle outgoing messages (Agent -> WhatsApp)
+    pi.on("agent_start", async (_event, _ctx) => {
+        if (sessionManager.getStatus() !== 'connected') return;
+        const lastJid = whatsappService.getLastRemoteJid();
+        if (lastJid) {
+            await whatsappService.sendPresence(lastJid, 'composing');
+        }
+    });
+
+    pi.on("message_end", async (event, ctx) => {
+        if (sessionManager.getStatus() !== 'connected') return;
+
+        const { message } = event;
+        // Only reply if it's the assistant and we have a valid target
+        if (message.role === "assistant") {
+            const lastJid = whatsappService.getLastRemoteJid();
+            const text = message.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+
+            if (lastJid && text) {
+                try {
+                    await whatsappService.sendMessage(lastJid, text);
+                    ctx.ui.notify(`Sent reply to WhatsApp contact`, 'info');
+                } catch (error) {
+                    ctx.ui.notify(`Failed to send WhatsApp reply`, 'error');
+                }
+            }
+        }
+    });
+
+    pi.on("session_shutdown", async () => {
+        console.log("[WhatsApp-Pi] Session shutdown detected. Stopping WhatsApp service...");
+        await whatsappService.stop();
+    });
+}