diodejs 0.1.5 → 0.2.0

package/README.md

@@ -15,6 +15,35 @@ If you want to enable debug logs, set environment variable DEBUG to true.
 
 Can also use .env files
 
+### Connection Settings
+
+Connection retry behavior can be configured via environment variables:
+
+| Environment Variable | Description | Default |
+|----------------------|-------------|---------|
+| DIODE_MAX_RETRIES | Maximum number of reconnection attempts | Infinity |
+| DIODE_RETRY_DELAY | Initial delay between retries (ms) | 1000 |
+| DIODE_MAX_RETRY_DELAY | Maximum delay between retries (ms) | 30000 |
+| DIODE_AUTO_RECONNECT | Whether to automatically reconnect | true |
+
+Example `.env` file:
+```
+DIODE_MAX_RETRIES=10
+DIODE_RETRY_DELAY=2000
+DIODE_MAX_RETRY_DELAY=20000
+DIODE_AUTO_RECONNECT=true
+```
+
+These settings can also be configured programmatically:
+```javascript
+connection.setReconnectOptions({
+  maxRetries: 10,
+  retryDelay: 2000,
+  maxRetryDelay: 20000,
+  autoReconnect: true
+});
+```
+
 ### Test RPC
 
 Here's a quick example to get you started with RPC functions using `DiodeRPC` Class
@@ -28,6 +57,26 @@ async function main() {
   const keyLocation = './db/keys.json'; // Optional, defaults to './db/keys.json'
 
   const connection = new DiodeConnection(host, port, keyLocation);
+  
+  // Configure reconnection (optional - overrides environment variables)
+  connection.setReconnectOptions({
+    maxRetries: Infinity, // Unlimited reconnection attempts
+    retryDelay: 1000,     // Initial delay of 1 second
+    maxRetryDelay: 30000, // Maximum delay of 30 seconds
+    autoReconnect: true   // Automatically reconnect on disconnection
+  });
+  
+  // Listen for reconnection events (optional)
+  connection.on('reconnecting', (info) => {
+    console.log(`Reconnecting... Attempt #${info.attempt} in ${info.delay}ms`);
+  });
+  connection.on('reconnected', () => {
+    console.log('Successfully reconnected!');
+  });
+  connection.on('reconnect_failed', () => {
+    console.log('Failed to reconnect after maximum attempts');
+  });
+  
   await connection.connect();
 
   const rpc = new DiodeRPC(connection);
@@ -68,15 +117,23 @@ async function main() {
   
     // Multiple or single port binding with configuration object
     const portsConfig = {
-      3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" },
-      3003: { targetPort: 443, deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2" } // Works with or without 0x prefix
+      3002: { 
+        targetPort: 80, 
+        deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tls" // Optional - defaults to TLS if not specified
+      },
+      3003: { 
+        targetPort: 443, 
+        deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tcp" // Can be "tls", "tcp", or "udp"
+      }
     };
     
     const portForward = new BindPort(connection, portsConfig);
     portForward.bind();
     
-    // You can also dynamically add and remove ports
-    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    // You can also dynamically add ports with protocol specification
+    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2", "udp");
     portForward.removePort(3003);
 }
 
@@ -95,7 +152,7 @@ async function main() {
     const connection = new DiodeConnection(host, port, keyLocation);
     await connection.connect();
   
-    // Legacy method - single port binding
+    // Legacy method - single port binding (defaults to TLS protocol)
     const portForward = new BindPort(connection, 3002, 80, "5365baf29cb7ab58de588dfc448913cb609283e2");
     portForward.bind();
 }
@@ -157,6 +214,16 @@ main();
   - `createTicketCommand()`: Creates a ticket command for authentication. Returns a promise.
   - `close()`: Closes the connection to the Diode server.
   - `getDeviceCertificate()`: Returns the generated certificate PEM.
+  - `setReconnectOptions(options)`: Configures reconnection behavior with the following options:
+    - `maxRetries` (number): Maximum reconnection attempts (default: Infinity)
+    - `retryDelay` (number): Initial delay between retries in ms (default: 1000)
+    - `maxRetryDelay` (number): Maximum delay between retries in ms (default: 30000)
+    - `autoReconnect` (boolean): Whether to automatically reconnect on disconnection (default: true)
+
+- **Events**:
+  - `reconnecting`: Emitted when a reconnection attempt is about to start, with `attempt` and `delay` information
+  - `reconnected`: Emitted when reconnection is successful
+  - `reconnect_failed`: Emitted when all reconnection attempts have failed
 
 #### `DiodeRPC`
 
@@ -190,13 +257,15 @@ main();
   New Constructor:
   - `new BindPort(connection, portsConfig)`
     - `connection` (DiodeConnection): An instance of `DiodeConnection`.
-    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with `targetPort` and `deviceIdHex`.
-      Example: `{ 3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" } }`
-      Note: deviceIdHex can be provided with or without the '0x' prefix.
+    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with:
+      - `targetPort` (number): The target port on the device.
+      - `deviceIdHex` (string): The device ID in hexadecimal format (with or without '0x' prefix).
+      - `protocol` (string, optional): The protocol to use ("tls", "tcp", or "udp"). Defaults to "tls".
 
 - **Methods**:
   - `bind()`: Binds all configured local ports to their target ports on the devices.
-  - `addPort(localPort, targetPort, deviceIdHex)`: Adds a new port binding configuration. deviceIdHex can include '0x' prefix.
+  - `addPort(localPort, targetPort, deviceIdHex, protocol)`: Adds a new port binding configuration.
+    - `protocol` (string, optional): The protocol to use. Can be "tls", "tcp", or "udp". Defaults to "tls".
   - `removePort(localPort)`: Removes a port binding configuration.
   - `bindSinglePort(localPort)`: Binds a single local port to its target.
   - `closeAllServers()`: Closes all active server instances.

package/bindPort.js

@@ -1,8 +1,45 @@
 const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
 const { Buffer } = require('buffer');
+const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
 const logger = require('./logger');
 
+// Custom Duplex stream to handle the Diode connection
+class DiodeSocket extends Duplex {
+  constructor(ref, rpc) {
+    super();
+    this.ref = ref;
+    this.rpc = rpc;
+    this.destroyed = false;
+  }
+
+  _write(chunk, encoding, callback) {
+    // Send data to the remote device via portSend
+    this.rpc.portSend(this.ref, chunk)
+      .then(() => callback())
+      .catch((err) => callback(err));
+  }
+
+  _read(size) {
+    // No need to implement this method for our use case
+  }
+
+  // Method to push data received from the remote device
+  pushData(data) {
+    if (!this.destroyed) {
+      this.push(data);
+    }
+  }
+
+  _destroy(err, callback) {
+    this.destroyed = true;
+    this.push(null);
+    callback(err);
+  }
+}
+
 class BindPort {
   constructor(connection, localPortOrPortsConfig, targetPort, deviceIdHex) {
     this.connection = connection;
@@ -12,7 +49,8 @@ class BindPort {
       this.portsConfig = {
         [localPortOrPortsConfig]: { 
           targetPort, 
-          deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+          deviceIdHex: this._stripHexPrefix(deviceIdHex),
+          protocol: 'tls' // Default protocol is tls
         }
       };
     } else {
@@ -20,10 +58,17 @@ class BindPort {
       this.portsConfig = localPortOrPortsConfig || {};
       
       // Strip 0x prefix from all deviceIdHex values in portsConfig
+      // And ensure protocol is specified (default to tls)
       for (const port in this.portsConfig) {
         if (this.portsConfig[port].deviceIdHex) {
           this.portsConfig[port].deviceIdHex = this._stripHexPrefix(this.portsConfig[port].deviceIdHex);
         }
+        // Set default protocol if not provided
+        if (!this.portsConfig[port].protocol) {
+          this.portsConfig[port].protocol = 'tls';
+        }
+        // Ensure protocol is uppercase
+        this.portsConfig[port].protocol = this.portsConfig[port].protocol.toLowerCase();
       }
     }
     
@@ -45,7 +90,6 @@ class BindPort {
   _setupMessageListener() {
     // Listen for data events from the device
     this.connection.on('unsolicited', (message) => {
-      // message is [messageId, [messageType, ...]]
       const [messageIdRaw, messageContent] = message;
       const messageTypeRaw = messageContent[0];
       const messageType = Buffer.from(messageTypeRaw).toString('utf8');
@@ -60,7 +104,13 @@ class BindPort {
         // Find the associated client socket from connection
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
-          clientSocket.write(data);
+          if (clientSocket.diodeSocket) {
+            // If it's a DiodeSocket, push data to it so tls can process
+            clientSocket.diodeSocket.pushData(data);
+          } else {
+            // Otherwise write directly to the socket
+            clientSocket.write(data);
+          }
         } else {
           const connectionInfo = this.connection.getConnection(dataRef);
           if (connectionInfo) {
@@ -76,6 +126,9 @@ class BindPort {
         // Close the associated client socket
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
+          if (clientSocket.diodeSocket) {
+            clientSocket.diodeSocket._destroy(null, () => {});
+          }
           clientSocket.end();
           this.connection.deleteClientSocket(dataRef);
           logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
@@ -100,7 +153,7 @@ class BindPort {
     });
   }
 
-  addPort(localPort, targetPort, deviceIdHex) {
+  addPort(localPort, targetPort, deviceIdHex, protocol = 'tls') {
     if (this.servers.has(localPort)) {
       logger.warn(`Port ${localPort} is already bound`);
       return false;
@@ -108,7 +161,8 @@ class BindPort {
     
     this.portsConfig[localPort] = { 
       targetPort, 
-      deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+      deviceIdHex: this._stripHexPrefix(deviceIdHex),
+      protocol: protocol.toLowerCase()
     };
     
     this.bindSinglePort(localPort);
@@ -151,70 +205,191 @@ class BindPort {
       return false;
     }
     
-    const { targetPort, deviceIdHex } = config;
+    const { targetPort, deviceIdHex, protocol = 'tls' } = config;
     const deviceId = Buffer.from(deviceIdHex, 'hex');
     
-    // Set up local server
-    const server = net.createServer(async (clientSocket) => {
-      logger.info(`Client connected to local server on port ${localPort}`);
-
-      // Open a new port on the device for this client
-      let ref;
-      try {
-        ref = await this.rpc.portOpen(deviceId, targetPort, 'rw');
+    // Format the target port with protocol prefix for the remote connection
+    const formattedTargetPort = `${protocol}:${targetPort}`;
+    logger.info(`Binding local port ${localPort} to remote ${formattedTargetPort}`);
+    
+    // For udp protocol, use udp server
+    if (protocol === 'udp') {
+      const server = dgram.createSocket('udp4');
+      
+      server.on('listening', () => {
+        logger.info(`udp server listening on port ${localPort} forwarding to device port ${targetPort}`);
+      });
+      
+      server.on('message', async (data, rinfo) => {
+        // Open a new port on the device if this is a new client
+        const clientKey = `${rinfo.address}:${rinfo.port}`;
+        let ref = server.clientRefs && server.clientRefs[clientKey];
+        
         if (!ref) {
-          logger.error(`Error opening port ${targetPort} on deviceId: ${deviceIdHex}`);
-          clientSocket.destroy();
-          return;
-        } else {
-          logger.info(`Port ${targetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          try {
+            ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+            if (!ref) {
+              logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+              return;
+            } else {
+              logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for udp client ${clientKey}`);
+              if (!server.clientRefs) server.clientRefs = {};
+              server.clientRefs[clientKey] = ref;
+              
+              // Store the client info
+              this.connection.addClientSocket(ref, {
+                address: rinfo.address,
+                port: rinfo.port,
+                protocol: 'udp',
+                write: (data) => {
+                  server.send(data, rinfo.port, rinfo.address);
+                }
+              });
+            }
+          } catch (error) {
+            logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+            return;
+          }
         }
-      } catch (error) {
-        logger.error(`Error opening port ${targetPort} on device: ${error}`);
-        clientSocket.destroy();
-        return;
-      }
-
-      // Store the client socket with the ref using connection's method
-      this.connection.addClientSocket(ref, clientSocket);
-
-      // When data is received from the client, send it to the device
-      clientSocket.on('data', async (data) => {
+        
+        // Send data to the device
         try {
           await this.rpc.portSend(ref, data);
         } catch (error) {
-          logger.error(`Error sending data to device: ${error}`);
-          clientSocket.destroy();
+          logger.error(`Error sending udp data to device: ${error}`);
         }
       });
+      
+      server.on('error', (err) => {
+        logger.error(`udp Server error: ${err}`);
+      });
+      
+      server.bind(localPort);
+      this.servers.set(parseInt(localPort), server);
+    } else {
+      // For TCP and tls protocols, use TCP server locally
+      const server = net.createServer(async (clientSocket) => {
+        logger.info(`Client connected to local server on port ${localPort}`);
 
-      // Handle client socket closure
-      clientSocket.on('end', async () => {
-        logger.info('Client disconnected');
-        if (ref && this.connection.hasClientSocket(ref)) {
+        // Open a new port on the device for this client
+        let ref;
+        try {
+          ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+          if (!ref) {
+            logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+            clientSocket.destroy();
+            return;
+          } else {
+            logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          }
+        } catch (error) {
+          logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+          clientSocket.destroy();
+          return;
+        }
+
+        if (protocol === 'tls') {
+          // For tls protocol, create a proper tls connection
           try {
-            await this.rpc.portClose(ref);
-            logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
-            this.connection.deleteClientSocket(ref);
+            // Create a DiodeSocket to handle communication with the device
+            const diodeSocket = new DiodeSocket(ref, this.rpc);
+            
+            // Get the device certificate for tls
+            const certPem = this.connection.getDeviceCertificate();
+            if (!certPem) {
+              throw new Error('No device certificate available');
+            }
+            
+            // Setup tls options for client mode
+            const tlsOptions = {
+              cert: certPem,
+              key: certPem,
+              rejectUnauthorized: false,
+              ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+              ecdhCurve: 'secp256k1',
+              minVersion: 'TLSv1.2',
+              maxVersion: 'TLSv1.2',
+            };
+            
+            // Create tls socket as client (not server)
+            const tlsSocket = tls.connect({
+              socket: diodeSocket,
+              ...tlsOptions
+            }, () => {
+              logger.info(`tls connection established to device ${deviceIdHex}`);
+            });
+            
+            // Pipe data between the client socket and the tls socket
+            tlsSocket.pipe(clientSocket).pipe(tlsSocket);
+            
+            // Handle tls socket errors
+            tlsSocket.on('error', (err) => {
+              logger.error(`tls Socket error: ${err}`);
+              clientSocket.destroy();
+            });
+            
+            // Store reference to the diodeSocket so we can push data to it
+            const socketWrapper = {
+              diodeSocket,
+              tlsSocket,
+              end: () => {
+                tlsSocket.end();
+                diodeSocket._destroy(null, () => {});
+              }
+            };
+            
+            // Store the socket wrapper
+            this.connection.addClientSocket(ref, socketWrapper);
+            
           } catch (error) {
-            logger.error(`Error closing port on device: ${error}`);
+            logger.error(`Error setting up tls connection: ${error}`);
+            clientSocket.destroy();
+            return;
           }
         } else {
-          logger.warn('Ref is invalid or no longer in clientSockets.');
+          // For TCP protocol, just use the raw socket
+          this.connection.addClientSocket(ref, clientSocket);
+          
+          // Handle data from client to device
+          clientSocket.on('data', async (data) => {
+            try {
+              await this.rpc.portSend(ref, data);
+            } catch (error) {
+              logger.error(`Error sending data to device: ${error}`);
+              clientSocket.destroy();
+            }
+          });
         }
-      });
 
-      // Handle client socket errors
-      clientSocket.on('error', (err) => {
-        logger.error('Client socket error:', err);
+        // Handle client socket closure (common for all protocols)
+        clientSocket.on('end', async () => {
+          logger.info('Client disconnected');
+          if (ref && this.connection.hasClientSocket(ref)) {
+            try {
+              await this.rpc.portClose(ref);
+              logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
+              this.connection.deleteClientSocket(ref);
+            } catch (error) {
+              logger.error(`Error closing port on device: ${error}`);
+            }
+          } else {
+            logger.warn('Ref is invalid or no longer in clientSockets.');
+          }
+        });
+
+        // Handle client socket errors
+        clientSocket.on('error', (err) => {
+          logger.error(`Client socket error: ${err}`);
+        });
       });
-    });
 
-    server.listen(localPort, () => {
-      logger.info(`Local server listening on port ${localPort} forwarding to device port ${targetPort}`);
-    });
+      server.listen(localPort, () => {
+        logger.info(`Local server listening on port ${localPort} forwarding to device ${protocol} port ${targetPort}`);
+      });
+      
+      this.servers.set(parseInt(localPort), server);
+    }
     
-    this.servers.set(parseInt(localPort), server);
     return true;
   }
 

package/connection.js

@@ -13,6 +13,8 @@ const DiodeRPC = require('./rpc');
 const abi = require('ethereumjs-abi');
 const logger = require('./logger');
 const path = require('path');
+// Add dotenv for environment variables
+require('dotenv').config();
 
 class DiodeConnection extends EventEmitter {
   constructor(host, port, keyLocation = './db/keys.json') {
@@ -37,9 +39,38 @@ class DiodeConnection extends EventEmitter {
     this.certPem = null;
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
+    
+    // Load reconnection properties from environment variables with defaults
+    const envMaxRetries = process.env.DIODE_MAX_RETRIES;
+    this.maxRetries = envMaxRetries !== undefined ? 
+                      (envMaxRetries.toLowerCase() === 'infinity' ? Infinity : parseInt(envMaxRetries, 10)) : 
+                      Infinity;
+    
+    this.retryDelay = parseInt(process.env.DIODE_RETRY_DELAY, 10) || 1000; // Default: 1 second
+    this.maxRetryDelay = parseInt(process.env.DIODE_MAX_RETRY_DELAY, 10) || 30000; // Default: 30 seconds
+    
+    // Parse boolean from string ('true'/'false')
+    const envAutoReconnect = process.env.DIODE_AUTO_RECONNECT;
+    this.autoReconnect = envAutoReconnect !== undefined ? 
+                        (envAutoReconnect.toLowerCase() === 'true') : 
+                        true;
+    
+    this.retryCount = 0;
+    this.retryTimeoutId = null;
+    
+    // Log the reconnection settings
+    logger.info(`Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
+      this.maxRetries === Infinity ? 'Infinity' : this.maxRetries
+    }, Retry Delay: ${this.retryDelay}ms, Max Retry Delay: ${this.maxRetryDelay}ms`);
   }
 
   connect() {
+    // Clear any existing retry timeout
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
+    }
+
     return new Promise((resolve, reject) => {
       // Generate a temporary certificate valid for 1 month
       this.certPem = generateCert(this.keyPair.prvKeyObj, this.keyPair.pubKeyObj);
@@ -56,8 +87,10 @@ class DiodeConnection extends EventEmitter {
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
         logger.info('Connected to Diode.io server');
+        // Reset retry counter on successful connection
+        this.retryCount = 0;
         // Set keep-alive to prevent connection timeout forever
-        this.socket.setKeepAlive(true, 0);
+        this.socket.setKeepAlive(true, 1500);
   
         // Send the ticketv2 command
         try {
@@ -79,14 +112,87 @@ class DiodeConnection extends EventEmitter {
           logger.error(`Error handling data: ${error}`);
         }
       });
+
       this.socket.on('error', (err) => {
         logger.error(`Connection error: ${err}`);
-        reject(err);
+          reject(err);
+      });
+
+      this.socket.on('end', () => {
+        logger.info('Disconnected from server');
+        this._handleDisconnect();
+      });
+
+      this.socket.on('close', (hadError) => {
+        logger.info(`Connection closed${hadError ? ' due to error' : ''}`);
+        this._handleDisconnect();
+      });
+
+      this.socket.on('timeout', () => {
+        logger.warn('Connection timeout');
+        this._handleDisconnect();
       });
-      this.socket.on('end', () => logger.info('Disconnected from server'));
     });
   }
 
+  // New method to handle reconnection with exponential backoff
+  _reconnect() {
+    if (!this.autoReconnect || this.isReconnecting) return;
+    
+    this.retryCount++;
+    
+    if (this.maxRetries !== Infinity && this.retryCount > this.maxRetries) {
+      logger.error(`Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
+      this.emit('reconnect_failed');
+      return;
+    }
+    
+    // Calculate delay with exponential backoff
+    const delay = Math.min(this.retryDelay * Math.pow(1.5, this.retryCount - 1), this.maxRetryDelay);
+    
+    logger.info(`Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
+    this.emit('reconnecting', { attempt: this.retryCount, delay });
+    
+    this.retryTimeoutId = setTimeout(() => {
+      this.isReconnecting = true;
+      
+      // Clear existing socket if any
+      if (this.socket) {
+        this.socket.removeAllListeners();
+        if (!this.socket.destroyed) {
+          this.socket.destroy();
+        }
+        this.socket = null;
+      }
+      
+      // Connect again
+      this.connect()
+        .then(() => {
+          this.isReconnecting = false;
+          this.emit('reconnected');
+          logger.info('Successfully reconnected to Diode.io server');
+        })
+        .catch((err) => {
+          this.isReconnecting = false;
+          logger.error(`Reconnection attempt failed: ${err}`);
+        });
+    }, delay);
+  }
+
+  // Helper method to handle disconnection events
+  _handleDisconnect() {
+    // Reset socket to null to ensure we don't try to use it
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.destroy();
+    }
+    this.socket = null;
+    
+    // Don't try to reconnect if we're intentionally closing
+    if (this.autoReconnect && !this.isReconnecting) {
+      this._reconnect();
+    }
+  }
+
   _ensureConnected() {
     if (this.socket && !this.socket.destroyed) {
       return Promise.resolve();
@@ -94,20 +200,58 @@ class DiodeConnection extends EventEmitter {
     if (this.connectPromise) {
       return this.connectPromise;
     }
-    this.isReconnecting = true;
-    this.connectPromise = this.connect()
-      .then(() => {
-        this.isReconnecting = false;
-        this.connectPromise = null;
-      })
-      .catch((err) => {
-        this.isReconnecting = false;
-        this.connectPromise = null;
-        throw err;
-      });
+    
+    this.connectPromise = new Promise((resolve, reject) => {
+
+      if (this.isReconnecting) {
+        // If we're already reconnecting, wait for the reconnection to complete
+        this.once('reconnected', resolve);
+        //wait for max retry delay
+        setTimeout(() => {
+          reject(new Error('Reconnection timed out'));
+        }, this.maxRetryDelay);
+      } else {
+        this._reconnect();
+        this.once('reconnected', resolve);
+        //wait for max retry delay
+        setTimeout(() => {
+          reject(new Error('Reconnection timed out'));
+        }, this.maxRetryDelay);
+      }
+    });
+    
     return this.connectPromise;
   }
 
+  // Method to set reconnection options
+  setReconnectOptions(options = {}) {
+    if (typeof options.maxRetries === 'number') {
+      this.maxRetries = options.maxRetries;
+    }
+    if (typeof options.retryDelay === 'number') {
+      this.retryDelay = options.retryDelay;
+    }
+    if (typeof options.maxRetryDelay === 'number') {
+      this.maxRetryDelay = options.maxRetryDelay;
+    }
+    if (typeof options.autoReconnect === 'boolean') {
+      this.autoReconnect = options.autoReconnect;
+    }
+    return this;
+  }
+
+  // Update close method to prevent reconnection when intentionally closing
+  close() {
+    this.autoReconnect = false;
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
+    }
+    if (this.socket) {
+      this.socket.end();
+    }
+  }
+
   _handleData(data) {
     // Append new data to the receive buffer
     this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
@@ -428,10 +572,6 @@ class DiodeConnection extends EventEmitter {
     return this.requestId;
   }
 
-  close() {
-    this.socket.end();
-  }
-
   // Client sockets management methods (for BindPort)
   addClientSocket(ref, socket) {
     this.clientSockets.set(ref.toString('hex'), socket);

package/examples/portForwardTest.js

@@ -9,8 +9,8 @@ async function main() {
     await connection.connect();
   
     const portForward = new BindPort(connection, {
-        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039" },
-        3004: { targetPort: 443, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" }
+        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", protocol: "tcp" },
+        3004: { targetPort: 8081, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2", protocol: "tls" }
       });
     portForward.bind();
 
@@ -23,7 +23,7 @@ async function main() {
     // after 10 seconds, add port 3003 back
     setTimeout(() => {
         console.log("Adding port 3003 back");
-        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039");
+        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", "tcp");
     }, 10000);
     
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {

package/publishPort.js

@@ -254,7 +254,7 @@ class PublishPort extends EventEmitter {
     // Create a DiodeSocket instance
     const diodeSocket = new DiodeSocket(ref, this.rpc);
 
-    certPem = this.connection.getDeviceCertificate();
+    const certPem = this.connection.getDeviceCertificate();
 
     // TLS options with your server's certificate and key
     const tlsOptions = {