meshcentral-api.js

Go to the documentation of this file.

/**
 * MeshCentral API Client
 * 
 * Provides programmatic access to MeshCentral server for:
 * - Authentication and session management
 * - Device listing and status
 * - Login token generation for web-based remote desktop
 * - Real-time device data synchronization
 */
 
const https = require('https');
const crypto = require('crypto');
const WebSocket = require('ws');
 
/**
 *
 */
class MeshCentralAPI {
  /**
   *
   * @param config
   */
  constructor(config) {
    // Support both object config and positional params
    if (typeof config === 'object' && config !== null && config.url) {
      this.baseUrl = config.url.replace(/\/$/, '');
      this.username = config.username;
      this.password = config.password;
    } else if (typeof config === 'string') {
      this.baseUrl = config.replace(/\/$/, '');
      this.username = arguments[1];
      this.password = arguments[2];
    } else {
      throw new Error('Invalid constructor arguments. Expected: { url, username, password } or (url, username, password)');
    }
    this.cookie = null;
    this.ws = null;
    this.messageHandlers = new Map();
    this.nextMessageId = 1;
    this.cachedMeshes = null;
    this.cachedNodes = null;
    
    // WebSocket reconnection state
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 10;
    this.reconnectDelay = 1000; // Start at 1 second
    this.reconnecting = false;
    this.intentionalClose = false;
    
    // Connection monitoring
    this.pingInterval = null;
    this.lastPingTime = null;
    this.lastPongTime = null;
  }
 
  /**
   * Make HTTPS request to MeshCentral (bypassing self-signed cert)
   * @param method
   * @param path
   * @param data
   * @param headers
   * @param isFormEncoded
   */
  async _request(method, path, data = null, headers = {}, isFormEncoded = false) {
    return new Promise((resolve, reject) => {
      const url = new URL(path, this.baseUrl);
      
      // Prepare request body
      let requestBody = null;
      if (data) {
        if (isFormEncoded) {
          // URL-encode form data
          requestBody = Object.keys(data)
            .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
            .join('&');
        } else {
          requestBody = JSON.stringify(data);
        }
      }
      
      const options = {
        hostname: url.hostname,
        port: url.port || 443,
        path: url.pathname + url.search,
        method: method,
        headers: {
          'Content-Type': isFormEncoded ? 'application/x-www-form-urlencoded' : 'application/json',
          ...headers
        },
        rejectUnauthorized: false // Accept self-signed certificates
      };
 
      if (requestBody) {
        options.headers['Content-Length'] = Buffer.byteLength(requestBody);
      }
 
      // Add cookie if we have one
      if (this.cookie) {
        options.headers['Cookie'] = this.cookie;
      }
 
      const req = https.request(options, (res) => {
        let body = '';
        
        res.on('data', (chunk) => {
          body += chunk;
        });
 
        res.on('end', () => {
          // Save cookie from login - need both xid and xid.sig
          if (res.headers['set-cookie']) {
            // Join all cookies with semicolon
            this.cookie = res.headers['set-cookie']
              .map(c => c.split(';')[0])
              .join('; ');
            console.log(`🍪 Saved session cookie: ${this.cookie.substring(0, 100)}...`);
          }
 
          try {
            const jsonBody = body ? JSON.parse(body) : {};
            resolve({
              statusCode: res.statusCode,
              headers: res.headers,
              body: jsonBody
            });
          } catch (e) {
            resolve({
              statusCode: res.statusCode,
              headers: res.headers,
              body: body
            });
          }
        });
      });
 
      req.on('error', reject);
 
      if (requestBody) {
        req.write(requestBody);
      }
 
      req.end();
    });
  }
 
  /**
   * Login to MeshCentral and establish session
   * Uses cookie-based authentication with form-encoded data
   */
  async login() {
    try {
      console.log(`🔐 MeshCentral login attempt - URL: ${this.baseUrl}, Username: ${this.username}`);
      
      // MeshCentral uses form-based login that sets cookies
      const response = await this._request('POST', '/login', {
        action: 'login',
        username: this.username,
        password: this.password,
        token: ''
      }, {}, true); // true = form-encoded
 
      // Check if we got a cookie (session established)
      if (this.cookie) {
        console.log('✅ MeshCentral login successful');
        return true;
      } else {
        console.error('❌ MeshCentral login failed - no cookie received:', response.statusCode, response.body);
        throw new Error(`Login failed: ${response.statusCode} - No session cookie received`);
      }
    } catch (error) {
      console.error('❌ MeshCentral login error:', error.message);
      throw error;
    }
  }
 
  /**
   * Connect to MeshCentral WebSocket for real-time data
   */
  async connectWebSocket() {
    return new Promise((resolve, reject) => {
      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
        resolve(true);
        return;
      }
 
      if (!this.cookie) {
        reject(new Error('No session cookie available. Please login first.'));
        return;
      }
 
      const wsUrl = this.baseUrl.replace('https://', 'wss://').replace('http://', 'ws://') + '/control.ashx';
      
      // console.log(`🔗 Connecting to WebSocket: ${wsUrl}`);
      // console.log(`🍪 Cookie: ${this.cookie}`);
      
      this.ws = new WebSocket(wsUrl, {
        rejectUnauthorized: false,
        headers: {
          'Cookie': this.cookie
        }
      });
 
      this.ws.on('open', () => {
        console.log('✅ MeshCentral WebSocket connected');
        
        // Reset reconnection state on successful connection
        this.reconnectAttempts = 0;
        this.reconnecting = false;
        
        // Start ping/pong keep-alive
        this.startKeepAlive();
        
        // Authentication is handled via the Cookie header
        // No need to send authcookie message
        
        // Wait a bit for the connection to be fully ready
        setTimeout(() => resolve(true), 500);
      });
 
      this.ws.on('message', (data) => {
        try {
          const message = JSON.parse(data.toString());
          
          // Update pong time on any message (MeshCentral doesn't send explicit pongs)
          this.lastPongTime = Date.now();
          
          console.log(`📩 Received: ${message.action}`);
          // console.log('📨 WebSocket received:', JSON.stringify(message).substring(0, 200));
          this._handleWebSocketMessage(message);
        } catch (e) {
          console.error('Failed to parse WebSocket message:', e);
        }
      });
 
      this.ws.on('error', (error) => {
        console.error('❌ MeshCentral WebSocket error:', error.message);
        // Don't reject here - let the close handler deal with reconnection
        // reject(error);
      });
 
      this.ws.on('close', (code, reason) => {
        console.log(`🔌 MeshCentral WebSocket disconnected - Code: ${code}, Reason: ${reason || 'unknown'}`);
        
        // Stop keep-alive
        this.stopKeepAlive();
        
        this.ws = null;
        
        // Auto-reconnect unless intentionally closed
        if (!this.intentionalClose) {
          this.handleReconnect();
        } else {
          console.log('⏹️  Intentional close - not reconnecting');
        }
      });
    });
  }
 
  /**
   * Handle incoming WebSocket messages
   * @param message
   */
  _handleWebSocketMessage(message) {
    // Cache meshes and nodes when they arrive
    if (message.action === 'meshes') {
      this.cachedMeshes = message.meshes || [];
      console.log(`Received ${this.cachedMeshes.length} mesh(es) from server`);
    }
    if (message.action === 'nodes') {
      this.cachedNodes = message.nodes || [];
    }
    if (message.action === 'userinfo') {
      console.log(`User info: siteadmin=${message.userinfo?.siteadmin}, email=${message.userinfo?.email}`);
    }
 
    // Handle responses to our requests
    if (message.responseid && this.messageHandlers.has(message.responseid)) {
      const handler = this.messageHandlers.get(message.responseid);
      handler(message);
      this.messageHandlers.delete(message.responseid);
    }
 
    // Handle events (device connect/disconnect, etc.)
    if (message.action === 'event') {
      this._handleEvent(message);
    }
  }
 
  /**
   * Handle MeshCentral events
   * @param event
   */
  _handleEvent(event) {
    // Events like: node connect, node disconnect, node change, etc.
    console.log('MeshCentral event:', event);
  }
 
  /**
   * Send WebSocket message and wait for response
   * @param message
   * @param timeout
   */
  async _sendWebSocketMessage(message, timeout = 5000) {
    return new Promise((resolve, reject) => {
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        reject(new Error('WebSocket not connected'));
        return;
      }
 
      const messageId = 'msg_' + this.nextMessageId++;
      message.responseid = messageId;
 
      const timer = setTimeout(() => {
        this.messageHandlers.delete(messageId);
        reject(new Error('WebSocket request timeout'));
      }, timeout);
 
      this.messageHandlers.set(messageId, (response) => {
        clearTimeout(timer);
        resolve(response);
      });
 
      this.ws.send(JSON.stringify(message));
    });
  }
 
  /**
   * Get list of all device groups (meshes) using control API
   */
  async getMeshes() {
    try {
      // Ensure WebSocket connection is established
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        this.cachedMeshes = null; // Reset cache
        await this.connectWebSocket();
        // Wait longer for MeshCentral to send us the meshes
        await new Promise(resolve => setTimeout(resolve, 3000));
      }
 
      if (this.cachedMeshes) {
        console.log(`Found ${this.cachedMeshes.length} mesh(es)`);
        return this.cachedMeshes;
      }
      
      console.error('No meshes received from MeshCentral');
      return [];
    } catch (error) {
      console.error('Failed to get meshes:', error.message);
      return [];
    }
  }
 
  /**
   * Create a new device group (mesh) for tenant isolation
   * @param meshName
   * @param description
   */
  async createMesh(meshName, description = '') {
    try {
      // Ensure WebSocket connection is established
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        console.log('[MeshCentral] WebSocket not open, connecting...');
        await this.connectWebSocket();
      }
 
      console.log(`[MeshCentral] Creating mesh: ${meshName}`);
      const response = await this._sendWebSocketMessage({
        action: 'createmesh',
        meshname: meshName,
        meshtype: 2, // Agent mesh (not AMT)
        desc: description
      });
      
      console.log('[MeshCentral] Create mesh response:', JSON.stringify(response));
      
      if (response && response.meshid) {
        console.log(`✅ [MeshCentral] Created mesh: ${meshName} (${response.meshid})`);
        return {
          meshId: response.meshid,
          meshName: meshName
        };
      }
      
      if (response && response.error) {
        console.error(`❌ [MeshCentral] Create mesh error: ${response.error}`);
      } else {
        console.error('❌ [MeshCentral] Failed to create mesh - no meshid in response:', response);
      }
      return null;
    } catch (error) {
      console.error('❌ [MeshCentral] Failed to create mesh (exception):', error.message);
      return null;
    }
  }
 
  /**
   * Create a new user account for tenant isolation
   * @param username
   * @param password
   * @param email
   * @param realname
   */
  async createUser(username, password, email = '', realname = '') {
    try {
      // Ensure WebSocket connection is established
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        await this.connectWebSocket();
      }
 
      const response = await this._sendWebSocketMessage({
        action: 'adduser',
        username: username,
        pass: password,
        email: email,
        emailVerified: true, // Skip email verification
        randomPassword: false,
        resetNextLogin: false,
        siteadmin: 0, // No site admin rights
        consoleOnly: false
      });
      
      if (response && response.result === 'ok') {
        console.log(`Created user: ${username}`);
        return {
          username: username,
          userId: response.userid || `user//${username}`
        };
      }
      
      console.error('Failed to create user:', response);
      return null;
    } catch (error) {
      console.error('Failed to create user:', error.message);
      return null;
    }
  }
 
  /**
   * Add user to a mesh with specific permissions
   * @param userId
   * @param meshId
   * @param rights
   */
  async addUserToMesh(userId, meshId, rights = 0xFFFFFFFF) {
    try {
      // Ensure WebSocket connection is established
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        await this.connectWebSocket();
      }
 
      // rights: 0xFFFFFFFF = full access
      // Common rights: 
      //   - Remote Desktop: 0x00000008
      //   - Terminal: 0x00000010
      //   - Files: 0x00000020
      //   - Full: 0xFFFFFFFF
      const response = await this._sendWebSocketMessage({
        action: 'addmeshuser',
        meshid: meshId,
        userid: userId,
        meshadmin: rights
      });
      
      if (response && response.result === 'ok') {
        console.log(`Added user ${userId} to mesh ${meshId}`);
        return true;
      }
      
      console.error('Failed to add user to mesh:', response);
      return false;
    } catch (error) {
      console.error('Failed to add user to mesh:', error.message);
      return false;
    }
  }
 
  /**
   * Complete tenant setup: create user, create mesh, link them
   * @param tenantData
   */
  async setupTenant(tenantData) {
    try {
      const { tenantId, tenantName, subdomain } = tenantData;
      
      // Generate unique username and secure password
      const username = subdomain || `tenant_${tenantId}`;
      const password = crypto.randomBytes(32).toString('hex');
      const meshName = `${tenantName} Devices`;
      
      console.log(`Setting up MeshCentral for tenant: ${tenantName}`);
      
      // Step 1: Create user
      const user = await this.createUser(
        username,
        password,
        `${username}@meshcentral.local`,
        tenantName
      );
      
      if (!user) {
        throw new Error('Failed to create MeshCentral user');
      }
      
      // Step 2: Create mesh (device group)
      const mesh = await this.createMesh(
        meshName,
        `Device group for ${tenantName}`
      );
      
      if (!mesh) {
        throw new Error('Failed to create MeshCentral mesh');
      }
      
      // Step 3: Add user to mesh with full permissions
      const linked = await this.addUserToMesh(user.userId, mesh.meshId, 0xFFFFFFFF);
      
      if (!linked) {
        throw new Error('Failed to link user to mesh');
      }
      
      console.log(`✅ MeshCentral tenant setup complete for: ${tenantName}`);
      
      return {
        username: username,
        password: password, // Return for encryption/storage
        userId: user.userId,
        meshId: mesh.meshId,
        meshName: mesh.meshName
      };
      
    } catch (error) {
      console.error('Failed to setup tenant:', error.message);
      throw error;
    }
  }
 
  /**
   * Get list of all devices (nodes) using control API
   */
  async getNodes() {
    try {
      // Ensure WebSocket connection is established
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        await this.connectWebSocket();
      }
 
      const response = await this._sendWebSocketMessage({
        action: 'nodes'
      });
      
      if (response && response.nodes) {
        console.log(`Found ${response.nodes.length} node(s)`);
        return response.nodes;
      }
      
      console.error('Failed to get nodes:', response);
      return [];
    } catch (error) {
      console.error('Failed to get nodes:', error.message);
      return [];
    }
  }
 
  /**
   * Get specific node details by node ID
   * @param nodeId
   */
  async getNode(nodeId) {
    try {
      await this.connectWebSocket();
      
      const response = await this._sendWebSocketMessage({
        action: 'nodes',
        nodeids: [nodeId]
      });
 
      const nodes = response.nodes || [];
      return nodes.length > 0 ? nodes[0] : null;
    } catch (error) {
      console.error('Failed to get node:', error.message);
      return null;
    }
  }
 
  /**
   * Get node system information
   * @param nodeId
   */
  async getNodeSystemInfo(nodeId) {
    try {
      await this.connectWebSocket();
      
      const response = await this._sendWebSocketMessage({
        action: 'getsysinfo',
        nodeid: nodeId
      });
 
      return response.sysinfo || null;
    } catch (error) {
      console.error('Failed to get node system info:', error.message);
      return null;
    }
  }
 
  /**
   * Generate a login token for embedding MeshCentral
   * Uses MeshCentral's WebSocket createLoginToken command to generate proper authentication tokens
   * @param nodeId
   */
  async generateLoginToken(nodeId = null) {
    try {
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        throw new Error('WebSocket not connected. Call connectWebSocket() first.');
      }
 
      // Request MeshCentral to generate a login token via WebSocket
      const tokenName = `Dashboard-${Date.now()}`;
      const response = await this._sendWebSocketMessage({
        action: 'createLoginToken',
        name: tokenName,
        expire: 60 // 60 minutes
      }, 10000);
      
      if (!response.tokenUser || !response.tokenPass) {
        throw new Error('Failed to get login token from MeshCentral: ' + (response.result || 'unknown error'));
      }
      
      // Build the embed URL with user/pass parameters
      // MeshCentral supports ?user=xxx&pass=yyy for URL-based authentication
      let embedUrl = `${this.baseUrl}/?user=${encodeURIComponent(response.tokenUser)}&pass=${encodeURIComponent(response.tokenPass)}`;
      
      if (nodeId) {
        embedUrl += `&gotonode=${encodeURIComponent(nodeId)}&viewmode=11&hide=31`;
        // viewmode=11 is remote desktop
        // hide=31 hides header(1), tabs(2), footer(4), title(8), toolbar(16) = 31
      }
 
      return {
        tokenUser: response.tokenUser,
        tokenPass: response.tokenPass,
        embedUrl: embedUrl,
        expiresAt: response.expire ? new Date(response.expire) : new Date(Date.now() + 3600000)
      };
    } catch (error) {
      console.error('Failed to generate login token:', error.message);
      throw error;
    }
  }
 
  /**
   * Get MeshAgent installer download link
   * @param meshId
   * @param platform
   */
  getAgentInstallerUrl(meshId, platform = 'win32') {
    const platformMap = {
      'win32': 'meshagent.exe',
      'linux': 'meshagent',
      'darwin': 'meshagent'
    };
    
    const filename = platformMap[platform] || 'meshagent.exe';
    return `${this.baseUrl}/meshagents?id=${meshId}&installflags=0&meshinstall=${filename}`;
  }
 
  /**
   * Get server information
   */
  async getServerInfo() {
    try {
      const response = await this._request('GET', '/');
      return {
        url: this.baseUrl,
        connected: this.cookie !== null
      };
    } catch (error) {
      console.error('Failed to get server info:', error.message);
      return null;
    }
  }
 
  /**
   * Close WebSocket connection
   */
  disconnect() {
    if (this.ws) {
      this.ws.close();
      this.ws = null;
    }
  }
 
  /**
   * Parse node data to extract useful information
   * @param node
   */
  static parseNodeData(node) {
    // Extract hardware identifiers for matching
    const hardwareInfo = {
      macAddresses: [],
      motherboardId: null,
      biosId: null,
      systemUuid: null
    };
 
    // Extract MAC addresses from network interfaces
    if (node.netif) {
      for (const iface of Object.values(node.netif)) {
        if (iface.mac && iface.mac !== '00:00:00:00:00:00') {
          hardwareInfo.macAddresses.push(iface.mac.toUpperCase());
        }
      }
    }
 
    // Extract hardware IDs from system info (may be available in some fields)
    if (node.sysinfo) {
      hardwareInfo.motherboardId = node.sysinfo.motherboard?.uuid;
      hardwareInfo.biosId = node.sysinfo.bios?.id;
      hardwareInfo.systemUuid = node.sysinfo.system?.uuid;
    }
 
    return {
      nodeId: node._id || node.nodeid,
      name: node.name,
      hostname: node.host,
      meshId: node.meshid,
      icon: node.icon,
      conn: node.conn, // Connection status (bitmask)
      connected: (node.conn & 1) === 1, // Bit 0 = agent connected
      ip: node.ip,
      publicIp: node.publicip,
      os: node.osdesc,
      platform: node.platform,
      lastConnected: node.lastconnect ? new Date(node.lastconnect * 1000) : null,
      lastSeen: node.lastseen ? new Date(node.lastseen * 1000) : null,
      agentVersion: node.agentversion,
      users: node.users,
      hardware: hardwareInfo
    };
  }
 
  /**
   * Get detailed system information for a node
   * Returns parsed hardware data suitable for agent table population
   * @param sysinfo
   */
  static parseSystemInfo(sysinfo) {
    if (!sysinfo) return null;
 
    const parsed = {
      os: {
        name: sysinfo.osdesc || null,
        version: sysinfo.osver || null,
        architecture: sysinfo.arch || null
      },
      cpu: {
        model: sysinfo.cpu?.name || null,
        cores: sysinfo.cpu?.cores || null,
        speed: sysinfo.cpu?.speed || null
      },
      memory: {
        totalBytes: null,
        modules: []
      },
      motherboard: {
        manufacturer: sysinfo.board?.manufacturer || null,
        product: sysinfo.board?.product || null,
        uuid: sysinfo.board?.uuid || null
      },
      bios: {
        vendor: sysinfo.bios?.vendor || null,
        version: sysinfo.bios?.version || null,
        date: sysinfo.bios?.date || null
      },
      network: [],
      storage: [],
      gpu: sysinfo.gpu || null
    };
 
    // Parse memory modules
    if (sysinfo.memory) {
      for (const [key, mem] of Object.entries(sysinfo.memory)) {
        if (mem.capacity) {
          const capacityMb = parseInt(mem.capacity);
          parsed.memory.modules.push({
            slot: key,
            capacityMb: capacityMb,
            manufacturer: mem.manufacturer || null,
            partNumber: mem.partNumber || null,
            speed: mem.speed || null
          });
          parsed.memory.totalBytes = (parsed.memory.totalBytes || 0) + (capacityMb * 1024 * 1024);
        }
      }
    }
 
    // Parse network interfaces
    if (sysinfo.netif) {
      for (const [name, iface] of Object.entries(sysinfo.netif)) {
        parsed.network.push({
          name: name,
          mac: iface.mac || null,
          ipv4: iface.v4addr || null,
          ipv6: iface.v6addr || null,
          gateway: iface.gw || null,
          dhcp: iface.dhcp || false,
          speed: iface.speed || null
        });
      }
    }
 
    // Parse storage
    if (sysinfo.storage) {
      for (const [name, drive] of Object.entries(sysinfo.storage)) {
        parsed.storage.push({
          name: name,
          model: drive.model || null,
          capacityMb: drive.capacity ? parseInt(drive.capacity) : null,
          type: drive.type || null,
          status: drive.status || null
        });
      }
    }
 
    return parsed;
  }
 
  /**
   * Update device notes/tags (for storing tenant UUID and metadata)
   * @param nodeId
   * @param root0
   * @param root0.tenantId
   * @param root0.customerId
   * @param root0.notes
   * @param root0.tags
   */
  async updateDeviceMetadata(nodeId, { tenantId = null, customerId = null, notes = null, tags = null }) {
    try {
      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
        await this.connectWebSocket();
      }
 
      const updates = {};
      
      // Build tags array: [tenant:UUID, customer:ID, ...custom tags]
      if (tenantId || customerId || tags) {
        updates.tags = [];
        
        if (tenantId) {
          updates.tags.push(`tenant:${tenantId}`);
        }
        
        if (customerId) {
          updates.tags.push(`customer:${customerId}`);
        }
        
        if (Array.isArray(tags)) {
          updates.tags.push(...tags);
        }
      }
      
      // Add description/notes
      if (notes) {
        updates.desc = notes;
      }
 
      const response = await this._sendWebSocketMessage({
        action: 'changedevice',
        nodeid: nodeId,
        ...updates
      });
 
      console.log(`✅ Updated device metadata for ${nodeId.substring(0, 30)}...`);
      return response;
    } catch (error) {
      console.error('Failed to update device metadata:', error.message);
      return null;
    }
  }
 
  /**
   * Parse tags from device to extract tenant/customer IDs
   * @param tags
   */
  static parseDeviceTags(tags) {
    const result = {
      tenantId: null,
      customerId: null,
      customTags: []
    };
 
    if (!Array.isArray(tags)) return result;
 
    for (const tag of tags) {
      if (typeof tag !== 'string') continue;
 
      if (tag.startsWith('tenant:')) {
        result.tenantId = tag.substring(7);
      } else if (tag.startsWith('customer:')) {
        result.customerId = tag.substring(9);
      } else {
        result.customTags.push(tag);
      }
    }
 
    return result;
  }
 
  /**
   * Handle WebSocket reconnection with exponential backoff
   */
  handleReconnect() {
    if (this.reconnecting) {
      return; // Already reconnecting
    }
 
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.error(`❌ Max reconnection attempts (${this.maxReconnectAttempts}) reached. Giving up.`);
      return;
    }
 
    this.reconnecting = true;
 
    // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s max
    const delay = Math.min(
      this.reconnectDelay * Math.pow(2, this.reconnectAttempts),
      30000 // Max 30 seconds
    );
 
    this.reconnectAttempts++;
    console.log(`⏳ Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
 
    setTimeout(async () => {
      try {
        await this.connectWebSocket();
        console.log('✅ Reconnected successfully');
      } catch (err) {
        console.error('❌ Reconnection failed:', err.message);
        this.reconnecting = false;
        // handleReconnect will be called again by the close handler
      }
    }, delay);
  }
 
  /**
   * Start ping/pong keep-alive mechanism
   * Sends a ping every 30 seconds to keep connection alive
   */
  startKeepAlive() {
    // Clear any existing interval
    this.stopKeepAlive();
 
    this.pingInterval = setInterval(() => {
      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
        this.lastPingTime = Date.now();
        
        // MeshCentral doesn't have a dedicated ping/pong
        // Send a minimal request to keep connection alive
        try {
          this.ws.send(JSON.stringify({ action: 'ping' }));
          
          // Check if we haven't received any messages in 60 seconds
          if (this.lastPongTime && (Date.now() - this.lastPongTime) > 60000) {
            console.warn('⚠️  No response from MeshCentral in 60s, connection may be dead');
            // Force reconnect
            this.ws.close();
          }
        } catch (error) {
          console.error('❌ Failed to send keep-alive ping:', error.message);
          this.ws.close();
        }
      }
    }, 30000); // Every 30 seconds
 
    console.log('💓 Keep-alive started (30s interval)');
  }
 
  /**
   * Stop ping/pong keep-alive
   */
  stopKeepAlive() {
    if (this.pingInterval) {
      clearInterval(this.pingInterval);
      this.pingInterval = null;
      console.log('💔 Keep-alive stopped');
    }
  }
 
  /**
   * Gracefully close WebSocket connection (no auto-reconnect)
   */
  closeWebSocket() {
    this.intentionalClose = true;
    this.stopKeepAlive();
    
    if (this.ws) {
      this.ws.close();
      this.ws = null;
    }
    
    console.log('🛑 WebSocket closed gracefully');
  }
 
  /**
   * Check WebSocket connection health
   */
  isWebSocketConnected() {
    return this.ws && this.ws.readyState === WebSocket.OPEN;
  }
 
  /**
   * Get connection statistics
   */
  getConnectionStats() {
    return {
      connected: this.isWebSocketConnected(),
      reconnectAttempts: this.reconnectAttempts,
      lastPingTime: this.lastPingTime,
      lastPongTime: this.lastPongTime,
      latency: this.lastPongTime && this.lastPingTime 
        ? this.lastPongTime - this.lastPingTime 
        : null
    };
  }
}
 
module.exports = MeshCentralAPI;