neoagent 2.2.1-beta.7 → 2.3.0

package/server/services/messaging/http_platforms.js

@@ -217,6 +217,27 @@ class ConfigurableHttpPlatform extends BasePlatform {
     if (!inboundAllowed(this.config, req)) return { handled: false, status: 403, body: 'Forbidden' };
     const msg = genericMessageFromWebhook(this.name, this.config, req);
     if (!msg) return { handled: true, status: 202, body: 'ignored' };
+    const access = this._checkInboundAccess({
+      platform: this.name,
+      senderId: String(msg.sender || ''),
+      chatId: String(msg.chatId || ''),
+      isDirect: !msg.isGroup,
+      isShared: Boolean(msg.isGroup),
+      groupId: msg.isGroup ? String(msg.chatId || '') : '',
+      channelId: msg.isGroup ? String(msg.chatId || '') : '',
+      serverId: '',
+      roomId: msg.isGroup ? String(msg.chatId || '') : '',
+      roleIds: [],
+      phoneNumber: '',
+      wasMentioned: false,
+    }, {
+      senderName: msg.senderName || null,
+      meta: msg.isGroup ? `Chat: ${msg.chatId}` : '',
+      groupLabel: String(msg.chatId || ''),
+      channelLabel: String(msg.chatId || ''),
+      roomLabel: String(msg.chatId || ''),
+    });
+    if (!access.allowed) return { handled: true, status: 202, body: 'blocked' };
     this.emit('message', msg);
     return { handled: true, status: 200, body: 'OK' };
   }
@@ -318,7 +339,7 @@ class SlackPlatform extends BasePlatform {
       ? 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', {
+    const message = {
       platform: 'slack',
       chatId: String(event.channel || 'slack'),
       sender: String(event.user || event.bot_id || 'slack'),
@@ -332,7 +353,28 @@ class SlackPlatform extends BasePlatform {
       timestamp: event.event_ts ? new Date(Number(event.event_ts) * 1000).toISOString() : new Date().toISOString(),
       threadTs: event.thread_ts || null,
       rawMessage: body,
+      wasMentioned,
+    };
+    const access = this._checkInboundAccess({
+      platform: 'slack',
+      senderId: message.sender,
+      chatId: message.chatId,
+      isDirect: !isGroup,
+      isShared: isGroup,
+      groupId: isGroup ? message.chatId : '',
+      channelId: isGroup ? message.chatId : '',
+      serverId: '',
+      roomId: '',
+      roleIds: [],
+      phoneNumber: '',
+      wasMentioned,
+    }, {
+      senderName: message.senderName,
+      meta: isGroup ? `Channel: ${message.chatId}` : '',
+      channelLabel: message.chatId,
     });
+    if (!access.allowed) return { handled: true, status: 202, body: 'blocked' };
+    this.emit('message', message);
     return { handled: true, status: 200, body: 'OK' };
   }
 }
@@ -345,23 +387,43 @@ class GoogleChatPlatform extends ConfigurableHttpPlatform {
   async handleWebhook(req) {
     if (!inboundAllowed(this.config, req)) return { handled: false, status: 403, body: 'Forbidden' };
     const body = req.body || {};
-    const message = body.message || body;
-    const content = message.argumentText || message.text || body.text;
+    const incoming = body.message || body;
+    const content = incoming.argumentText || incoming.text || body.text;
     if (!content) return { handled: true, status: 202, body: 'ignored' };
-    this.emit('message', {
+    const message = {
       platform: 'google_chat',
-      chatId: String(message.space?.name || body.space?.name || this.config.defaultTo || 'google_chat'),
-      sender: String(body.user?.name || message.sender?.name || 'google_chat'),
-      senderName: body.user?.displayName || message.sender?.displayName || null,
-      senderDisplayName: body.user?.displayName || message.sender?.displayName || null,
-      senderTag: body.user?.name || message.sender?.name || null,
+      chatId: String(incoming.space?.name || body.space?.name || this.config.defaultTo || 'google_chat'),
+      sender: String(body.user?.name || incoming.sender?.name || 'google_chat'),
+      senderName: body.user?.displayName || incoming.sender?.displayName || null,
+      senderDisplayName: body.user?.displayName || incoming.sender?.displayName || null,
+      senderTag: body.user?.name || incoming.sender?.name || null,
       content: String(content),
       mediaType: null,
       isGroup: true,
-      messageId: String(message.name || crypto.randomUUID()),
+      messageId: String(incoming.name || crypto.randomUUID()),
       timestamp: new Date().toISOString(),
       rawMessage: body,
+    };
+    const access = this._checkInboundAccess({
+      platform: 'google_chat',
+      senderId: message.sender,
+      chatId: message.chatId,
+      isDirect: false,
+      isShared: true,
+      groupId: '',
+      channelId: '',
+      serverId: '',
+      roomId: message.chatId,
+      roleIds: [],
+      phoneNumber: '',
+      wasMentioned: false,
+    }, {
+      senderName: message.senderName,
+      meta: `Space: ${message.chatId}`,
+      roomLabel: message.chatId,
     });
+    if (!access.allowed) return { handled: true, status: 202, body: 'blocked' };
+    this.emit('message', message);
     return { handled: true, status: 200, body: { text: 'Received.' } };
   }
 }
@@ -376,7 +438,7 @@ class TeamsPlatform extends ConfigurableHttpPlatform {
     const body = req.body || {};
     const content = body.text || body.message?.text || body.value?.text;
     if (!content) return { handled: true, status: 202, body: 'ignored' };
-    this.emit('message', {
+    const message = {
       platform: 'teams',
       chatId: String(body.conversation?.id || body.channelData?.channel?.id || this.config.defaultTo || 'teams'),
       sender: String(body.from?.id || 'teams'),
@@ -389,7 +451,27 @@ class TeamsPlatform extends ConfigurableHttpPlatform {
       messageId: String(body.id || crypto.randomUUID()),
       timestamp: body.timestamp || new Date().toISOString(),
       rawMessage: body,
+    };
+    const access = this._checkInboundAccess({
+      platform: 'teams',
+      senderId: message.sender,
+      chatId: message.chatId,
+      isDirect: false,
+      isShared: true,
+      groupId: '',
+      channelId: message.chatId,
+      serverId: '',
+      roomId: '',
+      roleIds: [],
+      phoneNumber: '',
+      wasMentioned: false,
+    }, {
+      senderName: message.senderName,
+      meta: `Conversation: ${message.chatId}`,
+      channelLabel: message.chatId,
     });
+    if (!access.allowed) return { handled: true, status: 202, body: 'blocked' };
+    this.emit('message', message);
     return { handled: true, status: 200, body: { type: 'message', text: 'Received.' } };
   }
 }
@@ -473,7 +555,7 @@ class MatrixPlatform extends BasePlatform {
           ? String(content).replaceAll(this.userId, '').trim()
           : String(content);
         if (!cleanContent) continue;
-        this.emit('message', {
+        const message = {
           platform: 'matrix',
           chatId: roomId,
           sender: String(event.sender || roomId),
@@ -486,7 +568,27 @@ class MatrixPlatform extends BasePlatform {
           messageId: String(event.event_id || crypto.randomUUID()),
           timestamp: event.origin_server_ts ? new Date(event.origin_server_ts).toISOString() : new Date().toISOString(),
           rawMessage: event,
+        };
+        const access = this._checkInboundAccess({
+          platform: 'matrix',
+          senderId: message.sender,
+          chatId: message.chatId,
+          isDirect: false,
+          isShared: true,
+          groupId: '',
+          channelId: '',
+          serverId: '',
+          roomId: roomId,
+          roleIds: [],
+          phoneNumber: '',
+          wasMentioned: this.userId ? String(content).includes(this.userId) : false,
+        }, {
+          senderName: message.senderName,
+          meta: `Room: ${roomId}`,
+          roomLabel: roomId,
         });
+        if (!access.allowed) continue;
+        this.emit('message', message);
       }
     }
   }
@@ -574,7 +676,7 @@ class SignalPlatform extends ConfigurableHttpPlatform {
       const dataMessage = envelope.dataMessage || {};
       const content = dataMessage.message || '';
       if (!content) continue;
-      this.emit('message', {
+      const message = {
         platform: 'signal',
         chatId: String(envelope.sourceNumber || envelope.source || 'signal'),
         sender: String(envelope.sourceNumber || envelope.source || 'signal'),
@@ -587,7 +689,27 @@ class SignalPlatform extends ConfigurableHttpPlatform {
         messageId: String(envelope.timestamp || crypto.randomUUID()),
         timestamp: envelope.timestamp ? new Date(Number(envelope.timestamp)).toISOString() : new Date().toISOString(),
         rawMessage: item,
+      };
+      const access = this._checkInboundAccess({
+        platform: 'signal',
+        senderId: message.sender,
+        chatId: message.chatId,
+        isDirect: !message.isGroup,
+        isShared: message.isGroup,
+        groupId: message.isGroup ? message.chatId : '',
+        channelId: '',
+        serverId: '',
+        roomId: '',
+        roleIds: [],
+        phoneNumber: message.sender,
+        wasMentioned: false,
+      }, {
+        senderName: message.senderName,
+        meta: message.isGroup ? `Group: ${message.chatId}` : '',
+        groupLabel: message.chatId,
       });
+      if (!access.allowed) continue;
+      this.emit('message', message);
     }
   }
 
@@ -640,7 +762,7 @@ class LinePlatform extends ConfigurableHttpPlatform {
     for (const event of events) {
       const content = event.message?.text || '';
       if (!content) continue;
-      this.emit('message', {
+      const message = {
         platform: 'line',
         chatId: String(event.source?.groupId || event.source?.roomId || event.source?.userId || 'line'),
         sender: String(event.source?.userId || 'line'),
@@ -652,7 +774,28 @@ class LinePlatform extends ConfigurableHttpPlatform {
         messageId: String(event.message?.id || event.webhookEventId || crypto.randomUUID()),
         timestamp: event.timestamp ? new Date(Number(event.timestamp)).toISOString() : new Date().toISOString(),
         rawMessage: event,
+      };
+      const access = this._checkInboundAccess({
+        platform: 'line',
+        senderId: message.sender,
+        chatId: message.chatId,
+        isDirect: !message.isGroup,
+        isShared: message.isGroup,
+        groupId: event.source?.groupId ? String(event.source.groupId) : '',
+        channelId: '',
+        serverId: '',
+        roomId: event.source?.roomId ? String(event.source.roomId) : '',
+        roleIds: [],
+        phoneNumber: '',
+        wasMentioned: false,
+      }, {
+        senderName: message.senderName,
+        meta: event.source?.groupId ? `Group: ${event.source.groupId}` : (event.source?.roomId ? `Room: ${event.source.roomId}` : ''),
+        groupLabel: event.source?.groupId ? String(event.source.groupId) : '',
+        roomLabel: event.source?.roomId ? String(event.source.roomId) : '',
       });
+      if (!access.allowed) continue;
+      this.emit('message', message);
     }
     return { handled: true, status: 200, body: 'OK' };
   }
@@ -795,7 +938,7 @@ class IrcPlatform extends BasePlatform {
         ? content.replace(new RegExp(`(^|\\s)${this.nick.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[:,]?\\s*`, 'i'), ' ').trim()
         : content;
       if (!cleanContent) continue;
-      this.emit('message', {
+      const message = {
         platform: this.name,
         chatId: target,
         sender: nick,
@@ -807,7 +950,27 @@ class IrcPlatform extends BasePlatform {
         isGroup,
         messageId: crypto.randomUUID(),
         timestamp: new Date().toISOString(),
+      };
+      const access = this._checkInboundAccess({
+        platform: this.name,
+        senderId: nick,
+        chatId: target,
+        isDirect: !isGroup,
+        isShared: isGroup,
+        groupId: '',
+        channelId: isGroup ? target : '',
+        serverId: '',
+        roomId: '',
+        roleIds: [],
+        phoneNumber: '',
+        wasMentioned: !isGroup || new RegExp(`(^|\\s)${this.nick.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}[:,]?\\b`, 'i').test(content),
+      }, {
+        senderName: nick,
+        meta: isGroup ? `Channel: ${target}` : '',
+        channelLabel: target,
       });
+      if (!access.allowed) continue;
+      this.emit('message', message);
     }
   }
 

package/server/services/messaging/manager.js

@@ -22,29 +22,17 @@ const {
   createGenericPlatformClass,
 } = require('./http_platforms');
 const { normalizeOutgoingMessageForPlatform } = require('./formatting_guides');
-
-const GENERIC_ALLOWLIST_PLATFORMS = new Set([
-  'slack',
-  'google_chat',
-  'teams',
-  'matrix',
-  'signal',
-  'imessage',
-  'bluebubbles',
-  'irc',
-  'feishu',
-  'line',
-  'mattermost',
-  'nextcloud_talk',
-  'nostr',
-  'synology_chat',
-  'tlon',
-  'twitch',
-  'zalo',
-  'zalo_personal',
-  'wechat',
-  'webchat',
-]);
+const {
+  accessPolicyKey,
+  legacyWhitelistKey,
+  getPlatformAccessCapabilities,
+  normalizeAccessPolicy,
+  migrateLegacyWhitelist,
+  parseStoredAccessPolicy,
+  evaluateAccessPolicy,
+  summarizeAccessPolicy,
+  classifyRecentTarget,
+} = require('./access_policy');
 
 const LEGACY_WHATSAPP_AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth');
 
@@ -70,6 +58,7 @@ class MessagingManager extends EventEmitter {
     this.io = io;
     this.voiceRuntimeManager = options.voiceRuntimeManager || null;
     this.platforms = new Map();
+    this.accessSuggestions = new Map();
     this.messageHandlers = [];
     this.isShuttingDown = false;
     this.platformTypes = {
@@ -176,6 +165,41 @@ class MessagingManager extends EventEmitter {
       .get(userId, key);
   }
 
+  _upsertSetting(userId, agentId, key, value) {
+    db.prepare(
+      `INSERT INTO agent_settings (user_id, agent_id, key, value)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(user_id, agent_id, key) DO UPDATE SET value = excluded.value`
+    ).run(userId, agentId, key, JSON.stringify(value));
+  }
+
+  _accessSuggestionKey(userId, agentId, platformName) {
+    return `${userId}:${agentId}:${platformName}:access-suggestions`;
+  }
+
+  _rememberAccessSuggestions(userId, agentId, platformName, suggestions = []) {
+    if (!Array.isArray(suggestions) || suggestions.length === 0) return;
+    const key = this._accessSuggestionKey(userId, agentId, platformName);
+    const existing = this.accessSuggestions.get(key) || [];
+    const merged = [...suggestions, ...existing].filter((item) => item && item.rule && item.bucket);
+    const unique = [];
+    const seen = new Set();
+    for (const item of merged) {
+      const id = `${item.bucket}:${item.rule.scope}:${item.rule.value}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      unique.push(item);
+      if (unique.length >= 24) break;
+    }
+    this.accessSuggestions.set(key, unique);
+  }
+
+  _loadAccessPolicy(userId, agentId, platformName) {
+    const policyRow = this._setting(userId, agentId, accessPolicyKey(platformName));
+    const legacyRow = this._setting(userId, agentId, legacyWhitelistKey(platformName));
+    return parseStoredAccessPolicy(platformName, policyRow?.value, legacyRow?.value);
+  }
+
   _scopedPlatformAuthDir(userId, agentId, platformName) {
     return path.join(
       AGENT_DATA_DIR,
@@ -249,6 +273,7 @@ class MessagingManager extends EventEmitter {
     config = { ...(config || {}) };
     config.userId = userId;
     config.agentId = agentId;
+    config.accessPolicy = this._loadAccessPolicy(userId, agentId, platformName);
     const PlatformClass = this.platformTypes[platformName];
     if (!PlatformClass) throw new Error(`Unknown platform: ${platformName}`);
 
@@ -268,10 +293,6 @@ class MessagingManager extends EventEmitter {
         }
       };
 
-      const wlRow = this._setting(userId, agentId, 'platform_whitelist_telnyx');
-      if (wlRow) {
-        try { config.allowedNumbers = JSON.parse(wlRow.value); } catch { /* ignore */ }
-      }
       const secretRow = this._setting(userId, agentId, 'platform_voice_secret_telnyx');
       if (secretRow) {
         try { config.voiceSecret = JSON.parse(secretRow.value); } catch { config.voiceSecret = secretRow.value; }
@@ -301,32 +322,6 @@ class MessagingManager extends EventEmitter {
       config.voiceRuntimeManager = this.voiceRuntimeManager || null;
     }
 
-    // Inject saved allowlists for platforms that enforce access in the adapter.
-    if (platformName === 'discord') {
-      const wlRow = this._setting(userId, agentId, '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 = this._setting(userId, agentId, 'platform_whitelist_telegram');
-      if (wlRow) {
-        try { config.allowedIds = JSON.parse(wlRow.value); } catch { /* ignore */ }
-      }
-    }
-
-    if (GENERIC_ALLOWLIST_PLATFORMS.has(platformName)) {
-      const wlRow = this._setting(userId, agentId, `platform_whitelist_${platformName}`);
-      if (wlRow) {
-        try {
-          const parsed = JSON.parse(wlRow.value);
-          if (Array.isArray(parsed)) config.allowedIds = parsed;
-        } catch { /* ignore */ }
-      }
-    }
-
     const storedConfig = JSON.stringify(this._persistableConfig(config) || {});
 
     const key = this._key(userId, agentId, platformName);
@@ -373,22 +368,26 @@ class MessagingManager extends EventEmitter {
 
     // Telnyx-specific: blocked inbound caller notification
     platform.on('blocked_caller', (info) => {
+      this._rememberAccessSuggestions(userId, agentId, platformName, info?.suggestions || []);
       this.io.to(`user:${userId}`).emit('messaging:blocked_sender', {
         platform: platformName,
         sender: info.caller,
         chatId: info.ccId,
-        senderName: null
+        senderName: null,
+        meta: info.meta || '',
+        suggestions: info.suggestions || null,
       });
     });
 
-    // Discord / Telegram: blocked sender notification with suggestions
+    // Adapter-level blocked sender notification with suggestions
     platform.on('blocked_sender', (info) => {
+      this._rememberAccessSuggestions(userId, agentId, platformName, info?.suggestions || []);
       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),
+        meta: info.meta || (info.guildName ? `Server: ${info.guildName}` : (info.groupName ? `Group: ${info.groupName}` : null)),
         suggestions: info.suggestions || null,
       });
     });
@@ -679,13 +678,88 @@ class MessagingManager extends EventEmitter {
     };
   }
 
+  getAccessPolicy(userId, platformName, options = {}) {
+    const agentId = this._agentId(userId, options);
+    return this._loadAccessPolicy(userId, agentId, platformName);
+  }
+
+  setAccessPolicy(userId, platformName, policy, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const normalized = normalizeAccessPolicy(platformName, policy);
+    this._upsertSetting(userId, agentId, accessPolicyKey(platformName), normalized);
+    const key = this._key(userId, agentId, platformName);
+    const platform = this.platforms.get(key);
+    if (platform?.setAccessPolicy) {
+      platform.setAccessPolicy(normalized);
+    }
+    return normalized;
+  }
+
+  evaluateAccess(userId, platformName, context, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const key = this._key(userId, agentId, platformName);
+    const platform = this.platforms.get(key);
+    if (platform?.evaluateAccess) {
+      return platform.evaluateAccess(context);
+    }
+    return evaluateAccessPolicy(
+      this._loadAccessPolicy(userId, agentId, platformName),
+      context,
+      platformName,
+    );
+  }
+
+  async getAccessCatalog(userId, platformName, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const key = this._key(userId, agentId, platformName);
+    const platform = this.platforms.get(key);
+    let discoveredTargets = [];
+    if (platform?.listAccessTargets) {
+      discoveredTargets = await Promise.resolve(platform.listAccessTargets()).catch(() => []);
+    }
+
+    const recentRows = db.prepare(
+      `SELECT platform_chat_id, metadata
+       FROM messages
+       WHERE user_id = ? AND agent_id = ? AND platform = ? AND platform_chat_id IS NOT NULL
+       ORDER BY id DESC
+       LIMIT 40`
+    ).all(userId, agentId, platformName);
+    const recentTargets = recentRows
+      .map((row) => {
+        let metadata = {};
+        try {
+          metadata = row.metadata ? JSON.parse(row.metadata) : {};
+        } catch {
+          metadata = {};
+        }
+        return classifyRecentTarget(platformName, { ...row, metadata });
+      })
+      .filter(Boolean);
+
+    const seen = new Set();
+    const unique = (items) => items.filter((item) => {
+      const keyValue = `${item.bucket}:${item.scope}:${item.value}`;
+      if (seen.has(keyValue)) return false;
+      seen.add(keyValue);
+      return true;
+    });
+
+    return {
+      capabilities: getPlatformAccessCapabilities(platformName),
+      discoveredTargets: unique([...(Array.isArray(discoveredTargets) ? discoveredTargets : []), ...recentTargets]),
+      suggestedTargets: unique(this.accessSuggestions.get(this._accessSuggestionKey(userId, agentId, platformName)) || []),
+      policy: this._loadAccessPolicy(userId, agentId, platformName),
+      summary: summarizeAccessPolicy(platformName, this._loadAccessPolicy(userId, agentId, platformName)),
+    };
+  }
+
   /**
    * Update the allowed-numbers list on a live Telnyx platform instance.
    */
   updateTelnyxAllowedNumbers(userId, numbers, options = {}) {
-    const key = this._key(userId, this._agentId(userId, options), 'telnyx');
-    const platform = this.platforms.get(key);
-    if (platform?.setAllowedNumbers) platform.setAllowedNumbers(numbers);
+    const migrated = migrateLegacyWhitelist('telnyx', numbers);
+    return this.setAccessPolicy(userId, 'telnyx', migrated, options);
   }
 
   /**
@@ -710,10 +784,7 @@ class MessagingManager extends EventEmitter {
    * Accepts prefixed strings: "user:ID", "guild:ID", "channel:ID"
    */
   updateDiscordAllowedIds(userId, ids, options = {}) {
-    const key = this._key(userId, this._agentId(userId, options), 'discord');
-    const platform = this.platforms.get(key);
-    if (platform?.setAllowedEntries) platform.setAllowedEntries(ids);
-    else if (platform?.setAllowedIds) platform.setAllowedIds(ids); // legacy fallback
+    return this.setAccessPolicy(userId, 'discord', migrateLegacyWhitelist('discord', ids), options);
   }
 
   /**
@@ -721,15 +792,11 @@ class MessagingManager extends EventEmitter {
    * Accepts prefixed strings: "user:ID", "group:ID"
    */
   updateTelegramAllowedIds(userId, ids, options = {}) {
-    const key = this._key(userId, this._agentId(userId, options), 'telegram');
-    const platform = this.platforms.get(key);
-    if (platform?.setAllowedEntries) platform.setAllowedEntries(ids);
+    return this.setAccessPolicy(userId, 'telegram', migrateLegacyWhitelist('telegram', ids), options);
   }
 
   updateAllowedEntries(userId, platformName, ids, options = {}) {
-    const key = this._key(userId, this._agentId(userId, options), platformName);
-    const platform = this.platforms.get(key);
-    if (platform?.setAllowedEntries) platform.setAllowedEntries(ids);
+    return this.setAccessPolicy(userId, platformName, migrateLegacyWhitelist(platformName, ids), options);
   }
 }