@push.rocks/smartnetwork 4.0.2 → 4.1.0

package/dist_ts/smartnetwork.classes.smartnetwork.d.ts

@@ -67,6 +67,13 @@ export declare class SmartNetwork {
      * Check if a local port is unused (both IPv4 and IPv6)
      */
     isLocalPortUnused(port: number): Promise<boolean>;
+    /**
+     * Find the first available port within a given range
+     * @param startPort The start of the port range (inclusive)
+     * @param endPort The end of the port range (inclusive)
+     * @returns The first available port number, or null if no ports are available
+     */
+    findFreePort(startPort: number, endPort: number): Promise<number | null>;
     /**
      * checks wether a remote port is available
      * @param domainArg

package/dist_ts/smartnetwork.classes.smartnetwork.js

@@ -116,6 +116,30 @@ export class SmartNetwork {
         const result = resultIpV4 === true && resultIpV6 === true;
         return result;
     }
+    /**
+     * Find the first available port within a given range
+     * @param startPort The start of the port range (inclusive)
+     * @param endPort The end of the port range (inclusive)
+     * @returns The first available port number, or null if no ports are available
+     */
+    async findFreePort(startPort, endPort) {
+        // Validate port range
+        if (startPort < 1 || startPort > 65535 || endPort < 1 || endPort > 65535) {
+            throw new NetworkError('Port numbers must be between 1 and 65535', 'EINVAL');
+        }
+        if (startPort > endPort) {
+            throw new NetworkError('Start port must be less than or equal to end port', 'EINVAL');
+        }
+        // Check each port in the range
+        for (let port = startPort; port <= endPort; port++) {
+            const isUnused = await this.isLocalPortUnused(port);
+            if (isUnused) {
+                return port;
+            }
+        }
+        // No free port found in the range
+        return null;
+    }
     /**
      * checks wether a remote port is available
      * @param domainArg
@@ -313,4 +337,4 @@ export class SmartNetwork {
         return value;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartnetwork.classes.smartnetwork.js","sourceRoot":"","sources":["../ts/smartnetwork.classes.smartnetwork.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartnetwork.classes.smartnetwork.js","sourceRoot":"","sources":["../ts/smartnetwork.classes.smartnetwork.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartnetwork",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "private": false,
   "description": "A toolkit for network diagnostics including speed tests, port availability checks, and more.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -1,6 +1,6 @@
 # @push.rocks/smartnetwork
 
-network diagnostics
+Comprehensive network diagnostics and utilities for Node.js applications
 
 ## Install
 
@@ -10,20 +10,9 @@ To install `@push.rocks/smartnetwork`, run the following command in your termina
 npm install @push.rocks/smartnetwork --save
 ```
 
-### Performing a Traceroute
-
-You can perform a hop-by-hop traceroute to measure latency per hop. Falls back to a single-hop stub if the `traceroute` binary is unavailable.
-
-```typescript
-const hops = await myNetwork.traceroute('google.com', { maxHops: 10, timeout: 5000 });
-hops.forEach((h) => console.log(`${h.ttl}\t${h.ip}\t${h.rtt === null ? '*' : h.rtt + ' ms'}`));
-```
-
-This command will download `@push.rocks/smartnetwork` and add it to your project's `package.json` file.
-
 ## Usage
 
-In this section, we will dive deep into the capabilities of the `@push.rocks/smartnetwork` package, exploring its various features through TypeScript examples. The package is designed to simplify network diagnostics tasks, including speed tests, port availability checks, ping operations, and more.
+The `@push.rocks/smartnetwork` package provides a comprehensive suite of network diagnostic tools including speed tests, port availability checks, ping operations, DNS resolution, HTTP endpoint health checks, and more.
 
 ### Basic Setup
 
@@ -37,135 +26,294 @@ Then, create an instance of `SmartNetwork`:
 
 ```typescript
 const myNetwork = new SmartNetwork();
-```
 
-### Performing a Speed Test
+// Or with caching enabled (60 seconds TTL)
+const myNetworkCached = new SmartNetwork({ cacheTtl: 60000 });
+```
 
-You can measure the network speed using the `getSpeed` method. It supports optional parameters:
+### Network Speed Testing
 
-- `parallelStreams`: number of concurrent streams (default: 1)
-- `duration`: test duration in seconds (default: fixed segments)
+Measure network download and upload speeds using Cloudflare's speed test infrastructure:
 
 ```typescript
 const speedTest = async () => {
-  // Default fixed-segment test
-  let r = await myNetwork.getSpeed();
-  console.log(`Download: ${r.downloadSpeed} Mbps, Upload: ${r.uploadSpeed} Mbps`);
-
-  // Parallel + duration-based test
-  r = await myNetwork.getSpeed({ parallelStreams: 3, duration: 5 });
-  console.log(`Download: ${r.downloadSpeed} Mbps, Upload: ${r.uploadSpeed} Mbps`);
+  // Basic speed test
+  const result = await myNetwork.getSpeed();
+  console.log(`Download: ${result.downloadSpeed} Mbps`);
+  console.log(`Upload: ${result.uploadSpeed} Mbps`);
+
+  // Advanced speed test with options
+  const advancedResult = await myNetwork.getSpeed({ 
+    parallelStreams: 3,  // Number of concurrent connections
+    duration: 5          // Test duration in seconds
+  });
+  console.log(`Download: ${advancedResult.downloadSpeed} Mbps`);
+  console.log(`Upload: ${advancedResult.uploadSpeed} Mbps`);
 };
-
-speedTest();
 ```
 
-### Checking Port Availability Locally
+### Port Management
+
+#### Check Local Port Availability
 
-The `isLocalPortUnused` method allows you to check if a specific port on your local machine is available for use.
+Verify if a specific port is available on your local machine (checks both IPv4 and IPv6):
 
 ```typescript
 const checkLocalPort = async (port: number) => {
   const isUnused = await myNetwork.isLocalPortUnused(port);
   if (isUnused) {
-    console.log(`Port ${port} is available.`);
+    console.log(`Port ${port} is available`);
   } else {
-    console.log(`Port ${port} is in use.`);
+    console.log(`Port ${port} is in use`);
   }
 };
 
-checkLocalPort(8080); // Example port number
+await checkLocalPort(8080);
+```
+
+#### Find Free Port in Range
+
+Automatically find the first available port within a specified range:
+
+```typescript
+const findFreePort = async () => {
+  // Find a free port between 3000 and 3100
+  const freePort = await myNetwork.findFreePort(3000, 3100);
+  
+  if (freePort) {
+    console.log(`Found free port: ${freePort}`);
+  } else {
+    console.log('No free ports available in the specified range');
+  }
+};
 ```
 
-### Checking Remote Port Availability
+#### Check Remote Port Availability
 
-To verify if a port is available on a remote server, use `isRemotePortAvailable`. You can specify target as `"host:port"` or host plus a numeric port.
+Verify if a port is open on a remote server:
 
 ```typescript
-// Using "host:port"
-await myNetwork.isRemotePortAvailable('example.com:443');
+// Method 1: Using "host:port" syntax
+const isOpen1 = await myNetwork.isRemotePortAvailable('example.com:443');
+
+// Method 2: Using separate host and port
+const isOpen2 = await myNetwork.isRemotePortAvailable('example.com', 443);
 
-// Using host + port
-await myNetwork.isRemotePortAvailable('example.com', 443);
+// Method 3: With options (retries, timeout)
+const isOpen3 = await myNetwork.isRemotePortAvailable('example.com', {
+  port: 443,
+  protocol: 'tcp',     // Only TCP is supported
+  retries: 3,          // Number of connection attempts
+  timeout: 5000        // Timeout per attempt in ms
+});
 
-// UDP is not supported:
+// Note: UDP is not supported and will throw an error
 try {
-  await myNetwork.isRemotePortAvailable('example.com', { port: 53, protocol: 'udp' });
+  await myNetwork.isRemotePortAvailable('example.com', { 
+    port: 53, 
+    protocol: 'udp' 
+  });
 } catch (e) {
-  console.error((e as any).code); // ENOTSUP
+  console.error(e.code); // ENOTSUP
 }
 ```
 
-### Using Ping
+### Network Connectivity
+
+#### Ping Operations
 
-The `ping` method sends ICMP echo requests and optionally repeats them to collect statistics.
+Send ICMP echo requests to test connectivity and measure latency:
 
 ```typescript
-// Single ping
-const p1 = await myNetwork.ping('google.com');
-console.log(`Alive: ${p1.alive}, RTT: ${p1.time} ms`);
+// Simple ping
+const pingResult = await myNetwork.ping('google.com');
+console.log(`Host alive: ${pingResult.alive}`);
+console.log(`RTT: ${pingResult.time} ms`);
+
+// Ping with statistics (multiple pings)
+const pingStats = await myNetwork.ping('google.com', { 
+  count: 5,          // Number of pings
+  timeout: 1000      // Timeout per ping in ms
+});
+
+console.log(`Packet loss: ${pingStats.packetLoss}%`);
+console.log(`Min: ${pingStats.min} ms`);
+console.log(`Max: ${pingStats.max} ms`);
+console.log(`Avg: ${pingStats.avg.toFixed(2)} ms`);
+console.log(`Stddev: ${pingStats.stddev.toFixed(2)} ms`);
+```
+
+#### Traceroute
 
-// Multiple pings with statistics
-const stats = await myNetwork.ping('google.com', { count: 5 });
-console.log(
-  `min=${stats.min} ms, max=${stats.max} ms, avg=${stats.avg.toFixed(2)} ms, loss=${stats.packetLoss}%`,
-);
+Perform hop-by-hop network path analysis:
+
+```typescript
+const hops = await myNetwork.traceroute('google.com', { 
+  maxHops: 10,      // Maximum number of hops
+  timeout: 5000     // Timeout in ms
+});
+
+hops.forEach(hop => {
+  const rtt = hop.rtt === null ? '*' : `${hop.rtt} ms`;
+  console.log(`${hop.ttl}\t${hop.ip}\t${rtt}`);
+});
 ```
 
-### Getting Network Gateways
+Note: Falls back to a single-hop stub if the `traceroute` binary is unavailable on the system.
 
-You can also retrieve network interfaces (gateways) and determine the default gateway. Caching with TTL is supported via constructor options.
+### DNS Operations
+
+Resolve DNS records for a hostname:
 
 ```typescript
-// Create with cache TTL of 60 seconds
-const netCached = new SmartNetwork({ cacheTtl: 60000 });
+const dnsRecords = await myNetwork.resolveDns('example.com');
 
-// List all interfaces
-const gateways = await netCached.getGateways();
-console.log(gateways);
+console.log('A records:', dnsRecords.A);        // IPv4 addresses
+console.log('AAAA records:', dnsRecords.AAAA);  // IPv6 addresses
+console.log('MX records:', dnsRecords.MX);      // Mail servers
 
-// Get default gateway
-const defaultGw = await netCached.getDefaultGateway();
-console.log(defaultGw);
+// MX records include priority
+dnsRecords.MX.forEach(mx => {
+  console.log(`Mail server: ${mx.exchange} (priority: ${mx.priority})`);
+});
 ```
 
-### Discovering Public IP Addresses
+### HTTP/HTTPS Endpoint Health Checks
 
-To find out your public IPv4 and IPv6 addresses (with caching):
+Check the health and response time of HTTP/HTTPS endpoints:
 
 ```typescript
-const publicIps = await netCached.getPublicIps();
-console.log(`Public IPv4: ${publicIps.v4}`);
-console.log(`Public IPv6: ${publicIps.v6}`);
+const health = await myNetwork.checkEndpoint('https://example.com', {
+  timeout: 5000  // Request timeout in ms
+});
+
+console.log(`Status: ${health.status}`);
+console.log(`RTT: ${health.rtt} ms`);
+console.log('Headers:', health.headers);
 ```
 
-The `@push.rocks/smartnetwork` package provides an easy-to-use, comprehensive suite of tools for network diagnostics and monitoring, encapsulating complex network operations into simple asynchronous methods. By leveraging TypeScript, developers can benefit from type checking, ensuring that they can work with clear structures and expectations.
+### Network Interface Information
 
-These examples offer a glimpse into the module's utility in real-world scenarios, demonstrating its versatility in handling common network tasks. Whether you're developing a network-sensitive application, diagnosing connectivity issues, or simply curious about your network performance, `@push.rocks/smartnetwork` equips you with the tools you need.
+#### Get Network Gateways
 
-### Plugin Architecture
+List all network interfaces on the system:
+
+```typescript
+const gateways = await myNetwork.getGateways();
+
+Object.entries(gateways).forEach(([name, interfaces]) => {
+  console.log(`Interface: ${name}`);
+  interfaces.forEach(iface => {
+    console.log(`  ${iface.family}: ${iface.address}`);
+    console.log(`  Netmask: ${iface.netmask}`);
+    console.log(`  MAC: ${iface.mac}`);
+  });
+});
+```
+
+#### Get Default Gateway
 
-You can extend `SmartNetwork` with custom plugins by registering them at runtime:
+Retrieve the system's default network gateway:
 
 ```typescript
-import { SmartNetwork } from '@push.rocks/smartnetwork';
+const defaultGateway = await myNetwork.getDefaultGateway();
+
+if (defaultGateway) {
+  console.log('IPv4 Gateway:', defaultGateway.ipv4.address);
+  console.log('IPv6 Gateway:', defaultGateway.ipv6.address);
+}
+```
 
-// Define your plugin class or constructor
-class MyCustomPlugin {
-  // plugin implementation goes here
+### Public IP Discovery
+
+Discover your public IPv4 and IPv6 addresses:
+
+```typescript
+const publicIps = await myNetwork.getPublicIps();
+
+console.log(`Public IPv4: ${publicIps.v4 || 'Not available'}`);
+console.log(`Public IPv6: ${publicIps.v6 || 'Not available'}`);
+```
+
+### Caching
+
+SmartNetwork supports caching for gateway and public IP lookups to reduce repeated network calls:
+
+```typescript
+// Create instance with 60-second cache TTL
+const cachedNetwork = new SmartNetwork({ cacheTtl: 60000 });
+
+// These calls will use cached results if called within 60 seconds
+const gateways1 = await cachedNetwork.getGateways();
+const publicIps1 = await cachedNetwork.getPublicIps();
+
+// Subsequent calls within TTL return cached results
+const gateways2 = await cachedNetwork.getGateways();    // From cache
+const publicIps2 = await cachedNetwork.getPublicIps();  // From cache
+```
+
+### Plugin Architecture
+
+Extend SmartNetwork's functionality with custom plugins:
+
+```typescript
+// Define your plugin
+class CustomNetworkPlugin {
+  constructor(private smartNetwork: SmartNetwork) {}
+  
+  async customMethod() {
+    // Your custom network functionality
+  }
 }
 
-// Register and unregister your plugin by name
-SmartNetwork.registerPlugin('myPlugin', MyCustomPlugin);
-// Later, remove it if no longer needed
-SmartNetwork.unregisterPlugin('myPlugin');
+// Register the plugin
+SmartNetwork.registerPlugin('customPlugin', CustomNetworkPlugin);
+
+// Use the plugin
+const network = new SmartNetwork();
+const plugin = new (SmartNetwork.pluginsRegistry.get('customPlugin'))(network);
+await plugin.customMethod();
+
+// Unregister when no longer needed
+SmartNetwork.unregisterPlugin('customPlugin');
+```
+
+### Error Handling
+
+The package uses custom `NetworkError` class for network-related errors:
+
+```typescript
+import { NetworkError } from '@push.rocks/smartnetwork';
+
+try {
+  await myNetwork.isRemotePortAvailable('example.com', { protocol: 'udp' });
+} catch (error) {
+  if (error instanceof NetworkError) {
+    console.error(`Network error: ${error.message}`);
+    console.error(`Error code: ${error.code}`);
+  }
+}
 ```
 
-Plugins enable you to dynamically augment the core functionality without altering the library's source.
+### TypeScript Support
+
+This package is written in TypeScript and provides full type definitions. Key interfaces include:
+
+```typescript
+interface SmartNetworkOptions {
+  cacheTtl?: number;  // Cache TTL in milliseconds
+}
+
+interface Hop {
+  ttl: number;        // Time to live
+  ip: string;         // IP address of the hop
+  rtt: number | null; // Round trip time in ms
+}
+```
 
 ## License and Legal Information
 
-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 
@@ -180,4 +328,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/smartnetwork.classes.smartnetwork.ts

@@ -143,6 +143,33 @@ export class SmartNetwork {
     return result;
   }
 
+  /**
+   * Find the first available port within a given range
+   * @param startPort The start of the port range (inclusive)
+   * @param endPort The end of the port range (inclusive)
+   * @returns The first available port number, or null if no ports are available
+   */
+  public async findFreePort(startPort: number, endPort: number): Promise<number | null> {
+    // Validate port range
+    if (startPort < 1 || startPort > 65535 || endPort < 1 || endPort > 65535) {
+      throw new NetworkError('Port numbers must be between 1 and 65535', 'EINVAL');
+    }
+    if (startPort > endPort) {
+      throw new NetworkError('Start port must be less than or equal to end port', 'EINVAL');
+    }
+
+    // Check each port in the range
+    for (let port = startPort; port <= endPort; port++) {
+      const isUnused = await this.isLocalPortUnused(port);
+      if (isUnused) {
+        return port;
+      }
+    }
+
+    // No free port found in the range
+    return null;
+  }
+
   /**
    * checks wether a remote port is available
    * @param domainArg