neoagent 2.0.5 → 2.0.7

package/server/routes/settings.js

@@ -1,5 +1,6 @@
 const express = require('express');
 const fs = require('fs');
+const path = require('path');
 const router = express.Router();
 const db = require('../db/database');
 const { requireAuth } = require('../middleware/auth');
@@ -28,6 +29,17 @@ function readUpdateStatus() {
   }
 }
 
+function writeUpdateStatus(patch) {
+  const next = {
+    ...readUpdateStatus(),
+    ...patch,
+    updatedAt: new Date().toISOString()
+  };
+  fs.mkdirSync(path.dirname(UPDATE_STATUS_FILE), { recursive: true });
+  fs.writeFileSync(UPDATE_STATUS_FILE, JSON.stringify(next, null, 2));
+  return next;
+}
+
 // Get supported models metadata
 router.get('/meta/models', async (req, res) => {
   const { getSupportedModels } = require('../services/ai/models');
@@ -221,6 +233,16 @@ router.post('/update', (req, res) => {
     return res.status(409).json({ success: false, error: 'An update is already running' });
   }
   console.log('[Settings] Triggering update-runner...');
+  writeUpdateStatus({
+    state: 'running',
+    progress: 1,
+    phase: 'starting',
+    message: 'Launching update job',
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    changelog: [],
+    logs: []
+  });
 
   // Spawn detached runner so status survives server restarts.
   const child = spawn(process.execPath, ['scripts/update-runner.js'], {
@@ -229,6 +251,16 @@ router.post('/update', (req, res) => {
     cwd: APP_DIR
   });
 
+  child.once('error', (error) => {
+    writeUpdateStatus({
+      state: 'failed',
+      progress: 100,
+      phase: 'failed',
+      message: `Failed to launch update job: ${error.message}`,
+      completedAt: new Date().toISOString()
+    });
+  });
+
   child.unref();
   res.json({ success: true, message: 'Update triggered', pid: child.pid });
 });

package/server/services/messaging/automation.js

@@ -180,8 +180,7 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
     }
   }
 
-  const enforceEmptyWhitelist = msg.platform === 'whatsapp';
-  const shouldCheckWhitelist = whitelist.length > 0 || enforceEmptyWhitelist;
+  const shouldCheckWhitelist = whitelist.length > 0;
 
   if (!shouldCheckWhitelist) {
     return true;
@@ -196,11 +195,22 @@ async function isAllowedMessagingSender({ io, userId, msg }) {
   console.log(
     `[Messaging] Blocked ${msg.platform} message from ${msg.sender} (not in whitelist)`
   );
+  const suggestions = [];
+  if (msg.platform === 'whatsapp') {
+    const normalizedSender = normalizeWhatsAppId(msg.sender || msg.chatId);
+    if (normalizedSender) {
+      suggestions.push({
+        label: `Add sender (${msg.senderName || normalizedSender})`,
+        prefixedId: normalizedSender
+      });
+    }
+  }
   io.to(`user:${userId}`).emit('messaging:blocked_sender', {
     platform: msg.platform,
     sender: msg.sender,
     chatId: msg.chatId,
-    senderName: msg.senderName || null
+    senderName: msg.senderName || null,
+    suggestions: suggestions.length > 0 ? suggestions : null
   });
   return false;
 }

package/server/services/messaging/discord.js

@@ -65,6 +65,30 @@ class DiscordPlatform extends BasePlatform {
 
       this._client.once('error', (err) => { clearTimeout(timeout); reject(err); });
       this._client.on('error', (err) => console.error('[Discord] Client error:', err.message));
+      this._client.on('shardDisconnect', (event, shardId) => {
+        this.status = 'disconnected';
+        console.warn(`[Discord] Shard ${shardId} disconnected (${event?.code || 'unknown'})`);
+        this.emit('disconnected', {
+          manual: false,
+          shardId,
+          code: event?.code || null,
+          reason: event?.reason || null,
+        });
+      });
+      this._client.on('shardReconnecting', (shardId) => {
+        this.status = 'connecting';
+        console.log(`[Discord] Shard ${shardId} reconnecting`);
+      });
+      this._client.on('shardResume', (_replayedEvents, shardId) => {
+        this.status = 'connected';
+        console.log(`[Discord] Shard ${shardId} resumed`);
+        this.emit('connected');
+      });
+      this._client.on('invalidated', () => {
+        this.status = 'logged_out';
+        console.warn('[Discord] Session invalidated');
+        this.emit('logged_out');
+      });
       this._client.on('messageCreate', (msg) => this._handleMessage(msg));
 
       this._client.login(this.token).catch((err) => { clearTimeout(timeout); reject(err); });
@@ -88,8 +112,11 @@ class DiscordPlatform extends BasePlatform {
 
   /** Returns {allowed, requireMention} */
   _checkAccess(message) {
-    // Empty whitelist: block everyone (add via the allow popup)
-    if (this.allowedEntries.size === 0) return { allowed: false, requireMention: false };
+    // 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 userId = message.author.id;

package/server/services/messaging/telegram.js

@@ -86,8 +86,10 @@ class TelegramPlatform extends BasePlatform {
   _checkAccess(msg) {
     const userId = String(msg.from.id);
     const chatId = String(msg.chat.id); // negative for groups
+    const isPrivate = msg.chat.type === 'private';
 
-    if (this.allowedEntries.size === 0) return { allowed: false, requireMention: false };
+    // Default behavior with no allow-list: respond in private chats and require @mention in groups.
+    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 }; // legacy