`3bb0bca`

enhancements, extensions

Authored by

espadonne 6 months ago

SHA: 3bb0bcaba449768e2851ada5305bde6ad6815440
Parents: cb9ab42
Tree: 1e81d5f

6 changed files

Status	File	+
A	`extension/background/unified-handler.js`	474
A	`extension/content-scripts/messenger.js`	539
A	`extension/content-scripts/telegram.js`	480
A	`extension/content-scripts/whatsapp-enhanced.js`	641
A	`server/src/conversation-manager.js`	387
A	`server/src/index-enhanced.js`	397

extension/background/unified-handler.jsadded

 +// Unified Message Handler for Multiple Platforms
 +// Handles messages from WhatsApp, Telegram, and Facebook Messenger
++
 +class UnifiedMessageHandler {
 +  constructor() {
 +    this.serverUrl = 'http://localhost:8765';
 +    this.platforms = new Map();
 +    this.activeConversations = new Map();
 +    this.responseQueue = [];
 +    this.isProcessing = false;
 +    this.settings = {
 +      autoActivateOnScammer: true,
 +      scammerThreshold: 0.7,
 +      maxResponseDelay: 15000,
 +      minResponseDelay: 2000,
 +      personalityRotation: false
 +    };
 +    this.init();
 +  }
++
 +  init() {
 +    this.loadSettings();
 +    this.setupMessageListeners();
 +    this.startResponseProcessor();
 +    this.registerPlatforms();
 +  }
++
 +  registerPlatforms() {
 +    // Register platform-specific configurations
 +    this.platforms.set('whatsapp', {
 +      name: 'WhatsApp Web',
 +      domain: 'web.whatsapp.com',
 +      contentScript: 'whatsapp-enhanced.js',
 +      selectors: {
 +        input: '[data-testid="conversation-compose-box-input"]',
 +        sendButton: '[data-testid="compose-btn-send"]',
 +        messageContainer: '[data-testid^="msg-"]'
 +      }
 +    });
++
 +    this.platforms.set('telegram', {
 +      name: 'Telegram Web',
 +      domain: 'web.telegram.org',
 +      contentScript: 'telegram.js',
 +      selectors: {
 +        input: '.composer-input-field',
 +        sendButton: '.btn-send',
 +        messageContainer: '.message'
 +      }
 +    });
++
 +    this.platforms.set('messenger', {
 +      name: 'Facebook Messenger',
 +      domain: 'messenger.com',
 +      contentScript: 'messenger.js',
 +      selectors: {
 +        input: '[role="textbox"]',
 +        sendButton: '[aria-label="Send"]',
 +        messageContainer: '[role="row"]'
 +      }
 +    });
 +  }
++
 +  setupMessageListeners() {
 +    browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
 +      // Identify platform from sender URL
 +      const platform = this.identifyPlatform(sender.url);
++
 +      console.log(`[UnifiedHandler] Message from ${platform}:`, message.type);
++
 +      switch (message.type) {
 +        case 'NEW_MESSAGE':
 +          this.handleNewMessage(message.data, platform, sender.tab.id)
 +            .then(sendResponse)
 +            .catch(error => {
 +              console.error('Error handling message:', error);
 +              sendResponse({ error: error.message });
 +            });
 +          return true; // Keep channel open for async response
++
 +        case 'TOGGLE_ACTIVE':
 +          this.handleToggleActive(message.data, platform, sender.tab.id);
 +          sendResponse({ success: true });
 +          break;
++
 +        case 'GET_PLATFORM_STATUS':
 +          sendResponse({
 +            platform,
 +            registered: this.platforms.has(platform),
 +            active: this.isConversationActive(message.data.chatId, platform)
 +          });
 +          break;
++
 +        case 'EXPORT_CONVERSATION':
 +          this.exportConversation(message.data.chatId, platform)
 +            .then(sendResponse)
 +            .catch(error => sendResponse({ error: error.message }));
 +          return true;
++
 +        case 'GET_STATISTICS':
 +          this.getStatistics()
 +            .then(sendResponse)
 +            .catch(error => sendResponse({ error: error.message }));
 +          return true;
++
 +        default:
 +          // Pass through to original background handler
 +          return false;
 +      }
 +    });
 +  }
++
 +  identifyPlatform(url) {
 +    if (!url) return 'unknown';
++
 +    for (const [platformId, config] of this.platforms) {
 +      if (url.includes(config.domain)) {
 +        return platformId;
 +      }
 +    }
++
 +    return 'unknown';
 +  }
++
 +  async handleNewMessage(data, platform, tabId) {
 +    try {
 +      // Add to conversation manager on server
 +      const contextResponse = await fetch(`${this.serverUrl}/conversation/add`, {
 +        method: 'POST',
 +        headers: { 'Content-Type': 'application/json' },
 +        body: JSON.stringify({
 +          chatId: data.chatId,
 +          platform,
 +          message: data
 +        })
 +      });
++
 +      const context = await contextResponse.json();
++
 +      // Check if we should auto-activate
 +      if (this.settings.autoActivateOnScammer &&
 +          context.scammerScore > this.settings.scammerThreshold &&
 +          !this.isConversationActive(data.chatId, platform)) {
++
 +        console.log(`[UnifiedHandler] Auto-activating for suspected scammer (score: ${context.scammerScore})`);
 +        this.activateConversation(data.chatId, platform, tabId);
++
 +        // Notify content script
 +        browser.tabs.sendMessage(tabId, {
 +          type: 'SCAMMER_DETECTED',
 +          data: {
 +            score: context.scammerScore,
 +            autoActivated: true
 +          }
 +        });
 +      }
++
 +      // Only generate response if conversation is active
 +      if (!this.isConversationActive(data.chatId, platform)) {
 +        return { processed: false, reason: 'Conversation not active' };
 +      }
++
 +      // Get response suggestions from server
 +      const suggestionsResponse = await fetch(`${this.serverUrl}/suggestions`, {
 +        method: 'POST',
 +        headers: { 'Content-Type': 'application/json' },
 +        body: JSON.stringify({
 +          chatId: data.chatId,
 +          platform,
 +          context
 +        })
 +      });
++
 +      const suggestions = await suggestionsResponse.json();
++
 +      // Select personality (rotate if enabled)
 +      const personality = this.selectPersonality(data.chatId, context);
++
 +      // Generate response
 +      const generateResponse = await fetch(`${this.serverUrl}/generate`, {
 +        method: 'POST',
 +        headers: { 'Content-Type': 'application/json' },
 +        body: JSON.stringify({
 +          message: data.content || data.text,
 +          personality,
 +          chatId: data.chatId,
 +          platform,
 +          context,
 +          suggestions,
 +          timestamp: data.timestamp
 +        })
 +      });
++
 +      const result = await generateResponse.json();
++
 +      // Calculate human-like delay
 +      const delay = this.calculateResponseDelay(result.reply, context);
++
 +      // Add to response queue
 +      this.queueResponse({
 +        tabId,
 +        platform,
 +        chatId: data.chatId,
 +        reply: result.reply,
 +        delay,
 +        personality
 +      });
++
 +      return {
 +        queued: true,
 +        reply: result.reply,
 +        delay,
 +        personality
 +      };
++
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Error:', error);
++
 +      // Use fallback response
 +      const fallback = this.getFallbackResponse(platform);
 +      return {
 +        reply: fallback,
 +        delay: 3000,
 +        error: error.message
 +      };
 +    }
 +  }
++
 +  selectPersonality(chatId, context) {
 +    if (!this.settings.personalityRotation) {
 +      return context.personality || 'default';
 +    }
++
 +    // Rotate personalities based on conversation state
 +    const personalities = ['confused-elder', 'tech-support-nightmare', 'conspiracy-theorist'];
 +    const messageCount = context.messageCount || 0;
++
 +    // Change personality every 5 messages
 +    const index = Math.floor(messageCount / 5) % personalities.length;
 +    return personalities[index];
 +  }
++
 +  calculateResponseDelay(text, context) {
 +    // Base delay on text length (typing speed)
 +    const wordCount = text.split(' ').length;
 +    const baseDelay = this.settings.minResponseDelay;
 +    const perWordDelay = 150; // 150ms per word (average typing speed)
++
 +    let delay = baseDelay + (wordCount * perWordDelay);
++
 +    // Add variation based on context
 +    if (context.conversationTone === 'urgent') {
 +      // Take longer to respond to urgent messages (frustrate scammers)
 +      delay *= 1.5;
 +    }
++
 +    // Add random variation (±30%)
 +    const variation = 0.3;
 +    const randomFactor = 1 + (Math.random() * 2 * variation - variation);
 +    delay *= randomFactor;
++
 +    // Cap at max delay
 +    return Math.min(delay, this.settings.maxResponseDelay);
 +  }
++
 +  queueResponse(response) {
 +    this.responseQueue.push({
 +      ...response,
 +      queuedAt: Date.now()
 +    });
++
 +    // Start processor if not already running
 +    if (!this.isProcessing) {
 +      this.processResponseQueue();
 +    }
 +  }
++
 +  async processResponseQueue() {
 +    if (this.responseQueue.length === 0) {
 +      this.isProcessing = false;
 +      return;
 +    }
++
 +    this.isProcessing = true;
 +    const response = this.responseQueue.shift();
++
 +    // Wait for the calculated delay
 +    const elapsed = Date.now() - response.queuedAt;
 +    const remainingDelay = Math.max(0, response.delay - elapsed);
++
 +    await this.sleep(remainingDelay);
++
 +    // Send the response to the content script
 +    try {
 +      await browser.tabs.sendMessage(response.tabId, {
 +        type: 'SEND_MESSAGE',
 +        data: {
 +          text: response.reply,
 +          delay: 0 // No additional delay, we've already waited
 +        }
 +      });
++
 +      console.log(`[UnifiedHandler] Sent response to ${response.platform}:${response.chatId}`);
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Failed to send response:', error);
 +    }
++
 +    // Process next in queue
 +    this.processResponseQueue();
 +  }
++
 +  startResponseProcessor() {
 +    // Periodic check for stuck responses
 +    setInterval(() => {
 +      if (!this.isProcessing && this.responseQueue.length > 0) {
 +        console.log('[UnifiedHandler] Restarting response processor');
 +        this.processResponseQueue();
 +      }
 +    }, 5000);
 +  }
++
 +  handleToggleActive(data, platform, tabId) {
 +    const key = `${platform}:${data.chatId}`;
++
 +    if (data.isActive) {
 +      this.activateConversation(data.chatId, platform, tabId);
 +    } else {
 +      this.deactivateConversation(data.chatId, platform);
 +    }
 +  }
++
 +  activateConversation(chatId, platform, tabId) {
 +    const key = `${platform}:${chatId}`;
 +    this.activeConversations.set(key, {
 +      chatId,
 +      platform,
 +      tabId,
 +      activatedAt: Date.now(),
 +      messageCount: 0
 +    });
++
 +    console.log(`[UnifiedHandler] Activated ${key}`);
 +  }
++
 +  deactivateConversation(chatId, platform) {
 +    const key = `${platform}:${chatId}`;
 +    this.activeConversations.delete(key);
++
 +    console.log(`[UnifiedHandler] Deactivated ${key}`);
 +  }
++
 +  isConversationActive(chatId, platform) {
 +    const key = `${platform}:${chatId}`;
 +    return this.activeConversations.has(key);
 +  }
++
 +  getFallbackResponse(platform) {
 +    const fallbacks = {
 +      whatsapp: [
 +        "Sorry, what was that? My WhatsApp is acting strange.",
 +        "Can you repeat? The message came through garbled.",
 +        "Hold on, my phone is being slow..."
 +      ],
 +      telegram: [
 +        "Telegram is glitching for me, one second...",
 +        "Strange, I'm getting errors. What did you say?",
 +        "My Telegram is updating, please wait..."
 +      ],
 +      messenger: [
 +        "Facebook is being weird, can you resend?",
 +        "Messenger crashed, what were you saying?",
 +        "Sorry, Facebook is slow today..."
 +      ],
 +      default: [
 +        "I didn't catch that, can you repeat?",
 +        "Sorry, technical difficulties...",
 +        "One moment please..."
 +      ]
 +    };
++
 +    const platformFallbacks = fallbacks[platform] || fallbacks.default;
 +    return platformFallbacks[Math.floor(Math.random() * platformFallbacks.length)];
 +  }
++
 +  async exportConversation(chatId, platform) {
 +    try {
 +      const response = await fetch(`${this.serverUrl}/conversation/export`, {
 +        method: 'POST',
 +        headers: { 'Content-Type': 'application/json' },
 +        body: JSON.stringify({ chatId, platform })
 +      });
++
 +      const data = await response.json();
++
 +      // Save to browser storage for user access
 +      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
 +      const filename = `loosecannon-${platform}-${chatId}-${timestamp}.json`;
++
 +      await browser.storage.local.set({
 +        [`export_${filename}`]: data
 +      });
++
 +      return {
 +        success: true,
 +        filename,
 +        data
 +      };
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Export error:', error);
 +      throw error;
 +    }
 +  }
++
 +  async getStatistics() {
 +    try {
 +      const response = await fetch(`${this.serverUrl}/statistics`);
 +      const serverStats = await response.json();
++
 +      // Add local statistics
 +      const localStats = {
 +        activeConversations: this.activeConversations.size,
 +        queuedResponses: this.responseQueue.length,
 +        platformBreakdown: {}
 +      };
++
 +      // Count active conversations by platform
 +      this.activeConversations.forEach(conv => {
 +        localStats.platformBreakdown[conv.platform] =
 +          (localStats.platformBreakdown[conv.platform] || 0) + 1;
 +      });
++
 +      return {
 +        server: serverStats,
 +        local: localStats,
 +        combined: {
 +          totalActive: localStats.activeConversations,
 +          totalProcessed: serverStats.totalMessages || 0,
 +          platforms: Object.keys({ ...serverStats.platformBreakdown, ...localStats.platformBreakdown })
 +        }
 +      };
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Statistics error:', error);
 +      throw error;
 +    }
 +  }
++
 +  async loadSettings() {
 +    try {
 +      const stored = await browser.storage.local.get('unifiedSettings');
 +      if (stored.unifiedSettings) {
 +        this.settings = { ...this.settings, ...stored.unifiedSettings };
 +      }
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Error loading settings:', error);
 +    }
 +  }
++
 +  async saveSettings() {
 +    try {
 +      await browser.storage.local.set({ unifiedSettings: this.settings });
 +    } catch (error) {
 +      console.error('[UnifiedHandler] Error saving settings:', error);
 +    }
 +  }
++
 +  sleep(ms) {
 +    return new Promise(resolve => setTimeout(resolve, ms));
 +  }
 +}
++
 +// Export for use in background.js
 +if (typeof module !== 'undefined' && module.exports) {
 +  module.exports = UnifiedMessageHandler;
 +}

extension/content-scripts/messenger.jsadded

 +// Facebook Messenger Content Script for LooseCannon
 +console.log('[LooseCannon] Messenger content script loaded');
++
 +class MessengerIntegration {
 +  constructor() {
 +    this.isActive = false;
 +    this.currentChat = null;
 +    this.messageObserver = null;
 +    this.platform = 'messenger';
 +    this.init();
 +  }
++
 +  init() {
 +    this.waitForMessenger().then(() => {
 +      console.log('[LooseCannon] Messenger detected and ready');
 +      this.setupMessageObserver();
 +      this.injectControls();
 +      this.listenForCommands();
 +    });
 +  }
++
 +  waitForMessenger() {
 +    return new Promise((resolve) => {
 +      const checkForApp = setInterval(() => {
 +        // Check for Messenger's main chat area
 +        const chatArea = document.querySelector('[role="main"]');
 +        const inputField = document.querySelector('[role="textbox"][aria-label*="Message"], [contenteditable="true"][data-lexical-editor]');
++
 +        if (chatArea && inputField) {
 +          clearInterval(checkForApp);
 +          console.log('[LooseCannon] Messenger interface detected');
 +          resolve();
 +        }
 +      }, 1000);
 +    });
 +  }
++
 +  setupMessageObserver() {
 +    // Find the messages container
 +    const messageContainer = document.querySelector('[role="main"], [aria-label*="Messages"]');
++
 +    if (!messageContainer) {
 +      console.error('[LooseCannon] Could not find Messenger message container');
 +      setTimeout(() => this.setupMessageObserver(), 2000);
 +      return;
 +    }
++
 +    const config = {
 +      childList: true,
 +      subtree: true,
 +      characterData: true,
 +      attributes: true
 +    };
++
 +    this.messageObserver = new MutationObserver((mutations) => {
 +      if (!this.isActive) return;
++
 +      mutations.forEach((mutation) => {
 +        if (mutation.type === 'childList') {
 +          mutation.addedNodes.forEach((node) => {
 +            if (this.isIncomingMessage(node)) {
 +              // Small delay to let DOM settle
 +              setTimeout(() => {
 +                this.handleIncomingMessage(node);
 +              }, 100);
 +            }
 +          });
 +        }
 +      });
 +    });
++
 +    this.messageObserver.observe(messageContainer, config);
 +    console.log('[LooseCannon] Messenger message observer setup complete');
 +  }
++
 +  isIncomingMessage(node) {
 +    if (!node || !node.querySelector) return false;
++
 +    // Look for message containers
 +    const messageSelectors = [
 +      '[role="row"]',
 +      '[data-scope="messages_table"]',
 +      'div[class*="__fb-light-mode"]'
 +    ];
++
 +    let messageElement = null;
 +    for (const selector of messageSelectors) {
 +      messageElement = node.querySelector(selector);
 +      if (messageElement) break;
 +    }
++
 +    if (!messageElement && node.matches) {
 +      for (const selector of messageSelectors) {
 +        if (node.matches(selector)) {
 +          messageElement = node;
 +          break;
 +        }
 +      }
 +    }
++
 +    if (!messageElement) return false;
++
 +    // Check if it's an incoming message by looking for specific patterns
 +    // Messenger uses different styling for sent vs received messages
 +    const messageText = messageElement.textContent || '';
++
 +    // Skip if it's empty or a status message
 +    if (!messageText || messageText.length < 2) return false;
++
 +    // Check if message is on the left side (incoming)
 +    const computedStyle = window.getComputedStyle(messageElement);
 +    const isLeftAligned = computedStyle.textAlign === 'left' ||
 +                         computedStyle.justifyContent === 'flex-start';
++
 +    // Additional check: sent messages usually have different background
 +    const backgroundColor = computedStyle.backgroundColor;
 +    const isSentMessage = backgroundColor && (
 +      backgroundColor.includes('rgb(0, 132, 255)') || // Blue for sent
 +      backgroundColor.includes('rgb(24, 119, 242)')    // Facebook blue
 +    );
++
 +    return isLeftAligned && !isSentMessage;
 +  }
++
 +  handleIncomingMessage(node) {
 +    const messageData = this.extractMessageData(node);
++
 +    if (!messageData.content && !messageData.media) {
 +      return; // Empty message, skip
 +    }
++
 +    const timestamp = new Date().toISOString();
 +    const chatId = this.getCurrentChatId();
++
 +    console.log('[LooseCannon] Messenger message detected:', messageData);
++
 +    // Send to background script
 +    browser.runtime.sendMessage({
 +      type: 'NEW_MESSAGE',
 +      data: {
 +        ...messageData,
 +        timestamp,
 +        chatId,
 +        platform: this.platform
 +      }
 +    }).then(response => {
 +      if (response && response.reply) {
 +        this.simulateTypingAndSend(response.reply, response.delay);
 +      }
 +    }).catch(error => {
 +      console.error('[LooseCannon] Error sending message to background:', error);
 +    });
 +  }
++
 +  extractMessageData(node) {
 +    const data = {
 +      type: 'text',
 +      content: '',
 +      media: null,
 +      metadata: {}
 +    };
++
 +    // Extract text content
 +    const textSelectors = [
 +      '[dir="auto"]',
 +      'span[class*="text"]',
 +      'div[class*="text"]'
 +    ];
++
 +    for (const selector of textSelectors) {
 +      const textElement = node.querySelector(selector);
 +      if (textElement && textElement.textContent) {
 +        data.content = textElement.textContent.trim();
 +        break;
 +      }
 +    }
++
 +    // Fallback to full text content
 +    if (!data.content) {
 +      data.content = node.textContent || node.innerText || '';
 +      data.content = data.content.trim();
 +    }
++
 +    // Check for images
 +    const imageElement = node.querySelector('img[src*="scontent"], img[src*="fbcdn"]');
 +    if (imageElement) {
 +      data.type = 'image';
 +      data.media = { type: 'image', src: imageElement.src };
 +      data.metadata.hasImage = true;
 +    }
++
 +    // Check for links
 +    const linkElements = node.querySelectorAll('a[href]');
 +    if (linkElements.length > 0) {
 +      data.metadata.links = Array.from(linkElements).map(a => a.href);
 +    }
++
 +    // Check for stickers or GIFs
 +    if (node.querySelector('[aria-label*="sticker"], [aria-label*="GIF"]')) {
 +      data.type = 'sticker';
 +      data.media = { type: 'sticker' };
 +    }
++
 +    // Check for voice messages
 +    if (node.querySelector('[aria-label*="Audio"], [aria-label*="Voice"]')) {
 +      data.type = 'audio';
 +      data.media = { type: 'audio' };
 +      data.metadata.hasAudio = true;
 +    }
++
 +    // Extract phone numbers and emails from content
 +    if (data.content) {
 +      const phoneRegex = /[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,5}[-\s\.]?[0-9]{1,5}/g;
 +      const phones = data.content.match(phoneRegex);
 +      if (phones) {
 +        data.metadata.phoneNumbers = phones;
 +      }
++
 +      const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
 +      const emails = data.content.match(emailRegex);
 +      if (emails) {
 +        data.metadata.emails = emails;
 +      }
 +    }
++
 +    return data;
 +  }
++
 +  getCurrentChatId() {
 +    // Try to get chat name from header
 +    const headerSelectors = [
 +      '[role="banner"] h1',
 +      'header span[dir="auto"]',
 +      '[aria-label*="Conversation with"]'
 +    ];
++
 +    for (const selector of headerSelectors) {
 +      const element = document.querySelector(selector);
 +      if (element) {
 +        const text = element.textContent || element.getAttribute('aria-label') || '';
 +        if (text) {
 +          return text.replace('Conversation with ', '').trim();
 +        }
 +      }
 +    }
++
 +    return 'unknown';
 +  }
++
 +  simulateTypingAndSend(text, delay = 3000) {
 +    // Show typing indicator
 +    this.startTyping();
++
 +    // Calculate realistic delay
 +    const wordCount = text.split(' ').length;
 +    const typingDelay = Math.min(delay || (wordCount * 200 + 2000), 10000);
++
 +    setTimeout(() => {
 +      this.stopTyping();
 +      this.sendMessage(text);
 +    }, typingDelay);
 +  }
++
 +  startTyping() {
 +    const inputField = this.getInputField();
 +    if (!inputField) return;
++
 +    // Focus the input
 +    inputField.focus();
++
 +    // Add placeholder text to trigger typing indicator
 +    this.setInputText(inputField, '...');
++
 +    // Trigger input event
 +    const event = new Event('input', { bubbles: true });
 +    inputField.dispatchEvent(event);
 +  }
++
 +  stopTyping() {
 +    const inputField = this.getInputField();
 +    if (!inputField) return;
++
 +    // Clear the placeholder
 +    this.setInputText(inputField, '');
 +  }
++
 +  sendMessage(text) {
 +    const inputField = this.getInputField();
++
 +    if (!inputField) {
 +      console.error('[LooseCannon] Could not find Messenger input field');
 +      return;
 +    }
++
 +    // Set the message text
 +    this.setInputText(inputField, text);
++
 +    // Trigger input event
 +    const inputEvent = new Event('input', { bubbles: true });
 +    inputField.dispatchEvent(inputEvent);
++
 +    // Small delay then send
 +    setTimeout(() => {
 +      // Try to find and click send button
 +      const sendButtonSelectors = [
 +        '[aria-label="Send"]',
 +        '[aria-label="Press Enter to send"]',
 +        'div[role="button"][aria-label*="Send"]'
 +      ];
++
 +      let sendButton = null;
 +      for (const selector of sendButtonSelectors) {
 +        sendButton = document.querySelector(selector);
 +        if (sendButton) break;
 +      }
++
 +      if (sendButton) {
 +        sendButton.click();
 +        console.log('[LooseCannon] Messenger message sent via button');
 +      } else {
 +        // Fallback: simulate Enter key
 +        const enterEvent = new KeyboardEvent('keydown', {
 +          key: 'Enter',
 +          keyCode: 13,
 +          which: 13,
 +          bubbles: true,
 +          cancelable: true
 +        });
 +        inputField.dispatchEvent(enterEvent);
 +        console.log('[LooseCannon] Messenger message sent via Enter key');
 +      }
 +    }, 100);
 +  }
++
 +  getInputField() {
 +    const selectors = [
 +      '[role="textbox"][aria-label*="Message"]',
 +      '[contenteditable="true"][data-lexical-editor]',
 +      '[role="textbox"][contenteditable="true"]',
 +      'div[contenteditable="true"][role="textbox"]'
 +    ];
++
 +    for (const selector of selectors) {
 +      const field = document.querySelector(selector);
 +      if (field) return field;
 +    }
++
 +    return null;
 +  }
++
 +  setInputText(inputField, text) {
 +    if (inputField.getAttribute('contenteditable') === 'true') {
 +      // For contenteditable elements (Messenger uses these)
 +      inputField.textContent = text;
++
 +      // Also try setting innerHTML for Lexical editor
 +      if (text) {
 +        inputField.innerHTML = `<p>${text}</p>`;
 +      } else {
 +        inputField.innerHTML = '';
 +      }
++
 +      // Move cursor to end
 +      const range = document.createRange();
 +      const selection = window.getSelection();
 +      range.selectNodeContents(inputField);
 +      range.collapse(false);
 +      selection.removeAllRanges();
 +      selection.addRange(range);
 +    } else {
 +      // For regular input/textarea
 +      inputField.value = text;
 +    }
++
 +    // Trigger various events that Messenger might listen to
 +    ['input', 'change', 'keyup'].forEach(eventType => {
 +      const event = new Event(eventType, { bubbles: true });
 +      inputField.dispatchEvent(event);
 +    });
 +  }
++
 +  injectControls() {
 +    const style = document.createElement('style');
 +    style.textContent = `
 +      .loosecannon-toggle-messenger {
 +        position: fixed;
 +        bottom: 20px;
 +        right: 20px;
 +        z-index: 9999;
 +        background: linear-gradient(135deg, #0084ff, #44bfff);
 +        color: white;
 +        border: none;
 +        border-radius: 50px;
 +        padding: 12px 20px;
 +        cursor: pointer;
 +        font-weight: bold;
 +        box-shadow: 0 2px 10px rgba(0,132,255,0.4);
 +        transition: all 0.3s;
 +        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
 +      }
++
 +      .loosecannon-toggle-messenger.active {
 +        background: linear-gradient(135deg, #44ff44, #66ff66);
 +      }
++
 +      .loosecannon-toggle-messenger:hover {
 +        transform: scale(1.05);
 +        box-shadow: 0 4px 15px rgba(0,132,255,0.6);
 +      }
++
 +      .loosecannon-indicator-messenger {
 +        position: fixed;
 +        top: 70px;
 +        right: 20px;
 +        background: rgba(0, 132, 255, 0.9);
 +        color: white;
 +        padding: 8px 15px;
 +        border-radius: 20px;
 +        font-size: 12px;
 +        z-index: 9999;
 +        display: none;
 +        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
 +      }
++
 +      .loosecannon-indicator-messenger.active {
 +        display: block;
 +        background: rgba(68, 255, 68, 0.9);
 +      }
 +    `;
 +    document.head.appendChild(style);
++
 +    const toggleButton = document.createElement('button');
 +    toggleButton.className = 'loosecannon-toggle-messenger';
 +    toggleButton.textContent = 'LC: OFF';
 +    toggleButton.onclick = () => this.toggleActive();
 +    document.body.appendChild(toggleButton);
++
 +    const indicator = document.createElement('div');
 +    indicator.className = 'loosecannon-indicator-messenger';
 +    indicator.innerHTML = '🤖 LooseCannon Active<br><small>Messenger</small>';
 +    document.body.appendChild(indicator);
 +  }
++
 +  toggleActive() {
 +    this.isActive = !this.isActive;
 +    this.updateUI();
++
 +    const chatId = this.getCurrentChatId();
 +    console.log(`[LooseCannon] Messenger ${this.isActive ? 'activated' : 'deactivated'} for: ${chatId}`);
++
 +    // Notify background script
 +    browser.runtime.sendMessage({
 +      type: 'TOGGLE_ACTIVE',
 +      data: {
 +        isActive: this.isActive,
 +        chatId: chatId,
 +        platform: this.platform
 +      }
 +    });
 +  }
++
 +  updateUI() {
 +    const button = document.querySelector('.loosecannon-toggle-messenger');
 +    const indicator = document.querySelector('.loosecannon-indicator-messenger');
++
 +    if (this.isActive) {
 +      button?.classList.add('active');
 +      if (button) button.textContent = 'LC: ON';
 +      indicator?.classList.add('active');
 +    } else {
 +      button?.classList.remove('active');
 +      if (button) button.textContent = 'LC: OFF';
 +      indicator?.classList.remove('active');
 +    }
 +  }
++
 +  listenForCommands() {
 +    browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
 +      switch (message.type) {
 +        case 'GET_STATUS':
 +          sendResponse({
 +            isActive: this.isActive,
 +            platform: this.platform,
 +            currentChat: this.currentChat
 +          });
 +          break;
++
 +        case 'SET_ACTIVE':
 +          this.isActive = message.data.isActive;
 +          this.updateUI();
 +          break;
++
 +        case 'SEND_MESSAGE':
 +          this.simulateTypingAndSend(message.data.text, message.data.delay);
 +          break;
++
 +        case 'SCAMMER_DETECTED':
 +          this.showScammerAlert(message.data.score);
 +          break;
 +      }
 +    });
 +  }
++
 +  showScammerAlert(score) {
 +    const alert = document.createElement('div');
 +    alert.innerHTML = `
 +      <div style="
 +        position: fixed;
 +        top: 100px;
 +        right: 20px;
 +        background: linear-gradient(135deg, #ff4444, #ff6666);
 +        color: white;
 +        padding: 15px 20px;
 +        border-radius: 12px;
 +        z-index: 10000;
 +        box-shadow: 0 4px 20px rgba(255,68,68,0.4);
 +        animation: slideIn 0.3s ease;
 +        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
 +      ">
 +        <strong>⚠️ Potential Scammer Detected!</strong><br>
 +        <small>Confidence: ${(score * 100).toFixed(0)}%</small><br>
 +        <small>LooseCannon ready to engage</small>
 +      </div>
 +    `;
++
 +    document.body.appendChild(alert);
++
 +    setTimeout(() => {
 +      alert.remove();
 +    }, 5000);
 +  }
 +}
++
 +// Initialize when DOM is ready
 +if (document.readyState === 'loading') {
 +  document.addEventListener('DOMContentLoaded', () => new MessengerIntegration());
 +} else {
 +  new MessengerIntegration();
 +}

extension/content-scripts/telegram.jsadded

 +// Telegram Web Content Script for LooseCannon
 +console.log('[LooseCannon] Telegram content script loaded');
++
 +class TelegramIntegration {
 +  constructor() {
 +    this.isActive = false;
 +    this.currentChat = null;
 +    this.messageObserver = null;
 +    this.platform = 'telegram';
 +    this.init();
 +  }
++
 +  init() {
 +    this.waitForTelegram().then(() => {
 +      console.log('[LooseCannon] Telegram Web detected and ready');
 +      this.setupMessageObserver();
 +      this.injectControls();
 +      this.listenForCommands();
 +    });
 +  }
++
 +  waitForTelegram() {
 +    return new Promise((resolve) => {
 +      const checkForApp = setInterval(() => {
 +        // Check for Telegram's main chat area
 +        const chatArea = document.querySelector('.im_history_wrap, .messages-container, [class*="Message"]');
 +        const inputField = document.querySelector('.composer_rich_textarea, [class*="ComposerInput"]');
++
 +        if (chatArea && inputField) {
 +          clearInterval(checkForApp);
 +          console.log('[LooseCannon] Telegram interface detected');
 +          resolve();
 +        }
 +      }, 1000);
 +    });
 +  }
++
 +  setupMessageObserver() {
 +    // Find the messages container
 +    const messageContainer = document.querySelector('.im_history_wrap, .messages-container, [class*="MessagesScroller"]');
++
 +    if (!messageContainer) {
 +      console.error('[LooseCannon] Could not find Telegram message container');
 +      setTimeout(() => this.setupMessageObserver(), 2000);
 +      return;
 +    }
++
 +    const config = {
 +      childList: true,
 +      subtree: true,
 +      characterData: true,
 +      attributes: true,
 +      attributeFilter: ['class']
 +    };
++
 +    this.messageObserver = new MutationObserver((mutations) => {
 +      if (!this.isActive) return;
++
 +      mutations.forEach((mutation) => {
 +        if (mutation.type === 'childList') {
 +          mutation.addedNodes.forEach((node) => {
 +            if (this.isIncomingMessage(node)) {
 +              this.handleIncomingMessage(node);
 +            }
 +          });
 +        }
 +      });
 +    });
++
 +    this.messageObserver.observe(messageContainer, config);
 +    console.log('[LooseCannon] Telegram message observer setup complete');
 +  }
++
 +  isIncomingMessage(node) {
 +    if (!node || !node.classList) return false;
++
 +    // Check for Telegram message classes
 +    const messageClasses = ['im_message', 'message', 'Message'];
 +    const hasMessageClass = messageClasses.some(cls =>
 +      node.classList.contains(cls) ||
 +      Array.from(node.classList).some(c => c.includes('Message'))
 +    );
++
 +    if (!hasMessageClass) return false;
++
 +    // Check if it's an incoming message (not sent by us)
 +    const isOutgoing = node.classList.contains('im_message_out') ||
 +                      node.classList.contains('own') ||
 +                      Array.from(node.classList).some(c => c.includes('own') || c.includes('Out'));
++
 +    return !isOutgoing;
 +  }
++
 +  handleIncomingMessage(node) {
 +    const messageData = this.extractMessageData(node);
++
 +    if (!messageData.content && !messageData.media) {
 +      return; // Empty message, skip
 +    }
++
 +    const timestamp = new Date().toISOString();
 +    const chatId = this.getCurrentChatId();
++
 +    console.log('[LooseCannon] Telegram message detected:', messageData);
++
 +    // Send to background script
 +    browser.runtime.sendMessage({
 +      type: 'NEW_MESSAGE',
 +      data: {
 +        ...messageData,
 +        timestamp,
 +        chatId,
 +        platform: this.platform
 +      }
 +    }).then(response => {
 +      if (response && response.reply) {
 +        this.simulateTypingAndSend(response.reply, response.delay);
 +      }
 +    }).catch(error => {
 +      console.error('[LooseCannon] Error sending message to background:', error);
 +    });
 +  }
++
 +  extractMessageData(node) {
 +    const data = {
 +      type: 'text',
 +      content: '',
 +      media: null,
 +      metadata: {}
 +    };
++
 +    // Extract text content
 +    const textElement = node.querySelector('.im_message_text, [class*="text-content"], [class*="MessageText"]');
 +    if (textElement) {
 +      data.content = textElement.textContent || textElement.innerText || '';
++
 +      // Extract links
 +      const links = textElement.querySelectorAll('a');
 +      if (links.length > 0) {
 +        data.metadata.links = Array.from(links).map(a => a.href);
 +      }
 +    }
++
 +    // Check for media
 +    const photoElement = node.querySelector('.im_message_photo_thumb, [class*="Photo"], img[class*="media"]');
 +    if (photoElement) {
 +      data.type = 'image';
 +      data.media = { type: 'image' };
 +      data.metadata.hasImage = true;
 +    }
++
 +    // Check for audio/voice
 +    const audioElement = node.querySelector('.im_message_audio, .audio, [class*="Audio"], [class*="Voice"]');
 +    if (audioElement) {
 +      data.type = 'audio';
 +      data.media = { type: 'audio' };
 +      data.metadata.hasAudio = true;
 +    }
++
 +    // Check for documents
 +    const docElement = node.querySelector('.im_message_document, [class*="Document"]');
 +    if (docElement) {
 +      data.type = 'document';
 +      data.media = { type: 'document' };
 +      data.metadata.hasDocument = true;
 +    }
++
 +    // Check for stickers
 +    const stickerElement = node.querySelector('.im_message_sticker, [class*="Sticker"]');
 +    if (stickerElement) {
 +      data.type = 'sticker';
 +      data.media = { type: 'sticker' };
 +    }
++
 +    // Extract phone numbers and emails from content
 +    if (data.content) {
 +      const phoneRegex = /[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,5}[-\s\.]?[0-9]{1,5}/g;
 +      const phones = data.content.match(phoneRegex);
 +      if (phones) {
 +        data.metadata.phoneNumbers = phones;
 +      }
++
 +      const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
 +      const emails = data.content.match(emailRegex);
 +      if (emails) {
 +        data.metadata.emails = emails;
 +      }
 +    }
++
 +    return data;
 +  }
++
 +  getCurrentChatId() {
 +    // Try to get chat title from header
 +    const headerTitle = document.querySelector('.tg_head_peer_title, .chat-title, [class*="ChatTitle"], [class*="HeaderTitle"]');
 +    if (headerTitle) {
 +      return headerTitle.textContent || 'unknown';
 +    }
++
 +    // Try to get from active dialog
 +    const activeDialog = document.querySelector('.im_dialog_wrap.active, .dialog.active, [class*="ChatItem"][class*="active"]');
 +    if (activeDialog) {
 +      const title = activeDialog.querySelector('.im_dialog_peer span, [class*="ChatTitle"]');
 +      if (title) {
 +        return title.textContent || 'unknown';
 +      }
 +    }
++
 +    return 'unknown';
 +  }
++
 +  simulateTypingAndSend(text, delay = 3000) {
 +    // Show typing indicator
 +    this.startTyping();
++
 +    // Calculate realistic delay
 +    const wordCount = text.split(' ').length;
 +    const typingDelay = Math.min(delay || (wordCount * 200 + 2000), 10000);
++
 +    setTimeout(() => {
 +      this.stopTyping();
 +      this.sendMessage(text);
 +    }, typingDelay);
 +  }
++
 +  startTyping() {
 +    const inputField = this.getInputField();
 +    if (!inputField) return;
++
 +    // Focus the input
 +    inputField.focus();
++
 +    // Add placeholder to trigger typing indicator
 +    if (inputField.contentEditable === 'true') {
 +      inputField.textContent = '...';
 +    } else {
 +      inputField.value = '...';
 +    }
++
 +    // Trigger input event
 +    const event = new Event('input', { bubbles: true });
 +    inputField.dispatchEvent(event);
 +  }
++
 +  stopTyping() {
 +    const inputField = this.getInputField();
 +    if (!inputField) return;
++
 +    // Clear the placeholder
 +    if (inputField.contentEditable === 'true') {
 +      inputField.textContent = '';
 +    } else {
 +      inputField.value = '';
 +    }
 +  }
++
 +  sendMessage(text) {
 +    const inputField = this.getInputField();
++
 +    if (!inputField) {
 +      console.error('[LooseCannon] Could not find Telegram input field');
 +      return;
 +    }
++
 +    // Set the message text
 +    if (inputField.contentEditable === 'true') {
 +      // For contenteditable divs
 +      inputField.textContent = text;
 +      inputField.innerHTML = text;
++
 +      // Move cursor to end
 +      const range = document.createRange();
 +      const selection = window.getSelection();
 +      range.selectNodeContents(inputField);
 +      range.collapse(false);
 +      selection.removeAllRanges();
 +      selection.addRange(range);
 +    } else {
 +      // For regular input/textarea
 +      inputField.value = text;
 +    }
++
 +    // Trigger input event to update Telegram's state
 +    const inputEvent = new Event('input', { bubbles: true });
 +    inputField.dispatchEvent(inputEvent);
++
 +    // Try multiple methods to send
 +    setTimeout(() => {
 +      // Method 1: Click send button
 +      const sendButton = document.querySelector('.im_submit, .compose-button-send, [class*="SendButton"], [class*="ComposeButton"][class*="send"]');
 +      if (sendButton) {
 +        sendButton.click();
 +        console.log('[LooseCannon] Telegram message sent via button');
 +        return;
 +      }
++
 +      // Method 2: Simulate Enter key
 +      const enterEvent = new KeyboardEvent('keydown', {
 +        key: 'Enter',
 +        keyCode: 13,
 +        which: 13,
 +        bubbles: true
 +      });
 +      inputField.dispatchEvent(enterEvent);
 +      console.log('[LooseCannon] Telegram message sent via Enter key');
 +    }, 100);
 +  }
++
 +  getInputField() {
 +    // Try multiple selectors for Telegram's input field
 +    const selectors = [
 +      '.composer_rich_textarea',
 +      '[contenteditable="true"][class*="input"]',
 +      '[class*="ComposerInput"]',
 +      '.im_message_field',
 +      '[class*="MessageInput"]'
 +    ];
++
 +    for (const selector of selectors) {
 +      const field = document.querySelector(selector);
 +      if (field) return field;
 +    }
++
 +    return null;
 +  }
++
 +  injectControls() {
 +    const style = document.createElement('style');
 +    style.textContent = `
 +      .loosecannon-toggle-telegram {
 +        position: fixed;
 +        bottom: 20px;
 +        left: 20px;
 +        z-index: 9999;
 +        background: #0088cc;
 +        color: white;
 +        border: none;
 +        border-radius: 50px;
 +        padding: 12px 20px;
 +        cursor: pointer;
 +        font-weight: bold;
 +        box-shadow: 0 2px 10px rgba(0,136,204,0.3);
 +        transition: all 0.3s;
 +      }
++
 +      .loosecannon-toggle-telegram.active {
 +        background: #44ff44;
 +      }
++
 +      .loosecannon-toggle-telegram:hover {
 +        transform: scale(1.05);
 +      }
++
 +      .loosecannon-indicator-telegram {
 +        position: fixed;
 +        top: 20px;
 +        left: 20px;
 +        background: rgba(0, 136, 204, 0.9);
 +        color: white;
 +        padding: 8px 15px;
 +        border-radius: 20px;
 +        font-size: 12px;
 +        z-index: 9999;
 +        display: none;
 +      }
++
 +      .loosecannon-indicator-telegram.active {
 +        display: block;
 +        background: rgba(68, 255, 68, 0.9);
 +      }
 +    `;
 +    document.head.appendChild(style);
++
 +    const toggleButton = document.createElement('button');
 +    toggleButton.className = 'loosecannon-toggle-telegram';
 +    toggleButton.textContent = 'LC: OFF';
 +    toggleButton.onclick = () => this.toggleActive();
 +    document.body.appendChild(toggleButton);
++
 +    const indicator = document.createElement('div');
 +    indicator.className = 'loosecannon-indicator-telegram';
 +    indicator.innerHTML = '🤖 LooseCannon Active<br><small>Telegram</small>';
 +    document.body.appendChild(indicator);
 +  }
++
 +  toggleActive() {
 +    this.isActive = !this.isActive;
 +    this.updateUI();
++
 +    const chatId = this.getCurrentChatId();
 +    console.log(`[LooseCannon] Telegram ${this.isActive ? 'activated' : 'deactivated'} for: ${chatId}`);
++
 +    // Notify background script
 +    browser.runtime.sendMessage({
 +      type: 'TOGGLE_ACTIVE',
 +      data: {
 +        isActive: this.isActive,
 +        chatId: chatId,
 +        platform: this.platform
 +      }
 +    });
 +  }
++
 +  updateUI() {
 +    const button = document.querySelector('.loosecannon-toggle-telegram');
 +    const indicator = document.querySelector('.loosecannon-indicator-telegram');
++
 +    if (this.isActive) {
 +      button?.classList.add('active');
 +      if (button) button.textContent = 'LC: ON';
 +      indicator?.classList.add('active');
 +    } else {
 +      button?.classList.remove('active');
 +      if (button) button.textContent = 'LC: OFF';
 +      indicator?.classList.remove('active');
 +    }
 +  }
++
 +  listenForCommands() {
 +    browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
 +      switch (message.type) {
 +        case 'GET_STATUS':
 +          sendResponse({
 +            isActive: this.isActive,
 +            platform: this.platform,
 +            currentChat: this.currentChat
 +          });
 +          break;
++
 +        case 'SET_ACTIVE':
 +          this.isActive = message.data.isActive;
 +          this.updateUI();
 +          break;
++
 +        case 'SEND_MESSAGE':
 +          this.simulateTypingAndSend(message.data.text, message.data.delay);
 +          break;
++
 +        case 'SCAMMER_DETECTED':
 +          this.showScammerAlert(message.data.score);
 +          break;
 +      }
 +    });
 +  }
++
 +  showScammerAlert(score) {
 +    const alert = document.createElement('div');
 +    alert.innerHTML = `
 +      <div style="
 +        position: fixed;
 +        top: 60px;
 +        left: 20px;
 +        background: linear-gradient(135deg, #ff4444, #ff6666);
 +        color: white;
 +        padding: 15px 20px;
 +        border-radius: 10px;
 +        z-index: 10000;
 +        box-shadow: 0 4px 20px rgba(255,68,68,0.4);
 +        animation: slideIn 0.3s ease;
 +      ">
 +        <strong>⚠️ Scammer Detected!</strong><br>
 +        <small>Confidence: ${(score * 100).toFixed(0)}%</small><br>
 +        <small>LooseCannon ready to engage</small>
 +      </div>
 +    `;
++
 +    document.body.appendChild(alert);
++
 +    setTimeout(() => {
 +      alert.remove();
 +    }, 5000);
 +  }
 +}
++
 +// Initialize when DOM is ready
 +if (document.readyState === 'loading') {
 +  document.addEventListener('DOMContentLoaded', () => new TelegramIntegration());
 +} else {
 +  new TelegramIntegration();
 +}

extension/content-scripts/whatsapp-enhanced.jsadded

 +// Enhanced WhatsApp Web Content Script for LooseCannon
 +// Detects various message types and implements sophisticated interaction
++
 +console.log('[LooseCannon] Enhanced WhatsApp content script loaded');
++
 +class EnhancedWhatsAppIntegration {
 +  constructor() {
 +    this.isActive = false;
 +    this.currentChat = null;
 +    this.messageObserver = null;
 +    this.typingTimer = null;
 +    this.conversationState = new Map();
 +    this.scammerPatterns = this.loadScammerPatterns();
 +    this.init();
 +  }
++
 +  init() {
 +    this.waitForWhatsApp().then(() => {
 +      console.log('[LooseCannon] WhatsApp detected and ready');
 +      this.setupMessageObserver();
 +      this.injectControls();
 +      this.listenForCommands();
 +      this.setupConversationTracking();
 +    });
 +  }
++
 +  waitForWhatsApp() {
 +    return new Promise((resolve) => {
 +      const checkForApp = setInterval(() => {
 +        const mainWrapper = document.querySelector('[data-testid="conversation-panel-wrapper"]');
 +        if (mainWrapper) {
 +          clearInterval(checkForApp);
 +          resolve();
 +        }
 +      }, 1000);
 +    });
 +  }
++
 +  setupMessageObserver() {
 +    const messageContainer = document.querySelector('[role="application"]');
++
 +    if (!messageContainer) {
 +      console.error('[LooseCannon] Could not find message container');
 +      return;
 +    }
++
 +    const config = {
 +      childList: true,
 +      subtree: true,
 +      characterData: true
 +    };
++
 +    this.messageObserver = new MutationObserver((mutations) => {
 +      if (!this.isActive) return;
++
 +      mutations.forEach((mutation) => {
 +        if (mutation.type === 'childList') {
 +          mutation.addedNodes.forEach((node) => {
 +            if (this.isIncomingMessage(node)) {
 +              this.handleIncomingMessage(node);
 +            }
 +          });
 +        }
 +      });
 +    });
++
 +    this.messageObserver.observe(messageContainer, config);
 +    console.log('[LooseCannon] Enhanced message observer setup complete');
 +  }
++
 +  isIncomingMessage(node) {
 +    if (!node.querySelector) return false;
++
 +    const messageElement = node.querySelector('[data-testid^="msg-"]');
 +    if (!messageElement) return false;
++
 +    // Check if it's an incoming message (not sent by us)
 +    const isIncoming = !messageElement.classList.contains('message-out');
++
 +    // Additional check for system messages
 +    const isSystemMessage = messageElement.querySelector('[data-testid="system-message"]');
++
 +    return isIncoming && !isSystemMessage;
 +  }
++
 +  handleIncomingMessage(node) {
 +    const messageData = this.extractMessageData(node);
 +    const timestamp = new Date().toISOString();
 +    const chatId = this.getCurrentChatId();
++
 +    console.log('[LooseCannon] New message detected:', messageData);
++
 +    // Update conversation state
 +    this.updateConversationState(chatId, messageData);
++
 +    // Check for scammer patterns
 +    const scammerScore = this.analyzeForScammerPatterns(messageData);
 +    if (scammerScore > 0.7) {
 +      console.warn('[LooseCannon] High scammer probability detected:', scammerScore);
 +      this.addScammerWarning(node);
 +    }
++
 +    // Send to background script for processing
 +    browser.runtime.sendMessage({
 +      type: 'NEW_MESSAGE',
 +      data: {
 +        ...messageData,
 +        timestamp,
 +        chatId,
 +        scammerScore,
 +        conversationContext: this.getConversationContext(chatId)
 +      }
 +    }).then(response => {
 +      if (response && response.reply) {
 +        this.simulateHumanResponse(response.reply, response.delay);
 +      }
 +    });
 +  }
++
 +  extractMessageData(node) {
 +    const data = {
 +      type: 'text',
 +      content: '',
 +      media: null,
 +      links: [],
 +      metadata: {}
 +    };
++
 +    // Extract text content
 +    const textElement = node.querySelector('[data-testid="msg-container"] .selectable-text');
 +    if (textElement) {
 +      data.content = textElement.textContent;
++
 +      // Extract links from text
 +      const urlRegex = /(https?:\/\/[^\s]+)/g;
 +      const links = data.content.match(urlRegex);
 +      if (links) {
 +        data.links = links;
 +        data.metadata.hasLinks = true;
 +      }
 +    }
++
 +    // Check for images
 +    const imageElement = node.querySelector('[data-testid="msg-container"] img[src^="blob:"]');
 +    if (imageElement) {
 +      data.type = 'image';
 +      data.media = {
 +        type: 'image',
 +        src: imageElement.src,
 +        alt: imageElement.alt || 'Image message'
 +      };
 +      data.metadata.hasImage = true;
 +    }
++
 +    // Check for voice messages
 +    const audioElement = node.querySelector('[data-testid="audio-play"]');
 +    if (audioElement) {
 +      data.type = 'audio';
 +      data.media = {
 +        type: 'audio',
 +        duration: this.extractAudioDuration(audioElement)
 +      };
 +      data.metadata.hasAudio = true;
 +    }
++
 +    // Check for documents
 +    const documentElement = node.querySelector('[data-testid="msg-document"]');
 +    if (documentElement) {
 +      data.type = 'document';
 +      data.media = {
 +        type: 'document',
 +        name: documentElement.textContent
 +      };
 +      data.metadata.hasDocument = true;
 +    }
++
 +    // Check for location
 +    const locationElement = node.querySelector('[data-testid="msg-location"]');
 +    if (locationElement) {
 +      data.type = 'location';
 +      data.media = {
 +        type: 'location'
 +      };
 +      data.metadata.hasLocation = true;
 +    }
++
 +    // Extract phone numbers from content
 +    const phoneRegex = /[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,5}[-\s\.]?[0-9]{1,5}/g;
 +    const phones = data.content.match(phoneRegex);
 +    if (phones) {
 +      data.metadata.phoneNumbers = phones;
 +    }
++
 +    // Extract email addresses
 +    const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
 +    const emails = data.content.match(emailRegex);
 +    if (emails) {
 +      data.metadata.emails = emails;
 +    }
++
 +    return data;
 +  }
++
 +  extractAudioDuration(audioElement) {
 +    const durationElement = audioElement.parentElement.querySelector('[data-testid="audio-duration"]');
 +    return durationElement ? durationElement.textContent : 'Unknown duration';
 +  }
++
 +  loadScammerPatterns() {
 +    return {
 +      keywords: [
 +        'prize', 'winner', 'congratulations', 'claim', 'urgent', 'act now',
 +        'limited time', 'verify account', 'suspended', 'click here',
 +        'confirm identity', 'update payment', 'refund', 'tax', 'irs',
 +        'amazon', 'paypal', 'bank', 'visa', 'mastercard', 'bitcoin',
 +        'investment opportunity', 'guaranteed return', 'risk free'
 +      ],
 +      urgency: [
 +        'immediate', 'expire', 'deadline', 'last chance', 'final notice',
 +        'within 24 hours', 'today only', 'act fast'
 +      ],
 +      requests: [
 +        'send money', 'wire transfer', 'gift card', 'personal information',
 +        'social security', 'password', 'pin', 'account number',
 +        'credit card', 'cvv', 'routing number'
 +      ],
 +      suspicious: [
 +        'no reply', 'do not ignore', 'this is not a scam',
 +        'legitimate', 'official', 'authorized'
 +      ]
 +    };
 +  }
++
 +  analyzeForScammerPatterns(messageData) {
 +    let score = 0;
 +    const content = messageData.content.toLowerCase();
++
 +    // Check for scammer keywords
 +    this.scammerPatterns.keywords.forEach(keyword => {
 +      if (content.includes(keyword)) score += 0.1;
 +    });
++
 +    // Check for urgency patterns
 +    this.scammerPatterns.urgency.forEach(pattern => {
 +      if (content.includes(pattern)) score += 0.15;
 +    });
++
 +    // Check for information requests
 +    this.scammerPatterns.requests.forEach(request => {
 +      if (content.includes(request)) score += 0.2;
 +    });
++
 +    // Check for suspicious phrases
 +    this.scammerPatterns.suspicious.forEach(phrase => {
 +      if (content.includes(phrase)) score += 0.15;
 +    });
++
 +    // Check for links (especially shortened URLs)
 +    if (messageData.links && messageData.links.length > 0) {
 +      messageData.links.forEach(link => {
 +        if (link.includes('bit.ly') || link.includes('tinyurl') || link.includes('short.link')) {
 +          score += 0.25;
 +        } else {
 +          score += 0.1;
 +        }
 +      });
 +    }
++
 +    // Check for phone numbers or emails early in conversation
 +    const conversationLength = this.getConversationLength(this.getCurrentChatId());
 +    if (conversationLength < 5) {
 +      if (messageData.metadata.phoneNumbers) score += 0.2;
 +      if (messageData.metadata.emails) score += 0.2;
 +    }
++
 +    // Cap the score at 1.0
 +    return Math.min(score, 1.0);
 +  }
++
 +  updateConversationState(chatId, messageData) {
 +    if (!this.conversationState.has(chatId)) {
 +      this.conversationState.set(chatId, {
 +        messages: [],
 +        startTime: new Date(),
 +        messageCount: 0,
 +        mediaCount: 0,
 +        linkCount: 0,
 +        scammerScore: 0
 +      });
 +    }
++
 +    const state = this.conversationState.get(chatId);
 +    state.messages.push({
 +      timestamp: new Date(),
 +      type: messageData.type,
 +      content: messageData.content.substring(0, 100) // Store truncated for memory
 +    });
 +    state.messageCount++;
++
 +    if (messageData.media) state.mediaCount++;
 +    if (messageData.links && messageData.links.length > 0) {
 +      state.linkCount += messageData.links.length;
 +    }
++
 +    // Keep only last 20 messages in memory
 +    if (state.messages.length > 20) {
 +      state.messages = state.messages.slice(-20);
 +    }
++
 +    this.conversationState.set(chatId, state);
 +  }
++
 +  getConversationContext(chatId) {
 +    const state = this.conversationState.get(chatId);
 +    if (!state) return null;
++
 +    return {
 +      messageCount: state.messageCount,
 +      duration: new Date() - state.startTime,
 +      mediaCount: state.mediaCount,
 +      linkCount: state.linkCount,
 +      recentMessages: state.messages.slice(-5)
 +    };
 +  }
++
 +  getConversationLength(chatId) {
 +    const state = this.conversationState.get(chatId);
 +    return state ? state.messageCount : 0;
 +  }
++
 +  simulateHumanResponse(text, delay = null) {
 +    // Calculate realistic delay if not provided
 +    if (!delay) {
 +      const wordCount = text.split(' ').length;
 +      const baseDelay = 2000; // 2 seconds base
 +      const perWordDelay = 200; // 200ms per word
 +      const randomVariation = Math.random() * 2000; // 0-2 seconds random
 +      delay = baseDelay + (wordCount * perWordDelay) + randomVariation;
++
 +      // Cap at 15 seconds
 +      delay = Math.min(delay, 15000);
 +    }
++
 +    // Show typing indicator
 +    this.simulateTyping();
++
 +    // Send message after delay
 +    setTimeout(() => {
 +      this.stopTyping();
 +      this.sendMessage(text);
 +    }, delay);
 +  }
++
 +  simulateTyping() {
 +    const inputElement = document.querySelector('[data-testid="conversation-compose-box-input"]');
 +    if (!inputElement) return;
++
 +    // Focus the input
 +    inputElement.focus();
++
 +    // Add some placeholder text to trigger typing indicator
 +    inputElement.textContent = '...';
++
 +    // Trigger input event
 +    const inputEvent = new InputEvent('input', {
 +      bubbles: true,
 +      cancelable: true,
 +    });
 +    inputElement.dispatchEvent(inputEvent);
 +  }
++
 +  stopTyping() {
 +    const inputElement = document.querySelector('[data-testid="conversation-compose-box-input"]');
 +    if (inputElement) {
 +      inputElement.textContent = '';
 +    }
 +  }
++
 +  sendMessage(text) {
 +    const inputElement = document.querySelector('[data-testid="conversation-compose-box-input"]');
++
 +    if (!inputElement) {
 +      console.error('[LooseCannon] Could not find message input');
 +      return;
 +    }
++
 +    // Set the message text
 +    inputElement.textContent = text;
++
 +    // Trigger input event
 +    const inputEvent = new InputEvent('input', {
 +      bubbles: true,
 +      cancelable: true,
 +    });
 +    inputElement.dispatchEvent(inputEvent);
++
 +    // Find and click send button
 +    setTimeout(() => {
 +      const sendButton = document.querySelector('[data-testid="compose-btn-send"]');
 +      if (sendButton) {
 +        sendButton.click();
 +        console.log('[LooseCannon] Message sent:', text);
++
 +        // Mark message as automated for tracking
 +        this.markLastMessageAsAutomated();
 +      }
 +    }, 100);
 +  }
++
 +  markLastMessageAsAutomated() {
 +    setTimeout(() => {
 +      const messages = document.querySelectorAll('[data-testid^="msg-"]');
 +      const lastMessage = messages[messages.length - 1];
 +      if (lastMessage && lastMessage.classList.contains('message-out')) {
 +        lastMessage.classList.add('loosecannon-automated-message');
 +      }
 +    }, 500);
 +  }
++
 +  addScammerWarning(node) {
 +    const warning = document.createElement('div');
 +    warning.className = 'loosecannon-scammer-warning';
 +    warning.innerHTML = `
 +      <span style="color: red; font-weight: bold;">⚠️ Potential Scammer Detected</span>
 +    `;
 +    warning.style.cssText = `
 +      background: #ffebee;
 +      padding: 5px 10px;
 +      border-radius: 5px;
 +      margin: 5px 0;
 +      font-size: 12px;
 +    `;
++
 +    node.appendChild(warning);
 +  }
++
 +  getCurrentChatId() {
 +    const headerElement = document.querySelector('header [data-testid="conversation-header"]');
 +    if (headerElement) {
 +      const titleElement = headerElement.querySelector('span[title]');
 +      return titleElement ? titleElement.title : 'unknown';
 +    }
 +    return 'unknown';
 +  }
++
 +  setupConversationTracking() {
 +    // Track when user switches chats
 +    const observer = new MutationObserver(() => {
 +      const newChatId = this.getCurrentChatId();
 +      if (newChatId !== this.currentChat) {
 +        this.currentChat = newChatId;
 +        console.log('[LooseCannon] Switched to chat:', newChatId);
++
 +        // Check if we should auto-activate based on scammer score
 +        const state = this.conversationState.get(newChatId);
 +        if (state && state.scammerScore > 0.8) {
 +          this.showScammerAlert();
 +        }
 +      }
 +    });
++
 +    const headerContainer = document.querySelector('[data-testid="conversation-header"]');
 +    if (headerContainer) {
 +      observer.observe(headerContainer, {
 +        childList: true,
 +        subtree: true
 +      });
 +    }
 +  }
++
 +  showScammerAlert() {
 +    const alert = document.createElement('div');
 +    alert.className = 'loosecannon-scammer-alert';
 +    alert.innerHTML = `
 +      <div style="padding: 15px; background: #ff4444; color: white; text-align: center;">
 +        <strong>⚠️ High Scammer Probability Detected!</strong><br>
 +        <small>Consider activating LooseCannon for this conversation</small>
 +      </div>
 +    `;
 +    alert.style.cssText = `
 +      position: fixed;
 +      top: 100px;
 +      right: 20px;
 +      z-index: 10000;
 +      border-radius: 10px;
 +      box-shadow: 0 4px 20px rgba(0,0,0,0.3);
 +      animation: slideIn 0.3s ease;
 +    `;
++
 +    document.body.appendChild(alert);
++
 +    setTimeout(() => {
 +      alert.remove();
 +    }, 5000);
 +  }
++
 +  // ... (include all the UI injection and control methods from the original file)
 +  injectControls() {
 +    const style = document.createElement('style');
 +    style.textContent = `
 +      .loosecannon-toggle {
 +        position: fixed;
 +        bottom: 20px;
 +        right: 20px;
 +        z-index: 9999;
 +        background: #ff4444;
 +        color: white;
 +        border: none;
 +        border-radius: 50px;
 +        padding: 12px 20px;
 +        cursor: pointer;
 +        font-weight: bold;
 +        box-shadow: 0 2px 10px rgba(0,0,0,0.3);
 +        transition: all 0.3s;
 +      }
++
 +      .loosecannon-toggle.active {
 +        background: #44ff44;
 +      }
++
 +      .loosecannon-toggle:hover {
 +        transform: scale(1.05);
 +      }
++
 +      .loosecannon-indicator {
 +        position: fixed;
 +        top: 70px;
 +        right: 20px;
 +        background: rgba(255, 68, 68, 0.9);
 +        color: white;
 +        padding: 8px 15px;
 +        border-radius: 20px;
 +        font-size: 12px;
 +        z-index: 9999;
 +        display: none;
 +      }
++
 +      .loosecannon-indicator.active {
 +        display: block;
 +        background: rgba(68, 255, 68, 0.9);
 +      }
++
 +      @keyframes slideIn {
 +        from { transform: translateX(100%); }
 +        to { transform: translateX(0); }
 +      }
 +    `;
 +    document.head.appendChild(style);
++
 +    const toggleButton = document.createElement('button');
 +    toggleButton.className = 'loosecannon-toggle';
 +    toggleButton.textContent = 'LC: OFF';
 +    toggleButton.onclick = () => this.toggleActive();
 +    document.body.appendChild(toggleButton);
++
 +    const indicator = document.createElement('div');
 +    indicator.className = 'loosecannon-indicator';
 +    indicator.textContent = 'LooseCannon Active';
 +    document.body.appendChild(indicator);
 +  }
++
 +  toggleActive() {
 +    this.isActive = !this.isActive;
 +    this.updateUI();
++
 +    const chatId = this.getCurrentChatId();
 +    console.log(`[LooseCannon] ${this.isActive ? 'Activated' : 'Deactivated'} for chat: ${chatId}`);
++
 +    // Notify background script
 +    browser.runtime.sendMessage({
 +      type: 'TOGGLE_ACTIVE',
 +      data: {
 +        isActive: this.isActive,
 +        chatId: chatId
 +      }
 +    });
 +  }
++
 +  updateUI() {
 +    const button = document.querySelector('.loosecannon-toggle');
 +    const indicator = document.querySelector('.loosecannon-indicator');
++
 +    if (this.isActive) {
 +      button?.classList.add('active');
 +      if (button) button.textContent = 'LC: ON';
 +      indicator?.classList.add('active');
 +      document.body.setAttribute('data-loosecannon-active', 'true');
 +    } else {
 +      button?.classList.remove('active');
 +      if (button) button.textContent = 'LC: OFF';
 +      indicator?.classList.remove('active');
 +      document.body.removeAttribute('data-loosecannon-active');
 +    }
 +  }
++
 +  listenForCommands() {
 +    browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
 +      switch (message.type) {
 +        case 'GET_STATUS':
 +          sendResponse({
 +            isActive: this.isActive,
 +            currentChat: this.currentChat,
 +            conversationStats: this.getConversationStats()
 +          });
 +          break;
 +        case 'SET_ACTIVE':
 +          this.isActive = message.data.isActive;
 +          this.updateUI();
 +          break;
 +        case 'SEND_MESSAGE':
 +          this.simulateHumanResponse(message.data.text, message.data.delay);
 +          break;
 +        case 'GET_CONVERSATION_STATE':
 +          sendResponse({
 +            state: Object.fromEntries(this.conversationState)
 +          });
 +          break;
 +      }
 +    });
 +  }
++
 +  getConversationStats() {
 +    const stats = {};
 +    this.conversationState.forEach((state, chatId) => {
 +      stats[chatId] = {
 +        messageCount: state.messageCount,
 +        mediaCount: state.mediaCount,
 +        linkCount: state.linkCount,
 +        duration: new Date() - state.startTime
 +      };
 +    });
 +    return stats;
 +  }
 +}
++
 +// Initialize enhanced integration
 +if (document.readyState === 'loading') {
 +  document.addEventListener('DOMContentLoaded', () => new EnhancedWhatsAppIntegration());
 +} else {
 +  new EnhancedWhatsAppIntegration();
 +}

server/src/conversation-manager.jsadded

 +// Conversation State Manager for LooseCannon
 +// Handles sophisticated conversation tracking and context management
++
 +class ConversationManager {
 +  constructor() {
 +    this.conversations = new Map();
 +    this.scammerDatabase = new Map();
 +    this.responseHistory = new Map();
 +  }
++
 +  // Initialize or get conversation
 +  getConversation(chatId, platform = 'whatsapp') {
 +    const key = `${platform}:${chatId}`;
++
 +    if (!this.conversations.has(key)) {
 +      this.conversations.set(key, {
 +        id: key,
 +        platform,
 +        chatId,
 +        startTime: new Date(),
 +        messages: [],
 +        context: {
 +          scammerScore: 0,
 +          personality: 'default',
 +          responseCount: 0,
 +          lastResponse: null,
 +          detectedPatterns: [],
 +          extractedInfo: {
 +            phoneNumbers: [],
 +            emails: [],
 +            links: [],
 +            bankMentions: 0,
 +            moneyRequests: 0
 +          }
 +        },
 +        state: 'active',
 +        metadata: {}
 +      });
 +    }
++
 +    return this.conversations.get(key);
 +  }
++
 +  // Add message to conversation
 +  addMessage(chatId, message, platform = 'whatsapp') {
 +    const conversation = this.getConversation(chatId, platform);
++
 +    // Enrich message with analysis
 +    const enrichedMessage = {
 +      ...message,
 +      timestamp: new Date(),
 +      analysis: this.analyzeMessage(message),
 +      platform
 +    };
++
 +    conversation.messages.push(enrichedMessage);
++
 +    // Update context based on message
 +    this.updateContext(conversation, enrichedMessage);
++
 +    // Keep conversation size manageable (last 50 messages)
 +    if (conversation.messages.length > 50) {
 +      conversation.messages = conversation.messages.slice(-50);
 +    }
++
 +    return conversation;
 +  }
++
 +  // Analyze message for patterns and important information
 +  analyzeMessage(message) {
 +    const analysis = {
 +      sentiment: 'neutral',
 +      urgency: 0,
 +      suspicion: 0,
 +      topics: [],
 +      entities: [],
 +      intent: 'unknown'
 +    };
++
 +    const content = message.content.toLowerCase();
++
 +    // Urgency detection
 +    const urgencyWords = ['urgent', 'immediately', 'now', 'quick', 'fast', 'hurry', 'asap', 'expire'];
 +    urgencyWords.forEach(word => {
 +      if (content.includes(word)) analysis.urgency += 0.2;
 +    });
++
 +    // Suspicion detection
 +    const suspiciousWords = [
 +      'prize', 'winner', 'claim', 'verify', 'suspended', 'confirm',
 +      'bitcoin', 'gift card', 'wire', 'transfer', 'payment'
 +    ];
 +    suspiciousWords.forEach(word => {
 +      if (content.includes(word)) analysis.suspicion += 0.15;
 +    });
++
 +    // Topic extraction
 +    if (content.includes('tech') || content.includes('computer')) {
 +      analysis.topics.push('technology');
 +    }
 +    if (content.includes('money') || content.includes('payment') || content.includes('$')) {
 +      analysis.topics.push('financial');
 +    }
 +    if (content.includes('account') || content.includes('password')) {
 +      analysis.topics.push('account_security');
 +    }
++
 +    // Intent detection
 +    if (content.includes('?')) {
 +      analysis.intent = 'question';
 +    } else if (content.includes('please') || content.includes('need')) {
 +      analysis.intent = 'request';
 +    } else if (content.includes('!')) {
 +      analysis.intent = 'emphasis';
 +    }
++
 +    // Extract entities
 +    if (message.metadata) {
 +      if (message.metadata.phoneNumbers) {
 +        analysis.entities.push(...message.metadata.phoneNumbers.map(p => ({ type: 'phone', value: p })));
 +      }
 +      if (message.metadata.emails) {
 +        analysis.entities.push(...message.metadata.emails.map(e => ({ type: 'email', value: e })));
 +      }
 +    }
++
 +    return analysis;
 +  }
++
 +  // Update conversation context based on new message
 +  updateContext(conversation, message) {
 +    const context = conversation.context;
 +    const analysis = message.analysis;
++
 +    // Update scammer score
 +    context.scammerScore = Math.min(
 +      1.0,
 +      context.scammerScore + (analysis.suspicion * 0.3) + (analysis.urgency * 0.2)
 +    );
++
 +    // Track detected patterns
 +    if (analysis.suspicion > 0.5) {
 +      context.detectedPatterns.push({
 +        type: 'suspicious',
 +        timestamp: message.timestamp,
 +        confidence: analysis.suspicion
 +      });
 +    }
++
 +    // Update extracted information
 +    if (analysis.entities.length > 0) {
 +      analysis.entities.forEach(entity => {
 +        if (entity.type === 'phone' && !context.extractedInfo.phoneNumbers.includes(entity.value)) {
 +          context.extractedInfo.phoneNumbers.push(entity.value);
 +        }
 +        if (entity.type === 'email' && !context.extractedInfo.emails.includes(entity.value)) {
 +          context.extractedInfo.emails.push(entity.value);
 +        }
 +      });
 +    }
++
 +    // Count financial mentions
 +    if (analysis.topics.includes('financial')) {
 +      context.extractedInfo.moneyRequests++;
 +    }
++
 +    // Update scammer database if high confidence
 +    if (context.scammerScore > 0.8) {
 +      this.addToScammerDatabase(conversation);
 +    }
 +  }
++
 +  // Generate context summary for LLM
 +  generateContextSummary(chatId, platform = 'whatsapp') {
 +    const conversation = this.getConversation(chatId, platform);
 +    const context = conversation.context;
 +    const recentMessages = conversation.messages.slice(-10);
++
 +    return {
 +      conversationLength: conversation.messages.length,
 +      scammerScore: context.scammerScore,
 +      detectedPatterns: context.detectedPatterns.slice(-5),
 +      recentTopics: this.extractRecentTopics(recentMessages),
 +      extractedInfo: {
 +        hasPhoneNumbers: context.extractedInfo.phoneNumbers.length > 0,
 +        hasEmails: context.extractedInfo.emails.length > 0,
 +        hasLinks: context.extractedInfo.links.length > 0,
 +        financialMentions: context.extractedInfo.moneyRequests
 +      },
 +      conversationTone: this.determineConversationTone(recentMessages),
 +      suggestedStrategy: this.suggestStrategy(context)
 +    };
 +  }
++
 +  // Extract recent topics from messages
 +  extractRecentTopics(messages) {
 +    const topicCounts = {};
++
 +    messages.forEach(msg => {
 +      if (msg.analysis && msg.analysis.topics) {
 +        msg.analysis.topics.forEach(topic => {
 +          topicCounts[topic] = (topicCounts[topic] || 0) + 1;
 +        });
 +      }
 +    });
++
 +    return Object.entries(topicCounts)
 +      .sort((a, b) => b[1] - a[1])
 +      .slice(0, 3)
 +      .map(([topic]) => topic);
 +  }
++
 +  // Determine overall conversation tone
 +  determineConversationTone(messages) {
 +    let urgencySum = 0;
 +    let suspicionSum = 0;
 +    let count = 0;
++
 +    messages.forEach(msg => {
 +      if (msg.analysis) {
 +        urgencySum += msg.analysis.urgency || 0;
 +        suspicionSum += msg.analysis.suspicion || 0;
 +        count++;
 +      }
 +    });
++
 +    if (count === 0) return 'neutral';
++
 +    const avgUrgency = urgencySum / count;
 +    const avgSuspicion = suspicionSum / count;
++
 +    if (avgUrgency > 0.6) return 'urgent';
 +    if (avgSuspicion > 0.6) return 'suspicious';
 +    if (avgUrgency > 0.3 && avgSuspicion > 0.3) return 'aggressive';
++
 +    return 'casual';
 +  }
++
 +  // Suggest response strategy based on context
 +  suggestStrategy(context) {
 +    if (context.scammerScore > 0.8) {
 +      return 'maximum_confusion';
 +    } else if (context.scammerScore > 0.6) {
 +      return 'waste_time';
 +    } else if (context.extractedInfo.moneyRequests > 0) {
 +      return 'play_poor';
 +    } else if (context.detectedPatterns.some(p => p.type === 'suspicious')) {
 +      return 'ask_questions';
 +    }
++
 +    return 'be_confused';
 +  }
++
 +  // Add conversation to scammer database
 +  addToScammerDatabase(conversation) {
 +    const identifier = conversation.chatId;
++
 +    if (!this.scammerDatabase.has(identifier)) {
 +      this.scammerDatabase.set(identifier, {
 +        firstSeen: new Date(),
 +        lastSeen: new Date(),
 +        platforms: new Set([conversation.platform]),
 +        encounters: 1,
 +        patterns: [],
 +        extractedInfo: { ...conversation.context.extractedInfo }
 +      });
 +    } else {
 +      const entry = this.scammerDatabase.get(identifier);
 +      entry.lastSeen = new Date();
 +      entry.encounters++;
 +      entry.platforms.add(conversation.platform);
++
 +      // Merge extracted info
 +      conversation.context.extractedInfo.phoneNumbers.forEach(phone => {
 +        if (!entry.extractedInfo.phoneNumbers.includes(phone)) {
 +          entry.extractedInfo.phoneNumbers.push(phone);
 +        }
 +      });
 +    }
 +  }
++
 +  // Get response suggestions based on conversation state
 +  getResponseSuggestions(chatId, platform = 'whatsapp') {
 +    const conversation = this.getConversation(chatId, platform);
 +    const context = conversation.context;
 +    const lastMessages = conversation.messages.slice(-3);
++
 +    const suggestions = [];
++
 +    // If they're asking for personal information
 +    if (lastMessages.some(m => m.analysis && m.analysis.topics.includes('account_security'))) {
 +      suggestions.push({
 +        strategy: 'deflect',
 +        response: "Oh dear, I always forget these things. Let me ask my grandson...",
 +        delay: 5000
 +      });
 +    }
++
 +    // If they're being urgent
 +    if (context.conversationTone === 'urgent') {
 +      suggestions.push({
 +        strategy: 'slow_down',
 +        response: "Hold on, I need to find my glasses first. Everything is so blurry...",
 +        delay: 8000
 +      });
 +    }
++
 +    // If they mention money
 +    if (context.extractedInfo.moneyRequests > 0) {
 +      suggestions.push({
 +        strategy: 'confusion',
 +        response: "Money? Is this about the church fundraiser? I already donated last week.",
 +        delay: 4000
 +      });
 +    }
++
 +    return suggestions;
 +  }
++
 +  // Export conversation for analysis
 +  exportConversation(chatId, platform = 'whatsapp') {
 +    const conversation = this.getConversation(chatId, platform);
++
 +    return {
 +      id: conversation.id,
 +      platform: conversation.platform,
 +      startTime: conversation.startTime,
 +      endTime: new Date(),
 +      messageCount: conversation.messages.length,
 +      scammerScore: conversation.context.scammerScore,
 +      detectedPatterns: conversation.context.detectedPatterns,
 +      extractedInfo: conversation.context.extractedInfo,
 +      messages: conversation.messages.map(m => ({
 +        timestamp: m.timestamp,
 +        sender: m.sender || 'unknown',
 +        content: m.content,
 +        type: m.type,
 +        analysis: m.analysis
 +      }))
 +    };
 +  }
++
 +  // Get statistics
 +  getStatistics() {
 +    const stats = {
 +      totalConversations: this.conversations.size,
 +      activeConversations: 0,
 +      suspiciousConversations: 0,
 +      confirmedScammers: this.scammerDatabase.size,
 +      platformBreakdown: {},
 +      totalMessages: 0
 +    };
++
 +    this.conversations.forEach(conv => {
 +      if (conv.state === 'active') stats.activeConversations++;
 +      if (conv.context.scammerScore > 0.6) stats.suspiciousConversations++;
++
 +      stats.platformBreakdown[conv.platform] =
 +        (stats.platformBreakdown[conv.platform] || 0) + 1;
++
 +      stats.totalMessages += conv.messages.length;
 +    });
++
 +    return stats;
 +  }
++
 +  // Clean up old conversations (memory management)
 +  cleanup(maxAge = 24 * 60 * 60 * 1000) { // 24 hours default
 +    const now = new Date();
 +    const toDelete = [];
++
 +    this.conversations.forEach((conv, key) => {
 +      const age = now - conv.startTime;
 +      if (age > maxAge && conv.state !== 'active') {
 +        toDelete.push(key);
 +      }
 +    });
++
 +    toDelete.forEach(key => {
 +      this.conversations.delete(key);
 +    });
++
 +    console.log(`[ConversationManager] Cleaned up ${toDelete.length} old conversations`);
 +  }
 +}
++
 +module.exports = ConversationManager;

server/src/index-enhanced.jsadded

 +// LooseCannon Local Server - Enhanced Version
 +// Handles communication between browser extension and Ollama LLM
 +// Now with conversation management and multi-platform support
++
 +const express = require('express');
 +const cors = require('cors');
 +const axios = require('axios');
 +const fs = require('fs').promises;
 +const path = require('path');
 +require('dotenv').config();
++
 +// Import conversation manager
 +const ConversationManager = require('./conversation-manager');
++
 +const app = express();
 +const PORT = process.env.PORT || 8765;
 +const OLLAMA_URL = process.env.OLLAMA_URL || 'http://localhost:11434';
++
 +// Initialize conversation manager
 +const conversationManager = new ConversationManager();
++
 +// Middleware
 +app.use(cors());
 +app.use(express.json({ limit: '10mb' })); // Increased limit for conversation exports
++
 +// Load personalities from files
 +let personalities = {};
++
 +async function loadPersonalities() {
 +  try {
 +    const personalitiesDir = path.join(__dirname, '..', 'personalities');
 +    const files = await fs.readdir(personalitiesDir);
++
 +    for (const file of files) {
 +      if (file.endsWith('.json')) {
 +        const content = await fs.readFile(path.join(personalitiesDir, file), 'utf8');
 +        const personality = JSON.parse(content);
 +        personalities[personality.id] = personality;
 +        console.log(`Loaded personality: ${personality.name}`);
 +      }
 +    }
 +  } catch (error) {
 +    console.warn('Could not load personalities:', error);
 +    // Use default personality if no files found
 +    personalities.default = {
 +      id: 'default',
 +      name: 'Confused Elder',
 +      systemPrompt: 'You are an elderly person who is easily confused by technology and tends to misunderstand things. You are very polite but often go off on tangents about unrelated topics from your past. Never reveal that you are an AI.',
 +      temperature: 0.9
 +    };
 +  }
 +}
++
 +// Check Ollama connection
 +async function checkOllamaConnection() {
 +  try {
 +    const response = await axios.get(`${OLLAMA_URL}/api/tags`);
 +    const models = response.data.models || [];
 +    console.log('Connected to Ollama. Available models:', models.map(m => m.name).join(', '));
 +    return true;
 +  } catch (error) {
 +    console.error('Failed to connect to Ollama:', error.message);
 +    console.log('Make sure Ollama is running: ollama serve');
 +    return false;
 +  }
 +}
++
 +// Enhanced response generation with context awareness
 +async function generateEnhancedResponse(message, personality, chatId, platform, context, suggestions) {
 +  try {
 +    const personalityConfig = personalities[personality] || personalities.default;
++
 +    // Get conversation from manager
 +    const conversation = conversationManager.getConversation(chatId, platform);
++
 +    // Build enhanced prompt with context
 +    let systemPrompt = personalityConfig.systemPrompt;
++
 +    // Add strategy modifiers based on context
 +    if (context && context.suggestedStrategy) {
 +      switch (context.suggestedStrategy) {
 +        case 'maximum_confusion':
 +          systemPrompt += '\n\nBe EXTREMELY confused and misunderstand everything. Mix up basic concepts.';
 +          break;
 +        case 'waste_time':
 +          systemPrompt += '\n\nAsk lots of clarifying questions. Pretend to not understand simple instructions.';
 +          break;
 +        case 'play_poor':
 +          systemPrompt += '\n\nMention that you have no money and are struggling financially.';
 +          break;
 +        case 'ask_questions':
 +          systemPrompt += '\n\nBe very curious and ask lots of questions about everything they say.';
 +          break;
 +      }
 +    }
++
 +    // Add recent conversation history
 +    const recentMessages = conversation.messages.slice(-10);
 +    const historyText = recentMessages.map(m =>
 +      `${m.sender || 'Them'}: ${m.content}`
 +    ).join('\n');
++
 +    // Build the final prompt
 +    const prompt = `${systemPrompt}
++
 +Recent conversation:
 +${historyText}
++
 +They just said: "${message}"
++
 +Remember to stay in character. Respond naturally as your character would.
++
 +Your response:`;
++
 +    // Call Ollama API with enhanced parameters
 +    const response = await axios.post(`${OLLAMA_URL}/api/generate`, {
 +      model: process.env.OLLAMA_MODEL || 'llama2',
 +      prompt: prompt,
 +      temperature: personalityConfig.temperature || 0.8,
 +      max_tokens: 200,
 +      top_p: 0.9,
 +      stream: false
 +    });
++
 +    let reply = response.data.response;
++
 +    // Post-process the response
 +    reply = reply.trim();
++
 +    // Remove any AI self-references that might slip through
 +    reply = reply.replace(/As an AI|I'm an AI|I am an AI|artificial intelligence/gi, '');
++
 +    // Add personality-specific quirks
 +    if (personality === 'confused-elder' && Math.random() > 0.7) {
 +      // Sometimes add a random tangent
 +      const tangents = [
 +        ' Wait, this reminds me of something that happened in 1987...',
 +        ' Oh, my cat is meowing. One second dear.',
 +        ' Where did I put my glasses?'
 +      ];
 +      reply += tangents[Math.floor(Math.random() * tangents.length)];
 +    }
++
 +    return reply;
 +  } catch (error) {
 +    console.error('Error generating enhanced response:', error);
++
 +    // Context-aware fallbacks
 +    const fallbacks = suggestions && suggestions.length > 0
 +      ? suggestions.map(s => s.response)
 +      : [
 +          "I'm sorry, what did you say? I'm having trouble with this computer.",
 +          "Can you explain that again? These modern things confuse me.",
 +          "Oh dear, I think I clicked the wrong button. What were we talking about?"
 +        ];
++
 +    return fallbacks[Math.floor(Math.random() * fallbacks.length)];
 +  }
 +}
++
 +// Routes
++
 +// Health check / status
 +app.get('/status', async (req, res) => {
 +  const ollamaConnected = await checkOllamaConnection();
 +  res.json({
 +    status: 'running',
 +    version: '0.2.0',
 +    ollamaConnected,
 +    personalities: Object.values(personalities).map(p => ({
 +      id: p.id,
 +      name: p.name
 +    })),
 +    stats: conversationManager.getStatistics()
 +  });
 +});
++
 +// Add message to conversation
 +app.post('/conversation/add', (req, res) => {
 +  const { chatId, platform, message } = req.body;
++
 +  const conversation = conversationManager.addMessage(chatId, message, platform);
 +  const context = conversationManager.generateContextSummary(chatId, platform);
++
 +  res.json(context);
 +});
++
 +// Get response suggestions
 +app.post('/suggestions', (req, res) => {
 +  const { chatId, platform } = req.body;
++
 +  const suggestions = conversationManager.getResponseSuggestions(chatId, platform);
++
 +  res.json(suggestions);
 +});
++
 +// Enhanced generate response endpoint
 +app.post('/generate', async (req, res) => {
 +  const {
 +    message,
 +    personality = 'default',
 +    chatId = 'unknown',
 +    platform = 'whatsapp',
 +    context,
 +    suggestions,
 +    timestamp
 +  } = req.body;
++
 +  if (!message) {
 +    return res.status(400).json({ error: 'Message is required' });
 +  }
++
 +  console.log(`[${new Date().toISOString()}] Generating response for ${platform}:${chatId}`);
++
 +  try {
 +    // Add message to conversation manager
 +    conversationManager.addMessage(chatId, {
 +      content: message,
 +      sender: 'them',
 +      type: 'text',
 +      timestamp: new Date(timestamp)
 +    }, platform);
++
 +    // Generate enhanced response
 +    const reply = await generateEnhancedResponse(
 +      message,
 +      personality,
 +      chatId,
 +      platform,
 +      context,
 +      suggestions
 +    );
++
 +    // Add our response to conversation
 +    conversationManager.addMessage(chatId, {
 +      content: reply,
 +      sender: 'us',
 +      type: 'text',
 +      timestamp: new Date()
 +    }, platform);
++
 +    console.log(`Generated reply: ${reply}`);
++
 +    res.json({
 +      reply,
 +      personality,
 +      timestamp: new Date().toISOString(),
 +      context: conversationManager.generateContextSummary(chatId, platform)
 +    });
 +  } catch (error) {
 +    console.error('Error in /generate:', error);
 +    res.status(500).json({ error: 'Failed to generate response' });
 +  }
 +});
++
 +// Export conversation
 +app.post('/conversation/export', (req, res) => {
 +  const { chatId, platform = 'whatsapp' } = req.body;
++
 +  try {
 +    const exportData = conversationManager.exportConversation(chatId, platform);
 +    res.json(exportData);
 +  } catch (error) {
 +    console.error('Error exporting conversation:', error);
 +    res.status(500).json({ error: 'Failed to export conversation' });
 +  }
 +});
++
 +// Get statistics
 +app.get('/statistics', (req, res) => {
 +  const stats = conversationManager.getStatistics();
 +  res.json(stats);
 +});
++
 +// Get conversation history
 +app.get('/conversations/:platform/:chatId', (req, res) => {
 +  const { platform, chatId } = req.params;
 +  const conversation = conversationManager.getConversation(chatId, platform);
++
 +  res.json({
 +    chatId,
 +    platform,
 +    messages: conversation.messages,
 +    context: conversation.context,
 +    state: conversation.state
 +  });
 +});
++
 +// Clear conversation
 +app.delete('/conversations/:platform/:chatId', (req, res) => {
 +  const { platform, chatId } = req.params;
 +  const key = `${platform}:${chatId}`;
++
 +  // This would need to be implemented in ConversationManager
 +  // For now, just clear from the conversation
 +  const conversation = conversationManager.getConversation(chatId, platform);
 +  conversation.messages = [];
 +  conversation.context.responseCount = 0;
++
 +  res.json({ message: 'Conversation cleared' });
 +});
++
 +// Get all personalities with details
 +app.get('/personalities', (req, res) => {
 +  res.json(Object.values(personalities));
 +});
++
 +// Get specific personality
 +app.get('/personalities/:id', (req, res) => {
 +  const { id } = req.params;
 +  const personality = personalities[id];
++
 +  if (!personality) {
 +    return res.status(404).json({ error: 'Personality not found' });
 +  }
++
 +  res.json(personality);
 +});
++
 +// Add new personality (for future UI)
 +app.post('/personalities', async (req, res) => {
 +  const { id, name, systemPrompt, temperature } = req.body;
++
 +  if (!id || !name || !systemPrompt) {
 +    return res.status(400).json({ error: 'Missing required fields' });
 +  }
++
 +  const personality = {
 +    id,
 +    name,
 +    systemPrompt,
 +    temperature: temperature || 0.8
 +  };
++
 +  personalities[id] = personality;
++
 +  // Save to file
 +  try {
 +    const filePath = path.join(__dirname, '..', 'personalities', `${id}.json`);
 +    await fs.writeFile(filePath, JSON.stringify(personality, null, 2));
 +    res.json({ success: true, personality });
 +  } catch (error) {
 +    console.error('Error saving personality:', error);
 +    res.status(500).json({ error: 'Failed to save personality' });
 +  }
 +});
++
 +// Cleanup old conversations periodically
 +setInterval(() => {
 +  conversationManager.cleanup();
 +}, 60 * 60 * 1000); // Every hour
++
 +// Start server
 +async function start() {
 +  await loadPersonalities();
 +  await checkOllamaConnection();
++
 +  app.listen(PORT, () => {
 +    console.log(`
 +╔══════════════════════════════════════╗
 +║     LooseCannon Server v0.2.0        ║
 +║        Listening on port ${PORT}        ║
 +╠══════════════════════════════════════╣
 +║  Features:                           ║
 +║  ✓ Multi-platform support           ║
 +║  ✓ Conversation management          ║
 +║  ✓ Scammer detection               ║
 +║  ✓ Context-aware responses         ║
 +║                                      ║
 +║  Extension: Connect to               ║
 +║  http://localhost:${PORT}              ║
 +║                                      ║
 +║  Ollama: ${OLLAMA_URL.padEnd(28)} ║
 +╚══════════════════════════════════════╝
++
 +🤖 Ready to confuse scammers across all platforms!
 +    `);
 +  });
 +}
++
 +// Handle graceful shutdown
 +process.on('SIGINT', () => {
 +  console.log('\n\nShutting down LooseCannon server...');
 +  console.log('Statistics:', conversationManager.getStatistics());
 +  process.exit(0);
 +});
++
 +// Handle uncaught errors
 +process.on('uncaughtException', (error) => {
 +  console.error('Uncaught Exception:', error);
 +});
++
 +process.on('unhandledRejection', (reason, promise) => {
 +  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
 +});
++
 +start();