@push.rocks/smartnetwork 4.10.0 → 5.0.0

package/ts/smartnetwork.classes.domainintelligence.ts

@@ -63,9 +63,9 @@ export interface IDomainIntelligenceOptions {
   timeout?: number;
   /**
    * Optional injected smartdns client. When provided, DomainIntelligence
-   * will not create or destroy its own client (the owner — typically
+   * will not create or terminate its own client (the owner — typically
    * SmartNetwork — manages lifecycle). When omitted, a short-lived client
-   * is created per DNS-layer query and destroyed in finally.
+   * is created per DNS-layer query and terminated in finally.
    */
   dnsClient?: TSmartdnsClient;
 }
@@ -114,6 +114,8 @@ export class DomainIntelligence {
 
   // Optional injected smartdns client (shared by SmartNetwork)
   private readonly sharedDnsClient: TSmartdnsClient | null;
+  private ownedDnsClient: TSmartdnsClient | null = null;
+  private dnsLifecycleQueue: Promise<void> = Promise.resolve();
 
   constructor(options?: IDomainIntelligenceOptions) {
     this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
@@ -169,9 +171,19 @@ export class DomainIntelligence {
       }
     }
 
+    if (dnsSettled.status === 'rejected') {
+      throw dnsSettled.reason;
+    }
+
     return result;
   }
 
+  /** 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());
+  }
+
   // ─── RDAP Layer (delegated to @push.rocks/smartwhois) ───────────────
 
   /**
@@ -252,8 +264,8 @@ export class DomainIntelligence {
    * field either populated or null.
    *
    * If a shared dnsClient was injected via constructor options, it is
-   * reused and NOT destroyed (ownership stays with the injector). Otherwise
-   * a short-lived client is created and destroyed in finally.
+   * reused and NOT terminated (ownership stays with the injector). Otherwise
+   * a short-lived client is created and terminated in finally.
    */
   private async queryDnsLayer(domain: string): Promise<{
     nameservers: string[] | null;
@@ -263,45 +275,66 @@ export class DomainIntelligence {
     txtRecords: string[] | null;
     soaRecord: string | null;
   } | null> {
-    const external = this.sharedDnsClient !== null;
-    let dnsClient: TSmartdnsClient | null = this.sharedDnsClient;
-    try {
-      if (!dnsClient) {
-        dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
-          strategy: 'prefer-system',
-          allowDohFallback: true,
-          timeoutMs: this.timeout,
-        });
+    const query = async (dnsClientArg: TSmartdnsClient) => {
+      try {
+        const [nsRes, aRes, aaaaRes, mxRes, txtRes, soaRes] = await Promise.allSettled([
+          dnsClientArg.getNameServers(domain),
+          dnsClientArg.getRecordsA(domain),
+          dnsClientArg.getRecordsAAAA(domain),
+          dnsClientArg.getRecords(domain, 'MX'),
+          dnsClientArg.getRecordsTxt(domain),
+          // 'SOA' is in smartdns's runtime dnsTypeMap but missing from the
+          // TDnsRecordType union in @tsclass/tsclass — cast to bypass the
+          // stale type definition.
+          dnsClientArg.getRecords(domain, 'SOA' as any),
+        ]);
+
+        return {
+          nameservers: this.parseNsResult(nsRes),
+          resolvedIpv4: this.dnsValuesOrNull(aRes),
+          resolvedIpv6: this.dnsValuesOrNull(aaaaRes),
+          mxRecords: this.parseMxRecords(mxRes),
+          txtRecords: this.dnsValuesOrNull(txtRes),
+          soaRecord: this.dnsFirstValueOrNull(soaRes),
+        };
+      } catch (err: any) {
+        this.logger.debug?.(`DNS layer failed for ${domain}: ${err.message}`);
+        return null;
       }
+    };
 
-      const [nsRes, aRes, aaaaRes, mxRes, txtRes, soaRes] = await Promise.allSettled([
-        dnsClient.getNameServers(domain),
-        dnsClient.getRecordsA(domain),
-        dnsClient.getRecordsAAAA(domain),
-        dnsClient.getRecords(domain, 'MX'),
-        dnsClient.getRecordsTxt(domain),
-        // 'SOA' is in smartdns's runtime dnsTypeMap but missing from the
-        // TDnsRecordType union in @tsclass/tsclass — cast to bypass the
-        // stale type definition.
-        dnsClient.getRecords(domain, 'SOA' as any),
-      ]);
-
-      return {
-        nameservers: this.parseNsResult(nsRes),
-        resolvedIpv4: this.dnsValuesOrNull(aRes),
-        resolvedIpv6: this.dnsValuesOrNull(aaaaRes),
-        mxRecords: this.parseMxRecords(mxRes),
-        txtRecords: this.dnsValuesOrNull(txtRes),
-        soaRecord: this.dnsFirstValueOrNull(soaRes),
-      };
-    } catch (err: any) {
-      this.logger.debug?.(`DNS layer failed for ${domain}: ${err.message}`);
-      return null;
-    } finally {
-      // Only destroy clients we created ourselves; leave injected ones alone.
-      if (!external && dnsClient) {
-        dnsClient.destroy();
+    if (this.sharedDnsClient) {
+      return query(this.sharedDnsClient);
+    }
+
+    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();
       }
+    });
+  }
+
+  private enqueueDnsLifecycle<T>(operationArg: () => Promise<T>): Promise<T> {
+    const result = this.dnsLifecycleQueue.then(operationArg);
+    this.dnsLifecycleQueue = result.then(() => {}, () => {});
+    return result;
+  }
+
+  private async terminateOwnedDnsClient(): Promise<void> {
+    const dnsClient = this.ownedDnsClient;
+    if (!dnsClient) return;
+    await dnsClient.terminate();
+    if (this.ownedDnsClient === dnsClient) {
+      this.ownedDnsClient = null;
     }
   }
 

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>;
 }
@@ -89,6 +89,8 @@ export class IpIntelligence {
 
   // 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;
@@ -130,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;
@@ -172,6 +178,12 @@ export class IpIntelligence {
     return result;
   }
 
+  /** 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());
+  }
+
   // ─── RDAP Subsystem (delegated to @push.rocks/smartwhois) ───────────
 
   /**
@@ -208,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;
     }
   }
 

package/ts/smartnetwork.classes.rustbridge.ts

@@ -46,28 +46,30 @@ type TNetworkCommands = {
   };
 };
 
-function getPlatformSuffix(): string | null {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  const platformMap: Record<string, string> = {
-    linux: 'linux',
-    darwin: 'macos',
-    win32: 'windows',
-  };
+/** 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';
+  }
+}
 
+/**
+ * The tsrust target of the shipped binary for this host: static musl builds for Linux amd64 and arm64
+ */
+function getDistRustTarget(): string | null {
   const archMap: Record<string, string> = {
     x64: 'amd64',
     arm64: 'arm64',
   };
-
-  const p = platformMap[platform];
-  const a = archMap[arch];
-
-  if (p && a) {
-    return `${p}_${a}`;
+  const arch = archMap[process.arch];
+  if (process.platform !== 'linux' || !arch) {
+    return null;
   }
-  return null;
+  return `linux_${arch}_musl`;
 }
 
 /**
@@ -85,6 +87,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(
@@ -92,12 +97,12 @@ export class RustNetworkBridge {
       '..',
     );
 
-    const platformSuffix = getPlatformSuffix();
+    const distRustTarget = getDistRustTarget();
     const localPaths: string[] = [];
 
-    // Platform-specific cross-compiled binary
-    if (platformSuffix) {
-      localPaths.push(path.join(packageDir, 'dist_rust', `rustnetwork_${platformSuffix}`));
+    // Shipped static binary for this host
+    if (distRustTarget) {
+      localPaths.push(path.join(packageDir, 'dist_rust', `rustnetwork_${distRustTarget}`));
     }
     // Native build without suffix
     localPaths.push(path.join(packageDir, 'dist_rust', 'rustnetwork'));
@@ -115,28 +120,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 =====