@devioarts/capacitor-mdns 0.0.2 → 0.1.0

package/electron/mdns.ts

@@ -1,4 +1,3 @@
-import type { Service, Browser } from 'bonjour-service';
 import Bonjour from 'bonjour-service';
 import { ipcMain } from 'electron';
 
@@ -7,9 +6,13 @@ import type {
   MdnsBroadcastResult,
   MdnsDiscoverOptions,
   MdnsDiscoverResult,
+  MdnsPluginPlatformResult,
   MdnsService,
   MdnsStopResult,
-} from '../src';
+} from '../src/definitions';
+
+type Service = InstanceType<typeof Bonjour.Service>;
+type Browser = InstanceType<typeof Bonjour.Browser>;
 
 /**
  * Electron main-process implementation of the mDNS/Bonjour functionality.
@@ -24,6 +27,11 @@ import type {
  * - TXT records are forwarded as strings when present.
  */
 export class mDNS {
+  private readonly publishTimeoutMs = 5000;
+  private readonly stopTimeoutMs = 3000;
+  private broadcastQueue: Promise<unknown> = Promise.resolve();
+  private destroyed = false;
+
   //<editor-fold desc="Init/Destroy">
   private ipcRegistered = false;
   private registerIpc(): void {
@@ -32,12 +40,14 @@ export class mDNS {
       ipcMain.removeHandler('mdns:startBroadcast');
       ipcMain.removeHandler('mdns:stopBroadcast');
       ipcMain.removeHandler('mdns:discover');
+      ipcMain.removeHandler('mdns:getPluginPlatform');
     } catch {
       /* ignore */
     }
     ipcMain.handle('mdns:startBroadcast', (_evt, o: MdnsBroadcastOptions) => this.startBroadcast(o));
     ipcMain.handle('mdns:stopBroadcast', () => this.stopBroadcast());
     ipcMain.handle('mdns:discover', (_evt, o: MdnsDiscoverOptions) => this.discover(o));
+    ipcMain.handle('mdns:getPluginPlatform', () => this.getPluginPlatform());
     this.ipcRegistered = true;
   }
 
@@ -47,6 +57,7 @@ export class mDNS {
       ipcMain.removeHandler('mdns:startBroadcast');
       ipcMain.removeHandler('mdns:stopBroadcast');
       ipcMain.removeHandler('mdns:discover');
+      ipcMain.removeHandler('mdns:getPluginPlatform');
     } catch {
       /* ignore */
     }
@@ -58,13 +69,16 @@ export class mDNS {
   }
 
   async destroy(): Promise<void> {
+    this.destroyed = true;
     this.unregisterIpc();
-    await this.stopBroadcast(); // no-op safe
-    try {
-      this.bonjour.destroy();
-    } catch (err) {
-      console.warn('[mDNS] bonjour.destroy error:', err);
-    }
+    await this.withBroadcastLock(async () => {
+      await this.stopBroadcastUnlocked();
+      try {
+        this.bonjour.destroy();
+      } catch (err) {
+        console.warn('[mDNS] bonjour.destroy error:', err);
+      }
+    });
   }
 
   //</editor-fold>
@@ -76,6 +90,20 @@ export class mDNS {
   private toErr(err: unknown): string {
     return err instanceof Error ? err.message : String(err);
   }
+  private validatePort(port: unknown): string | null {
+    return Number.isInteger(port) && typeof port === 'number' && port > 0 && port <= 65535
+      ? null
+      : 'Missing/invalid port';
+  }
+  private isRecord(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+  }
+  private withBroadcastLock<T>(work: () => Promise<T>): Promise<T> {
+    // Publish and stop share one Bonjour service; serializing them prevents orphaned advertisers.
+    const run = this.broadcastQueue.catch(() => undefined).then(work);
+    this.broadcastQueue = run.catch(() => undefined);
+    return run;
+  }
 
   private normalize(name: string): string {
     return name.replace(/ \(\d+\)$/, '');
@@ -86,8 +114,9 @@ export class mDNS {
       t = this.normalize(target);
     return c === t || c.startsWith(t);
   }
-  private parseType(typeWithDot?: string): { type: string; protocol: 'tcp' | 'udp' } {
-    const s = (typeWithDot ?? '_http._tcp.').replace(/\.$/, '');
+  private parseType(typeWithDot?: unknown): { type: string; protocol: 'tcp' | 'udp' } {
+    const raw = typeof typeWithDot === 'string' && typeWithDot.trim() ? typeWithDot.trim() : '_http._tcp.';
+    const s = raw.replace(/\.$/, '');
     const m = /^_([^.]+)\._(tcp|udp)$/.exec(s);
     if (!m) return { type: 'http', protocol: 'tcp' };
     return { type: m[1], protocol: m[2] as 'tcp' | 'udp' };
@@ -103,11 +132,19 @@ export class mDNS {
     if (!svc || !this.hasCbStop(svc)) return;
     try {
       await new Promise<void>((res) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          if (timeout) clearTimeout(timeout);
+          res();
+        };
+        const timeout = setTimeout(done, this.stopTimeoutMs);
         try {
-          svc.stop(() => res());
+          svc.stop(done);
         } catch (e) {
           console.warn('[mDNS] service.stop threw:', e);
-          res();
+          done();
         }
       });
     } catch (err) {
@@ -124,61 +161,93 @@ export class mDNS {
   }
 
   // ----------------------------- API -----------------------------
+  /**
+   * Return the Electron main-process implementation marker.
+   */
+  async getPluginPlatform(): Promise<MdnsPluginPlatformResult> {
+    return { platform: 'electron' };
+  }
+
   /**
    * Publish (advertise) a single Bonjour/mDNS service via bonjour-service.
    * @param options See MdnsBroadcastOptions for type/name/port/txt.
    * @returns Result indicating whether publishing is active and the final name.
    */
   async startBroadcast(options: MdnsBroadcastOptions): Promise<MdnsBroadcastResult> {
-    const { type, protocol } = this.parseType(options.type);
-    return new Promise<MdnsBroadcastResult>((resolve) => {
-      let settled = false;
-      const safeResolve = (r: MdnsBroadcastResult) => {
-        if (!settled) {
-          settled = true;
-          resolve(r);
-        }
-      };
+    return this.withBroadcastLock(async () => {
+      const safeOptions = (options ?? {}) as Partial<MdnsBroadcastOptions>;
+      const portError = this.validatePort(safeOptions.port);
+      if (portError) return { publishing: false, name: '', error: true, errorMessage: portError };
+      if (this.destroyed)
+        return { publishing: false, name: '', error: true, errorMessage: 'mDNS instance is destroyed' };
 
-      try {
-        const svc = this.bonjour.publish({
-          name: options.name || 'DevIOArtsMDNS',
-          type,
-          protocol,
-          port: options.port,
-          txt: options.txt,
-        });
+      await this.stopBroadcastUnlocked();
 
-        const onUp = () => {
-          try {
-            svc.removeListener('up', onUp);
-            svc.removeListener('error', onError);
-          } catch {
-            /* ignore */
-          }
-          safeResolve({ publishing: true, name: svc.name || '', error: false, errorMessage: null });
-        };
-        const onError = (err: unknown) => {
-          try {
-            svc.removeListener('up', onUp);
-            svc.removeListener('error', onError);
-          } catch {
-            /* ignore */
+      const { type, protocol } = this.parseType(safeOptions.type);
+      return new Promise<MdnsBroadcastResult>((resolve) => {
+        let settled = false;
+        let timeout: NodeJS.Timeout | null = null;
+        const safeResolve = (r: MdnsBroadcastResult) => {
+          if (!settled) {
+            settled = true;
+            if (timeout) {
+              clearTimeout(timeout);
+              timeout = null;
+            }
+            resolve(r);
           }
-          try {
-            if (this.hasCbStop(svc)) svc.stop();
-          } catch (e) {
-            console.warn('[mDNS] publish stop on error:', e);
-          }
-          safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(err) });
         };
 
-        svc.once('up', onUp);
-        svc.once('error', onError);
-        this.advertiser = svc;
-      } catch (e) {
-        safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(e) });
-      }
+        try {
+          const svc = this.bonjour.publish({
+            name:
+              typeof safeOptions.name === 'string' && safeOptions.name.trim()
+                ? safeOptions.name.trim()
+                : 'DevIOArtsMDNS',
+            type,
+            protocol,
+            port: safeOptions.port as number,
+            txt: this.isRecord(safeOptions.txt) ? this.normalizeTxt(safeOptions.txt) : undefined,
+          });
+
+          const cleanupListeners = () => {
+            try {
+              svc.removeListener('up', onUp);
+              svc.removeListener('error', onError);
+            } catch {
+              /* ignore */
+            }
+          };
+          const onUp = () => {
+            cleanupListeners();
+            safeResolve({ publishing: true, name: svc.name || '', error: false, errorMessage: null });
+          };
+          const onError = (err: unknown) => {
+            cleanupListeners();
+            void this.safeStopService(svc);
+            if (this.advertiser === svc) this.advertiser = undefined;
+            safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(err) });
+          };
+          const onTimeout = () => {
+            cleanupListeners();
+            void this.safeStopService(svc);
+            if (this.advertiser === svc) this.advertiser = undefined;
+            safeResolve({
+              publishing: false,
+              name: '',
+              error: true,
+              errorMessage: `Timed out waiting for service publish after ${this.publishTimeoutMs}ms`,
+            });
+          };
+
+          svc.once('up', onUp);
+          svc.once('error', onError);
+          timeout = setTimeout(onTimeout, this.publishTimeoutMs);
+          this.advertiser = svc;
+        } catch (e) {
+          safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(e) });
+        }
+      });
     });
   }
 
@@ -187,6 +256,10 @@ export class mDNS {
    * @returns Result indicating whether the advertiser is active and error info.
    */
   async stopBroadcast(): Promise<MdnsStopResult> {
+    return this.withBroadcastLock(() => this.stopBroadcastUnlocked());
+  }
+
+  private async stopBroadcastUnlocked(): Promise<MdnsStopResult> {
     try {
       if (this.advertiser) {
         await this.safeStopService(this.advertiser);
@@ -205,9 +278,14 @@ export class mDNS {
    * @param options See MdnsDiscoverOptions for type/name/timeout.
    */
   async discover(options: MdnsDiscoverOptions = {}): Promise<MdnsDiscoverResult> {
-    const { type, protocol } = this.parseType(options.type);
-    const targetId = options.name || null;
-    const timeoutMs = options.timeout ?? 3000;
+    const safeOptions = (options ?? {}) as Partial<MdnsDiscoverOptions>;
+    if (this.destroyed) {
+      return { error: true, errorMessage: 'mDNS instance is destroyed', servicesFound: 0, services: [] };
+    }
+
+    const { type, protocol } = this.parseType(safeOptions.type);
+    const targetId = typeof safeOptions.name === 'string' && safeOptions.name ? safeOptions.name : null;
+    const timeoutMs = typeof safeOptions.timeout === 'number' ? safeOptions.timeout : 3000;
 
     let browser: Browser | null = null;
     const services: MdnsService[] = [];
@@ -216,8 +294,11 @@ export class mDNS {
 
     return new Promise<MdnsDiscoverResult>((resolve) => {
       let timer: NodeJS.Timeout | null = null;
+      let settled = false;
 
       const finish = () => {
+        if (settled) return;
+        settled = true;
         if (browser) {
           this.safeStopBrowser(browser);
           browser = null;
@@ -243,7 +324,7 @@ export class mDNS {
             domain: 'local.',
             port: s.port ?? 0,
             hosts: Array.isArray(s.addresses) ? s.addresses.slice() : [],
-            txt: s.txt && Object.keys(s.txt).length ? (s.txt as Record<string, string>) : undefined,
+            txt: s.txt && Object.keys(s.txt).length ? this.normalizeTxt(s.txt) : undefined,
           };
           const key = `${item.name}:${item.port}`;
           if (!services.some((x) => `${x.name}:${x.port}` === key)) services.push(item);
@@ -251,12 +332,13 @@ export class mDNS {
         });
 
         // Record error and let the timeout conclude; results will still be returned.
-        browser.on('error', (err: unknown) => {
+        const onBrowserError = (err: unknown) => {
           hadError = true;
           errMsg = this.toErr(err);
-        });
+        };
+        (browser as any).on('error', onBrowserError);
 
-        timer = setTimeout(finish, timeoutMs);
+        timer = setTimeout(finish, Math.max(0, timeoutMs));
       } catch (err) {
         hadError = true;
         errMsg = this.toErr(err);
@@ -264,4 +346,10 @@ export class mDNS {
       }
     });
   }
+
+  private normalizeTxt(txt: Record<string, unknown>): Record<string, string> {
+    return Object.fromEntries(
+      Object.entries(txt).map(([key, value]) => [key, Buffer.isBuffer(value) ? value.toString('utf8') : String(value)]),
+    );
+  }
 }

package/electron/rollup.config.mjs

@@ -0,0 +1,22 @@
+const external = ['bonjour-service', 'electron'];
+
+export default [
+  {
+    input: 'electron/build/electron/src/index.js',
+    output: {
+      file: 'electron/dist/plugin.cjs.js',
+      format: 'cjs',
+      sourcemap: true,
+    },
+    external,
+  },
+  {
+    input: 'electron/build/electron/src/plugin-settings.js',
+    output: {
+      file: 'electron/dist/plugin-settings.js',
+      format: 'cjs',
+      sourcemap: true,
+    },
+    external,
+  },
+];

package/electron/src/index.ts

@@ -0,0 +1 @@
+export { mDNS } from '../mdns';

package/electron/src/plugin-settings.ts

@@ -0,0 +1,12 @@
+/**
+ * Metadata consumed by the capacitor-electron runtime generator (`npm run update`).
+ *
+ * Import path for the JS layer: `@devioarts/capacitor-mdns/electron/settings`.
+ */
+export const pluginSettings = {
+  pluginClass: 'mDNS',
+  pluginMethods: ['getPluginPlatform', 'startBroadcast', 'stopBroadcast', 'discover'] as const,
+  pluginEvents: [] as const,
+} as const;
+
+export type PluginSettings = typeof pluginSettings;

package/electron/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "lib": ["es2020"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "build",
+    "rootDir": "..",
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2017",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}

package/electron/types-public/index.d.ts

@@ -0,0 +1,25 @@
+import type {
+  MdnsBroadcastOptions,
+  MdnsBroadcastResult,
+  MdnsDiscoverOptions,
+  MdnsDiscoverResult,
+  MdnsPluginPlatformResult,
+  MdnsStopResult,
+} from '../../dist/esm/definitions';
+
+export declare class mDNS {
+  getPluginPlatform(): Promise<MdnsPluginPlatformResult>;
+  startBroadcast(options: MdnsBroadcastOptions): Promise<MdnsBroadcastResult>;
+  stopBroadcast(): Promise<MdnsStopResult>;
+  discover(options?: MdnsDiscoverOptions): Promise<MdnsDiscoverResult>;
+  init(): void;
+  destroy(): Promise<void>;
+}
+
+export declare const pluginSettings: {
+  readonly pluginClass: 'mDNS';
+  readonly pluginMethods: readonly ['getPluginPlatform', 'startBroadcast', 'stopBroadcast', 'discover'];
+  readonly pluginEvents: readonly [];
+};
+
+export type PluginSettings = typeof pluginSettings;