@push.rocks/smartnetwork 4.9.0 → 4.10.1

package/ts/smartnetwork.classes.ipintelligence.ts

@@ -53,9 +53,9 @@ export interface IIpIntelligenceOptions {
   timeout?: number;
   /**
    * Optional injected smartdns client. When provided, IpIntelligence will
-   * not create or destroy its own client (the owner — typically SmartNetwork —
+   * not create or terminate its own client (the owner — typically SmartNetwork —
    * manages lifecycle). When omitted, a short-lived client is created per
-   * Team Cymru lookup and destroyed in finally.
+   * Team Cymru lookup and terminated in finally.
    */
   dnsClient?: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>;
 }
@@ -64,30 +64,12 @@ export interface IIpIntelligenceOptions {
 const CITY_MMDB_URL = 'https://cdn.jsdelivr.net/npm/@ip-location-db/geolite2-city-mmdb/geolite2-city-ipv4.mmdb';
 const ASN_MMDB_URL = 'https://cdn.jsdelivr.net/npm/@ip-location-db/geolite2-asn-mmdb/geolite2-asn-ipv4.mmdb';
 
-// IANA bootstrap for RDAP
-const IANA_BOOTSTRAP_IPV4_URL = 'https://data.iana.org/rdap/ipv4.json';
-
 const DEFAULT_DB_MAX_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days
 const DEFAULT_TIMEOUT = 5000;
 
-/**
- * Parsed IANA bootstrap entry: a CIDR prefix mapped to an RDAP base URL
- */
-interface IBootstrapEntry {
-  prefix: string;
-  prefixNum: number;  // numeric representation of the network address
-  maskBits: number;
-  baseUrl: string;
-}
-
-interface IRdapNetworkInfo {
-  networkRange: string | null;
-  networkCidrs: string[] | null;
-}
-
 /**
  * IpIntelligence provides IP address intelligence by combining three data sources:
- * - RDAP (direct to RIRs) for registration/org data
+ * - RDAP (direct to RIRs, via @push.rocks/smartwhois) for registration/org data
  * - Team Cymru DNS for ASN
  * - MaxMind GeoLite2 (in-memory MMDB) for geolocation
  */
@@ -102,17 +84,23 @@ export class IpIntelligence {
   private lastFetchTime = 0;
   private refreshPromise: Promise<void> | null = null;
 
-  // RDAP bootstrap cache
-  private bootstrapEntries: IBootstrapEntry[] | null = null;
-  private bootstrapPromise: Promise<void> | null = null;
+  // RDAP client from smartwhois (owns bootstrap caching and RIR matching)
+  private readonly rdapClient: plugins.smartwhois.RdapClient;
 
   // Optional injected smartdns client (shared by SmartNetwork)
   private readonly sharedDnsClient: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns> | null;
+  private ownedDnsClient: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns> | null = null;
+  private dnsLifecycleQueue: Promise<void> = Promise.resolve();
 
   constructor(options?: IIpIntelligenceOptions) {
     this.dbMaxAge = options?.dbMaxAge ?? DEFAULT_DB_MAX_AGE;
     this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
     this.sharedDnsClient = options?.dnsClient ?? null;
+    this.rdapClient = new plugins.smartwhois.RdapClient({
+      requestTimeoutMs: this.timeout,
+      totalTimeoutMs: this.timeout,
+      userAgent: '@push.rocks/smartnetwork',
+    });
   }
 
   /**
@@ -144,6 +132,10 @@ export class IpIntelligence {
       this.queryMaxMind(ip),
     ]);
 
+    if (cymruResult.status === 'rejected') {
+      throw cymruResult.reason;
+    }
+
     // Merge RDAP results
     if (rdapResult.status === 'fulfilled' && rdapResult.value) {
       const rdap = rdapResult.value;
@@ -186,80 +178,16 @@ export class IpIntelligence {
     return result;
   }
 
-  // ─── RDAP Subsystem ─────────────────────────────────────────────────
-
-  /**
-   * Load and cache the IANA RDAP bootstrap file
-   */
-  private async ensureBootstrap(): Promise<void> {
-    if (this.bootstrapEntries) return;
-    if (this.bootstrapPromise) {
-      await this.bootstrapPromise;
-      return;
-    }
-
-    this.bootstrapPromise = (async () => {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-          const response = await fetch(IANA_BOOTSTRAP_IPV4_URL, {
-            signal: controller.signal,
-            headers: { 'User-Agent': '@push.rocks/smartnetwork' },
-          });
-          if (!response.ok) throw new Error(`HTTP ${response.status}`);
-          const data = await response.json() as { services: [string[], string[]][] };
-
-          const entries: IBootstrapEntry[] = [];
-          for (const [prefixes, urls] of data.services) {
-            const baseUrl = urls[0]; // first URL is preferred
-            for (const prefix of prefixes) {
-              const [network, bits] = prefix.split('/');
-              entries.push({
-                prefix,
-                prefixNum: this.ipToNumber(network),
-                maskBits: parseInt(bits, 10),
-                baseUrl: baseUrl.replace(/\/$/, ''), // strip trailing slash
-              });
-            }
-          }
-
-          // Sort by mask bits descending for longest-prefix match
-          entries.sort((a, b) => b.maskBits - a.maskBits);
-          this.bootstrapEntries = entries;
-        } finally {
-          clearTimeout(timeoutId);
-        }
-      } catch (err: any) {
-        this.logger.debug?.(`Failed to load RDAP bootstrap: ${err.message}`);
-        this.bootstrapEntries = []; // empty = all RDAP lookups will skip
-      }
-    })();
-
-    await this.bootstrapPromise;
-    this.bootstrapPromise = null;
+  /** Retry and confirm cleanup of a standalone DNS client, if one is retained. */
+  public stop(): Promise<void> {
+    if (this.sharedDnsClient) return Promise.resolve();
+    return this.enqueueDnsLifecycle(() => this.terminateOwnedDnsClient());
   }
 
-  /**
-   * Find the RDAP base URL for a given IP via longest-prefix match
-   */
-  private matchRir(ip: string): string | null {
-    if (!this.bootstrapEntries || this.bootstrapEntries.length === 0) return null;
-
-    const ipNum = this.ipToNumber(ip);
-
-    for (const entry of this.bootstrapEntries) {
-      const mask = (0xFFFFFFFF << (32 - entry.maskBits)) >>> 0;
-      if ((ipNum & mask) === (entry.prefixNum & mask)) {
-        return entry.baseUrl;
-      }
-    }
-
-    return null;
-  }
+  // ─── RDAP Subsystem (delegated to @push.rocks/smartwhois) ───────────
 
   /**
-   * Query RDAP for registration data
+   * Query RDAP for registration data via the smartwhois RdapClient (IPv4 and IPv6).
    */
   private async queryRdap(ip: string): Promise<{
     registrantOrg: string | null;
@@ -268,160 +196,20 @@ export class IpIntelligence {
     networkCidrs: string[] | null;
     abuseContact: string | null;
   } | null> {
-    await this.ensureBootstrap();
-    const baseUrl = this.matchRir(ip);
-    if (!baseUrl) return null;
-
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
-      const response = await fetch(`${baseUrl}/ip/${ip}`, {
-        signal: controller.signal,
-        headers: {
-          'Accept': 'application/rdap+json',
-          'User-Agent': '@push.rocks/smartnetwork',
-        },
-      });
-      if (!response.ok) return null;
-      const data = await response.json() as any;
-
-      let registrantOrg: string | null = null;
-      let registrantCountry: string | null = data.country || null;
-      let abuseContact: string | null = null;
-
-      const { networkRange, networkCidrs } = this.parseRdapNetworkInfo(data);
-
-      // Parse entities
-      if (data.entities && Array.isArray(data.entities)) {
-        for (const entity of data.entities) {
-          const roles: string[] = entity.roles || [];
-
-          if (roles.includes('registrant') || roles.includes('administrative')) {
-            const orgName = this.extractVcardFn(entity);
-            if (orgName) registrantOrg = orgName;
-
-            // Try to get country from registrant address if not at top level
-            if (!registrantCountry) {
-              registrantCountry = this.extractVcardCountry(entity);
-            }
-          }
-
-          if (roles.includes('abuse')) {
-            abuseContact = this.extractVcardEmail(entity);
-            // Check nested entities for abuse contact
-            if (!abuseContact && entity.entities) {
-              for (const subEntity of entity.entities) {
-                const subRoles: string[] = subEntity.roles || [];
-                if (subRoles.includes('abuse')) {
-                  abuseContact = this.extractVcardEmail(subEntity);
-                  if (abuseContact) break;
-                }
-              }
-            }
-          }
-        }
-      }
-
-      return { registrantOrg, registrantCountry, networkRange, networkCidrs, abuseContact };
+      const rdapRecord = await this.rdapClient.lookupIp(ip);
+      if (!rdapRecord) return null;
+      return {
+        registrantOrg: rdapRecord.registrantOrg ?? null,
+        registrantCountry: rdapRecord.registrantCountry ?? null,
+        networkRange: rdapRecord.networkRange ?? null,
+        networkCidrs: rdapRecord.networkCidrs ?? null,
+        abuseContact: rdapRecord.abuseEmail ?? null,
+      };
     } catch (err: any) {
       this.logger.debug?.(`RDAP query failed for ${ip}: ${err.message}`);
       return null;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-
-  private parseRdapNetworkInfo(data: any): IRdapNetworkInfo {
-    const cidrs = this.extractRdapCidrs(data);
-    if (cidrs.length > 0) {
-      return {
-        networkRange: cidrs[0],
-        networkCidrs: cidrs,
-      };
-    }
-
-    if (typeof data.startAddress === 'string' && typeof data.endAddress === 'string') {
-      const rangeCidrs = this.ipv4RangeToCidrs(data.startAddress, data.endAddress);
-      return {
-        networkRange: rangeCidrs.length === 1
-          ? rangeCidrs[0]
-          : `${data.startAddress} - ${data.endAddress}`,
-        networkCidrs: rangeCidrs.length > 0 ? rangeCidrs : null,
-      };
-    }
-
-    return { networkRange: null, networkCidrs: null };
-  }
-
-  private extractRdapCidrs(data: any): string[] {
-    if (!Array.isArray(data.cidr0_cidrs)) return [];
-    return data.cidr0_cidrs
-      .map((cidr: any) => {
-        const prefix = cidr?.v4prefix || cidr?.v6prefix;
-        const length = Number(cidr?.length);
-        if (typeof prefix !== 'string' || !Number.isInteger(length)) return null;
-        return `${prefix}/${length}`;
-      })
-      .filter(Boolean) as string[];
-  }
-
-  /**
-   * Extract the 'fn' (formatted name) from an entity's vcardArray
-   */
-  private extractVcardFn(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'fn') {
-        return prop[3] || null;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Extract email from an entity's vcardArray
-   */
-  private extractVcardEmail(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'email') {
-        return prop[3] || null;
-      }
     }
-    return null;
-  }
-
-  /**
-   * Extract country from an entity's vcardArray address field
-   */
-  private extractVcardCountry(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'adr') {
-        // The label parameter often contains the full address with country at the end
-        const label = prop[1]?.label;
-        if (typeof label === 'string') {
-          const lines = label.split('\n');
-          const lastLine = lines[lines.length - 1]?.trim();
-          if (lastLine && lastLine.length > 1) return lastLine;
-        }
-        // Also check the structured value (7-element array, last element is country)
-        const value = prop[3];
-        if (Array.isArray(value) && value.length >= 7 && value[6]) {
-          return value[6];
-        }
-      }
-    }
-    return null;
   }
 
   // ─── Team Cymru DNS Subsystem ───────────────────────────────────────
@@ -432,46 +220,68 @@ export class IpIntelligence {
    * Response: "ASN | prefix | CC | rir | date"
    */
   private async queryTeamCymru(ip: string): Promise<{ asn: number; prefix: string; country: string } | null> {
-    const external = this.sharedDnsClient !== null;
-    let dnsClient = this.sharedDnsClient;
-    try {
-      const reversed = ip.split('.').reverse().join('.');
-      const queryName = `${reversed}.origin.asn.cymru.com`;
-
-      if (!dnsClient) {
-        dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
-          strategy: 'prefer-system',
-          allowDohFallback: true,
-          timeoutMs: this.timeout,
-        });
+    const query = async (
+      dnsClientArg: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>,
+    ) => {
+      try {
+        const reversed = ip.split('.').reverse().join('.');
+        const queryName = `${reversed}.origin.asn.cymru.com`;
+        const records = await dnsClientArg.getRecordsTxt(queryName);
+        if (!records || records.length === 0) return null;
+
+        // Parse the first TXT record: "13335 | 1.1.1.0/24 | AU | apnic | 2011-08-11"
+        const txt = records[0].value || (records[0] as any).data;
+        if (!txt) return null;
+
+        const parts = txt.split('|').map((s: string) => s.trim());
+        if (parts.length < 3) return null;
+
+        const asn = parseInt(parts[0], 10);
+        if (isNaN(asn)) return null;
+
+        return {
+          asn,
+          prefix: parts[1] || '',
+          country: parts[2] || '',
+        };
+      } catch (err: any) {
+        this.logger.debug?.(`Team Cymru DNS query failed for ${ip}: ${err.message}`);
+        return null;
       }
+    };
 
-      const records = await dnsClient.getRecordsTxt(queryName);
-      if (!records || records.length === 0) return null;
-
-      // Parse the first TXT record: "13335 | 1.1.1.0/24 | AU | apnic | 2011-08-11"
-      const txt = records[0].value || (records[0] as any).data;
-      if (!txt) return null;
+    if (this.sharedDnsClient) {
+      return query(this.sharedDnsClient);
+    }
 
-      const parts = txt.split('|').map((s: string) => s.trim());
-      if (parts.length < 3) return null;
+    return this.enqueueDnsLifecycle(async () => {
+      await this.terminateOwnedDnsClient();
+      const dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
+        strategy: 'prefer-system',
+        allowDohFallback: true,
+        timeoutMs: this.timeout,
+      });
+      this.ownedDnsClient = dnsClient;
+      try {
+        return await query(dnsClient);
+      } finally {
+        await this.terminateOwnedDnsClient();
+      }
+    });
+  }
 
-      const asn = parseInt(parts[0], 10);
-      if (isNaN(asn)) return null;
+  private enqueueDnsLifecycle<T>(operationArg: () => Promise<T>): Promise<T> {
+    const result = this.dnsLifecycleQueue.then(operationArg);
+    this.dnsLifecycleQueue = result.then(() => {}, () => {});
+    return result;
+  }
 
-      return {
-        asn,
-        prefix: parts[1] || '',
-        country: parts[2] || '',
-      };
-    } catch (err: any) {
-      this.logger.debug?.(`Team Cymru DNS query failed for ${ip}: ${err.message}`);
-      return null;
-    } finally {
-      // Only destroy clients we created ourselves; leave injected ones alone.
-      if (!external && dnsClient) {
-        dnsClient.destroy();
-      }
+  private async terminateOwnedDnsClient(): Promise<void> {
+    const dnsClient = this.ownedDnsClient;
+    if (!dnsClient) return;
+    await dnsClient.terminate();
+    if (this.ownedDnsClient === dnsClient) {
+      this.ownedDnsClient = null;
     }
   }
 
@@ -601,71 +411,4 @@ export class IpIntelligence {
 
     return { country, countryCode, city, latitude, longitude, accuracyRadius, timezone, asn, asnOrg };
   }
-
-  // ─── Utilities ──────────────────────────────────────────────────────
-
-  /**
-   * Convert an IPv4 address string to a 32-bit unsigned number
-   */
-  private ipToNumber(ip: string): number {
-    const parts = ip.split('.');
-    return (
-      ((parseInt(parts[0], 10) << 24) |
-       (parseInt(parts[1], 10) << 16) |
-       (parseInt(parts[2], 10) << 8) |
-        parseInt(parts[3], 10)) >>> 0
-    );
-  }
-
-  private ipv4RangeToCidrs(startIp: string, endIp: string): string[] {
-    const start = this.ipv4ToBigInt(startIp);
-    const end = this.ipv4ToBigInt(endIp);
-    if (start === undefined || end === undefined || start > end) return [];
-
-    const cidrs: string[] = [];
-    let current = start;
-    while (current <= end) {
-      let maxBlockSize = current === 0n ? 1n << 32n : current & -current;
-      const remaining = end - current + 1n;
-      while (maxBlockSize > remaining) {
-        maxBlockSize = maxBlockSize / 2n;
-      }
-      const prefixLength = 32 - this.powerOfTwoExponent(maxBlockSize);
-      cidrs.push(`${this.numberToIpv4(current)}/${prefixLength}`);
-      current += maxBlockSize;
-    }
-    return cidrs;
-  }
-
-  private ipv4ToBigInt(ip: string): bigint | undefined {
-    const parts = ip.trim().split('.');
-    if (parts.length !== 4) return undefined;
-    let result = 0n;
-    for (const part of parts) {
-      if (!/^\d+$/.test(part)) return undefined;
-      const number = Number(part);
-      if (!Number.isInteger(number) || number < 0 || number > 255) return undefined;
-      result = (result * 256n) + BigInt(number);
-    }
-    return result;
-  }
-
-  private numberToIpv4(value: bigint): string {
-    return [
-      Number((value >> 24n) & 255n),
-      Number((value >> 16n) & 255n),
-      Number((value >> 8n) & 255n),
-      Number(value & 255n),
-    ].join('.');
-  }
-
-  private powerOfTwoExponent(value: bigint): number {
-    let exponent = 0;
-    let remaining = value;
-    while (remaining > 1n) {
-      remaining >>= 1n;
-      exponent++;
-    }
-    return exponent;
-  }
 }

package/ts/smartnetwork.classes.rustbridge.ts

@@ -46,6 +46,17 @@ type TNetworkCommands = {
   };
 };
 
+/** Internal marker for an activation failure whose cleanup still needs an owner. */
+export class RustNetworkBridgeActivationCleanupError extends AggregateError {
+  constructor(activationErrorArg: unknown, cleanupErrorArg: unknown) {
+    super(
+      [activationErrorArg, cleanupErrorArg],
+      'RustNetworkBridge activation failed and cleanup could not be confirmed',
+    );
+    this.name = 'RustNetworkBridgeActivationCleanupError';
+  }
+}
+
 function getPlatformSuffix(): string | null {
   const platform = process.platform;
   const arch = process.arch;
@@ -85,6 +96,9 @@ export class RustNetworkBridge {
   }
 
   private bridge: InstanceType<typeof plugins.smartrust.RustBridge<TNetworkCommands>>;
+  private readonly owners = new Set<object>();
+  private cleanupRequired = false;
+  private lifecycleQueue: Promise<void> = Promise.resolve();
 
   private constructor() {
     const packageDir = path.resolve(
@@ -115,28 +129,72 @@ export class RustNetworkBridge {
     });
   }
 
-  /**
-   * Spawn the Rust binary and wait for it to be ready.
-   */
-  public async start(): Promise<void> {
-    const ok = await this.bridge.spawn();
-    if (!ok) {
-      throw new Error('Failed to spawn rustnetwork binary');
-    }
+  private enqueueLifecycle(operationArg: () => Promise<void>): Promise<void> {
+    const result = this.lifecycleQueue.then(operationArg);
+    this.lifecycleQueue = result.catch(() => {});
+    return result;
   }
 
   /**
-   * Kill the Rust binary.
+   * Acquire the shared Rust binary and wait for it to be ready.
    */
-  public async stop(): Promise<void> {
-    this.bridge.kill();
+  public start(ownerArg: object = this): Promise<void> {
+    return this.enqueueLifecycle(async () => {
+      if (this.cleanupRequired) {
+        throw new Error('RustNetworkBridge cleanup must succeed before it can start again');
+      }
+      if (this.owners.size > 0 && !this.bridge.running) {
+        throw new Error('RustNetworkBridge stopped while it still had active owners');
+      }
+      if (this.owners.has(ownerArg)) return;
+      if (this.owners.size === 0) {
+        let activationError: unknown;
+        try {
+          const ok = await this.bridge.spawn();
+          if (ok) {
+            this.owners.add(ownerArg);
+            return;
+          }
+          activationError = new Error('Failed to spawn rustnetwork binary');
+        } catch (error) {
+          activationError = error;
+        }
+
+        try {
+          await this.bridge.terminate();
+        } catch (cleanupError) {
+          this.owners.add(ownerArg);
+          this.cleanupRequired = true;
+          throw new RustNetworkBridgeActivationCleanupError(
+            activationError,
+            cleanupError,
+          );
+        }
+        throw activationError;
+      }
+      this.owners.add(ownerArg);
+    });
   }
 
   /**
-   * Ensure the bridge is running before sending a command.
+   * Release one owner and terminate the Rust binary after the last release.
    */
-  private async ensureRunning(): Promise<void> {
-    // The bridge will throw if not spawned — we just call start() if not yet running
+  public stop(ownerArg: object = this): Promise<void> {
+    return this.enqueueLifecycle(async () => {
+      if (!this.owners.has(ownerArg)) return;
+      if (this.owners.size > 1) {
+        this.owners.delete(ownerArg);
+        return;
+      }
+      try {
+        await this.bridge.terminate();
+      } catch (error) {
+        this.cleanupRequired = true;
+        throw error;
+      }
+      this.cleanupRequired = false;
+      this.owners.delete(ownerArg);
+    });
   }
 
   // ===== Command wrappers =====