@push.rocks/smartnetwork 4.3.0 → 4.5.0

package/dist_ts/smartnetwork.classes.rustbridge.js

@@ -0,0 +1,98 @@
+import * as plugins from './smartnetwork.plugins.js';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function getPlatformSuffix() {
+    const platform = process.platform;
+    const arch = process.arch;
+    const platformMap = {
+        linux: 'linux',
+        darwin: 'macos',
+        win32: 'windows',
+    };
+    const archMap = {
+        x64: 'amd64',
+        arm64: 'arm64',
+    };
+    const p = platformMap[platform];
+    const a = archMap[arch];
+    if (p && a) {
+        return `${p}_${a}`;
+    }
+    return null;
+}
+/**
+ * Singleton bridge to the rustnetwork binary.
+ * Manages the IPC lifecycle for network diagnostics operations.
+ */
+export class RustNetworkBridge {
+    static { this.instance = null; }
+    static getInstance() {
+        if (!RustNetworkBridge.instance) {
+            RustNetworkBridge.instance = new RustNetworkBridge();
+        }
+        return RustNetworkBridge.instance;
+    }
+    constructor() {
+        const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+        const platformSuffix = getPlatformSuffix();
+        const localPaths = [];
+        // Platform-specific cross-compiled binary
+        if (platformSuffix) {
+            localPaths.push(path.join(packageDir, 'dist_rust', `rustnetwork_${platformSuffix}`));
+        }
+        // Native build without suffix
+        localPaths.push(path.join(packageDir, 'dist_rust', 'rustnetwork'));
+        // Local dev paths
+        localPaths.push(path.join(packageDir, 'rust', 'target', 'release', 'rustnetwork'));
+        localPaths.push(path.join(packageDir, 'rust', 'target', 'debug', 'rustnetwork'));
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'rustnetwork',
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30_000,
+            readyTimeoutMs: 10_000,
+            localPaths,
+            searchSystemPath: false,
+        });
+    }
+    /**
+     * Spawn the Rust binary and wait for it to be ready.
+     */
+    async start() {
+        const ok = await this.bridge.spawn();
+        if (!ok) {
+            throw new Error('Failed to spawn rustnetwork binary');
+        }
+    }
+    /**
+     * Kill the Rust binary.
+     */
+    async stop() {
+        this.bridge.kill();
+    }
+    /**
+     * Ensure the bridge is running before sending a command.
+     */
+    async ensureRunning() {
+        // The bridge will throw if not spawned — we just call start() if not yet running
+    }
+    // ===== Command wrappers =====
+    async ping(host, count, timeoutMs) {
+        return this.bridge.sendCommand('ping', { host, count, timeoutMs });
+    }
+    async traceroute(host, maxHops, timeoutMs) {
+        return this.bridge.sendCommand('traceroute', { host, maxHops, timeoutMs });
+    }
+    async tcpPortCheck(host, port, timeoutMs) {
+        return this.bridge.sendCommand('tcpPortCheck', { host, port, timeoutMs });
+    }
+    async isLocalPortFree(port) {
+        return this.bridge.sendCommand('isLocalPortFree', { port });
+    }
+    async defaultGateway() {
+        return this.bridge.sendCommand('defaultGateway', {});
+    }
+    async healthPing() {
+        return this.bridge.sendCommand('healthPing', {});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRuZXR3b3JrLmNsYXNzZXMucnVzdGJyaWRnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0bmV0d29yay5jbGFzc2VzLnJ1c3RicmlkZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSwyQkFBMkIsQ0FBQztBQUNyRCxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBOEN6QyxTQUFTLGlCQUFpQjtJQUN4QixNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDO0lBQ2xDLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUM7SUFFMUIsTUFBTSxXQUFXLEdBQTJCO1FBQzFDLEtBQUssRUFBRSxPQUFPO1FBQ2QsTUFBTSxFQUFFLE9BQU87UUFDZixLQUFLLEVBQUUsU0FBUztLQUNqQixDQUFDO0lBRUYsTUFBTSxPQUFPLEdBQTJCO1FBQ3RDLEdBQUcsRUFBRSxPQUFPO1FBQ1osS0FBSyxFQUFFLE9BQU87S0FDZixDQUFDO0lBRUYsTUFBTSxDQUFDLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2hDLE1BQU0sQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUV4QixJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUNYLE9BQU8sR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7SUFDckIsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sT0FBTyxpQkFBaUI7YUFDYixhQUFRLEdBQTZCLElBQUksQ0FBQztJQUVsRCxNQUFNLENBQUMsV0FBVztRQUN2QixJQUFJLENBQUMsaUJBQWlCLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDaEMsaUJBQWlCLENBQUMsUUFBUSxHQUFHLElBQUksaUJBQWlCLEVBQUUsQ0FBQztRQUN2RCxDQUFDO1FBQ0QsT0FBTyxpQkFBaUIsQ0FBQyxRQUFRLENBQUM7SUFDcEMsQ0FBQztJQUlEO1FBQ0UsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FDN0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUM1QyxJQUFJLENBQ0wsQ0FBQztRQUVGLE1BQU0sY0FBYyxHQUFHLGlCQUFpQixFQUFFLENBQUM7UUFDM0MsTUFBTSxVQUFVLEdBQWEsRUFBRSxDQUFDO1FBRWhDLDBDQUEwQztRQUMxQyxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ25CLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsV0FBVyxFQUFFLGVBQWUsY0FBYyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3ZGLENBQUM7UUFDRCw4QkFBOEI7UUFDOUIsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxXQUFXLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQztRQUNuRSxrQkFBa0I7UUFDbEIsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDO1FBQ25GLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQztRQUVqRixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQW1CO1lBQy9ELFVBQVUsRUFBRSxhQUFhO1lBQ3pCLE9BQU8sRUFBRSxDQUFDLGNBQWMsQ0FBQztZQUN6QixnQkFBZ0IsRUFBRSxNQUFNO1lBQ3hCLGNBQWMsRUFBRSxNQUFNO1lBQ3RCLFVBQVU7WUFDVixnQkFBZ0IsRUFBRSxLQUFLO1NBQ3hCLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLE1BQU0sRUFBRSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNyQyxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDUixNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7UUFDeEQsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQ7O09BRUc7SUFDSyxLQUFLLENBQUMsYUFBYTtRQUN6QixpRkFBaUY7SUFDbkYsQ0FBQztJQUVELCtCQUErQjtJQUV4QixLQUFLLENBQUMsSUFBSSxDQUNmLElBQVksRUFDWixLQUFjLEVBQ2QsU0FBa0I7UUFFbEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVLENBQ3JCLElBQVksRUFDWixPQUFnQixFQUNoQixTQUFrQjtRQUVsQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUM3RSxDQUFDO0lBRU0sS0FBSyxDQUFDLFlBQVksQ0FDdkIsSUFBWSxFQUNaLElBQVksRUFDWixTQUFrQjtRQUVsQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGNBQWMsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUM1RSxDQUFDO0lBRU0sS0FBSyxDQUFDLGVBQWUsQ0FDMUIsSUFBWTtRQUVaLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsaUJBQWlCLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFTSxLQUFLLENBQUMsY0FBYztRQUN6QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGdCQUFnQixFQUFFLEVBQTJCLENBQUMsQ0FBQztJQUNoRixDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVU7UUFDckIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxZQUFZLEVBQUUsRUFBMkIsQ0FBQyxDQUFDO0lBQzVFLENBQUMifQ==

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

@@ -1,7 +1,5 @@
 import * as plugins from './smartnetwork.plugins.js';
-/**
- * SmartNetwork simplifies actions within the network
- */
+import { type IIpIntelligenceResult } from './smartnetwork.classes.ipintelligence.js';
 /**
  * Configuration options for SmartNetwork
  */
@@ -23,7 +21,13 @@ export interface Hop {
 export interface IFindFreePortOptions {
     /** If true, selects a random available port within the range instead of the first one */
     randomize?: boolean;
+    /** Array of port numbers to exclude from the search */
+    exclude?: number[];
 }
+/**
+ * SmartNetwork simplifies actions within the network.
+ * Uses a Rust binary for system-dependent operations (ping, traceroute, port scanning, gateway detection).
+ */
 export declare class SmartNetwork {
     /** Static registry for external plugins */
     static pluginsRegistry: Map<string, any>;
@@ -33,10 +37,25 @@ export declare class SmartNetwork {
     static unregisterPlugin(name: string): void;
     private options;
     private cache;
+    private rustBridge;
+    private bridgeStarted;
+    private ipIntelligence;
     constructor(options?: SmartNetworkOptions);
     /**
-     * get network speed
-     * @param opts optional speed test parameters
+     * Start the Rust binary bridge. Must be called before using ping, traceroute,
+     * port scanning, or gateway operations. Safe to call multiple times.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the Rust binary bridge.
+     */
+    stop(): Promise<void>;
+    /**
+     * Ensure the Rust bridge is running before sending commands.
+     */
+    private ensureBridge;
+    /**
+     * Get network speed via Cloudflare speed test (pure TS, no Rust needed).
      */
     getSpeed(opts?: {
         parallelStreams?: number;
@@ -65,36 +84,16 @@ export declare class SmartNetwork {
         timeout?: number;
         count?: number;
     }): Promise<any>;
-    /**
-     * returns a promise with a boolean answer
-     * note: false also resolves with false as argument
-     * @param port
-     */
     /**
      * 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)
-     * @param options Optional configuration for port selection behavior
-     * @returns The first available port number (or random if options.randomize is true), or null if no ports are available
      */
     findFreePort(startPort: number, endPort: number, options?: IFindFreePortOptions): Promise<number | null>;
-    /**
-     * checks wether a remote port is available
-     * @param domainArg
-     */
-    /**
-     * Check if a remote port is available
-     * @param target host or "host:port"
-     * @param opts options including port, protocol (only tcp), retries and timeout
-     */
     /**
      * Check if a remote port is available
-     * @param target host or "host:port"
-     * @param portOrOpts either a port number (deprecated) or options object
      */
     isRemotePortAvailable(target: string, portOrOpts?: number | {
         port?: number;
@@ -103,22 +102,25 @@ export declare class SmartNetwork {
         retries?: number;
     }): Promise<boolean>;
     /**
-     * List network interfaces (gateways)
+     * List network interfaces (gateways) — pure TS, no Rust needed.
      */
     getGateways(): Promise<Record<string, plugins.os.NetworkInterfaceInfo[]>>;
+    /**
+     * Get the default gateway interface and its addresses.
+     */
     getDefaultGateway(): Promise<{
         ipv4: plugins.os.NetworkInterfaceInfo;
         ipv6: plugins.os.NetworkInterfaceInfo;
-    }>;
+    } | null>;
     /**
-     * Lookup public IPv4 and IPv6
+     * Lookup public IPv4 and IPv6 — pure TS, no Rust needed.
      */
     getPublicIps(): Promise<{
         v4: string | null;
         v6: string | null;
     }>;
     /**
-     * Resolve DNS records (A, AAAA, MX)
+     * Resolve DNS records (A, AAAA, MX) — uses smartdns, no Rust needed.
      */
     resolveDns(host: string): Promise<{
         A: string[];
@@ -129,23 +131,29 @@ export declare class SmartNetwork {
         }[];
     }>;
     /**
-     * Perform a simple HTTP/HTTPS endpoint health check
+     * Perform a simple HTTP/HTTPS endpoint health check — pure TS.
      */
     checkEndpoint(urlString: string, opts?: {
         timeout?: number;
+        rejectUnauthorized?: boolean;
     }): Promise<{
         status: number;
         headers: Record<string, string>;
         rtt: number;
     }>;
     /**
-     * Perform a traceroute: hop-by-hop latency using the system traceroute tool.
-     * Falls back to a single-hop stub if traceroute is unavailable or errors.
+     * Perform a traceroute: hop-by-hop latency using the Rust binary.
      */
     traceroute(host: string, opts?: {
         maxHops?: number;
         timeout?: number;
     }): Promise<Hop[]>;
+    /**
+     * Get IP intelligence: ASN, organization, geolocation, and RDAP registration data.
+     * Combines RDAP (RIRs), Team Cymru DNS, and MaxMind GeoLite2 — all run in parallel.
+     * Pure TS, no Rust needed.
+     */
+    getIpIntelligence(ip: string): Promise<IIpIntelligenceResult>;
     /**
      * Internal caching helper
      */