neoagent 2.1.18-beta.92 → 2.1.18-beta.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.18-beta.92",
+  "version": "2.1.18-beta.94",
   "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":"59aa584fdf100e6c78c785d8a5b565d1de4b48
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "2746919848" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "769435206" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/integrations/google/common.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { TextDecoder } = require('util');
 
 function bufferToBase64Url(buffer) {
   return Buffer.from(buffer)
@@ -15,13 +16,125 @@ function stringToBase64Url(text) {
   return bufferToBase64Url(Buffer.from(String(text || ''), 'utf8'));
 }
 
-function base64UrlToString(value) {
-  if (!value) return '';
-  const normalized = String(value)
+function base64UrlToBuffer(value) {
+  if (!value) return Buffer.alloc(0);
+  const raw = String(value);
+  const normalized = raw
     .replace(/-/g, '+')
     .replace(/_/g, '/')
-    .padEnd(Math.ceil(String(value).length / 4) * 4, '=');
-  return Buffer.from(normalized, 'base64').toString('utf8');
+    .padEnd(Math.ceil(raw.length / 4) * 4, '=');
+  return Buffer.from(normalized, 'base64');
+}
+
+function normalizeCharset(charset) {
+  const normalized = String(charset || 'utf-8').trim().toLowerCase();
+  if (!normalized) return 'utf-8';
+  if (normalized === 'utf8') return 'utf-8';
+  if (normalized === 'us-ascii') return 'ascii';
+  if (
+    normalized === 'latin1'
+    || normalized === 'latin-1'
+    || normalized === 'iso-8859-1'
+    || normalized === 'iso8859-1'
+  ) {
+    return 'windows-1252';
+  }
+  return normalized;
+}
+
+function decodeBytes(buffer, charset = 'utf-8') {
+  const bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer || '');
+  const candidates = [
+    normalizeCharset(charset),
+    'utf-8',
+    'windows-1252',
+  ];
+  for (const candidate of candidates) {
+    try {
+      return new TextDecoder(candidate, { fatal: false }).decode(bytes);
+    } catch {}
+  }
+  return bytes.toString('utf8');
+}
+
+function mojibakeScore(value) {
+  const text = String(value || '');
+  let score = 0;
+  for (const char of text) {
+    if (char === '\uFFFD') score += 4;
+    else if (char === 'Ã' || char === 'Â') score += 3;
+    else if (char === 'â' || char === 'ð' || char === 'ï') score += 2;
+  }
+  return score;
+}
+
+function repairMojibake(value) {
+  let current = String(value || '');
+  for (let i = 0; i < 2; i += 1) {
+    if (mojibakeScore(current) === 0) break;
+    const repaired = Buffer.from(current, 'latin1').toString('utf8');
+    if (!repaired || mojibakeScore(repaired) >= mojibakeScore(current)) break;
+    current = repaired;
+  }
+  return current;
+}
+
+function base64UrlToString(value) {
+  return repairMojibake(decodeBytes(base64UrlToBuffer(value), 'utf-8'));
+}
+
+function parseCharset(value) {
+  const match = /charset\s*=\s*("?)([^";\s]+)\1/i.exec(String(value || ''));
+  return match?.[2] || 'utf-8';
+}
+
+function decodeQuotedPrintableToBuffer(value) {
+  const cleaned = String(value || '').replace(/=\r?\n/g, '');
+  const bytes = [];
+  for (let i = 0; i < cleaned.length; i += 1) {
+    const char = cleaned[i];
+    if (
+      char === '='
+      && i + 2 < cleaned.length
+      && /^[0-9A-Fa-f]{2}$/.test(cleaned.slice(i + 1, i + 3))
+    ) {
+      bytes.push(Number.parseInt(cleaned.slice(i + 1, i + 3), 16));
+      i += 2;
+      continue;
+    }
+    bytes.push(char.charCodeAt(0));
+  }
+  return Buffer.from(bytes);
+}
+
+function decodeMimeWord(charset, encoding, value) {
+  const normalizedEncoding = String(encoding || '').trim().toUpperCase();
+  if (normalizedEncoding === 'B') {
+    return repairMojibake(
+      decodeBytes(Buffer.from(String(value || ''), 'base64'), charset),
+    );
+  }
+  if (normalizedEncoding === 'Q') {
+    return repairMojibake(
+      decodeBytes(
+        decodeQuotedPrintableToBuffer(String(value || '').replace(/_/g, ' ')),
+        charset,
+      ),
+    );
+  }
+  return String(value || '');
+}
+
+function decodeMimeWords(value) {
+  return String(value || '').replace(
+    /=\?([^?]+)\?([bqBQ])\?([^?]*)\?=/g,
+    (_, charset, encoding, encodedText) =>
+      decodeMimeWord(charset, encoding, encodedText),
+  );
+}
+
+function normalizeDecodedText(value) {
+  return repairMojibake(decodeMimeWords(value));
 }
 
 function getHeader(headers, name) {
@@ -31,7 +144,7 @@ function getHeader(headers, name) {
         (header) => String(header?.name || '').toLowerCase() === normalized,
       )
     : null;
-  return match?.value || null;
+  return match ? normalizeDecodedText(match.value) : null;
 }
 
 function stripHtml(html) {
@@ -45,11 +158,23 @@ function stripHtml(html) {
 
 function extractMessageBody(payload) {
   if (!payload) return '';
+  const headers = Array.isArray(payload.headers) ? payload.headers : [];
+  const contentType = getHeader(headers, 'Content-Type') || '';
+  const transferEncoding = (getHeader(headers, 'Content-Transfer-Encoding') || '').toLowerCase();
+  const charset = parseCharset(contentType);
   if (payload.body?.data && payload.mimeType === 'text/plain') {
-    return base64UrlToString(payload.body.data);
+    const raw = base64UrlToBuffer(payload.body.data);
+    const decoded = transferEncoding.includes('quoted-printable')
+      ? decodeBytes(decodeQuotedPrintableToBuffer(raw.toString('latin1')), charset)
+      : decodeBytes(raw, charset);
+    return normalizeDecodedText(decoded);
   }
   if (payload.body?.data && payload.mimeType === 'text/html') {
-    return stripHtml(base64UrlToString(payload.body.data));
+    const raw = base64UrlToBuffer(payload.body.data);
+    const decoded = transferEncoding.includes('quoted-printable')
+      ? decodeBytes(decodeQuotedPrintableToBuffer(raw.toString('latin1')), charset)
+      : decodeBytes(raw, charset);
+    return stripHtml(normalizeDecodedText(decoded));
   }
   if (!Array.isArray(payload.parts)) return '';
 
@@ -135,11 +260,13 @@ async function executeGoogleApiRequest(auth, args, options = {}) {
 }
 
 module.exports = {
+  base64UrlToBuffer,
   coerceStringList,
   ensureParentDir,
   executeGoogleApiRequest,
   extractMessageBody,
   getHeader,
+  normalizeDecodedText,
   stringToBase64Url,
   summarizeFile,
 };

package/server/services/integrations/google/gmail.js

@@ -6,6 +6,7 @@ const {
   executeGoogleApiRequest,
   extractMessageBody,
   getHeader,
+  normalizeDecodedText,
   stringToBase64Url,
 } = require('./common');
 
@@ -150,7 +151,7 @@ function summarizeMessage(message) {
     id: message.id,
     threadId: message.threadId,
     labelIds: Array.isArray(message.labelIds) ? message.labelIds : [],
-    snippet: message.snippet || '',
+    snippet: normalizeDecodedText(message.snippet || ''),
     internalDate: message.internalDate
       ? new Date(Number(message.internalDate)).toISOString()
       : null,
@@ -218,7 +219,7 @@ async function executeGmailTool(toolName, args, auth) {
               : null;
           return {
             id: thread.id || '',
-            snippet: thread.snippet || '',
+            snippet: normalizeDecodedText(thread.snippet || ''),
             historyId: thread.historyId || null,
             messageCount: Array.isArray(thread.messages)
               ? thread.messages.length
@@ -242,7 +243,7 @@ async function executeGmailTool(toolName, args, auth) {
       return {
         id: thread.id || '',
         historyId: thread.historyId || null,
-        snippet: thread.snippet || '',
+        snippet: normalizeDecodedText(thread.snippet || ''),
         messages: (Array.isArray(thread.messages) ? thread.messages : []).map(
           summarizeMessage,
         ),

package/server/services/messaging/discord.js

@@ -32,6 +32,7 @@ class DiscordPlatform extends BasePlatform {
 
     this._client = null;
     this._botUser = null;
+    this._manualDisconnect = false;
   }
 
   // ── Lifecycle ──────────────────────────────────────────────────────────────
@@ -39,6 +40,7 @@ class DiscordPlatform extends BasePlatform {
   async connect() {
     if (!this.token) throw new Error('Discord bot token is required');
 
+    this._manualDisconnect = false;
     if (this._client) { try { this._client.destroy(); } catch { } this._client = null; }
 
     this._client = new Client({
@@ -66,6 +68,7 @@ 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) => {
+        if (this._manualDisconnect) return;
         this.status = 'disconnected';
         console.warn(`[Discord] Shard ${shardId} disconnected (${event?.code || 'unknown'})`);
         this.emit('disconnected', {
@@ -76,15 +79,18 @@ class DiscordPlatform extends BasePlatform {
         });
       });
       this._client.on('shardReconnecting', (shardId) => {
+        if (this._manualDisconnect) return;
         this.status = 'connecting';
         console.log(`[Discord] Shard ${shardId} reconnecting`);
       });
       this._client.on('shardResume', (_replayedEvents, shardId) => {
+        if (this._manualDisconnect) return;
         this.status = 'connected';
         console.log(`[Discord] Shard ${shardId} resumed`);
         this.emit('connected');
       });
       this._client.on('invalidated', () => {
+        if (this._manualDisconnect) return;
         this.status = 'logged_out';
         console.warn('[Discord] Session invalidated');
         this.emit('logged_out');
@@ -96,6 +102,7 @@ class DiscordPlatform extends BasePlatform {
   }
 
   async disconnect() {
+    this._manualDisconnect = true;
     if (this._client) { try { this._client.destroy(); } catch { } this._client = null; }
     this.status = 'disconnected';
     this._botUser = null;

package/server/services/messaging/manager.js

@@ -107,6 +107,10 @@ class MessagingManager extends EventEmitter {
   }
 
   async ingestMessage(userId, platformName, msg, options = {}) {
+    if (this.isShuttingDown) {
+      return null;
+    }
+
     const agentId = this._agentId(userId, {
       ...options,
       agentId: options?.agentId ?? msg?.agentId ?? null,
@@ -136,9 +140,16 @@ class MessagingManager extends EventEmitter {
 
     const enrichedMsg = { ...msg, agentId, platform: platformName };
 
+    if (this.isShuttingDown) {
+      return enrichedMsg;
+    }
+
     this.io.to(`user:${userId}`).emit('messaging:message', enrichedMsg);
 
     for (const handler of this.messageHandlers) {
+      if (this.isShuttingDown) {
+        break;
+      }
       try {
         await handler(userId, enrichedMsg);
       } catch (err) {
@@ -332,14 +343,14 @@ class MessagingManager extends EventEmitter {
     const currentPlatform = () => this.platforms.get(key) === platform;
 
     platform.on('qr', (qr) => {
-      if (!currentPlatform()) return;
+      if (!currentPlatform() || this.isShuttingDown) return;
       this.io.to(`user:${userId}`).emit('messaging:qr', { agentId, platform: platformName, qr });
       db.prepare('UPDATE platform_connections SET status = ?, config = ? WHERE user_id = ? AND agent_id = ? AND platform = ?')
         .run('awaiting_qr', storedConfig, userId, agentId, platformName);
     });
 
     platform.on('connected', () => {
-      if (!currentPlatform()) return;
+      if (!currentPlatform() || this.isShuttingDown) return;
       this.io.to(`user:${userId}`).emit('messaging:connected', { agentId, platform: platformName });
       db.prepare('UPDATE platform_connections SET status = ?, last_connected = datetime(\'now\') WHERE user_id = ? AND agent_id = ? AND platform = ?')
         .run('connected', userId, agentId, platformName);
@@ -355,7 +366,7 @@ class MessagingManager extends EventEmitter {
     });
 
     platform.on('logged_out', () => {
-      if (!currentPlatform()) return;
+      if (!currentPlatform() || this.isShuttingDown) return;
       this.io.to(`user:${userId}`).emit('messaging:logged_out', { agentId, platform: platformName });
       db.prepare('UPDATE platform_connections SET status = ? WHERE user_id = ? AND agent_id = ? AND platform = ?')
         .run('logged_out', userId, agentId, platformName);
@@ -385,6 +396,7 @@ class MessagingManager extends EventEmitter {
     });
 
     platform.on('message', async (msg) => {
+      if (this.isShuttingDown) return;
       await this.ingestMessage(userId, platformName, msg, { agentId });
     });
 

package/server/services/messaging/telegram.js

@@ -18,6 +18,7 @@ class TelegramPlatform extends BasePlatform {
     this._botUser = null;
     this._contextBuffers = new Map();
     this._contextMaxSize = 25;
+    this._contextMaxChats = 200;
   }
 
   async connect() {
@@ -89,6 +90,7 @@ class TelegramPlatform extends BasePlatform {
     }
     this.status = 'disconnected';
     this._botUser = null;
+    this._contextBuffers.clear();
     this.emit('disconnected', { manual: true });
   }
 
@@ -158,6 +160,16 @@ class TelegramPlatform extends BasePlatform {
     const buf = this._contextBuffers.get(rawChatId);
     buf.push(entry);
     if (buf.length > this._contextMaxSize) buf.shift();
+
+    // Keep only the most recently active chat contexts so memory usage does not
+    // grow forever as the bot encounters new chats/groups over time.
+    this._contextBuffers.delete(rawChatId);
+    this._contextBuffers.set(rawChatId, buf);
+    while (this._contextBuffers.size > this._contextMaxChats) {
+      const oldestKey = this._contextBuffers.keys().next().value;
+      if (oldestKey == null) break;
+      this._contextBuffers.delete(oldestKey);
+    }
   }
 
   _getContext(rawChatId) {

package/server/services/messaging/whatsapp.js

@@ -16,6 +16,8 @@ class WhatsAppPlatform extends BasePlatform {
     this.reconnectAttempts = 0;
     this.maxReconnect = 5;
     this.authDir = config.authDir || AUTH_DIR;
+    this._manualDisconnect = false;
+    this._reconnectTimer = null;
   }
 
   _ownIds() {
@@ -53,6 +55,11 @@ class WhatsAppPlatform extends BasePlatform {
   }
 
   async connect() {
+    this._manualDisconnect = false;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
     if (!fs.existsSync(this.authDir)) fs.mkdirSync(this.authDir, { recursive: true });
 
     const {
@@ -108,15 +115,21 @@ class WhatsAppPlatform extends BasePlatform {
 
       if (connection === 'close') {
         const statusCode = lastDisconnect?.error?.output?.statusCode;
-        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+        const shouldReconnect = !this._manualDisconnect && statusCode !== DisconnectReason.loggedOut;
 
         this.status = 'disconnected';
-        this.emit('disconnected', { statusCode, shouldReconnect });
+        this.emit('disconnected', { statusCode, shouldReconnect, manual: this._manualDisconnect });
 
         if (shouldReconnect && this.reconnectAttempts < this.maxReconnect) {
           this.reconnectAttempts++;
           const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
-          setTimeout(() => this.connect(), delay);
+          this._reconnectTimer = setTimeout(() => {
+            this._reconnectTimer = null;
+            if (this._manualDisconnect) return;
+            this.connect().catch((err) => {
+              console.error('[WhatsApp] Reconnect failed:', err.message);
+            });
+          }, delay);
         } else if (statusCode === DisconnectReason.loggedOut) {
           fs.rmSync(this.authDir, { recursive: true, force: true });
           this.emit('logged_out');
@@ -234,6 +247,11 @@ class WhatsAppPlatform extends BasePlatform {
   }
 
   async disconnect() {
+    this._manualDisconnect = true;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
     if (this.sock) {
       this.sock.end();
       this.sock = null;
@@ -328,6 +346,11 @@ class WhatsAppPlatform extends BasePlatform {
   }
 
   async logout() {
+    this._manualDisconnect = true;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
     if (this.sock) {
       await this.sock.logout();
       this.sock = null;

package/server/services/voice/bufferedLiveRelayAdapter.js

@@ -49,11 +49,17 @@ class BufferedLiveRelayAdapter {
     if (!audioBytes.length) {
       return '';
     }
-    return this._transcribeAudioSnapshot(audioBytes, session.inputMimeType, {
-      model: session.voiceSettings?.liveSttModel,
-      userId: session.userId,
-      agentId: session.agentId,
-    });
+    try {
+      return await this._transcribeAudioSnapshot(audioBytes, session.inputMimeType, {
+        model: session.voiceSettings?.liveSttModel,
+        userId: session.userId,
+        agentId: session.agentId,
+      });
+    } finally {
+      // Release buffered audio immediately after commit so completed turns do
+      // not retain large input chunks until the next turn or explicit close.
+      session.resetInput(session.inputMimeType);
+    }
   }
 
   _schedulePartialTranscript(session) {

package/server/services/websocket.js

@@ -485,12 +485,16 @@ function setupWebSocket(io, services) {
         const data = asObject(raw);
         const agentId = resolveAgentFromPayload(userId, data);
         const sessionId = toOptionalString(data?.sessionId, 128);
-        await voiceRuntimeManager.openFlutterSession({
+        const session = await voiceRuntimeManager.openFlutterSession({
           userId,
           agentId,
           socket,
           sessionId: sessionId || null,
         });
+        if (!socket.data.voiceSessionIds) {
+          socket.data.voiceSessionIds = new Set();
+        }
+        socket.data.voiceSessionIds.add(session.id);
       } catch (err) {
         socket.emit('voice:error', { error: sanitizeError(err) });
       }
@@ -665,6 +669,7 @@ function setupWebSocket(io, services) {
           return socket.emit('voice:error', { error: 'sessionId is required' });
         }
         await voiceRuntimeManager.closeSession(sessionId, 'client_closed');
+        socket.data.voiceSessionIds?.delete(sessionId);
       } catch (err) {
         console.error(`[WS] voice:session_close failed for user ${userId}:`, err);
         socket.emit('voice:error', {
@@ -802,6 +807,18 @@ function setupWebSocket(io, services) {
     // ── Disconnect ──
 
     socket.on('disconnect', () => {
+      if (!voiceRuntimeManager || typeof voiceRuntimeManager.closeSession !== 'function') {
+        socket.data.voiceSessionIds?.clear?.();
+        console.log(`[WS] User ${userId} disconnected (${socket.id})`);
+        return;
+      }
+      const activeVoiceSessionIds = Array.from(socket.data.voiceSessionIds || []);
+      for (const sessionId of activeVoiceSessionIds) {
+        void voiceRuntimeManager.closeSession(sessionId, 'socket_disconnected').catch((err) => {
+          console.error(`[WS] Failed to close voice session ${sessionId} after socket disconnect:`, err);
+        });
+      }
+      socket.data.voiceSessionIds?.clear?.();
       console.log(`[WS] User ${userId} disconnected (${socket.id})`);
     });
   });