@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/ts/00_commitinfo_data.ts

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

package/ts/device/device.classes.device.ts

@@ -3,7 +3,6 @@
  * A device is a network endpoint that can have multiple features (capabilities)
  */
 
-import * as plugins from '../plugins.js';
 import type {
   TFeatureType,
   IFeatureInfo,
@@ -11,6 +10,7 @@ import type {
 } from '../interfaces/feature.interfaces.js';
 import type { TDeviceStatus, IRetryOptions } from '../interfaces/index.js';
 import { Feature, type TDeviceReference } from '../features/feature.abstract.js';
+import { ObservableEventEmitter } from '../events/index.js';
 
 // ============================================================================
 // Device Info Interface
@@ -69,7 +69,7 @@ export interface IDeviceCreateOptions {
  * }
  * ```
  */
-export class UniversalDevice extends plugins.events.EventEmitter {
+export class UniversalDevice extends ObservableEventEmitter {
   // ============================================================================
   // Properties
   // ============================================================================

package/ts/devicemanager.classes.devicemanager.ts

@@ -40,6 +40,12 @@ import type {
   TFeatureType,
   IDeviceSelector,
 } from './interfaces/index.js';
+import { ObservableEventEmitter } from './events/index.js';
+import {
+  SmbShareProvider,
+  type ISmbShareProviderDependencies,
+  type ISmbShareProviderOptions,
+} from './providers/index.js';
 
 /**
  * Default device manager options
@@ -132,10 +138,12 @@ function makeDeviceRef(address: string, port: number, name: string): { id: strin
  * via multiple methods (mDNS, SSDP, IP scan), features are merged into a
  * single UniversalDevice instance.
  */
-export class DeviceManager extends plugins.events.EventEmitter {
+export class DeviceManager extends ObservableEventEmitter {
   private mdnsDiscovery: MdnsDiscovery;
   private ssdpDiscovery: SsdpDiscovery;
   private _networkScanner: NetworkScanner | null = null;
+  private readonly smbProviders = new Set<SmbShareProvider>();
+  private readonly smbProviderSubscriptions = new Map<SmbShareProvider, plugins.rxjs.Subscription>();
 
   // Devices keyed by IP address for deduplication
   private devicesByIp: Map<string, UniversalDevice> = new Map();
@@ -546,17 +554,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 {
@@ -734,6 +780,61 @@ export class DeviceManager extends plugins.events.EventEmitter {
     return this.getDevicesWithFeature('snmp');
   }
 
+  // ============================================================================
+  // Host-side SMB providers
+  // ============================================================================
+
+  /**
+   * Start an SMB server and forward its events through this manager as `smb:*`.
+   */
+  public async provideSmbShares(
+    options: ISmbShareProviderOptions,
+    dependencies?: ISmbShareProviderDependencies
+  ): Promise<SmbShareProvider> {
+    const provider = new SmbShareProvider(options, dependencies);
+    const subscription = provider.events$.subscribe((event) => {
+      this.emit(`smb:${event.name}`, ...event.args);
+    });
+
+    try {
+      await provider.start();
+      this.smbProviders.add(provider);
+      this.smbProviderSubscriptions.set(provider, subscription);
+      return provider;
+    } catch (error) {
+      subscription.unsubscribe();
+      throw error;
+    }
+  }
+
+  /** Stop one SMB provider created by this manager. */
+  public async stopSmbShareProvider(provider: SmbShareProvider): Promise<void> {
+    try {
+      await provider.stop();
+    } finally {
+      this.smbProviderSubscriptions.get(provider)?.unsubscribe();
+      this.smbProviderSubscriptions.delete(provider);
+      this.smbProviders.delete(provider);
+    }
+  }
+
+  /** Stop every SMB provider owned by this manager. */
+  public async stopAllSmbShareProviders(): Promise<void> {
+    const results = await Promise.allSettled(
+      [...this.smbProviders].map((provider) => this.stopSmbShareProvider(provider))
+    );
+    const failures = results
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'One or more SMB providers failed to stop cleanly.');
+    }
+  }
+
+  public getSmbShareProviders(): SmbShareProvider[] {
+    return [...this.smbProviders];
+  }
+
   // ============================================================================
   // Manual Device Addition
   // ============================================================================
@@ -769,7 +870,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   public async addScanner(
     address: string,
     port: number,
-    protocol: 'escl' | 'sane' = 'escl',
+    protocol: 'brother' | 'escl' | 'sane' = 'escl',
     name?: string
   ): Promise<UniversalDevice> {
     const feature = new ScanFeature(
@@ -1033,7 +1134,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
             device = await this.addScanner(
               result.address,
               deviceInfo.port,
-              deviceInfo.protocol as 'escl' | 'sane',
+              deviceInfo.protocol as 'brother' | 'escl' | 'sane',
               deviceInfo.name
             );
           } else if (deviceInfo.type === 'printer' && deviceInfo.protocol === 'ipp') {
@@ -1060,7 +1161,8 @@ export class DeviceManager extends plugins.events.EventEmitter {
 
   /**
    * Discover scanners in a subnet and add them to the manager.
-   * Convenience method that focuses discovery on scanner protocols only (eSCL, SANE).
+   * Convenience method that focuses discovery on scanner protocols only
+   * (Brother native, eSCL/AirScan, and SANE).
    *
    * @param subnet CIDR notation subnet (e.g., '192.168.1.0/24')
    * @param options Optional discovery settings
@@ -1080,6 +1182,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   ): Promise<UniversalDevice[]> {
     await this.scanNetwork({
       ipRange: subnet,
+      probeBrother: true,
       probeEscl: true,
       probeSane: true,
       probeIpp: false,
@@ -1107,6 +1210,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   ): Promise<UniversalDevice[]> {
     await this.scanNetwork({
       ipRange: subnet,
+      probeBrother: false,
       probeEscl: false,
       probeSane: false,
       probeIpp: true,
@@ -1179,10 +1283,19 @@ export class DeviceManager extends plugins.events.EventEmitter {
    * Stop discovery and disconnect all devices
    */
   public async shutdown(): Promise<void> {
-    await this.stopDiscovery();
-    await this.disconnectAll();
+    const results = await Promise.allSettled([
+      this.stopDiscovery(),
+      this.stopAllSmbShareProviders(),
+      this.disconnectAll(),
+    ]);
     this.devicesByIp.clear();
     this.nameSourceByIp.clear();
+    const failures = results
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'DeviceManager shutdown was incomplete.');
+    }
   }
 }
 

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

@@ -1,5 +1,5 @@
 import * as plugins from '../plugins.js';
-import { EsclProtocol } from '../protocols/index.js';
+import { BrotherScanProtocol, EsclProtocol } from '../protocols/index.js';
 import {
   cidrToIps,
   ipRangeToIps,
@@ -19,6 +19,7 @@ const DEFAULT_PORTS = [
   631,   // IPP printers
   80,    // eSCL scanners (HTTP)
   443,   // eSCL scanners (HTTPS)
+  54921, // Brother native network scanners
   6566,  // SANE scanners
   9100,  // JetDirect printers
   7000,  // AirPlay speakers
@@ -35,6 +36,7 @@ const DEFAULT_OPTIONS: Required<Omit<INetworkScanOptions, 'ipRange' | 'startIp'
   concurrency: 50,
   timeout: 2000,
   ports: DEFAULT_PORTS,
+  probeBrother: true,
   probeEscl: true,
   probeIpp: true,
   probeSane: true,
@@ -205,6 +207,15 @@ export class NetworkScanner extends plugins.events.EventEmitter {
     const probePromises: Promise<void>[] = [];
 
     for (const port of openPorts) {
+      // Brother native scan service
+      if (opts.probeBrother && port === 54921) {
+        probePromises.push(
+          this.probeBrother(ip, port, timeout).then((device) => {
+            if (device) devices.push(device);
+          })
+        );
+      }
+
       // IPP probe (port 631)
       if (opts.probeIpp && port === 631) {
         probePromises.push(
@@ -282,6 +293,17 @@ export class NetworkScanner extends plugins.events.EventEmitter {
 
     await Promise.all(probePromises);
 
+    // Prefer a vendor transport that enforces scan settings over standards
+    // endpoints whose firmware may silently downgrade those settings.
+    const protocolPriority: Partial<Record<INetworkScanDevice['protocol'], number>> = {
+      brother: 0,
+      escl: 1,
+      sane: 2,
+    };
+    devices.sort((left, right) =>
+      (protocolPriority[left.protocol] ?? 10) - (protocolPriority[right.protocol] ?? 10)
+    );
+
     return devices;
   }
 
@@ -330,9 +352,36 @@ export class NetworkScanner extends plugins.events.EventEmitter {
     });
   }
 
+  /**
+   * Probe for Brother's native network scan service.
+   */
+  private async probeBrother(
+    ip: string,
+    port: number,
+    timeout: number
+  ): Promise<INetworkScanDevice | null> {
+    const brother = new BrotherScanProtocol(ip, port, { timeout, busyTimeout: 0 });
+    try {
+      await brother.connect();
+      return {
+        type: 'scanner',
+        protocol: 'brother',
+        port,
+        name: `Brother Scanner at ${ip}`,
+        model: undefined,
+      };
+    } catch {
+      // A busy endpoint is not selected because connection would fail; eSCL
+      // can still be discovered as a fallback on the same device.
+      return null;
+    } finally {
+      await brother.disconnect();
+    }
+  }
+
   /**
    * 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,