neoagent 2.3.1-beta.4 → 2.3.1-beta.41

package/server/services/manager.js

@@ -25,6 +25,7 @@ const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
 const { ScreenRecorder } = require('./desktop/screenRecorder');
+const { WearableService } = require('./wearable/service');
 const { assertRuntimeValidation, getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
@@ -429,11 +430,46 @@ function createWidgetService(app) {
   return widgetService;
 }
 
+function createWearableService(app) {
+  const wearableService = registerLocal(
+    app,
+    'wearableService',
+    new WearableService({ app }),
+  );
+  logServiceReady('Wearable service ready');
+  return wearableService;
+}
+
 function createScreenRecorder(app) {
+  const hasActiveRemoteCaptureSession = () => {
+    const desktopRegistry = app.locals.desktopCompanionRegistry;
+    if (desktopRegistry?.connectionsByUser instanceof Map) {
+      for (const userMap of desktopRegistry.connectionsByUser.values()) {
+        if (!(userMap instanceof Map)) continue;
+        for (const connection of userMap.values()) {
+          if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+            return true;
+          }
+        }
+      }
+    }
+
+    const extensionRegistry = app.locals.browserExtensionRegistry;
+    if (extensionRegistry?.connectionsByUser instanceof Map) {
+      for (const connection of extensionRegistry.connectionsByUser.values()) {
+        if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
   const screenRecorder = registerLocal(
     app,
     'screenRecorder',
-    new ScreenRecorder(),
+    new ScreenRecorder({ hasActiveRemoteCaptureSession }),
   );
   screenRecorder.start();
   logServiceReady('Screen recorder started');
@@ -525,6 +561,7 @@ async function startServices(app, io) {
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
     createWidgetService(app);
+    createWearableService(app);
     createScreenRecorder(app);
 
     restoreMessagingConnections(messagingManager);
@@ -589,6 +626,14 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.wearableGateway?.close) {
+    tasks.push(
+      app.locals.wearableGateway.close().catch((err) => {
+        console.error('[WearableGateway] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.browserControllers instanceof Map) {
     for (const controller of app.locals.browserControllers.values()) {
       tasks.push(

package/server/services/mcp/client.js

@@ -1,3 +1,5 @@
+'use strict';
+
 const EventEmitter = require('events');
 const crypto = require('crypto');
 const db = require('../../db/database');
@@ -5,6 +7,9 @@ const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
 const { SSEClientTransport } = require('@modelcontextprotocol/sdk/client/sse.js');
 const { validateRemoteMcpEndpoint } = require('../runtime/mcp');
 
+const CONSECUTIVE_FAIL_LIMIT = 3;
+const RECONNECT_DELAY_MS = 60_000;
+
 class DBAuthProvider {
   constructor(serverId, clientId, authServerUrl) {
     this.serverId = serverId;
@@ -50,7 +55,6 @@ class DBAuthProvider {
   }
 
   redirectToAuthorization(authorizationUrl) {
-    // Throw error so the API route catches it and returns the URL to the frontend
     throw new Error(`OAUTH_REDIRECT:${authorizationUrl.toString()}`);
   }
 
@@ -66,10 +70,30 @@ class DBAuthProvider {
   }
 }
 
+function extractErrorMessage(err) {
+  const raw = err?.message || String(err || 'Unknown error');
+  // Strip HTML bodies (e.g. Cloudflare 530 error pages) — keep only the first line
+  if (raw.includes('<!doctype') || raw.includes('<html') || raw.includes('<!DOCTYPE')) {
+    const httpMatch = raw.match(/HTTP (\d+)/i);
+    return httpMatch
+      ? `Server returned HTTP ${httpMatch[1]} — the MCP endpoint may be down or misconfigured`
+      : 'Server returned an HTML error page — the MCP endpoint may be down or misconfigured';
+  }
+  // ECONNREFUSED: pull out just the host/port
+  if (err?.code === 'ECONNREFUSED' || raw.includes('ECONNREFUSED')) {
+    const addrMatch = raw.match(/connect ECONNREFUSED ([^\s,]+)/);
+    return addrMatch
+      ? `Connection refused at ${addrMatch[1]} — is the MCP server running?`
+      : 'Connection refused — the MCP server is not reachable';
+  }
+  return raw.split('\n')[0].trim();
+}
+
 class MCPClient extends EventEmitter {
   constructor() {
     super();
     this.servers = new Map();
+    this._reconnectTimers = new Map();
   }
 
   async startServer(serverId, url, name = '', userId = null, options = {}) {
@@ -90,13 +114,12 @@ class MCPClient extends EventEmitter {
 
       const transportOpts = {
         requestInit: { headers: {} },
-        eventSourceInit: { headers: {} }
+        eventSourceInit: { headers: {} },
       };
 
       if (authObj.type === 'bearer' && authObj.token) {
         const h = `Bearer ${authObj.token}`;
         transportOpts.requestInit.headers['Authorization'] = h;
-        // Native EventSource doesn't support headers well in browsers, but Node.js EventSource / sse.js might
         transportOpts.eventSourceInit.headers['Authorization'] = h;
       } else if (authObj.type === 'oauth') {
         transportOpts.authProvider = new DBAuthProvider(serverId, authObj.clientId, authObj.authServerUrl);
@@ -105,7 +128,7 @@ class MCPClient extends EventEmitter {
       const transport = new SSEClientTransport(new URL(endpoint), transportOpts);
       const client = new Client(
         { name: 'NeoAgent', version: '1.0.0' },
-        { capabilities: { tools: {} } }
+        { capabilities: { tools: {} } },
       );
 
       const serverObj = {
@@ -119,7 +142,9 @@ class MCPClient extends EventEmitter {
         client,
         transport,
         tools: [],
-        status: 'starting'
+        status: 'starting',
+        consecutiveFails: 0,
+        lastError: null,
       };
 
       this.servers.set(serverId, serverObj);
@@ -129,17 +154,24 @@ class MCPClient extends EventEmitter {
       const server = this.servers.get(serverId);
       if (server) {
         server.status = 'running';
+        server.consecutiveFails = 0;
+        server.lastError = null;
         this.emit('server_status', { serverId, status: 'running' });
       }
 
       return { status: 'running' };
     } catch (err) {
+      const message = extractErrorMessage(err);
       const server = this.servers.get(serverId);
       if (server) {
+        server.consecutiveFails = (server.consecutiveFails || 0) + 1;
+        server.lastError = message;
         server.status = 'error';
-        this.emit('server_status', { serverId, status: 'error', error: err.message });
+        this.emit('server_status', { serverId, status: 'error', error: message });
       }
-      throw err;
+      const friendlyErr = new Error(message);
+      friendlyErr.originalError = err;
+      throw friendlyErr;
     }
   }
 
@@ -149,26 +181,62 @@ class MCPClient extends EventEmitter {
       throw new Error(`Server ${serverId} transport not initialized`);
     }
     await server.transport.finishAuth(code);
-    await server.client.connect(server.transport).catch(() => { }); // Reconnect using tokens
+    await server.client.connect(server.transport).catch(() => {});
 
     server.status = 'running';
+    server.consecutiveFails = 0;
+    server.lastError = null;
     this.emit('server_status', { serverId, status: 'running' });
   }
 
   async stopServer(serverId) {
+    const timer = this._reconnectTimers.get(serverId);
+    if (timer) {
+      clearTimeout(timer);
+      this._reconnectTimers.delete(serverId);
+    }
+
     const server = this.servers.get(serverId);
     if (!server) return;
 
     try {
       if (server.client) await server.client.close();
     } catch (err) {
-      console.error(`Error closing MCP client ${serverId}:`, err);
+      console.error(`[MCP] Error closing client ${serverId}:`, err.message);
     }
 
     this.servers.delete(serverId);
     this.emit('server_status', { serverId, status: 'stopped' });
   }
 
+  _scheduleReconnect(serverId, userId, options) {
+    if (this._reconnectTimers.has(serverId)) return;
+
+    const timer = setTimeout(async () => {
+      this._reconnectTimers.delete(serverId);
+      const server = this.servers.get(serverId);
+      if (!server || server.status === 'running') return;
+
+      const row = db.prepare('SELECT * FROM mcp_servers WHERE id = ? AND enabled = 1').get(serverId);
+      if (!row) return;
+
+      try {
+        await this.startServer(serverId, row.command, row.name, userId, options);
+        await this.listTools(serverId, userId);
+        console.log(`[MCP] Reconnected to ${row.name}`);
+      } catch (err) {
+        const server = this.servers.get(serverId);
+        if (server && server.consecutiveFails < CONSECUTIVE_FAIL_LIMIT) {
+          this._scheduleReconnect(serverId, userId, options);
+        } else {
+          console.warn(`[MCP] ${row.name} disabled after ${CONSECUTIVE_FAIL_LIMIT} consecutive failures: ${err.message}`);
+        }
+      }
+    }, RECONNECT_DELAY_MS);
+
+    this._reconnectTimers.set(serverId, timer);
+  }
+
   _getOwnedServer(serverId, userId = null) {
     const server = this.servers.get(serverId);
     if (!server) return null;
@@ -189,14 +257,30 @@ class MCPClient extends EventEmitter {
 
   async callTool(serverId, toolName, args = {}, userId = null) {
     const server = this._getOwnedServer(serverId, userId);
-    if (!server || server.status !== 'running') {
-      throw new Error(`Server ${serverId} not running`);
+    if (!server) throw new Error(`Server ${serverId} not found`);
+
+    if (server.status !== 'running') {
+      const hint = server.lastError ? ` (${server.lastError})` : '';
+      throw new Error(`MCP server "${server.name}" is not available${hint}`);
     }
 
-    return await server.client.callTool({
-      name: toolName,
-      arguments: args
-    });
+    try {
+      const result = await server.client.callTool({ name: toolName, arguments: args });
+      server.consecutiveFails = 0;
+      return result;
+    } catch (err) {
+      const message = extractErrorMessage(err);
+      server.consecutiveFails = (server.consecutiveFails || 0) + 1;
+      server.lastError = message;
+
+      if (server.consecutiveFails >= CONSECUTIVE_FAIL_LIMIT) {
+        server.status = 'error';
+        this.emit('server_status', { serverId, status: 'error', error: message });
+        this._scheduleReconnect(serverId, server.userId, { agentId: server.agentId });
+      }
+
+      throw new Error(`MCP tool "${toolName}" failed: ${message}`);
+    }
   }
 
   async callToolByName(fullName, args = {}, userId = null, options = {}) {
@@ -204,10 +288,10 @@ class MCPClient extends EventEmitter {
       if (userId != null && server.userId !== userId) continue;
       if (options.agentId && server.agentId && server.agentId !== options.agentId) continue;
       const prefix = `mcp_${server.slug}_`;
-      if (fullName.startsWith(prefix)) {
-        const originalName = fullName.substring(prefix.length);
-        return await this.callTool(serverId, originalName, args, userId);
-      }
+      if (!fullName.startsWith(prefix)) continue;
+
+      const originalName = fullName.substring(prefix.length);
+      return await this.callTool(serverId, originalName, args, userId);
     }
     return null;
   }
@@ -224,7 +308,7 @@ class MCPClient extends EventEmitter {
           name: `mcp_${server.slug}_${tool.name}`,
           originalName: tool.name,
           parameters: tool.inputSchema || tool.parameters,
-          serverId
+          serverId,
         });
       }
     }
@@ -242,7 +326,9 @@ class MCPClient extends EventEmitter {
         command: server.url,
         args: [],
         toolCount: server.tools.length,
-        serverInfo: null
+        error: server.lastError || null,
+        consecutiveFails: server.consecutiveFails || 0,
+        serverInfo: null,
       };
     }
     return statuses;
@@ -258,8 +344,14 @@ class MCPClient extends EventEmitter {
         await this.listTools(srv.id, userId);
         results.push({ id: srv.id, name: srv.name, status: 'running' });
       } catch (err) {
-        console.error(`Failed to start MCP server ${srv.name}:`, err.message);
-        results.push({ id: srv.id, name: srv.name, status: 'error', error: err.message });
+        const message = err.message;
+        console.error(`[MCP] Failed to start "${srv.name}":`, message);
+        // Schedule a reconnect attempt for transient failures (not auth errors)
+        const server = this.servers.get(srv.id);
+        if (server) {
+          this._scheduleReconnect(srv.id, userId, { agentId: srv.agent_id });
+        }
+        results.push({ id: srv.id, name: srv.name, status: 'error', error: message });
       }
     }
 
@@ -267,6 +359,11 @@ class MCPClient extends EventEmitter {
   }
 
   async shutdown() {
+    for (const timer of this._reconnectTimers.values()) {
+      clearTimeout(timer);
+    }
+    this._reconnectTimers.clear();
+
     const promises = [];
     for (const serverId of this.servers.keys()) {
       promises.push(this.stopServer(serverId));

package/server/services/memory/manager.js

@@ -12,6 +12,11 @@ const {
 const { getMemoryStorageDecision } = require('./policy');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 const { isMainAgent, resolveAgentId } = require('../agents/manager');
+const {
+  decryptLocalValue,
+  encryptLocalValue,
+  isLocalEncryptedValue,
+} = require('../../utils/local_secrets');
 
 async function getActiveProvider(userId, agentId = null) {
   try {
@@ -516,11 +521,43 @@ class MemoryManager {
         return {};
       }
     }
-    try { return JSON.parse(fs.readFileSync(filePath, 'utf-8')); } catch { return {}; }
+    try {
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return {};
+      }
+
+      let shouldMigrate = false;
+      const normalized = {};
+
+      for (const [service, rawValue] of Object.entries(parsed)) {
+        const value = String(rawValue || '');
+        if (!value) {
+          normalized[service] = '';
+          continue;
+        }
+
+        if (!isLocalEncryptedValue(value)) shouldMigrate = true;
+        normalized[service] = decryptLocalValue(value);
+      }
+
+      if (shouldMigrate) {
+        this.writeApiKeys(normalized, userId);
+      }
+
+      return normalized;
+    } catch {
+      return {};
+    }
   }
 
   writeApiKeys(keys, userId = null) {
-    fs.writeFileSync(this._userApiKeysPath(userId), JSON.stringify(keys, null, 2), 'utf-8');
+    const encrypted = {};
+    for (const [service, rawValue] of Object.entries(keys || {})) {
+      const value = String(rawValue || '');
+      encrypted[service] = value ? encryptLocalValue(value) : '';
+    }
+    fs.writeFileSync(this._userApiKeysPath(userId), JSON.stringify(encrypted, null, 2), 'utf-8');
   }
 
   setApiKey(service, key, userId = null) {

package/server/services/messaging/access_policy.js

@@ -165,6 +165,16 @@ const PLATFORM_CAPABILITIES = Object.freeze({
     sharedSpaceRuleScopes: Object.freeze(['channel', 'chat']),
     sharedActorRuleScopes: Object.freeze(['user']),
   }),
+  meshtastic: capabilityTemplate({
+    supportsDirectPolicy: false,
+    supportsSharedPolicy: true,
+    supportsMentionGate: false,
+    supportsDiscovery: false,
+    directRuleScopes: Object.freeze([]),
+    sharedSpaceRuleScopes: Object.freeze(['channel', 'chat']),
+    sharedActorRuleScopes: Object.freeze(['user']),
+    manualEntryHint: 'Add a Meshtastic node number or channel id.',
+  }),
   feishu: capabilityTemplate({ supportsDiscovery: false }),
   nextcloud_talk: capabilityTemplate({ supportsDiscovery: false }),
   nostr: capabilityTemplate({ supportsDiscovery: false }),

package/server/services/messaging/manager.js

@@ -9,6 +9,7 @@ const { WhatsAppPlatform } = require('./whatsapp');
 const { TelnyxVoicePlatform } = require('./telnyx');
 const { DiscordPlatform } = require('./discord');
 const { TelegramPlatform } = require('./telegram');
+const { MeshtasticPlatform } = require('./meshtastic');
 const {
   SlackPlatform,
   GoogleChatPlatform,
@@ -34,6 +35,7 @@ const {
   classifyRecentTarget,
 } = require('./access_policy');
 const { decryptValue, encryptValue } = require('../integrations/secrets');
+const { readMeshtasticEnabled } = require('./meshtastic_env');
 
 const LEGACY_WHATSAPP_AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth');
 
@@ -78,6 +80,7 @@ class MessagingManager extends EventEmitter {
       feishu: createGenericPlatformClass('feishu'),
       line: LinePlatform,
       mattermost: MattermostPlatform,
+      meshtastic: MeshtasticPlatform,
       nextcloud_talk: createGenericPlatformClass('nextcloud_talk'),
       nostr: createGenericPlatformClass('nostr'),
       synology_chat: createGenericPlatformClass('synology_chat'),
@@ -302,6 +305,9 @@ class MessagingManager extends EventEmitter {
     config.accessPolicy = this._loadAccessPolicy(userId, agentId, platformName);
     const PlatformClass = this.platformTypes[platformName];
     if (!PlatformClass) throw new Error(`Unknown platform: ${platformName}`);
+    if (platformName === 'meshtastic' && !readMeshtasticEnabled()) {
+      throw new Error('Meshtastic is disabled by environment configuration');
+    }
 
     if (platformName === 'whatsapp' && !config.authDir) {
       config.authDir = this._scopedPlatformAuthDir(userId, agentId, platformName);
@@ -545,6 +551,14 @@ class MessagingManager extends EventEmitter {
 
   getPlatformStatus(userId, platformName, options = {}) {
     const agentId = this._agentId(userId, options);
+    if (platformName === 'meshtastic' && !readMeshtasticEnabled()) {
+      return {
+        status: 'disabled',
+        authInfo: {
+          label: 'Disabled in env',
+        },
+      };
+    }
     const key = this._key(userId, agentId, platformName);
     const platform = this.platforms.get(key);
     if (!platform) {
@@ -562,7 +576,21 @@ class MessagingManager extends EventEmitter {
     const connections = db.prepare('SELECT platform, status, last_connected, agent_id FROM platform_connections WHERE user_id = ? AND agent_id = ?').all(userId, agentId);
     const statuses = {};
 
+    if (!readMeshtasticEnabled()) {
+      statuses.meshtastic = {
+        status: 'disabled',
+        agentId,
+        lastConnected: null,
+        authInfo: {
+          label: 'Disabled in env',
+        },
+      };
+    }
+
     for (const conn of connections) {
+      if (conn.platform === 'meshtastic' && !readMeshtasticEnabled()) {
+        continue;
+      }
       const key = this._key(userId, agentId, conn.platform);
       const platform = this.platforms.get(key);
       statuses[conn.platform] = {
@@ -616,6 +644,11 @@ class MessagingManager extends EventEmitter {
     ).all();
     for (const row of rows) {
       try {
+        if (row.platform === 'meshtastic' && !readMeshtasticEnabled()) {
+          db.prepare("UPDATE platform_connections SET status = 'disabled' WHERE user_id = ? AND agent_id = ? AND platform = ?")
+            .run(row.user_id, row.agent_id, row.platform);
+          continue;
+        }
         const config = this._decodeStoredConfig(row.config);
         console.log(`[Messaging] Restoring ${row.platform} for user ${row.user_id} agent ${row.agent_id || 'main'}`);
         await this.connectPlatform(row.user_id, row.platform, config, { agentId: row.agent_id });
@@ -627,6 +660,22 @@ class MessagingManager extends EventEmitter {
     }
   }
 
+  async updateMeshtasticEnabled(enabled) {
+    if (enabled) return;
+    const disconnects = [];
+    for (const [key, platform] of this.platforms.entries()) {
+      if (!key.endsWith(':meshtastic')) continue;
+      disconnects.push(
+        Promise.resolve(platform.disconnect()).catch(() => {}).then(() => {
+          this.platforms.delete(key);
+        })
+      );
+    }
+    await Promise.all(disconnects);
+    db.prepare("UPDATE platform_connections SET status = 'disabled' WHERE platform = 'meshtastic'")
+      .run();
+  }
+
   async shutdown() {
     this.isShuttingDown = true;