neoagent 2.3.1-beta.0 → 2.3.1-beta.100

package/server/services/manager.js

@@ -3,8 +3,6 @@
 const db = require('../db/database');
 const { MemoryManager } = require('./memory/manager');
 const { MCPClient } = require('./mcp/client');
-const { BrowserController } = require('./browser/controller');
-const { AndroidController } = require('./android/controller');
 const { AgentEngine } = require('./ai/engine');
 const { MultiStepOrchestrator } = require('./ai/multiStep');
 const { SkillRunner } = require('./ai/toolRunner');
@@ -15,19 +13,21 @@ const { WidgetService } = require('./widgets/service');
 const { setupWebSocket } = require('./websocket');
 const { registerMessagingAutomation } = require('./messaging/automation');
 const { RecordingManager } = require('./recordings/manager');
+const { SocialVideoService } = require('./social_video');
 const { VoiceRuntimeManager } = require('./voice/runtimeManager');
-const { CLIExecutor } = require('./cli/executor');
 const { AuthProviderManager } = require('./account/auth_provider_manager');
 const { IntegrationManager } = require('./integrations/manager');
 const { ArtifactStore } = require('./artifacts/store');
 const { RuntimeManager } = require('./runtime/manager');
+const { WorkspaceManager } = require('./workspace/manager');
 const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
-const { assertRuntimeValidation, getRuntimeValidation } = require('./runtime/validation');
+const { ScreenRecorder } = require('./desktop/screenRecorder');
+const { WearableService } = require('./wearable/service');
+const { getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
-  restoreBrowserHeadlessPreference,
   runBackgroundTask,
 } = require('./bootstrap_helpers');
 
@@ -40,18 +40,18 @@ function logServiceReady(message) {
   console.log(`[Services] ${message}`);
 }
 
-function createCliExecutor(app) {
-  const cliExecutor = registerLocal(app, 'cliExecutor', new CLIExecutor());
-  logServiceReady('CLI executor ready');
-  return cliExecutor;
-}
-
 function createArtifactStore(app) {
   const artifactStore = registerLocal(app, 'artifactStore', new ArtifactStore());
   logServiceReady('Artifact store ready');
   return artifactStore;
 }
 
+function createWorkspaceManager(app) {
+  const workspaceManager = registerLocal(app, 'workspaceManager', new WorkspaceManager());
+  logServiceReady('Workspace manager ready');
+  return workspaceManager;
+}
+
 function createBrowserExtensionRegistry(app) {
   const registry = registerLocal(app, 'browserExtensionRegistry', new BrowserExtensionRegistry());
   logServiceReady('Browser extension registry ready');
@@ -197,131 +197,32 @@ function createUserScopedControllerPool(app, {
 }
 
 function createBrowserController(app, artifactStore) {
-  function getUserHeadlessPreference(userId) {
-    try {
-      const row = db
-        .prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
-        .get(userId, 'headless_browser');
-      if (!row) return true;
-      return row.value !== 'false' && row.value !== false && row.value !== '0';
-    } catch (err) {
-      console.warn('[Services] Failed to read user headless_browser setting, defaulting to true:', getErrorMessage(err));
-      return true;
-    }
-  }
-
-  createUserScopedControllerPool(app, {
-    controllersKey: 'browserControllers',
-    creationPromisesKey: 'browserControllerCreationPromises',
-    lastAccessKey: 'browserControllerLastAccess',
-    resolverKey: 'getBrowserControllerForUser',
-    defaultControllerKey: 'browserController',
-    createController: async (userId) => {
-      const controller = new BrowserController({
-        userId,
-        artifactStore,
-        runtimeBackend: 'host',
-      });
-      controller.headless = getUserHeadlessPreference(userId);
-      return controller;
-    },
-    closeController: async (controller) => {
-      if (typeof controller.closeBrowser === 'function') {
-        await controller.closeBrowser();
-      }
-    },
-    closeErrorLabel: '[Browser] Failed to close stale browser controller',
+  registerLocal(app, 'getBrowserControllerForUser', async () => {
+    throw new Error('Host browser controller is disabled. Use the VM browser backend or a paired extension.');
   });
-
-  const browserController = registerLocal(
-    app,
-    'browserController',
-    new BrowserController({
-      artifactStore,
-      runtimeBackend: 'host',
-    }),
-  );
-  const { restored, userCount, headless } = restoreBrowserHeadlessPreference(
-    browserController,
-    db,
-  );
-
-  if (restored) {
-    logServiceReady(`Browser headless setting restored to ${headless}`);
-  }
-
-  logServiceReady(`Browser controller ready for ${userCount} user(s)`);
-  return browserController;
+  registerLocal(app, 'browserController', null);
+  logServiceReady('Browser controller disabled in VM-only mode');
+  return null;
 }
 
-function createAndroidController(app, artifactStore) {
-  createUserScopedControllerPool(app, {
-    controllersKey: 'androidControllers',
-    creationPromisesKey: 'androidControllerCreationPromises',
-    lastAccessKey: 'androidControllerLastAccess',
-    resolverKey: 'getAndroidControllerForUser',
-    defaultControllerKey: 'androidController',
-    createController: async (userId) => {
-      const controller = new AndroidController({
-        userId,
-        artifactStore,
-        runtimeBackend: 'host',
-      });
-      return controller;
-    },
-    closeController: async (controller) => {
-      if (typeof controller.close === 'function') {
-        await controller.close();
-      }
-    },
-    closeErrorLabel: '[Android] Failed to close stale Android controller',
-  });
-
-  const androidController = registerLocal(
-    app,
-    'androidController',
-    new AndroidController({
-      artifactStore,
-      runtimeBackend: 'host',
-    }),
-  );
-  logServiceReady('Android controller ready');
-  return androidController;
-}
-
-function createRuntimeManager(app, cliExecutor) {
+function createRuntimeManager(app) {
   const runtimeManager = registerLocal(
     app,
     'runtimeManager',
     new RuntimeManager({
-      cliExecutor,
       artifactStore: app.locals.artifactStore,
       browserExtensionRegistry: app.locals.browserExtensionRegistry,
-      getHostBrowserProvider: (userId) => {
-        const resolver = app.locals.getBrowserControllerForUser;
-        if (typeof resolver === 'function') {
-          return resolver(userId);
-        }
-        return app.locals.browserController;
-      },
-      getHostAndroidProvider: (userId) => {
-        const resolver = app.locals.getAndroidControllerForUser;
-        if (typeof resolver === 'function') {
-          return resolver(userId);
-        }
-        return app.locals.androidController;
-      },
     }),
   );
   logServiceReady('Runtime manager ready');
   return runtimeManager;
 }
 
-async function createSkillRunner(app, cliExecutor, runtimeManager) {
+async function createSkillRunner(app, runtimeManager) {
   const skillRunner = registerLocal(
     app,
     'skillRunner',
-    new SkillRunner({ executor: cliExecutor, runtimeManager }),
+    new SkillRunner({ runtimeManager }),
   );
   await skillRunner.loadSkills();
   logServiceReady('Skills loaded');
@@ -332,13 +233,13 @@ function createAgentEngine(
   app,
   io,
   {
-    cliExecutor,
     memoryManager,
     mcpClient,
     browserController,
     androidController,
     runtimeManager,
     skillRunner,
+    workspaceManager,
   },
 ) {
   const agentEngine = registerLocal(
@@ -346,12 +247,12 @@ function createAgentEngine(
     'agentEngine',
     new AgentEngine(io, {
       app,
-      cliExecutor,
       memoryManager,
       mcpClient,
       browserController,
       androidController,
       runtimeManager,
+      workspaceManager,
       messagingManager: null,
       skillRunner,
     }),
@@ -418,6 +319,19 @@ function createRecordingManager(app, io) {
   return recordingManager;
 }
 
+function createSocialVideoService(app) {
+  const socialVideoService = registerLocal(
+    app,
+    'socialVideoService',
+    new SocialVideoService({
+      artifactStore: app.locals.artifactStore,
+      runtimeManager: app.locals.runtimeManager,
+    }),
+  );
+  logServiceReady('Social video service ready');
+  return socialVideoService;
+}
+
 function createWidgetService(app) {
   const widgetService = registerLocal(
     app,
@@ -428,6 +342,52 @@ 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({ hasActiveRemoteCaptureSession }),
+  );
+  screenRecorder.start();
+  logServiceReady('Screen recorder started');
+  return screenRecorder;
+}
+
 function restoreMessagingConnections(messagingManager) {
   void runBackgroundTask('[Messaging] Restore error:', () =>
     messagingManager.restoreConnections(),
@@ -479,8 +439,8 @@ async function startServices(app, io) {
   console.log('[Services] Starting service initialization');
 
   try {
-    const cliExecutor = createCliExecutor(app);
     const artifactStore = createArtifactStore(app);
+    createWorkspaceManager(app);
     createBrowserExtensionRegistry(app);
     createDesktopCompanionRegistry(app);
     const memoryManager = createMemoryManager(app);
@@ -488,19 +448,21 @@ async function startServices(app, io) {
     createAuthProviderManager(app);
     const integrationManager = createIntegrationManager(app);
     const browserController = createBrowserController(app, artifactStore);
-    const androidController = createAndroidController(app, artifactStore);
-    const runtimeManager = createRuntimeManager(app, cliExecutor);
-    registerLocal(app, 'runtimeValidation', getRuntimeValidation(runtimeManager));
-    assertRuntimeValidation(runtimeManager);
-    const skillRunner = await createSkillRunner(app, cliExecutor, runtimeManager);
+    const runtimeManager = createRuntimeManager(app);
+    const runtimeValidation = getRuntimeValidation(runtimeManager);
+    registerLocal(app, 'runtimeValidation', runtimeValidation);
+    if (!runtimeValidation.ready) {
+      console.warn('[Services] Runtime validation is degraded:', runtimeValidation.issues.join(' '));
+    }
+    const skillRunner = await createSkillRunner(app, runtimeManager);
     const agentEngine = createAgentEngine(app, io, {
-      cliExecutor,
       memoryManager,
       mcpClient,
       browserController,
-      androidController,
+      androidController: null,
       runtimeManager,
       skillRunner,
+      workspaceManager: app.locals.workspaceManager,
     });
 
     createMultiStep(app, agentEngine, io);
@@ -512,7 +474,10 @@ async function startServices(app, io) {
 
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
+    createSocialVideoService(app);
     createWidgetService(app);
+    createWearableService(app);
+    createScreenRecorder(app);
 
     restoreMessagingConnections(messagingManager);
     restoreMcpClients(mcpClient);
@@ -576,29 +541,19 @@ async function stopServices(app) {
     );
   }
 
-  if (app.locals.browserControllers instanceof Map) {
-    for (const controller of app.locals.browserControllers.values()) {
-      tasks.push(
-        controller.closeBrowser().catch((err) => {
-          console.error('[Browser] User-scoped shutdown error:', getErrorMessage(err));
-        }),
-      );
-    }
-  }
-
-  if (app.locals.androidController) {
+  if (app.locals.wearableGateway?.close) {
     tasks.push(
-      app.locals.androidController.close().catch((err) => {
-        console.error('[Android] Shutdown error:', getErrorMessage(err));
+      app.locals.wearableGateway.close().catch((err) => {
+        console.error('[WearableGateway] Shutdown error:', getErrorMessage(err));
       }),
     );
   }
 
-  if (app.locals.androidControllers instanceof Map) {
-    for (const controller of app.locals.androidControllers.values()) {
+  if (app.locals.browserControllers instanceof Map) {
+    for (const controller of app.locals.browserControllers.values()) {
       tasks.push(
-        controller.close().catch((err) => {
-          console.error('[Android] User-scoped shutdown error:', getErrorMessage(err));
+        controller.closeBrowser().catch((err) => {
+          console.error('[Browser] User-scoped shutdown error:', getErrorMessage(err));
         }),
       );
     }
@@ -639,6 +594,15 @@ async function stopServices(app) {
     }
   }
 
+  if (app.locals.screenRecorder) {
+    try {
+      app.locals.screenRecorder.stop();
+      logServiceReady('Screen recorder stopped');
+    } catch (err) {
+      console.error('[ScreenRecorder] Stop error:', getErrorMessage(err));
+    }
+  }
+
   if (app.locals.browserExtensionRegistry) {
     try {
       app.locals.browserExtensionRegistry.closeAll();
@@ -657,15 +621,6 @@ async function stopServices(app) {
     }
   }
 
-  if (app.locals.cliExecutor) {
-    try {
-      app.locals.cliExecutor.killAll('shutdown');
-      logServiceReady('CLI executor processes terminated');
-    } catch (err) {
-      console.error('[CLI] Shutdown error:', getErrorMessage(err));
-    }
-  }
-
   await Promise.allSettled(tasks);
   logServiceReady('Shutdown tasks settled');
 }

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));