whatsapp-pi 1.0.14 → 1.0.16

package/package.json

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

package/src/services/session.manager.ts

@@ -21,6 +21,8 @@ export class SessionManager {
     private allowList: Contact[] = [];
     private blockList: Contact[] = [];
     private ignoredNumbers: Contact[] = [];
+    private openaiKey: string = '';
+    private visionModel: string = 'gpt-4o';
 
     public async ensureInitialized() {
         try {
@@ -54,6 +56,8 @@ 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.openaiKey = config.openaiKey || '';
+            this.visionModel = config.visionModel || 'gpt-4o';
         } catch (error) {
             // File not found is fine
         }
@@ -65,7 +69,9 @@ export class SessionManager {
                 allowList: this.allowList,
                 blockList: this.blockList,
                 ignoredNumbers: this.ignoredNumbers,
-                status: this.status
+                status: this.status,
+                openaiKey: this.openaiKey,
+                visionModel: this.visionModel
             };
             await writeFile(this.configPath, JSON.stringify(config, null, 2));
         } catch (error) {
@@ -195,6 +201,24 @@ export class SessionManager {
         await this.saveConfig();
     }
 
+    getOpenaiKey(): string {
+        return this.openaiKey;
+    }
+
+    async setOpenaiKey(key: string) {
+        this.openaiKey = key;
+        await this.saveConfig();
+    }
+
+    getVisionModel(): string {
+        return this.visionModel;
+    }
+
+    async setVisionModel(model: string) {
+        this.visionModel = model;
+        await this.saveConfig();
+    }
+
     getAuthDir(): string {
         return this.authDir;
     }

package/src/ui/menu.handler.ts

@@ -31,6 +31,7 @@ export class MenuHandler {
 
         options.push('Allowed Numbers');
         options.push('Blocked Numbers');
+        options.push('Vision Settings');
         options.push('Back');
 
         const choice = await ctx.ui.select(`WhatsApp (Status: ${status})`, options);
@@ -66,6 +67,9 @@ export class MenuHandler {
             case 'Blocked Numbers':
                 await this.manageBlockList(ctx);
                 break;
+            case 'Vision Settings':
+                await this.manageVisionSettings(ctx);
+                break;
         }
     }
 
@@ -158,4 +162,33 @@ export class MenuHandler {
             await this.manageBlockList(ctx);
         }
     }
+
+    private async manageVisionSettings(ctx: ExtensionCommandContext) {
+        const key = this.sessionManager.getOpenaiKey();
+        const model = this.sessionManager.getVisionModel();
+
+        const options = [
+            `API Key: ${key ? '********' : '(Not Set)'}`,
+            `Vision Model: ${model}`,
+            'Back'
+        ];
+
+        const choice = await ctx.ui.select('Vision Settings', options);
+
+        if (choice?.startsWith('API Key:')) {
+            const newKey = await ctx.ui.input('Enter OpenAI API Key (leave empty to clear):');
+            await this.sessionManager.setOpenaiKey(newKey || '');
+            ctx.ui.notify('OpenAI Key updated', 'info');
+            await this.manageVisionSettings(ctx);
+        } else if (choice?.startsWith('Vision Model:')) {
+            const newModel = await ctx.ui.input('Enter Vision Model (e.g., gpt-4o, gpt-4o-mini):', model);
+            if (newModel) {
+                await this.sessionManager.setVisionModel(newModel);
+                ctx.ui.notify('Vision model updated', 'info');
+            }
+            await this.manageVisionSettings(ctx);
+        } else {
+            await this.handleCommand(ctx);
+        }
+    }
 }

package/whatsapp-pi.ts

@@ -13,8 +13,8 @@ export default function (pi: ExtensionAPI) {
         default: false
     });
 
-    pi.registerFlag("whatsapp-pi-off", {
-        description: "Disable WhatsApp-Pi on startup",
+    pi.registerFlag("whatsapp-pi-online", {
+        description: "Enable WhatsApp-Pi on startup",
         type: "boolean",
         default: false
     });
@@ -120,13 +120,38 @@ export default function (pi: ExtensionAPI) {
         }
 
         // Handle media types
+        let imageBuffer: Buffer | undefined;
+        let imageMimeType: string | undefined;
+
         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 (msg.message.imageMessage) {
+            console.log(`[WhatsApp-Pi] Downloading image from ${pushName}...`);
+            try {
+                const { downloadContentFromMessage } = await import('@whiskeysockets/baileys');
+                const stream = await downloadContentFromMessage(msg.message.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 = msg.message.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 = msg.message.imageMessage.caption || "[Image]";
+            } catch (e) {
+                console.error(`[WhatsApp-Pi] Failed to download image:`, e);
+                text = "[Image (download failed)]";
+            }
         } else if (!text) {
-            if (msg.message.imageMessage) text = "[Image]";
-            else if (msg.message.videoMessage) text = "[Video]";
+            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]";
@@ -137,6 +162,57 @@ export default function (pi: ExtensionAPI) {
         // Always log to console so it appears in the TUI log pane
         console.log(`[WhatsApp-Pi] ${pushName} (+${sender}): ${text}`);
 
+        // Handle image with dedicated vision model if configured
+        if (imageBuffer && imageMimeType && sessionManager.getOpenaiKey()) {
+            console.log(`[WhatsApp-Pi] Using dedicated vision model (${sessionManager.getVisionModel()}) for image analysis...`);
+            try {
+                const openAiKey = sessionManager.getOpenaiKey();
+                const visionModel = sessionManager.getVisionModel();
+                
+                const response = await fetch("https://api.openai.com/v1/chat/completions", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${openAiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: visionModel,
+                        messages: [
+                            {
+                                role: "user",
+                                content: [
+                                    { type: "text", text: "Descreva esta imagem em detalhes. Se houver texto, transcreva-o." },
+                                    {
+                                        type: "image_url",
+                                        image_url: {
+                                            url: `data:${imageMimeType};base64,${imageBuffer.toString('base64')}`
+                                        }
+                                    }
+                                ]
+                            }
+                        ],
+                        max_tokens: 500
+                    })
+                });
+
+                if (response.ok) {
+                    const data = await response.json() as any;
+                    const description = data.choices[0].message.content;
+                    text = `${text}\n\n[Análise da Imagem por ${visionModel}]:\n${description}`;
+                    // Clear buffer/mime so we don't send the image again to Pi
+                    imageBuffer = undefined;
+                    imageMimeType = undefined;
+                } else {
+                    const error = await response.text();
+                    console.error(`[WhatsApp-Pi] OpenAI Vision API error:`, error);
+                    text = `${text}\n\n[Erro na análise da imagem: API retornou ${response.status}]`;
+                }
+            } catch (e) {
+                console.error(`[WhatsApp-Pi] Failed to analyze image with OpenAI:`, e);
+                text = `${text}\n\n[Erro ao processar imagem com OpenAI]`;
+            }
+        }
+
         // Handle commands
         if (text.trim().toLowerCase().startsWith('/compact')) {
             console.log(`[WhatsApp-Pi] Session compact requested by ${pushName}.`);
@@ -158,7 +234,14 @@ export default function (pi: ExtensionAPI) {
         }
 
         // Use a standard delivery for ALL messages to ensure TUI consistency
-        pi.sendUserMessage(`Mensagem de ${pushName} (+${sender}): ${text}`, { deliverAs: "followUp" });
+        if (imageBuffer && imageMimeType) {
+            pi.sendUserMessage([
+                { type: "text", text: `Mensagem de ${pushName} (+${sender}): ${text}` },
+                { type: "image", data: imageBuffer.toString('base64'), mimeType: imageMimeType }
+            ], { deliverAs: "followUp" });
+        } else {
+            pi.sendUserMessage(`Mensagem de ${pushName} (+${sender}): ${text}`, { deliverAs: "followUp" });
+        }
     });
 
     // Register commands