squidclaw 0.1.0

package/lib/channels/whatsapp/manager.js

@@ -0,0 +1,319 @@
+/**
+ * 🦑 WhatsApp Manager
+ * Multi-tenant WhatsApp session manager using Baileys
+ */
+
+import { makeWASocket, useMultiFileAuthState, makeCacheableSignalKeyStore, DisconnectReason } from '@whiskeysockets/baileys';
+import { Boom } from '@hapi/boom';
+import { join } from 'path';
+import { mkdirSync } from 'fs';
+import { logger } from '../../core/logger.js';
+import pino from 'pino';
+
+const baileyLogger = pino({ level: 'silent' });
+
+export class WhatsAppManager {
+  constructor(config, agentManager, home) {
+    this.config = config;
+    this.agentManager = agentManager;
+    this.home = home;
+    this.sessions = new Map(); // agentId → { socket, status }
+    this.onMessage = null; // callback: (agentId, contactId, message, metadata) => void
+  }
+
+  /**
+   * Start WhatsApp session for an agent
+   */
+  async startSession(agentId) {
+    if (this.sessions.has(agentId)) {
+      const existing = this.sessions.get(agentId);
+      if (existing.status === 'connected') {
+        logger.info('whatsapp', `Session for agent ${agentId} already connected`);
+        return existing;
+      }
+    }
+
+    const authDir = join(this.home, 'channels', 'whatsapp', agentId, 'auth');
+    mkdirSync(authDir, { recursive: true });
+
+    const { state, saveCreds } = await useMultiFileAuthState(authDir);
+    
+    const socket = makeWASocket({
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, baileyLogger),
+      },
+      printQRInTerminal: false,
+      logger: baileyLogger,
+      browser: ['Squidclaw', 'Chrome', '120.0.0'],
+      connectTimeoutMs: 30000,
+      retryRequestDelayMs: 2000,
+    });
+
+    const session = { socket, status: 'connecting', agentId };
+    this.sessions.set(agentId, session);
+
+    // Handle connection updates
+    socket.ev.on('connection.update', (update) => {
+      const { connection, lastDisconnect } = update;
+
+      if (connection === 'open') {
+        session.status = 'connected';
+        logger.info('whatsapp', `✅ Agent ${agentId} WhatsApp connected`);
+      }
+
+      if (connection === 'close') {
+        const statusCode = new Boom(lastDisconnect?.error)?.output?.statusCode;
+        session.status = 'disconnected';
+
+        if (statusCode === DisconnectReason.loggedOut) {
+          logger.warn('whatsapp', `Agent ${agentId} logged out — needs re-pairing`);
+          this.sessions.delete(agentId);
+        } else {
+          // Auto-reconnect
+          logger.info('whatsapp', `Agent ${agentId} disconnected (${statusCode}), reconnecting...`);
+          setTimeout(() => this.startSession(agentId), 5000);
+        }
+      }
+    });
+
+    // Save credentials on update
+    socket.ev.on('creds.update', saveCreds);
+
+    // Handle incoming messages
+    socket.ev.on('messages.upsert', async ({ messages: msgs }) => {
+      for (const msg of msgs) {
+        if (msg.key.fromMe) continue; // Skip our own messages
+        if (!msg.message) continue;
+
+        const contactId = msg.key.remoteJid;
+        if (!contactId || contactId === 'status@broadcast') continue;
+
+        // Extract message content
+        const content = this._extractContent(msg);
+        if (!content) continue;
+
+        const metadata = {
+          _rawMessage: msg,
+          pushName: msg.pushName,
+          messageId: msg.key.id,
+          timestamp: msg.messageTimestamp,
+          isGroup: contactId.endsWith('@g.us'),
+          mediaType: this._getMediaType(msg),
+        };
+
+        logger.info('whatsapp', `📱 ${agentId}: Message from ${msg.pushName || contactId}: ${content.substring(0, 50)}...`);
+
+        // Route to message handler
+        if (this.onMessage) {
+          try {
+            await this.onMessage(agentId, contactId, content, metadata);
+          } catch (err) {
+            logger.error('whatsapp', `Error processing message: ${err.message}`);
+          }
+        }
+      }
+    });
+
+    return session;
+  }
+
+  /**
+   * Send a message (with split support)
+   */
+  async sendMessage(agentId, contactId, text) {
+    const session = this.sessions.get(agentId);
+    if (!session?.socket || session.status !== 'connected') {
+      throw new Error(`WhatsApp not connected for agent ${agentId}`);
+    }
+    await session.socket.sendMessage(contactId, { text });
+  }
+
+  /**
+   * Send multiple messages with delays (human-like)
+   */
+  async sendMessages(agentId, contactId, messages, delayMs = 700) {
+    for (let i = 0; i < messages.length; i++) {
+      if (i > 0) {
+        // Random delay between 500-1000ms
+        const delay = delayMs + Math.random() * 500 - 250;
+        await new Promise(r => setTimeout(r, Math.max(300, delay)));
+      }
+      await this.sendMessage(agentId, contactId, messages[i]);
+    }
+  }
+
+  /**
+   * Send a reaction emoji
+   */
+  async sendReaction(agentId, contactId, messageId, emoji) {
+    const session = this.sessions.get(agentId);
+    if (!session?.socket || session.status !== 'connected') return;
+
+    await session.socket.sendMessage(contactId, {
+      react: { text: emoji, key: { remoteJid: contactId, id: messageId } },
+    });
+  }
+
+  /**
+   * Request a pairing code for WhatsApp login
+   */
+  async requestPairingCode(agentId, phoneNumber) {
+    const session = this.sessions.get(agentId);
+    if (!session?.socket) {
+      // Start a session first
+      await this.startSession(agentId);
+      await new Promise(r => setTimeout(r, 3000));
+    }
+
+    const sock = this.sessions.get(agentId)?.socket;
+    if (!sock) throw new Error('Could not create WhatsApp session');
+
+    const clean = phoneNumber.replace(/[^0-9]/g, '');
+    const code = await sock.requestPairingCode(clean);
+    return code;
+  }
+
+  /**
+   * Get all session statuses
+   */
+  getStatuses() {
+    const statuses = {};
+    for (const [agentId, session] of this.sessions) {
+      statuses[agentId] = {
+        status: session.status,
+        connected: session.status === 'connected',
+      };
+    }
+    return statuses;
+  }
+
+  /**
+   * Stop a session
+   */
+  async stopSession(agentId) {
+    const session = this.sessions.get(agentId);
+    if (session?.socket) {
+      try {
+        session.socket.end(undefined);
+      } catch {}
+      this.sessions.delete(agentId);
+    }
+  }
+
+  /**
+   * Stop all sessions
+   */
+  async stopAll() {
+    for (const agentId of this.sessions.keys()) {
+      await this.stopSession(agentId);
+    }
+  }
+
+  // ── Private helpers ──
+
+  _extractContent(msg) {
+    const m = msg.message;
+    if (!m) return null;
+
+    // Text message
+    if (m.conversation) return m.conversation;
+    if (m.extendedTextMessage?.text) return m.extendedTextMessage.text;
+
+    // Image with caption
+    if (m.imageMessage?.caption) return `[📸 Image] ${m.imageMessage.caption}`;
+    if (m.imageMessage) return '[📸 Image]';
+
+    // Video
+    if (m.videoMessage?.caption) return `[🎥 Video] ${m.videoMessage.caption}`;
+    if (m.videoMessage) return '[🎥 Video]';
+
+    // Audio/Voice
+    if (m.audioMessage) return '[🎤 Voice note]';
+
+    // Document
+    if (m.documentMessage) return `[📄 Document: ${m.documentMessage.fileName || 'file'}]`;
+
+    // Location
+    if (m.locationMessage) {
+      return `[📍 Location: ${m.locationMessage.degreesLatitude}, ${m.locationMessage.degreesLongitude}]`;
+    }
+
+    // Contact
+    if (m.contactMessage) return `[👤 Contact: ${m.contactMessage.displayName || 'contact'}]`;
+
+    // Sticker
+    if (m.stickerMessage) return '[🎭 Sticker]';
+
+    return null;
+  }
+
+  _getMediaType(msg) {
+    const m = msg.message;
+    if (!m) return null;
+    if (m.imageMessage) return 'image';
+    if (m.videoMessage) return 'video';
+    if (m.audioMessage) return 'audio';
+    if (m.documentMessage) return 'document';
+    if (m.locationMessage) return 'location';
+    if (m.contactMessage) return 'contact';
+    if (m.stickerMessage) return 'sticker';
+    return null;
+  }
+}
+
+// ── Voice Note Sending ──
+WhatsAppManager.prototype.sendVoiceNote = async function(agentId, contactId, audioBuffer) {
+  const session = this.sessions.get(agentId);
+  if (!session?.socket || session.status !== 'connected') {
+    throw new Error(`WhatsApp not connected for agent ${agentId}`);
+  }
+  await session.socket.sendMessage(contactId, {
+    audio: audioBuffer,
+    mimetype: 'audio/mp4',
+    ptt: true, // push to talk = voice note
+  });
+};
+
+// ── Image Sending ──
+WhatsAppManager.prototype.sendImage = async function(agentId, contactId, imageBuffer, caption) {
+  const session = this.sessions.get(agentId);
+  if (!session?.socket || session.status !== 'connected') {
+    throw new Error(`WhatsApp not connected for agent ${agentId}`);
+  }
+  await session.socket.sendMessage(contactId, {
+    image: imageBuffer,
+    caption: caption || '',
+  });
+};
+
+// ── Location Sending ──
+WhatsAppManager.prototype.sendLocation = async function(agentId, contactId, lat, lng, name) {
+  const session = this.sessions.get(agentId);
+  if (!session?.socket || session.status !== 'connected') return;
+  await session.socket.sendMessage(contactId, {
+    location: { degreesLatitude: lat, degreesLongitude: lng, name: name || '' },
+  });
+};
+
+// ── Contact Card Sending ──
+WhatsAppManager.prototype.sendContact = async function(agentId, contactId, vcard) {
+  const session = this.sessions.get(agentId);
+  if (!session?.socket || session.status !== 'connected') return;
+  await session.socket.sendMessage(contactId, {
+    contacts: { contacts: [{ vcard }] },
+  });
+};
+
+// ── Download Media from Message ──
+WhatsAppManager.prototype.downloadMedia = async function(agentId, message) {
+  const session = this.sessions.get(agentId);
+  if (!session?.socket) return null;
+  try {
+    const { downloadMediaMessage } = await import('@whiskeysockets/baileys');
+    return await downloadMediaMessage(message, 'buffer', {});
+  } catch (err) {
+    logger.error('whatsapp', `Media download failed: ${err.message}`);
+    return null;
+  }
+};

package/lib/channels/whatsapp/media.js

@@ -0,0 +1,228 @@
+/**
+ * 🦑 WhatsApp Media Handler
+ * Voice notes (receive/send), images, documents
+ */
+
+import { writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../../core/logger.js';
+
+export class MediaHandler {
+  constructor(config, home) {
+    this.config = config;
+    this.home = home;
+    this.mediaDir = join(home, 'media');
+    mkdirSync(this.mediaDir, { recursive: true });
+  }
+
+  /**
+   * Download media from a WhatsApp message
+   */
+  async downloadMedia(socket, message) {
+    try {
+      const { downloadMediaMessage } = await import('@whiskeysockets/baileys');
+      const buffer = await downloadMediaMessage(message, 'buffer', {});
+      return buffer;
+    } catch (err) {
+      logger.error('media', `Failed to download media: ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Transcribe a voice note using AI provider
+   */
+  async transcribeAudio(buffer, config) {
+    // Try OpenAI Whisper first
+    const openaiKey = config.ai?.providers?.openai?.key;
+    if (openaiKey) {
+      return this._transcribeWhisper(buffer, openaiKey);
+    }
+
+    // Try Groq Whisper
+    const groqKey = config.ai?.providers?.groq?.key;
+    if (groqKey) {
+      return this._transcribeGroqWhisper(buffer, groqKey);
+    }
+
+    logger.warn('media', 'No transcription provider available (need OpenAI or Groq key)');
+    return null;
+  }
+
+  async _transcribeWhisper(buffer, apiKey) {
+    const formData = new FormData();
+    const blob = new Blob([buffer], { type: 'audio/ogg' });
+    formData.append('file', blob, 'audio.ogg');
+    formData.append('model', 'whisper-1');
+
+    const res = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+      body: formData,
+    });
+
+    if (!res.ok) throw new Error(`Whisper API error: ${res.status}`);
+    const data = await res.json();
+    return data.text;
+  }
+
+  async _transcribeGroqWhisper(buffer, apiKey) {
+    const formData = new FormData();
+    const blob = new Blob([buffer], { type: 'audio/ogg' });
+    formData.append('file', blob, 'audio.ogg');
+    formData.append('model', 'whisper-large-v3');
+
+    const res = await fetch('https://api.groq.com/openai/v1/audio/transcriptions', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+      body: formData,
+    });
+
+    if (!res.ok) throw new Error(`Groq Whisper error: ${res.status}`);
+    const data = await res.json();
+    return data.text;
+  }
+
+  /**
+   * Generate voice note from text using TTS
+   */
+  async textToSpeech(text, voiceConfig = {}) {
+    const provider = voiceConfig.provider || 'edge-tts';
+
+    if (provider === 'edge-tts') {
+      return this._edgeTTS(text, voiceConfig.name || 'en-US-AriaNeural');
+    }
+
+    if (provider === 'openai') {
+      return this._openaiTTS(text, voiceConfig);
+    }
+
+    return null;
+  }
+
+  async _edgeTTS(text, voiceName) {
+    try {
+      const { MsEdgeTTS } = await import('node-edge-tts');
+      const tts = new MsEdgeTTS();
+      await tts.setMetadata(voiceName, 'audio-24khz-96kbitrate-mono-mp3');
+      const readable = tts.toStream(text);
+      
+      const chunks = [];
+      for await (const chunk of readable) {
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks);
+    } catch (err) {
+      logger.error('media', `Edge TTS failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  async _openaiTTS(text, voiceConfig) {
+    const apiKey = this.config.ai?.providers?.openai?.key;
+    if (!apiKey) return null;
+
+    const res = await fetch('https://api.openai.com/v1/audio/speech', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: 'tts-1',
+        input: text,
+        voice: voiceConfig.voice || 'nova',
+        response_format: 'opus',
+      }),
+    });
+
+    if (!res.ok) throw new Error(`OpenAI TTS error: ${res.status}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+
+  /**
+   * Analyze an image using vision API
+   */
+  async analyzeImage(buffer, prompt, config) {
+    // Try Anthropic Vision
+    const anthropicKey = config.ai?.providers?.anthropic?.key;
+    if (anthropicKey) {
+      return this._anthropicVision(buffer, prompt, anthropicKey, config);
+    }
+
+    // Try OpenAI Vision
+    const openaiKey = config.ai?.providers?.openai?.key;
+    if (openaiKey) {
+      return this._openaiVision(buffer, prompt, openaiKey);
+    }
+
+    return 'I can see you sent an image, but I don\'t have image analysis configured right now.';
+  }
+
+  async _anthropicVision(buffer, prompt, apiKey, config) {
+    const base64 = buffer.toString('base64');
+    const isOAuth = apiKey.includes('sk-ant-oat');
+
+    const headers = {
+      'content-type': 'application/json',
+      'anthropic-version': '2023-06-01',
+    };
+
+    if (isOAuth) {
+      headers['authorization'] = `Bearer ${apiKey}`;
+      headers['anthropic-beta'] = 'claude-code-20250219,oauth-2025-04-20';
+      headers['user-agent'] = 'squidclaw/0.1.0';
+      headers['x-app'] = 'squidclaw';
+      headers['anthropic-dangerous-direct-browser-access'] = 'true';
+    } else {
+      headers['x-api-key'] = apiKey;
+    }
+
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model: 'claude-sonnet-4-20250514',
+        max_tokens: 1024,
+        messages: [{
+          role: 'user',
+          content: [
+            { type: 'image', source: { type: 'base64', media_type: 'image/jpeg', data: base64 } },
+            { type: 'text', text: prompt || 'Describe this image briefly.' },
+          ],
+        }],
+      }),
+    });
+
+    if (!res.ok) throw new Error(`Vision API error: ${res.status}`);
+    const data = await res.json();
+    return data.content?.[0]?.text || 'Could not analyze image';
+  }
+
+  async _openaiVision(buffer, prompt, apiKey) {
+    const base64 = buffer.toString('base64');
+
+    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model: 'gpt-4o',
+        max_tokens: 1024,
+        messages: [{
+          role: 'user',
+          content: [
+            { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${base64}` } },
+            { type: 'text', text: prompt || 'Describe this image briefly.' },
+          ],
+        }],
+      }),
+    });
+
+    if (!res.ok) throw new Error(`Vision API error: ${res.status}`);
+    const data = await res.json();
+    return data.choices?.[0]?.message?.content || 'Could not analyze image';
+  }
+}