@ecobridge.xyz/devicemanager 3.0.2 → 3.1.1

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@ecobridge.xyz/devicemanager',
-  version: '3.0.2',
+  version: '3.1.1',
   description: 'a device manager for talking to devices on network and over usb'
 }

package/ts/devicemanager.classes.devicemanager.ts

@@ -546,17 +546,55 @@ export class DeviceManager extends plugins.events.EventEmitter {
   // ============================================================================
 
   public async startDiscovery(): Promise<void> {
-    await Promise.all([
-      this.mdnsDiscovery.start(),
-      this.ssdpDiscovery.start(),
+    const startResults = await Promise.allSettled([
+      Promise.resolve().then(() => this.mdnsDiscovery.start()),
+      Promise.resolve().then(() => this.ssdpDiscovery.start()),
     ]);
+    const startupFailures = startResults
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+    if (startupFailures.length === 0) {
+      return;
+    }
+
+    const cleanupResults = await Promise.allSettled([
+      Promise.resolve().then(() => this.mdnsDiscovery.stop()),
+      Promise.resolve().then(() => this.ssdpDiscovery.stop()),
+    ]);
+    const cleanupFailures = cleanupResults
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+
+    if (startupFailures.length === 1 && cleanupFailures.length === 0) {
+      throw startupFailures[0];
+    }
+
+    const message = cleanupFailures.length > 0
+      ? 'Device discovery failed to start and rollback cleanup was incomplete.'
+      : 'Multiple discovery transports failed to start.';
+    throw new AggregateError(
+      [...startupFailures, ...cleanupFailures],
+      message,
+      { cause: startupFailures[0] }
+    );
   }
 
   public async stopDiscovery(): Promise<void> {
-    await Promise.all([
-      this.mdnsDiscovery.stop(),
-      this.ssdpDiscovery.stop(),
+    const stopResults = await Promise.allSettled([
+      Promise.resolve().then(() => this.mdnsDiscovery.stop()),
+      Promise.resolve().then(() => this.ssdpDiscovery.stop()),
     ]);
+    const stopFailures = stopResults
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+
+    if (stopFailures.length > 0) {
+      throw new AggregateError(
+        stopFailures,
+        'One or more discovery transports failed to stop cleanly.',
+        { cause: stopFailures[0] }
+      );
+    }
   }
 
   public get isDiscovering(): boolean {

package/ts/discovery/discovery.classes.mdns.ts

@@ -117,20 +117,49 @@ export class MdnsDiscovery extends plugins.events.EventEmitter {
       return;
     }
 
-    // Stop all browsers
-    for (const browser of this.browsers) {
-      browser.stop();
-    }
+    const browsers = this.browsers;
+    const bonjour = this.bonjour;
+    const cleanupErrors: unknown[] = [];
     this.browsers = [];
-
-    // Destroy bonjour instance
-    if (this.bonjour) {
-      this.bonjour.destroy();
-      this.bonjour = null;
+    this.bonjour = null;
+
+    try {
+      for (const browser of browsers) {
+        try {
+          browser.stop();
+        } catch (error) {
+          cleanupErrors.push(error);
+        }
+      }
+    } finally {
+      try {
+        if (bonjour) {
+          await new Promise<void>((resolve, reject) => {
+            try {
+              bonjour.destroy((error?: Error) => error ? reject(error) : resolve());
+            } catch (error) {
+              reject(error);
+            }
+          });
+        }
+      } catch (error) {
+        cleanupErrors.push(error);
+      } finally {
+        this.isRunning = false;
+        try {
+          this.emit('stopped');
+        } catch (error) {
+          cleanupErrors.push(error);
+        }
+      }
     }
 
-    this.isRunning = false;
-    this.emit('stopped');
+    if (cleanupErrors.length === 1) {
+      throw cleanupErrors[0];
+    }
+    if (cleanupErrors.length > 1) {
+      throw new AggregateError(cleanupErrors, 'Failed to stop mDNS discovery cleanly.');
+    }
   }
 
   /**

package/ts/discovery/discovery.classes.networkscanner.ts

@@ -332,7 +332,7 @@ export class NetworkScanner extends plugins.events.EventEmitter {
 
   /**
    * Probe for IPP printer using a simple HTTP check
-   * We avoid using the full ipp library for probing since it can hang and produce noisy output
+   * Use a minimal request instead of an external IPP client for discovery probing.
    */
   private async probeIpp(
     ip: string,