neoagent 1.0.0

package/server/services/messaging/manager.js

@@ -0,0 +1,328 @@
+const db = require('../../db/database');
+const { WhatsAppPlatform } = require('./whatsapp');
+const { TelnyxVoicePlatform } = require('./telnyx');
+const { DiscordPlatform } = require('./discord');
+const { TelegramPlatform } = require('./telegram');
+
+class MessagingManager {
+  constructor(io) {
+    this.io = io;
+    this.platforms = new Map();
+    this.messageHandlers = [];
+    this.platformTypes = {
+      whatsapp: WhatsAppPlatform,
+      telnyx:   TelnyxVoicePlatform,
+      discord:  DiscordPlatform,
+      telegram: TelegramPlatform,
+    };
+  }
+
+  registerHandler(handler) {
+    this.messageHandlers.push(handler);
+  }
+
+  async connectPlatform(userId, platformName, config = {}) {
+    const PlatformClass = this.platformTypes[platformName];
+    if (!PlatformClass) throw new Error(`Unknown platform: ${platformName}`);
+
+    // For Telnyx, inject saved whitelist and voice secret into config before constructing
+    if (platformName === 'telnyx') {
+      const wlRow = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(userId, 'platform_whitelist_telnyx');
+      if (wlRow) {
+        try { config.allowedNumbers = JSON.parse(wlRow.value); } catch { /* ignore */ }
+      }
+      const secretRow = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(userId, 'platform_voice_secret_telnyx');
+      if (secretRow) {
+        try { config.voiceSecret = JSON.parse(secretRow.value); } catch { config.voiceSecret = secretRow.value; }
+      }
+    }
+
+    // For Discord, inject saved allowedIds whitelist
+    if (platformName === 'discord') {
+      const wlRow = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(userId, 'platform_whitelist_discord');
+      if (wlRow) {
+        try { config.allowedIds = JSON.parse(wlRow.value); } catch { /* ignore */ }
+      }
+    }
+
+    // For Telegram, inject saved allowedIds whitelist
+    if (platformName === 'telegram') {
+      const wlRow = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(userId, 'platform_whitelist_telegram');
+      if (wlRow) {
+        try { config.allowedIds = JSON.parse(wlRow.value); } catch { /* ignore */ }
+      }
+    }
+
+    const key = `${userId}:${platformName}`;
+    let platform = this.platforms.get(key);
+
+    if (platform) {
+      await platform.disconnect().catch(() => {});
+    }
+
+    platform = new PlatformClass(config);
+    this.platforms.set(key, platform);
+
+    platform.on('qr', (qr) => {
+      this.io.to(`user:${userId}`).emit('messaging:qr', { platform: platformName, qr });
+      db.prepare('UPDATE platform_connections SET status = ?, config = ? WHERE user_id = ? AND platform = ?')
+        .run('awaiting_qr', JSON.stringify(config), userId, platformName);
+    });
+
+    platform.on('connected', () => {
+      this.io.to(`user:${userId}`).emit('messaging:connected', { platform: platformName });
+      db.prepare('UPDATE platform_connections SET status = ?, last_connected = datetime(\'now\') WHERE user_id = ? AND platform = ?')
+        .run('connected', userId, platformName);
+    });
+
+    platform.on('disconnected', (info) => {
+      this.io.to(`user:${userId}`).emit('messaging:disconnected', { platform: platformName, ...info });
+      db.prepare('UPDATE platform_connections SET status = ? WHERE user_id = ? AND platform = ?')
+        .run('disconnected', userId, platformName);
+    });
+
+    platform.on('logged_out', () => {
+      this.io.to(`user:${userId}`).emit('messaging:logged_out', { platform: platformName });
+      db.prepare('UPDATE platform_connections SET status = ? WHERE user_id = ? AND platform = ?')
+        .run('logged_out', userId, platformName);
+      this.platforms.delete(key);
+    });
+
+    // Telnyx-specific: blocked inbound caller notification
+    platform.on('blocked_caller', (info) => {
+      this.io.to(`user:${userId}`).emit('messaging:blocked_sender', {
+        platform: platformName,
+        sender: info.caller,
+        chatId: info.ccId,
+        senderName: null
+      });
+    });
+
+    // Discord / Telegram: blocked sender notification with suggestions
+    platform.on('blocked_sender', (info) => {
+      this.io.to(`user:${userId}`).emit('messaging:blocked_sender', {
+        platform: platformName,
+        sender: info.sender,
+        chatId: info.chatId,
+        senderName: info.senderName || null,
+        meta: info.guildName ? `Server: ${info.guildName}` : (info.groupName ? `Group: ${info.groupName}` : null),
+        suggestions: info.suggestions || null,
+      });
+    });
+
+    platform.on('message', async (msg) => {
+      db.prepare('INSERT INTO messages (user_id, role, content, platform, platform_msg_id, platform_chat_id, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+        .run(userId, 'user', msg.content, platformName, msg.messageId, msg.chatId,
+          JSON.stringify({ sender: msg.sender, senderName: msg.senderName, isGroup: msg.isGroup, mediaType: msg.mediaType }),
+          msg.timestamp);
+
+      // Enrich with platform name so handlers and the web UI always have it
+      const enrichedMsg = { platform: platformName, ...msg };
+
+      this.io.to(`user:${userId}`).emit('messaging:message', enrichedMsg);
+
+      for (const handler of this.messageHandlers) {
+        try {
+          await handler(userId, enrichedMsg);
+        } catch (err) {
+          console.error('Message handler error:', err.message);
+        }
+      }
+    });
+
+    const existing = db.prepare('SELECT id FROM platform_connections WHERE user_id = ? AND platform = ?').get(userId, platformName);
+    if (!existing) {
+      db.prepare('INSERT INTO platform_connections (user_id, platform, config, status) VALUES (?, ?, ?, ?)')
+        .run(userId, platformName, JSON.stringify(config), 'connecting');
+    } else {
+      db.prepare('UPDATE platform_connections SET config = ?, status = ? WHERE user_id = ? AND platform = ?')
+        .run(JSON.stringify(config), 'connecting', userId, platformName);
+    }
+
+    await platform.connect();
+    return { status: platform.getStatus() };
+  }
+
+  async disconnectPlatform(userId, platformName) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (!platform) return { status: 'not_connected' };
+
+    await platform.disconnect();
+    this.platforms.delete(key);
+
+    db.prepare('UPDATE platform_connections SET status = ? WHERE user_id = ? AND platform = ?')
+      .run('disconnected', userId, platformName);
+
+    return { status: 'disconnected' };
+  }
+
+  async sendMessage(userId, platformName, to, content, mediaPath) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (!platform) throw new Error(`Platform ${platformName} not connected`);
+
+    // Sentinel: agent can choose not to reply by sending [NO RESPONSE]
+    if (!mediaPath && typeof content === 'string' && content.trim().toUpperCase() === '[NO RESPONSE]') {
+      return { success: true, suppressed: true };
+    }
+
+    const result = await platform.sendMessage(to, content, { mediaPath });
+
+    db.prepare('INSERT INTO messages (user_id, role, content, platform, platform_chat_id, media_path) VALUES (?, ?, ?, ?, ?, ?)')
+      .run(userId, 'assistant', content, platformName, to, mediaPath || null);
+
+    // Notify the web UI so the sent message appears in chat
+    this.io.to(`user:${userId}`).emit('messaging:sent', {
+      platform: platformName,
+      to,
+      content,
+      mediaPath: mediaPath || null
+    });
+
+    return { success: true, result };
+  }
+
+  getPlatformStatus(userId, platformName) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (!platform) {
+      const conn = db.prepare('SELECT status FROM platform_connections WHERE user_id = ? AND platform = ?').get(userId, platformName);
+      return { status: conn?.status || 'not_configured' };
+    }
+    return {
+      status: platform.getStatus(),
+      authInfo: platform.getAuthInfo()
+    };
+  }
+
+  getAllStatuses(userId) {
+    const connections = db.prepare('SELECT platform, status, last_connected FROM platform_connections WHERE user_id = ?').all(userId);
+    const statuses = {};
+
+    for (const conn of connections) {
+      const key = `${userId}:${conn.platform}`;
+      const platform = this.platforms.get(key);
+      statuses[conn.platform] = {
+        status: platform ? platform.getStatus() : conn.status,
+        lastConnected: conn.last_connected,
+        authInfo: platform?.getAuthInfo() || null
+      };
+    }
+
+    return statuses;
+  }
+
+  async logoutPlatform(userId, platformName) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (platform && platform.logout) {
+      await platform.logout();
+    }
+    this.platforms.delete(key);
+    db.prepare('DELETE FROM platform_connections WHERE user_id = ? AND platform = ?').run(userId, platformName);
+    return { status: 'logged_out' };
+  }
+
+  async restoreConnections() {
+    const rows = db.prepare(
+      "SELECT user_id, platform, config FROM platform_connections WHERE status IN ('connected', 'awaiting_qr')"
+    ).all();
+    for (const row of rows) {
+      try {
+        const config = row.config ? JSON.parse(row.config) : {};
+        console.log(`[Messaging] Restoring ${row.platform} for user ${row.user_id}`);
+        await this.connectPlatform(row.user_id, row.platform, config);
+      } catch (err) {
+        console.error(`[Messaging] Failed to restore ${row.platform} for user ${row.user_id}:`, err.message);
+        db.prepare("UPDATE platform_connections SET status = 'disconnected' WHERE user_id = ? AND platform = ?")
+          .run(row.user_id, row.platform);
+      }
+    }
+  }
+
+  async makeCall(userId, to, greeting) {
+    const key = `${userId}:telnyx`;
+    const platform = this.platforms.get(key);
+    if (!platform) throw new Error('Telnyx Voice is not connected');
+    if (!platform.initiateCall) throw new Error('Telnyx platform does not support outbound calls');
+    const result = await platform.initiateCall(to, greeting);
+    this.io.to(`user:${userId}`).emit('messaging:call_initiated', { platform: 'telnyx', to, callControlId: result.callControlId });
+    return { success: true, ...result };
+  }
+
+  async markRead(userId, platformName, chatId, messageId) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (!platform?.markRead) return;
+    return platform.markRead(chatId, messageId);
+  }
+
+  async sendTyping(userId, platformName, chatId, isTyping) {
+    const key = `${userId}:${platformName}`;
+    const platform = this.platforms.get(key);
+    if (!platform?.sendTyping) return;
+    return platform.sendTyping(chatId, isTyping);
+  }
+
+  /**
+   * Route a raw Telnyx webhook event to the correct user's platform instance.
+   * We find the Telnyx platform instance that owns this call_control_id, or fall
+   * back to the first connected Telnyx instance.
+   */
+  async handleTelnyxWebhook(event) {
+    // Try to find the platform by connection_id or phone number from event payload
+    for (const [key, platform] of this.platforms.entries()) {
+      if (platform.name === 'telnyx') {
+        await platform.handleWebhook(event);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Update the allowed-numbers list on a live Telnyx platform instance.
+   */
+  updateTelnyxAllowedNumbers(userId, numbers) {
+    const key = `${userId}:telnyx`;
+    const platform = this.platforms.get(key);
+    if (platform?.setAllowedNumbers) platform.setAllowedNumbers(numbers);
+  }
+
+  /**
+   * Update the voice secret code on a live Telnyx platform instance.
+   */
+  updateTelnyxVoiceSecret(userId, secret) {
+    const key = `${userId}:telnyx`;
+    const platform = this.platforms.get(key);
+    if (platform?.setVoiceSecret) platform.setVoiceSecret(secret);
+  }
+
+  /**
+   * Update the allowed-entries list on a live Discord platform instance.
+   * Accepts prefixed strings: "user:ID", "guild:ID", "channel:ID"
+   */
+  updateDiscordAllowedIds(userId, ids) {
+    const key = `${userId}:discord`;
+    const platform = this.platforms.get(key);
+    if (platform?.setAllowedEntries) platform.setAllowedEntries(ids);
+    else if (platform?.setAllowedIds) platform.setAllowedIds(ids); // legacy fallback
+  }
+
+  /**
+   * Update the allowed-entries list on a live Telegram platform instance.
+   * Accepts prefixed strings: "user:ID", "group:ID"
+   */
+  updateTelegramAllowedIds(userId, ids) {
+    const key = `${userId}:telegram`;
+    const platform = this.platforms.get(key);
+    if (platform?.setAllowedEntries) platform.setAllowedEntries(ids);
+  }
+}
+
+module.exports = { MessagingManager };

package/server/services/messaging/telegram.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const { BasePlatform } = require('./base');
+const TelegramBot = require('node-telegram-bot-api');
+
+/**
+ * Whitelist entry format (prefixed strings):
+ *   "user:ID"   → always respond in DMs, no mention needed
+ *   "group:ID"  → respond in this group/supergroup when @mentioned
+ *   "ID"        → legacy plain ID, treated as "user"
+ *
+ * Telegram group/supergroup IDs are negative numbers (e.g. -1001234567890).
+ *
+ * chatId emitted on message events:
+ *   DMs:    "dm_<userId>"
+ *   Groups: "<chatId>"  (negative integer as string)
+ */
+class TelegramPlatform extends BasePlatform {
+  constructor(config = {}) {
+    super('telegram', config);
+    this.supportsGroups = true;
+    this.supportsMedia  = false;
+
+    this.botToken       = config.botToken || '';
+    this.allowedEntries = Array.isArray(config.allowedIds) ? config.allowedIds : [];
+
+    this._bot           = null;
+    this._botUser       = null;
+    // In-memory ring buffer of recent messages per raw chatId (Telegram has no fetch history API for bots)
+    this._contextBuffers = new Map();
+    this._contextMaxSize = 25;
+  }
+
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+
+  async connect() {
+    if (!this.botToken) throw new Error('Telegram bot token is required');
+
+    if (this._bot) { try { await this._bot.stopPolling(); } catch {} this._bot = null; }
+
+    this._bot = new TelegramBot(this.botToken, { polling: true });
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Telegram login timed out after 20 s')), 20000);
+
+      this._bot.getMe()
+        .then((me) => {
+          clearTimeout(timeout);
+          this._botUser = me;
+          this.status = 'connected';
+          console.log(`[Telegram] Logged in as @${me.username} (${me.id})`);
+          this.emit('connected');
+          resolve({ status: 'connected' });
+        })
+        .catch((err) => { clearTimeout(timeout); reject(err); });
+
+      this._bot.on('message', (msg) => this._handleMessage(msg));
+      this._bot.on('polling_error', (err) => {
+        console.error('[Telegram] Polling error:', err.message);
+        if (err.message && err.message.includes('401')) {
+          this.status = 'error';
+          this.emit('error', { message: 'Invalid bot token' });
+        }
+      });
+    });
+  }
+
+  async disconnect() {
+    if (this._bot) { try { await this._bot.stopPolling(); } catch {} this._bot = null; }
+    this.status   = 'disconnected';
+    this._botUser = null;
+    this.emit('disconnected', { manual: true });
+  }
+
+  async logout()   { await this.disconnect(); }
+  getStatus()      { return this.status; }
+  getAuthInfo()    { return this._botUser ? { username: this._botUser.username, id: this._botUser.id } : null; }
+
+  // ── Whitelist ──────────────────────────────────────────────────────────────
+
+  setAllowedEntries(entries) {
+    this.allowedEntries = Array.isArray(entries) ? entries : [];
+    console.log(`[Telegram] Whitelist updated: ${this.allowedEntries.length} entry(ies)`);
+  }
+
+  /** Returns {allowed, requireMention} */
+  _checkAccess(msg) {
+    const isPrivate = msg.chat.type === 'private';
+    const userId    = String(msg.from.id);
+    const chatId    = String(msg.chat.id);  // negative for groups
+
+    if (!this.allowedEntries.length) return { allowed: false, requireMention: false };
+
+    for (const entry of this.allowedEntries) {
+      const colon = entry.indexOf(':');
+      const type  = colon > 0 ? entry.slice(0, colon) : 'user';
+      const id    = colon > 0 ? entry.slice(colon + 1) : entry;
+
+      if (type === 'user'  && id === userId) return { allowed: true, requireMention: false };
+      if (type === 'group' && id === chatId) return { allowed: true, requireMention: true  };
+    }
+    return { allowed: false, requireMention: false };
+  }
+
+  _isMentioned(msg) {
+    if (!this._botUser) return false;
+    const text     = msg.text || msg.caption || '';
+    const entities = msg.entities || msg.caption_entities || [];
+    for (const e of entities) {
+      if (e.type === 'mention') {
+        const mention = text.slice(e.offset, e.offset + e.length);
+        if (mention.toLowerCase() === `@${this._botUser.username.toLowerCase()}`) return true;
+      }
+    }
+    return false;
+  }
+
+  _stripMention(text) {
+    if (!this._botUser) return (text || '').trim();
+    return (text || '')
+      .replace(new RegExp(`@${this._botUser.username}`, 'gi'), '')
+      .replace(/\s{2,}/g, ' ')
+      .trim();
+  }
+
+  // ── Context buffer (since Telegram bots can't fetch message history) ───────
+
+  _addToContext(rawChatId, entry) {
+    if (!this._contextBuffers.has(rawChatId)) this._contextBuffers.set(rawChatId, []);
+    const buf = this._contextBuffers.get(rawChatId);
+    buf.push(entry);
+    if (buf.length > this._contextMaxSize) buf.shift();
+  }
+
+  _getContext(rawChatId) {
+    return [...(this._contextBuffers.get(rawChatId) || [])];
+  }
+
+  // ── Message handler ────────────────────────────────────────────────────────
+
+  async _handleMessage(msg) {
+    if (!msg.from || msg.from.is_bot) return;
+
+    const isPrivate  = msg.chat.type === 'private';
+    const userId     = String(msg.from.id);
+    const rawChatId  = String(msg.chat.id);
+    const outputChatId = isPrivate ? `dm_${userId}` : rawChatId;
+
+    const text = msg.text || msg.caption || '';
+    const senderName = [msg.from.first_name, msg.from.last_name].filter(Boolean).join(' ')
+      || msg.from.username || userId;
+
+    // Always record into context buffer (even blocked messages add context)
+    this._addToContext(rawChatId, {
+      author:  senderName,
+      content: text || (msg.photo ? '[photo]' : msg.document ? '[document]' : '[empty]'),
+      mine:    false,
+    });
+
+    const { allowed, requireMention } = this._checkAccess(msg);
+
+    if (!allowed) {
+      const suggestions = [
+        { label: `Add user (${senderName})`, prefixedId: `user:${userId}` },
+      ];
+      if (!isPrivate) suggestions.push({
+        label: `Add group (${msg.chat.title || rawChatId})`,
+        prefixedId: `group:${rawChatId}`,
+      });
+
+      this.emit('blocked_sender', {
+        sender:    userId,
+        chatId:    outputChatId,
+        senderName,
+        groupName: msg.chat.title || null,
+        suggestions,
+      });
+      return;
+    }
+
+    // Group entries require @mention to activate
+    if (requireMention && !this._isMentioned(msg)) return;
+
+    let content = requireMention ? this._stripMention(text) : text;
+    if (!content && msg.photo)    content = `[photo]`;
+    if (!content && msg.document) content = `[document: ${msg.document.file_name || 'file'}]`;
+    if (!content) return;
+
+    const fullSenderName = isPrivate
+      ? senderName
+      : `${senderName} in ${msg.chat.title || rawChatId}`;
+
+    const channelContext = (!isPrivate && requireMention) ? this._getContext(rawChatId) : null;
+
+    this.emit('message', {
+      platform:       'telegram',
+      chatId:         outputChatId,
+      sender:         userId,
+      senderName:     fullSenderName,
+      content,
+      mediaType:      null,
+      isGroup:        !isPrivate,
+      messageId:      String(msg.message_id),
+      timestamp:      new Date(msg.date * 1000).toISOString(),
+      channelContext,
+      channelName:    isPrivate ? null : (msg.chat.title || rawChatId),
+      groupName:      msg.chat.title || null,
+    });
+  }
+
+  // ── Send ───────────────────────────────────────────────────────────────────
+
+  /**
+   * to: "dm_<userId>" for DMs, or a raw chat ID (e.g. "-1001234567890") for groups
+   */
+  async sendMessage(to, content, _options = {}) {
+    if (!this._bot || this.status !== 'connected') throw new Error('Telegram not connected');
+
+    const telegramChatId = to.startsWith('dm_') ? to.slice(3) : to;
+    await this._bot.sendMessage(telegramChatId, content);
+
+    // Store outgoing message in context buffer
+    if (this._botUser) {
+      this._addToContext(telegramChatId, {
+        author:  `[bot] ${this._botUser.username}`,
+        content,
+        mine:    true,
+      });
+    }
+
+    return { success: true };
+  }
+
+  async sendTyping(chatId, _isTyping) {
+    if (!this._bot || this.status !== 'connected') return;
+    try {
+      const id = chatId.startsWith('dm_') ? chatId.slice(3) : chatId;
+      await this._bot.sendChatAction(id, 'typing');
+    } catch { /* non-fatal */ }
+  }
+}
+
+module.exports = { TelegramPlatform };