neoagent 2.1.18-beta.20 → 2.1.18-beta.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.18-beta.20",
+  "version": "2.1.18-beta.21",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"425cfb54d01a9472b3e81d9e76fd63a4a44cfb
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "3746008503" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "3528621237" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/messaging/automation.js

@@ -125,6 +125,7 @@ async function processQueuedMessage({
   queue.running = true;
   let stopTypingKeepalive = async () => {};
   try {
+    const runId = randomUUID();
     await messagingManager
       .markRead(userId, msg.platform, msg.chatId, msg.messageId, { agentId })
       .catch(() => {});
@@ -132,6 +133,7 @@ async function processQueuedMessage({
       messagingManager,
       userId,
       agentId,
+      runId,
       platform: msg.platform,
       chatId: msg.chatId
     });
@@ -139,6 +141,7 @@ async function processQueuedMessage({
     const prompt = buildIncomingPrompt(msg);
     const conversationId = ensureConversation(userId, msg);
     const runOptions = {
+      runId,
       agentId,
       triggerSource: 'messaging',
       conversationId,
@@ -180,6 +183,7 @@ function startTypingKeepalive({
   messagingManager,
   userId,
   agentId,
+  runId,
   platform,
   chatId,
   intervalMs = 4000
@@ -187,6 +191,26 @@ function startTypingKeepalive({
   let stopped = false;
   let timer = null;
   let releaseWait = null;
+  let stopPromise = null;
+
+  const matchesRunDelivery = (event) => (
+    event?.runId
+    && runId
+    && event.runId === runId
+    && event.userId === userId
+    && event.platform === platform
+    && event.to === chatId
+  );
+
+  const onMessageSent = (event) => {
+    if (matchesRunDelivery(event)) {
+      stop().catch(() => {});
+    }
+  };
+
+  if (typeof messagingManager?.on === 'function' && typeof messagingManager?.off === 'function') {
+    messagingManager.on('message_sent', onMessageSent);
+  }
 
   const wait = () =>
     new Promise((resolve) => {
@@ -205,21 +229,30 @@ function startTypingKeepalive({
     }
   })();
 
-  return async () => {
-    stopped = true;
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    if (releaseWait) {
-      releaseWait();
-      releaseWait = null;
-    }
-    await loop.catch(() => {});
-    await messagingManager
-      .sendTyping(userId, platform, chatId, false, { agentId })
-      .catch(() => {});
+  const stop = async () => {
+    if (stopPromise) return stopPromise;
+    stopPromise = (async () => {
+      if (typeof messagingManager?.off === 'function') {
+        messagingManager.off('message_sent', onMessageSent);
+      }
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (releaseWait) {
+        releaseWait();
+        releaseWait = null;
+      }
+      await loop.catch(() => {});
+      await messagingManager
+        .sendTyping(userId, platform, chatId, false, { agentId })
+        .catch(() => {});
+    })();
+    return stopPromise;
   };
+
+  return stop;
 }
 
 function ensureConversation(userId, msg) {
@@ -331,7 +364,12 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
   const shouldCheckWhitelist = whitelist.length > 0;
 
   if (!shouldCheckWhitelist) {
-    return true;
+    if (!msg.isGroup) return true;
+    console.log(
+      `[Messaging] Blocked ${msg.platform} group message from ${msg.sender} (no group allowlist configured)`
+    );
+    emitBlockedSenderSuggestion({ io, userId, msg });
+    return false;
   }
 
   const candidates = messagingAllowlistCandidates(msg).map(normalize).filter(Boolean);
@@ -346,6 +384,11 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
   console.log(
     `[Messaging] Blocked ${msg.platform} message from ${msg.sender} (not in whitelist)`
   );
+  emitBlockedSenderSuggestion({ io, userId, msg });
+  return false;
+}
+
+function emitBlockedSenderSuggestion({ io, userId, msg }) {
   const suggestions = [];
   if (msg.platform === 'whatsapp') {
     const normalizedSender = normalizeWhatsAppId(msg.sender || msg.chatId);
@@ -367,7 +410,7 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
     if (chatId && chatId !== sender) {
       suggestions.push({
         label: `Add chat (${chatId})`,
-        prefixedId: msg.isGroup ? `channel:${chatId}` : chatId
+        prefixedId: msg.isGroup ? `group:${chatId}` : chatId
       });
     }
   }
@@ -378,10 +421,10 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
     senderName: msg.senderName || null,
     suggestions: suggestions.length > 0 ? suggestions : null
   });
-  return false;
 }
 
 module.exports = {
   isAllowedMessagingSender,
-  registerMessagingAutomation
+  registerMessagingAutomation,
+  startTypingKeepalive
 };

package/server/services/messaging/discord.js

@@ -10,7 +10,7 @@ const {
 
 /**
  * Whitelist entry format (prefixed strings):
- *   "user:SNOWFLAKE"    → always respond, no mention needed (DMs + guild messages)
+ *   "user:SNOWFLAKE"    → allow DMs; allow guild messages only when @mentioned
  *   "guild:SNOWFLAKE"   → respond in any channel of this server when @mentioned
  *   "channel:SNOWFLAKE" → respond in this channel when @mentioned
  *   "SNOWFLAKE"         → legacy plain ID, treated as "user"
@@ -112,23 +112,25 @@ class DiscordPlatform extends BasePlatform {
 
   /** Returns {allowed, requireMention} */
   _checkAccess(message) {
-    // Default behavior with no allow-list: respond in DMs and require a mention in guilds.
-    if (this.allowedEntries.size === 0) {
-      const isDM = message.channel.type === ChannelType.DM;
-      return { allowed: true, requireMention: !isDM };
-    }
-
-    // Check prefixed entries
+    const isDM = message.channel.type === ChannelType.DM;
     const userId = message.author.id;
     const guildId = message.guildId || null;
     const channelId = message.channelId;
+    const userAllowed = super._checkAccess(`user:${userId}`) || super._checkAccess(userId);
 
-    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 (isDM) {
+      return {
+        allowed: this.allowedEntries.size === 0 || userAllowed,
+        requireMention: false,
+      };
+    }
 
-    return { allowed: false, requireMention: false };
+    return {
+      allowed: userAllowed
+        || (guildId && super._checkAccess(`guild:${guildId}`))
+        || super._checkAccess(`channel:${channelId}`),
+      requireMention: true,
+    };
   }
 
   _isMentioned(message) {
@@ -171,6 +173,8 @@ class DiscordPlatform extends BasePlatform {
 
     const { allowed, requireMention } = this._checkAccess(message);
 
+    if (requireMention && !this._isMentioned(message)) return;
+
     if (!allowed) {
       const suggestions = [
         { label: `Add user (${message.author.username})`, prefixedId: `user:${userId}` },
@@ -188,9 +192,6 @@ class DiscordPlatform extends BasePlatform {
       return;
     }
 
-    // guild/channel entries require @mention to activate
-    if (requireMention && !this._isMentioned(message)) return;
-
     let content = requireMention ? this._stripMention(message.content) : (message.content || '');
     if (message.attachments.size > 0) {
       const urls = [...message.attachments.values()].map(a => a.url).join(', ');
@@ -241,8 +242,9 @@ class DiscordPlatform extends BasePlatform {
     return { success: true };
   }
 
-  async sendTyping(chatId, _isTyping) {
+  async sendTyping(chatId, isTyping) {
     if (!this._client || this.status !== 'connected') return;
+    if (!isTyping) return;
     try {
       if (chatId.startsWith('dm_')) {
         const user = await this._client.users.fetch(chatId.slice(3));

package/server/services/messaging/http_platforms.js

@@ -282,19 +282,34 @@ class SlackPlatform extends BasePlatform {
 
     const event = body.event || body;
     if (event.type !== 'message' || event.subtype || !event.text) {
+      if (event.type !== 'app_mention') {
+        return { handled: true, status: 202, body: 'ignored' };
+      }
+    }
+    if (event.subtype || !event.text) {
       return { handled: true, status: 202, body: 'ignored' };
     }
     if (this._botUserId && event.user === this._botUserId) {
       return { handled: true, status: 202, body: 'ignored' };
     }
+    const isGroup = String(event.channel_type || '') !== 'im';
+    const wasMentioned = event.type === 'app_mention'
+      || (this._botUserId && String(event.text || '').includes(`<@${this._botUserId}>`));
+    if (isGroup && !wasMentioned) {
+      return { handled: true, status: 202, body: 'ignored' };
+    }
+    const content = this._botUserId
+      ? String(event.text).replace(new RegExp(`<@${this._botUserId}>`, 'g'), '').trim()
+      : String(event.text);
+    if (!content) return { handled: true, status: 202, body: 'ignored' };
     this.emit('message', {
       platform: 'slack',
       chatId: String(event.channel || 'slack'),
       sender: String(event.user || event.bot_id || 'slack'),
       senderName: event.username || null,
-      content: String(event.text),
+      content,
       mediaType: null,
-      isGroup: String(event.channel_type || '') !== 'im',
+      isGroup,
       messageId: String(event.client_msg_id || event.ts || crypto.randomUUID()),
       timestamp: event.event_ts ? new Date(Number(event.event_ts) * 1000).toISOString() : new Date().toISOString(),
       threadTs: event.thread_ts || null,
@@ -431,12 +446,17 @@ class MatrixPlatform extends BasePlatform {
         if (event.sender && this.userId && event.sender === this.userId) continue;
         const content = event.content?.body || '';
         if (!content) continue;
+        if (this.userId && !content.includes(this.userId)) continue;
+        const cleanContent = this.userId
+          ? String(content).replaceAll(this.userId, '').trim()
+          : String(content);
+        if (!cleanContent) continue;
         this.emit('message', {
           platform: 'matrix',
           chatId: roomId,
           sender: String(event.sender || roomId),
           senderName: event.sender || null,
-          content: String(content),
+          content: cleanContent,
           mediaType: null,
           isGroup: true,
           messageId: String(event.event_id || crypto.randomUUID()),
@@ -739,14 +759,23 @@ class IrcPlatform extends BasePlatform {
       if (!match) continue;
       const [, nick, target, content] = match;
       if (nick === this.nick) continue;
+      const isGroup = target.startsWith('#');
+      if (isGroup) {
+        const escaped = this.nick.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (!new RegExp(`(^|\\s)${escaped}[:,]?\\b`, 'i').test(content)) continue;
+      }
+      const cleanContent = isGroup
+        ? content.replace(new RegExp(`(^|\\s)${this.nick.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[:,]?\\s*`, 'i'), ' ').trim()
+        : content;
+      if (!cleanContent) continue;
       this.emit('message', {
         platform: this.name,
         chatId: target,
         sender: nick,
         senderName: nick,
-        content,
+        content: cleanContent,
         mediaType: null,
-        isGroup: target.startsWith('#'),
+        isGroup,
         messageId: crypto.randomUUID(),
         timestamp: new Date().toISOString(),
       });

package/server/services/messaging/manager.js

@@ -1,3 +1,4 @@
+const EventEmitter = require('events');
 const db = require('../../db/database');
 const fs = require('fs');
 const path = require('path');
@@ -62,8 +63,9 @@ class IMessageMessagingPlatform extends BlueBubblesPlatform {
   constructor(config = {}) { super('imessage', config); }
 }
 
-class MessagingManager {
+class MessagingManager extends EventEmitter {
   constructor(io) {
+    super();
     this.io = io;
     this.platforms = new Map();
     this.messageHandlers = [];
@@ -342,6 +344,17 @@ class MessagingManager {
       runId
     });
 
+    this.emit('message_sent', {
+      userId,
+      agentId,
+      platform: platformName,
+      to,
+      content,
+      mediaPath,
+      runId,
+      result
+    });
+
     return { success: true, result };
   }
 

package/server/services/messaging/telegram.js

@@ -100,33 +100,55 @@ class TelegramPlatform extends BasePlatform {
     const userId = String(msg.from.id);
     const chatId = String(msg.chat.id);
     const isPrivate = msg.chat.type === 'private';
+    const userAllowed = super._checkAccess(`user:${userId}`) || super._checkAccess(userId);
 
-    if (this.allowedEntries.size === 0) return { allowed: true, requireMention: !isPrivate };
-
-    if (super._checkAccess(`user:${userId}`)) return { allowed: true, requireMention: false };
-    if (super._checkAccess(userId)) return { allowed: true, requireMention: false };
-    if (super._checkAccess(`group:${chatId}`)) return { allowed: true, requireMention: true };
+    if (isPrivate) {
+      return {
+        allowed: this.allowedEntries.size === 0 || userAllowed,
+        requireMention: false,
+      };
+    }
 
-    return { allowed: false, requireMention: false };
+    return {
+      allowed: userAllowed || super._checkAccess(`group:${chatId}`),
+      requireMention: true,
+    };
   }
 
   _isMentioned(msg) {
     if (!this._botUser) return false;
     const text = msg.text || msg.caption || '';
     const entities = msg.entities || msg.caption_entities || [];
+    const botId = String(this._botUser.id || '');
+    const botUsername = String(this._botUser.username || '').toLowerCase();
+    const botMention = `@${botUsername}`;
     for (const e of entities) {
+      const value = text.slice(e.offset, e.offset + e.length).toLowerCase();
       if (e.type === 'mention') {
-        const mention = text.slice(e.offset, e.offset + e.length);
-        if (mention.toLowerCase() === `@${this._botUser.username.toLowerCase()}`) return true;
+        if (value === botMention) return true;
+      }
+      if (e.type === 'bot_command') {
+        if (value.endsWith(botMention)) return true;
       }
+      if (e.type === 'text_mention' && String(e.user?.id || '') === botId) {
+        return true;
+      }
+    }
+    if (msg.reply_to_message?.from && String(msg.reply_to_message.from.id || '') === botId) {
+      return true;
+    }
+    if (botUsername) {
+      const escaped = botUsername.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      if (new RegExp(`(^|\\s)@${escaped}\\b`, 'i').test(text)) return true;
     }
     return false;
   }
 
   _stripMention(text) {
     if (!this._botUser) return (text || '').trim();
+    const username = String(this._botUser.username || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     return (text || '')
-      .replace(new RegExp(`@${this._botUser.username}`, 'gi'), '')
+      .replace(new RegExp(`@${username}`, 'gi'), '')
       .replace(/\s{2,}/g, ' ')
       .trim();
   }
@@ -168,6 +190,8 @@ class TelegramPlatform extends BasePlatform {
 
     const { allowed, requireMention } = this._checkAccess(msg);
 
+    if (requireMention && !this._isMentioned(msg)) return;
+
     if (!allowed) {
       const suggestions = [
         { label: `Add user (${senderName})`, prefixedId: `user:${userId}` },
@@ -187,8 +211,6 @@ class TelegramPlatform extends BasePlatform {
       return;
     }
 
-    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'}]`;
@@ -235,8 +257,9 @@ class TelegramPlatform extends BasePlatform {
     return { success: true };
   }
 
-  async sendTyping(chatId, _isTyping) {
+  async sendTyping(chatId, isTyping) {
     if (!this._bot || this.status !== 'connected') return;
+    if (!isTyping) return;
     try {
       const id = chatId.startsWith('dm_') ? chatId.slice(3) : chatId;
       await this._bot.telegram.sendChatAction(id, 'typing');

package/server/services/messaging/whatsapp.js

@@ -1,7 +1,7 @@
 const { BasePlatform } = require('./base');
 const path = require('path');
 const fs = require('fs');
-const { toWhatsAppJid } = require('../../utils/whatsapp');
+const { normalizeWhatsAppId, toWhatsAppJid } = require('../../utils/whatsapp');
 const { DATA_DIR } = require('../../../runtime/paths');
 
 const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth');
@@ -18,6 +18,40 @@ class WhatsAppPlatform extends BasePlatform {
     this.authDir = config.authDir || AUTH_DIR;
   }
 
+  _ownIds() {
+    return new Set([
+      this.sock?.user?.id,
+      this.sock?.user?.jid,
+    ]
+      .map(normalizeWhatsAppId)
+      .filter(Boolean));
+  }
+
+  _contextInfo(message = {}) {
+    return message.extendedTextMessage?.contextInfo
+      || message.imageMessage?.contextInfo
+      || message.videoMessage?.contextInfo
+      || message.documentMessage?.contextInfo
+      || message.audioMessage?.contextInfo
+      || message.conversation?.contextInfo
+      || null;
+  }
+
+  _isGroupAddressedToBot(message = {}) {
+    const ownIds = this._ownIds();
+    if (ownIds.size === 0) return false;
+    const contextInfo = this._contextInfo(message);
+    const mentions = Array.isArray(contextInfo?.mentionedJid) ? contextInfo.mentionedJid : [];
+    if (mentions.some((jid) => ownIds.has(normalizeWhatsAppId(jid)))) return true;
+    if (ownIds.has(normalizeWhatsAppId(contextInfo?.participant))) return true;
+    const text = message.conversation
+      || message.extendedTextMessage?.text
+      || message.imageMessage?.caption
+      || message.videoMessage?.caption
+      || '';
+    return [...ownIds].some((id) => text.includes(`@${id}`));
+  }
+
   async connect() {
     if (!fs.existsSync(this.authDir)) fs.mkdirSync(this.authDir, { recursive: true });
 
@@ -133,6 +167,7 @@ class WhatsAppPlatform extends BasePlatform {
         }
 
         if (!content && !mediaType) continue;
+        if (isGroup && !this._isGroupAddressedToBot(msg.message || {})) continue;
 
         let localMediaPath = null;
         if (mediaType && mediaType !== 'sticker') {