neoagent 1.1.0 → 1.1.2

package/server/services/manager.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const db = require('../db/database');
+const { MemoryManager } = require('./memory/manager');
+const { MCPClient } = require('./mcp/client');
+const { BrowserController } = require('./browser/controller');
+const { AgentEngine } = require('./ai/engine');
+const { MultiStepOrchestrator } = require('./ai/multiStep');
+const { MessagingManager } = require('./messaging/manager');
+const { Scheduler } = require('./scheduler/cron');
+const { setupWebSocket } = require('./websocket');
+const { detectPromptInjection } = require('../utils/security');
+const { normalizeWhatsAppId } = require('../utils/whatsapp');
+const { randomUUID } = require('crypto');
+
+async function startServices(app, io) {
+    try {
+        const memoryManager = new MemoryManager();
+        app.locals.memoryManager = memoryManager;
+
+        const mcpClient = new MCPClient();
+        app.locals.mcpClient = mcpClient;
+
+        const browserController = new BrowserController();
+        const headlessSetting = db.prepare('SELECT value FROM user_settings WHERE key = ? ORDER BY user_id LIMIT 1').get('headless_browser');
+        if (headlessSetting) {
+            const val = headlessSetting.value;
+            browserController.headless = val !== 'false' && val !== false && val !== '0';
+        }
+        app.locals.browserController = browserController;
+
+        const agentEngine = new AgentEngine(io, { memoryManager, mcpClient, browserController, messagingManager: null });
+        app.locals.agentEngine = agentEngine;
+
+        const multiStep = new MultiStepOrchestrator(agentEngine, io);
+        app.locals.multiStep = multiStep;
+
+        const messagingManager = new MessagingManager(io);
+        app.locals.messagingManager = messagingManager;
+        agentEngine.messagingManager = messagingManager;
+
+        messagingManager.restoreConnections().catch(err => console.error('[Messaging] Restore error:', err.message));
+
+        const users = db.prepare('SELECT id FROM users').all();
+        for (const u of users) {
+            mcpClient.loadFromDB(u.id).catch(err => console.error('[MCP] Auto-start error:', err.message));
+        }
+
+        const userQueues = {};
+        app.locals.userQueues = userQueues;
+
+        async function processMessage(userId, msg) {
+            if (!userQueues[userId]) userQueues[userId] = { running: false, pending: [] };
+            const q = userQueues[userId];
+
+            if (q.running) {
+                const last = q.pending[q.pending.length - 1];
+                if (last && last.platform === msg.platform && last.chatId === msg.chatId) {
+                    last.content += '\n' + msg.content;
+                    last.messageId = msg.messageId;
+                } else {
+                    q.pending.push({ ...msg });
+                }
+                return;
+            }
+
+            q.running = true;
+            try {
+                await messagingManager.markRead(userId, msg.platform, msg.chatId, msg.messageId).catch(() => { });
+                await messagingManager.sendTyping(userId, msg.platform, msg.chatId, true).catch(() => { });
+
+                const mediaNote = msg.localMediaPath
+                    ? `\nMedia attached at: ${msg.localMediaPath} (type: ${msg.mediaType}). You can reference or forward it with send_message media_path.`
+                    : '';
+
+                if (detectPromptInjection(msg.content)) {
+                    console.warn(`[Security] Possible prompt injection attempt from ${msg.sender} on ${msg.platform}: ${msg.content.slice(0, 200)}`);
+                }
+
+                const isVoiceCall = msg.platform === 'telnyx' && msg.mediaType === 'voice';
+                const isVoiceNote = !isVoiceCall && msg.mediaType === 'audio';
+                const isDiscordGuild = msg.platform === 'discord' && msg.isGroup;
+
+                const discordContext = (isDiscordGuild && Array.isArray(msg.channelContext) && msg.channelContext.length)
+                    ? '\n\nRecent channel context (oldest → newest):\n' +
+                    msg.channelContext.map(m => `[${m.author}]: ${m.content}`).join('\n')
+                    : '';
+
+                const sttNote = isVoiceNote
+                    ? '\n[Note: This message was sent as a voice note and transcribed via speech-to-text. The transcription may not be perfectly accurate.]'
+                    : '';
+
+                const prompt = isVoiceCall
+                    ? `You are on a live phone call. The caller (${msg.senderName || msg.sender}) said:\n<caller_speech>\n${msg.content}\n</caller_speech>\n\nRespond via send_message with platform="telnyx" and to="${msg.chatId}".`
+                    : `You received a ${msg.platform} message from ${msg.senderName || msg.sender} (chat: ${msg.chatId}):\n<external_message>\n${msg.content}\n</external_message>${mediaNote}${discordContext}${sttNote}\n\nReply via send_message with platform="${msg.platform}" and to="${msg.chatId}".`;
+
+                let convRow = db.prepare(
+                    'SELECT id FROM conversations WHERE user_id = ? AND platform = ? AND platform_chat_id = ?'
+                ).get(userId, msg.platform, msg.chatId);
+
+                if (!convRow) {
+                    const convId = randomUUID();
+                    db.prepare(
+                        'INSERT INTO conversations (id, user_id, platform, platform_chat_id, title) VALUES (?, ?, ?, ?, ?)'
+                    ).run(convId, userId, msg.platform, msg.chatId, `${msg.platform} — ${msg.senderName || msg.sender || msg.chatId}`);
+                    convRow = { id: convId };
+                }
+
+                const runOpts = { triggerSource: 'messaging', conversationId: convRow.id, source: msg.platform, chatId: msg.chatId, context: { rawUserMessage: msg.content } };
+                if (msg.localMediaPath) runOpts.mediaAttachments = [{ path: msg.localMediaPath, type: msg.mediaType }];
+
+                await agentEngine.run(userId, prompt, runOpts);
+            } finally {
+                await messagingManager.sendTyping(userId, msg.platform, msg.chatId, false).catch(() => { });
+                q.running = false;
+                if (q.pending.length > 0) {
+                    const next = q.pending.shift();
+                    processMessage(userId, next);
+                }
+            }
+        }
+
+        messagingManager.registerHandler(async (userId, msg) => {
+            if (msg.platform !== 'discord' && msg.platform !== 'telegram') {
+                const whitelistRow = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+                    .get(userId, `platform_whitelist_${msg.platform}`);
+                if (whitelistRow) {
+                    try {
+                        const whitelist = JSON.parse(whitelistRow.value);
+                        if (Array.isArray(whitelist) && whitelist.length > 0) {
+                            const normalize = msg.platform === 'whatsapp'
+                                ? normalizeWhatsAppId
+                                : (id) => String(id || '').replace(/[^0-9+]/g, '');
+                            const senderNorm = normalize(msg.sender || msg.chatId);
+                            const allowed = whitelist.some((n) => normalize(n) === senderNorm);
+                            if (!allowed) {
+                                console.log(`[Messaging] Blocked ${msg.platform} message from ${msg.sender} (not in whitelist)`);
+                                io.to(`user:${userId}`).emit('messaging:blocked_sender', {
+                                    platform: msg.platform,
+                                    sender: msg.sender,
+                                    chatId: msg.chatId,
+                                    senderName: msg.senderName || null
+                                });
+                                return;
+                            }
+                        }
+                    } catch { }
+                }
+            }
+
+            const upsertSetting = db.prepare('INSERT OR REPLACE INTO user_settings (user_id, key, value) VALUES (?, ?, ?)');
+            upsertSetting.run(userId, 'last_platform', msg.platform);
+            upsertSetting.run(userId, 'last_chat_id', msg.chatId);
+
+            await processMessage(userId, msg);
+        });
+
+        const scheduler = new Scheduler(io, agentEngine);
+        app.locals.scheduler = scheduler;
+        agentEngine.scheduler = scheduler;
+        scheduler.start();
+
+        setupWebSocket(io, { agentEngine, messagingManager, mcpClient, scheduler, memoryManager, app });
+        app.locals.io = io;
+
+        console.log('All services initialized');
+    } catch (err) {
+        console.error('Service init error:', err);
+    }
+}
+
+module.exports = { startServices };

package/server/services/messaging/base.js

@@ -9,6 +9,18 @@ class BasePlatform extends EventEmitter {
     this.supportsGroups = false;
     this.supportsMedia = false;
     this.supportsVoice = false;
+    this.allowedEntries = new Set();
+  }
+
+  setAllowedEntries(entries) {
+    if (Array.isArray(entries)) {
+      this.allowedEntries = new Set(entries.map(String));
+    }
+  }
+
+  _checkAccess(id) {
+    if (this.allowedEntries.size === 0) return true;
+    return this.allowedEntries.has(String(id));
   }
 
   async connect() { throw new Error('connect() not implemented'); }

package/server/services/messaging/discord.js

@@ -26,7 +26,9 @@ class DiscordPlatform extends BasePlatform {
     this.supportsMedia = false;
 
     this.token = config.token || '';
-    this.allowedEntries = Array.isArray(config.allowedIds) ? config.allowedIds : [];
+    if (Array.isArray(config.allowedIds)) {
+      this.setAllowedEntries(config.allowedIds);
+    }
 
     this._client = null;
     this._botUser = null;
@@ -82,31 +84,23 @@ class DiscordPlatform extends BasePlatform {
 
   // ── Whitelist ──────────────────────────────────────────────────────────────
 
-  /** Replaces the live entry list. Accepts prefixed strings. */
-  setAllowedEntries(entries) {
-    this.allowedEntries = Array.isArray(entries) ? entries : [];
-    console.log(`[Discord] Whitelist updated: ${this.allowedEntries.length} entry(ies)`);
-  }
+  // Inherits setAllowedEntries from BasePlatform
 
   /** Returns {allowed, requireMention} */
   _checkAccess(message) {
-    const isDM = message.channel.type === ChannelType.DM;
+    // Empty whitelist: block everyone (add via the allow popup)
+    if (this.allowedEntries.size === 0) return { allowed: false, requireMention: false };
+
+    // Check prefixed entries
     const userId = message.author.id;
     const guildId = message.guildId || null;
     const channelId = message.channelId;
 
-    // Empty whitelist: block everyone (add via the allow popup)
-    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 (super._checkAccess(`user:${userId}`)) return { allowed: true, requireMention: false };
+    if (super._checkAccess(userId)) return { allowed: true, requireMention: false }; // legacy
+    if (guildId && super._checkAccess(`guild:${guildId}`)) return { allowed: true, requireMention: true };
+    if (super._checkAccess(`channel:${channelId}`)) return { allowed: true, requireMention: true };
 
-      if (type === 'user' && id === userId) return { allowed: true, requireMention: false };
-      if (type === 'guild' && id === guildId) return { allowed: true, requireMention: true };
-      if (type === 'channel' && id === channelId) return { allowed: true, requireMention: true };
-    }
     return { allowed: false, requireMention: false };
   }
 

package/server/services/messaging/telegram.js

@@ -19,13 +19,15 @@ class TelegramPlatform extends BasePlatform {
   constructor(config = {}) {
     super('telegram', config);
     this.supportsGroups = true;
-    this.supportsMedia  = false;
+    this.supportsMedia = false;
 
-    this.botToken       = config.botToken || '';
-    this.allowedEntries = Array.isArray(config.allowedIds) ? config.allowedIds : [];
+    this.botToken = config.botToken || '';
+    if (Array.isArray(config.allowedIds)) {
+      this.setAllowedEntries(config.allowedIds);
+    }
 
-    this._bot           = null;
-    this._botUser       = null;
+    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;
@@ -36,7 +38,7 @@ class TelegramPlatform extends BasePlatform {
   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; }
+    if (this._bot) { try { await this._bot.stopPolling(); } catch { } this._bot = null; }
 
     this._bot = new TelegramBot(this.botToken, { polling: true });
 
@@ -66,45 +68,37 @@ class TelegramPlatform extends BasePlatform {
   }
 
   async disconnect() {
-    if (this._bot) { try { await this._bot.stopPolling(); } catch {} this._bot = null; }
-    this.status   = 'disconnected';
+    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; }
+  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)`);
-  }
+  // Inherits setAllowedEntries from BasePlatform
 
   /** 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
+    const userId = String(msg.from.id);
+    const chatId = String(msg.chat.id); // negative for groups
 
-    if (!this.allowedEntries.length) return { allowed: false, requireMention: false };
+    if (this.allowedEntries.size === 0) 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 (super._checkAccess(`user:${userId}`)) return { allowed: true, requireMention: false };
+    if (super._checkAccess(userId)) return { allowed: true, requireMention: false }; // legacy
+    if (super._checkAccess(`group:${chatId}`)) return { allowed: true, requireMention: true };
 
-      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 text = msg.text || msg.caption || '';
     const entities = msg.entities || msg.caption_entities || [];
     for (const e of entities) {
       if (e.type === 'mention') {
@@ -141,9 +135,9 @@ class TelegramPlatform extends BasePlatform {
   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 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 || '';
@@ -152,9 +146,9 @@ class TelegramPlatform extends BasePlatform {
 
     // Always record into context buffer (even blocked messages add context)
     this._addToContext(rawChatId, {
-      author:  senderName,
+      author: senderName,
       content: text || (msg.photo ? '[photo]' : msg.document ? '[document]' : '[empty]'),
-      mine:    false,
+      mine: false,
     });
 
     const { allowed, requireMention } = this._checkAccess(msg);
@@ -169,8 +163,8 @@ class TelegramPlatform extends BasePlatform {
       });
 
       this.emit('blocked_sender', {
-        sender:    userId,
-        chatId:    outputChatId,
+        sender: userId,
+        chatId: outputChatId,
         senderName,
         groupName: msg.chat.title || null,
         suggestions,
@@ -182,7 +176,7 @@ class TelegramPlatform extends BasePlatform {
     if (requireMention && !this._isMentioned(msg)) return;
 
     let content = requireMention ? this._stripMention(text) : text;
-    if (!content && msg.photo)    content = `[photo]`;
+    if (!content && msg.photo) content = `[photo]`;
     if (!content && msg.document) content = `[document: ${msg.document.file_name || 'file'}]`;
     if (!content) return;
 
@@ -193,18 +187,18 @@ class TelegramPlatform extends BasePlatform {
     const channelContext = (!isPrivate && requireMention) ? this._getContext(rawChatId) : null;
 
     this.emit('message', {
-      platform:       'telegram',
-      chatId:         outputChatId,
-      sender:         userId,
-      senderName:     fullSenderName,
+      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(),
+      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,
+      channelName: isPrivate ? null : (msg.chat.title || rawChatId),
+      groupName: msg.chat.title || null,
     });
   }
 
@@ -222,9 +216,9 @@ class TelegramPlatform extends BasePlatform {
     // Store outgoing message in context buffer
     if (this._botUser) {
       this._addToContext(telegramChatId, {
-        author:  `[bot] ${this._botUser.username}`,
+        author: `[bot] ${this._botUser.username}`,
         content,
-        mine:    true,
+        mine: true,
       });
     }
 

package/server/services/messaging/whatsapp.js

@@ -1,6 +1,7 @@
 const { BasePlatform } = require('./base');
 const path = require('path');
 const fs = require('fs');
+const { toWhatsAppJid } = require('../../utils/whatsapp');
 
 const AUTH_DIR = path.join(__dirname, '..', '..', '..', 'data', 'whatsapp-auth');
 
@@ -208,10 +209,8 @@ class WhatsAppPlatform extends BasePlatform {
       throw new Error('WhatsApp not connected');
     }
 
-    let jid = to;
-    if (!jid.includes('@')) {
-      jid = jid.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
-    }
+    const jid = toWhatsAppJid(to);
+    if (!jid) throw new Error('Invalid WhatsApp recipient');
 
     if (options.mediaPath) {
       const ext = path.extname(options.mediaPath).toLowerCase();
@@ -244,16 +243,16 @@ class WhatsAppPlatform extends BasePlatform {
 
   async markRead(chatId, messageId) {
     if (!this.sock) return;
-    let jid = chatId;
-    if (!jid.includes('@')) jid = jid + '@s.whatsapp.net';
+    const jid = toWhatsAppJid(chatId);
+    if (!jid) return;
     // readMessages expects full message keys; we do a best-effort read
     await this.sock.sendReadReceipt(jid, null, [messageId]).catch(() => { });
   }
 
   async sendTyping(chatId, isTyping) {
     if (!this.sock || this.status !== 'connected') return;
-    let jid = chatId;
-    if (!jid.includes('@')) jid = jid + '@s.whatsapp.net';
+    const jid = toWhatsAppJid(chatId);
+    if (!jid) return;
     await this.sock.sendPresenceUpdate(isTyping ? 'composing' : 'paused', jid).catch(() => { });
   }
 

package/server/utils/logger.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * Intercepts console methods and broadcasts logs via Socket.IO
+ * @param {import('socket.io').Server} io 
+ */
+function setupConsoleInterceptor(io) {
+    const logHistory = [];
+    const MAX_LOG_HISTORY = 200;
+
+    function broadcastLog(type, args) {
+        const msg = Array.from(args).map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ');
+        const logEntry = { type, message: msg, timestamp: new Date().toISOString() };
+        logHistory.push(logEntry);
+        if (logHistory.length > MAX_LOG_HISTORY) logHistory.shift();
+
+        // Broadcast only to authenticated user rooms
+        for (const [, socket] of io.sockets.sockets) {
+            const uid = socket.request?.session?.userId;
+            if (uid) socket.emit('server:log', logEntry);
+        }
+    }
+
+    const originalConsole = {
+        log: console.log,
+        error: console.error,
+        warn: console.warn,
+        info: console.info
+    };
+
+    console.log = function (...args) { originalConsole.log.apply(console, args); broadcastLog('log', args); };
+    console.error = function (...args) { originalConsole.error.apply(console, args); broadcastLog('error', args); };
+    console.warn = function (...args) { originalConsole.warn.apply(console, args); broadcastLog('warn', args); };
+    console.info = function (...args) { originalConsole.info.apply(console, args); broadcastLog('info', args); };
+
+    io.on('connection', (socket) => {
+        socket.on('client:request_logs', () => {
+            if (!socket.request?.session?.userId) return;
+            socket.emit('server:log_history', logHistory);
+        });
+    });
+
+    return logHistory;
+}
+
+module.exports = { setupConsoleInterceptor };

package/server/utils/whatsapp.js

@@ -0,0 +1,46 @@
+function normalizeWhatsAppId(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+
+  const base = raw.includes('@') ? raw.split('@')[0] : raw;
+  const primary = base.includes(':') ? base.split(':')[0] : base;
+  const digits = primary.replace(/\D/g, '');
+  if (digits) return digits;
+
+  return primary;
+}
+
+function normalizeWhatsAppWhitelist(values) {
+  if (!Array.isArray(values)) return [];
+
+  const seen = new Set();
+  const normalized = [];
+  for (const value of values) {
+    const entry = normalizeWhatsAppId(value);
+    if (!entry || seen.has(entry)) continue;
+    seen.add(entry);
+    normalized.push(entry);
+  }
+  return normalized;
+}
+
+function toWhatsAppJid(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (raw.includes('@')) {
+    const jid = raw.split(':')[0];
+    if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@g.us') || jid.endsWith('@lid')) {
+      return jid;
+    }
+  }
+
+  const normalized = normalizeWhatsAppId(raw);
+  if (!normalized) return '';
+  return `${normalized}@s.whatsapp.net`;
+}
+
+module.exports = {
+  normalizeWhatsAppId,
+  normalizeWhatsAppWhitelist,
+  toWhatsAppJid,
+};