@basmilius/apple-common 0.1.3 → 0.2.1

package/dist/cli.d.ts

@@ -2,19 +2,3 @@ import { type Interface } from "node:readline";
 export declare const cli: Interface;
 export declare function prompt(message: string): Promise<string>;
 export declare function waitFor(ms: number): Promise<void>;
-declare class Reporter {
-	#private;
-	all(): void;
-	disable(group: DebugGroup): void;
-	enable(group: DebugGroup): void;
-	isEnabled(group: DebugGroup): boolean;
-	debug(...data: any[]): void;
-	error(...data: any[]): void;
-	info(...data: any[]): void;
-	net(...data: any[]): void;
-	raw(...data: any[]): void;
-	warn(...data: any[]): void;
-}
-export declare const reporter: Reporter;
-type DebugGroup = "debug" | "error" | "info" | "net" | "raw" | "warn";
-export {};

package/dist/connection.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import type { Context } from "./context";
 import type { ConnectionState, EventMap } from "./types";
 type ConnectionEventMap = {
 	close: [hadError: boolean];
@@ -11,10 +12,11 @@ type ConnectionEventMap = {
 export declare class Connection<TEventMap extends EventMap> extends EventEmitter<ConnectionEventMap | TEventMap> {
 	#private;
 	get address(): string;
+	get context(): Context;
 	get port(): number;
 	get isConnected(): boolean;
 	get state(): ConnectionState;
-	constructor(address: string, port: number);
+	constructor(context: Context, address: string, port: number);
 	connect(): Promise<void>;
 	destroy(): Promise<void>;
 	disconnect(): Promise<void>;
@@ -24,7 +26,7 @@ export declare class Connection<TEventMap extends EventMap> extends EventEmitter
 }
 export declare class EncryptionAwareConnection<TEventMap extends EventMap> extends Connection<TEventMap> {
 	get isEncrypted(): boolean;
-	enableEncryption(readKey: Buffer, writeKey: Buffer): Promise<void>;
+	enableEncryption(readKey: Buffer, writeKey: Buffer): void;
 }
 export declare class EncryptionState {
 	readKey: Buffer;

package/dist/context.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from "./reporter";
+export declare class Context {
+	#private;
+	get deviceId(): string;
+	get logger(): Logger;
+	constructor(deviceId: string);
+}

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 export { v4 as uuid } from "uuid";
 export { Chacha20, Curve25519, hkdf } from "./crypto";
 export { type DiscoveryResult, Discovery } from "./discovery";
-export { getLocalIP, getMacAddress, TimingServer } from "./net";
-export { prompt, waitFor, cli, reporter } from "./cli";
+export { getLocalIP, getMacAddress } from "./net";
+export { prompt, waitFor, cli } from "./cli";
 export { Connection, EncryptionAwareConnection, EncryptionState } from "./connection";
+export { Context } from "./context";
 export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, COMPANION_LINK_SERVICE, HTTP_TIMEOUT, RAOP_SERVICE } from "./const";
 export { type AccessoryCredentials, type AccessoryKeys, AccessoryPair, AccessoryVerify } from "./pairing";
+export { type Logger, type Reporter, reporter } from "./reporter";
 export { ENCRYPTION } from "./symbols";
-export { uint16ToBE, uint53ToLE } from "./utils";
+export { TimingServer } from "./timing";
+export { randomInt32, randomInt64, uint16ToBE, uint53ToLE } from "./utils";
+export type { ConnectionState, EventMap } from "./types";

package/dist/index.js

@@ -821,45 +821,6 @@ async function waitFor(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-class Reporter {
-  #enabled = [];
-  all() {
-    this.#enabled = ["debug", "error", "info", "net", "raw", "warn"];
-  }
-  disable(group) {
-    if (this.#enabled.includes(group)) {
-      this.#enabled.splice(this.#enabled.indexOf(group), 1);
-    }
-  }
-  enable(group) {
-    if (!this.#enabled.includes(group)) {
-      this.#enabled.push(group);
-    }
-  }
-  isEnabled(group) {
-    return this.#enabled.includes(group);
-  }
-  debug(...data) {
-    this.isEnabled("debug") && console.debug(`\x1B[36m[debug]\x1B[39m`, ...data);
-  }
-  error(...data) {
-    this.isEnabled("error") && console.error(`\x1B[31m[error]\x1B[39m`, ...data);
-  }
-  info(...data) {
-    this.isEnabled("info") && console.info(`\x1B[32m[info]\x1B[39m`, ...data);
-  }
-  net(...data) {
-    this.isEnabled("net") && console.info(`\x1B[33m[net]\x1B[39m`, ...data);
-  }
-  raw(...data) {
-    this.isEnabled("raw") && console.log(`\x1B[34m[raw]\x1B[39m`, ...data);
-  }
-  warn(...data) {
-    this.isEnabled("warn") && console.warn(`\x1B[33m[warn]\x1B[39m`, ...data);
-  }
-}
-var reporter = new Reporter;
-
 // src/const.ts
 var AIRPLAY_TRANSIENT_PIN = "3939";
 var HTTP_TIMEOUT = 6000;
@@ -947,64 +908,9 @@ function getMacAddress_default() {
   }
   return "00:00:00:00:00:00";
 }
-// src/net/timing.ts
-import { createSocket } from "node:dgram";
-import { NTP } from "@basmilius/apple-encoding";
-class timing_default {
-  get port() {
-    return this.#port;
-  }
-  #socket;
-  #port = 0;
-  constructor() {
-    this.#socket = createSocket("udp4");
-    this.#socket.on("error", (err) => this.#onError(err));
-    this.#socket.on("message", (data, info) => this.#onMessage(data, info));
-  }
-  async close() {
-    this.#socket.close();
-    this.#port = 0;
-  }
-  async listen() {
-    return new Promise((resolve) => {
-      this.#socket.once("listening", () => this.#onListening());
-      this.#socket.bind(0, resolve);
-    });
-  }
-  async#onError(err) {
-    reporter.error("Timing server error", err);
-  }
-  async#onListening() {
-    const { port } = this.#socket.address();
-    this.#port = port;
-  }
-  async#onMessage(data, info) {
-    try {
-      const request = NTP.decode(data);
-      const ntp = NTP.now();
-      const [receivedSeconds, receivedFraction] = NTP.parts(ntp);
-      reporter.info(`Timing server ntp=${ntp} receivedSeconds=${receivedSeconds} receivedFraction=${receivedFraction}`);
-      const response = NTP.encode({
-        proto: request.proto,
-        type: 83 | 128,
-        seqno: request.seqno,
-        padding: 0,
-        reftime_sec: request.sendtime_sec,
-        reftime_frac: request.sendtime_frac,
-        recvtime_sec: receivedSeconds,
-        recvtime_frac: receivedFraction,
-        sendtime_sec: receivedSeconds,
-        sendtime_frac: receivedFraction
-      });
-      this.#socket.send(response, info.port, info.address);
-    } catch (err) {
-      reporter.warn(`Timing server received malformed packet (${data.length} bytes) from ${info.address}:${info.port}`, err);
-    }
-  }
-}
 // src/connection.ts
 import { EventEmitter } from "node:events";
-import { Socket as Socket2 } from "node:net";
+import { Socket } from "node:net";
 
 // src/symbols.ts
 var ENCRYPTION = Symbol();
@@ -1019,6 +925,9 @@ class Connection extends EventEmitter {
   get address() {
     return this.#address;
   }
+  get context() {
+    return this.#context;
+  }
   get port() {
     return this.#port;
   }
@@ -1044,6 +953,7 @@ class Connection extends EventEmitter {
   #address;
   #port;
   #bindings;
+  #context;
   #debug = false;
   #retryAttempt = 0;
   #retryAttempts = 3;
@@ -1053,10 +963,11 @@ class Connection extends EventEmitter {
   #socket;
   #state;
   #connectPromise;
-  constructor(address, port) {
+  constructor(context, address, port) {
     super();
     this.#address = address;
     this.#port = port;
+    this.#context = context;
     this.#bindings = {
       onClose: this.#onClose.bind(this),
       onConnect: this.#onConnect.bind(this),
@@ -1121,7 +1032,7 @@ class Connection extends EventEmitter {
     return new Promise((resolve, reject) => {
       this.#state = "connecting";
       this.#connectPromise = { resolve, reject };
-      this.#socket = new Socket2;
+      this.#socket = new Socket;
       this.#socket.setTimeout(SOCKET_TIMEOUT);
       this.#socket.on("close", this.#bindings.onClose);
       this.#socket.on("connect", this.#bindings.onConnect);
@@ -1129,7 +1040,7 @@ class Connection extends EventEmitter {
       this.#socket.on("end", this.#bindings.onEnd);
       this.#socket.on("error", this.#bindings.onError);
       this.#socket.on("timeout", this.#bindings.onTimeout);
-      reporter.net(`Connecting to ${this.#address}:${this.#port}...`);
+      this.#context.logger.net(`Connecting to ${this.#address}:${this.#port}...`);
       this.#socket.connect({
         host: this.#address,
         port: this.#port,
@@ -1158,7 +1069,7 @@ class Connection extends EventEmitter {
       return;
     }
     this.#retryAttempt++;
-    reporter.net(`Retry attempt ${this.#retryAttempt} / ${this.#retryAttempts} in ${this.#retryInterval}ms...`);
+    this.#context.logger.net(`Retry attempt ${this.#retryAttempt} / ${this.#retryAttempts} in ${this.#retryInterval}ms...`);
     const { resolve, reject } = this.#connectPromise ?? NOOP_PROMISE_HANDLER;
     this.#cleanup();
     this.#retryTimeout = setTimeout(async () => {
@@ -1174,7 +1085,7 @@ class Connection extends EventEmitter {
     const wasConnected = this.#state === "connected";
     if (this.#state !== "closing") {
       this.#state = "disconnected";
-      reporter.net(`Connection closed (${hadError ? "with error" : "normally"}).`);
+      this.#context.logger.net(`Connection closed (${hadError ? "with error" : "normally"}).`);
     }
     this.emit("close", hadError);
     if (wasConnected && this.#retryEnabled && hadError) {
@@ -1193,9 +1104,9 @@ class Connection extends EventEmitter {
   #onData(data) {
     if (this.#debug) {
       const cutoff = Math.min(data.byteLength, 64);
-      reporter.debug(`Received ${data.byteLength} bytes of data.`);
-      reporter.debug(`hex=${data.subarray(0, cutoff).toString("hex")}`);
-      reporter.debug(`ascii=${data.toString("ascii").replace(/[^\x20-\x7E]/g, ".").substring(0, cutoff)}`);
+      this.#context.logger.debug(`Received ${data.byteLength} bytes of data.`);
+      this.#context.logger.debug(`hex=${data.subarray(0, cutoff).toString("hex")}`);
+      this.#context.logger.debug(`ascii=${data.toString("ascii").replace(/[^\x20-\x7E]/g, ".").substring(0, cutoff)}`);
     }
     this.emit("data", data);
   }
@@ -1203,11 +1114,11 @@ class Connection extends EventEmitter {
     this.emit("end");
   }
   #onError(err) {
-    reporter.error(`Connection error: ${err.message}`);
+    this.#context.logger.error(`Connection error: ${err.message}`);
     if (this.listenerCount("error") > 0) {
       this.emit("error", err);
     } else {
-      reporter.warn("No error handler registered. This is likely a bug.", this.constructor.name, "#onError");
+      this.#context.logger.warn("No error handler registered. This is likely a bug.", this.constructor.name, "#onError");
     }
     if (this.#state === "connecting") {
       this.#scheduleRetry(err);
@@ -1216,7 +1127,7 @@ class Connection extends EventEmitter {
     }
   }
   #onTimeout() {
-    reporter.error("Connection timed out.");
+    this.#context.logger.error("Connection timed out.");
     const err = new Error("Connection timed out.");
     this.emit("timeout");
     if (this.#state === "connecting") {
@@ -1233,7 +1144,7 @@ class EncryptionAwareConnection extends Connection {
     return !!this[ENCRYPTION];
   }
   [ENCRYPTION];
-  async enableEncryption(readKey, writeKey) {
+  enableEncryption(readKey, writeKey) {
     this[ENCRYPTION] = new EncryptionState(readKey, writeKey);
   }
 }
@@ -1250,20 +1161,119 @@ class EncryptionState {
     this.writeKey = writeKey;
   }
 }
+// src/reporter.ts
+class Logger {
+  #id;
+  constructor(id) {
+    this.#id = id;
+  }
+  debug(...data) {
+    debug(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+  error(...data) {
+    error(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+  info(...data) {
+    info(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+  net(...data) {
+    net(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+  raw(...data) {
+    raw(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+  warn(...data) {
+    warn(`\x1B[36m[${this.#id}]\x1B[39m`, ...data);
+  }
+}
+
+class Reporter {
+  #enabled = [];
+  all() {
+    this.#enabled = ["debug", "error", "info", "net", "raw", "warn"];
+  }
+  disable(group) {
+    if (this.#enabled.includes(group)) {
+      this.#enabled.splice(this.#enabled.indexOf(group), 1);
+    }
+  }
+  enable(group) {
+    if (!this.#enabled.includes(group)) {
+      this.#enabled.push(group);
+    }
+  }
+  isEnabled(group) {
+    return this.#enabled.includes(group);
+  }
+}
+function debug(...data) {
+  reporter.isEnabled("debug") && console.debug(`\x1B[36m[debug]\x1B[39m`, ...data);
+}
+function error(...data) {
+  reporter.isEnabled("error") && console.error(`\x1B[31m[error]\x1B[39m`, ...data);
+}
+function info(...data) {
+  reporter.isEnabled("info") && console.info(`\x1B[32m[info]\x1B[39m`, ...data);
+}
+function net(...data) {
+  reporter.isEnabled("net") && console.info(`\x1B[33m[net]\x1B[39m`, ...data);
+}
+function raw(...data) {
+  reporter.isEnabled("raw") && console.log(`\x1B[34m[raw]\x1B[39m`, ...data);
+}
+function warn(...data) {
+  reporter.isEnabled("warn") && console.warn(`\x1B[33m[warn]\x1B[39m`, ...data);
+}
+var reporter = new Reporter;
+
+// src/context.ts
+class Context {
+  get deviceId() {
+    return this.#deviceId;
+  }
+  get logger() {
+    return this.#logger;
+  }
+  #deviceId;
+  #logger;
+  constructor(deviceId) {
+    this.#deviceId = deviceId;
+    this.#logger = new Logger(deviceId);
+  }
+}
 // src/pairing.ts
 import { OPack, TLV8 } from "@basmilius/apple-encoding";
 import { SRP, SrpClient } from "fast-srp-hap";
 import { v4 as uuid } from "uuid";
 import tweetnacl2 from "tweetnacl";
 
-class AccessoryPair {
+class BasePairing {
+  get context() {
+    return this.#context;
+  }
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  tlv(buffer) {
+    const data = TLV8.decode(buffer);
+    if (data.has(TLV8.Value.Error)) {
+      TLV8.bail(data);
+    }
+    this.#context.logger.raw("Decoded TLV", data);
+    return data;
+  }
+}
+
+class AccessoryPair extends BasePairing {
   #name;
   #pairingId;
   #requestHandler;
   #publicKey;
   #secretKey;
   #srp;
-  constructor(requestHandler) {
+  constructor(context, requestHandler) {
+    super(context);
     this.#name = "basmilius/apple-protocols";
     this.#pairingId = Buffer.from(uuid().toUpperCase());
     this.#requestHandler = requestHandler;
@@ -1317,7 +1327,7 @@ class AccessoryPair {
       [TLV8.Value.State, TLV8.State.M1],
       ...additionalTlv
     ]));
-    const data = tlv(response);
+    const data = this.tlv(response);
     const publicKey = data.get(TLV8.Value.PublicKey);
     const salt = data.get(TLV8.Value.Salt);
     return { publicKey, salt };
@@ -1336,7 +1346,7 @@ class AccessoryPair {
       [TLV8.Value.PublicKey, m2.publicKey],
       [TLV8.Value.Proof, m2.proof]
     ]));
-    const data = tlv(response);
+    const data = this.tlv(response);
     const serverProof = data.get(TLV8.Value.Proof);
     return { serverProof };
   }
@@ -1380,7 +1390,7 @@ class AccessoryPair {
       [TLV8.Value.State, TLV8.State.M5],
       [TLV8.Value.EncryptedData, encrypted]
     ]));
-    const data = tlv(response);
+    const data = this.tlv(response);
     const encryptedDataRaw = data.get(TLV8.Value.EncryptedData);
     const encryptedData = encryptedDataRaw.subarray(0, -16);
     const encryptedTag = encryptedDataRaw.subarray(-16);
@@ -1421,10 +1431,11 @@ class AccessoryPair {
   }
 }
 
-class AccessoryVerify {
+class AccessoryVerify extends BasePairing {
   #ephemeralKeyPair;
   #requestHandler;
-  constructor(requestHandler) {
+  constructor(context, requestHandler) {
+    super(context);
     this.#ephemeralKeyPair = exports_curve25519.generateKeyPair();
     this.#requestHandler = requestHandler;
   }
@@ -1439,7 +1450,7 @@ class AccessoryVerify {
       [TLV8.Value.State, TLV8.State.M1],
       [TLV8.Value.PublicKey, Buffer.from(this.#ephemeralKeyPair.publicKey)]
     ]));
-    const data = tlv(response);
+    const data = this.tlv(response);
     const serverPublicKey = data.get(TLV8.Value.PublicKey);
     const encryptedData = data.get(TLV8.Value.EncryptedData);
     return {
@@ -1507,15 +1518,71 @@ class AccessoryVerify {
     };
   }
 }
-function tlv(buffer) {
-  const data = TLV8.decode(buffer);
-  if (data.has(TLV8.Value.Error)) {
-    TLV8.bail(data);
+// src/timing.ts
+import { createSocket } from "node:dgram";
+import { NTP } from "@basmilius/apple-encoding";
+class TimingServer {
+  get port() {
+    return this.#port;
+  }
+  #logger;
+  #socket;
+  #port = 0;
+  constructor() {
+    this.#logger = new Logger("timing-server");
+    this.#socket = createSocket("udp4");
+    this.#socket.on("error", (err) => this.#onError(err));
+    this.#socket.on("message", (data, info2) => this.#onMessage(data, info2));
+  }
+  async close() {
+    this.#socket.close();
+    this.#port = 0;
+  }
+  async listen() {
+    return new Promise((resolve) => {
+      this.#socket.once("listening", () => this.#onListening());
+      this.#socket.bind(0, resolve);
+    });
+  }
+  async#onError(err) {
+    this.#logger.error("Timing server error", err);
+  }
+  async#onListening() {
+    const { port } = this.#socket.address();
+    this.#port = port;
+  }
+  async#onMessage(data, info2) {
+    try {
+      const request = NTP.decode(data);
+      const ntp = NTP.now();
+      const [receivedSeconds, receivedFraction] = NTP.parts(ntp);
+      this.#logger.info(`Timing server ntp=${ntp} receivedSeconds=${receivedSeconds} receivedFraction=${receivedFraction}`);
+      const response = NTP.encode({
+        proto: request.proto,
+        type: 83 | 128,
+        seqno: request.seqno,
+        padding: 0,
+        reftime_sec: request.sendtime_sec,
+        reftime_frac: request.sendtime_frac,
+        recvtime_sec: receivedSeconds,
+        recvtime_frac: receivedFraction,
+        sendtime_sec: receivedSeconds,
+        sendtime_frac: receivedFraction
+      });
+      this.#socket.send(response, info2.port, info2.address);
+    } catch (err) {
+      this.#logger.warn(`Timing server received malformed packet (${data.length} bytes) from ${info2.address}:${info2.port}`, err);
+    }
   }
-  reporter.raw("Decoded TLV", data);
-  return data;
 }
 // src/utils.ts
+import { randomBytes } from "node:crypto";
+function randomInt32() {
+  return randomBytes(4).readUInt32BE(0);
+}
+function randomInt64() {
+  return randomBytes(8).readBigUint64LE(0);
+}
 function uint16ToBE(value) {
   const buffer = Buffer.alloc(2);
   buffer.writeUInt16BE(value, 0);
@@ -1551,12 +1618,14 @@ export {
   uint53ToLE,
   uint16ToBE,
   reporter,
+  randomInt64,
+  randomInt32,
   prompt,
   hkdf_default as hkdf,
   getMacAddress_default as getMacAddress,
   getLocalIP_default as getLocalIP,
   cli,
-  timing_default as TimingServer,
+  TimingServer,
   RAOP_SERVICE,
   HTTP_TIMEOUT,
   EncryptionState,
@@ -1564,6 +1633,7 @@ export {
   ENCRYPTION,
   Discovery,
   exports_curve25519 as Curve25519,
+  Context,
   Connection,
   exports_chacha20 as Chacha20,
   COMPANION_LINK_SERVICE,

package/dist/net/index.d.ts

@@ -1,3 +1,2 @@
 export { default as getLocalIP } from "./getLocalIP";
 export { default as getMacAddress } from "./getMacAddress";
-export { default as TimingServer } from "./timing";

package/dist/pairing.d.ts

@@ -1,6 +1,13 @@
-export declare class AccessoryPair {
+import type { Context } from "./context";
+declare abstract class BasePairing {
 	#private;
-	constructor(requestHandler: RequestHandler);
+	get context(): Context;
+	constructor(context: Context);
+	tlv(buffer: Buffer): Map<number, Buffer>;
+}
+export declare class AccessoryPair extends BasePairing {
+	#private;
+	constructor(context: Context, requestHandler: RequestHandler);
 	start(): Promise<void>;
 	pin(askPin: () => Promise<string>): Promise<AccessoryCredentials>;
 	transient(): Promise<AccessoryKeys>;
@@ -11,9 +18,9 @@ export declare class AccessoryPair {
 	m5(m4: PairM4): Promise<PairM5>;
 	m6(m4: PairM4, m5: PairM5): Promise<AccessoryCredentials>;
 }
-export declare class AccessoryVerify {
+export declare class AccessoryVerify extends BasePairing {
 	#private;
-	constructor(requestHandler: RequestHandler);
+	constructor(context: Context, requestHandler: RequestHandler);
 	start(credentials: AccessoryCredentials): Promise<AccessoryKeys>;
 }
 type RequestHandler = (step: "m1" | "m3" | "m5", data: Buffer) => Promise<Buffer>;

package/dist/reporter.d.ts

@@ -0,0 +1,20 @@
+type DebugGroup = "debug" | "error" | "info" | "net" | "raw" | "warn";
+export declare class Logger {
+	#private;
+	constructor(id: string);
+	debug(...data: any[]): void;
+	error(...data: any[]): void;
+	info(...data: any[]): void;
+	net(...data: any[]): void;
+	raw(...data: any[]): void;
+	warn(...data: any[]): void;
+}
+export declare class Reporter {
+	#private;
+	all(): void;
+	disable(group: DebugGroup): void;
+	enable(group: DebugGroup): void;
+	isEnabled(group: DebugGroup): boolean;
+}
+export declare const reporter: Reporter;
+export {};

package/dist/{net/timing.d.ts → timing.d.ts}

@@ -1,4 +1,4 @@
-export default class {
+export declare class TimingServer {
 	#private;
 	get port(): number;
 	constructor();

package/dist/utils.d.ts

@@ -1,2 +1,4 @@
+export declare function randomInt32(): number;
+export declare function randomInt64(): bigint;
 export declare function uint16ToBE(value: number): Buffer;
 export declare function uint53ToLE(value: number): Buffer;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-common",
     "description": "Common features shared across various apple protocol packages.",
-    "version": "0.1.3",
+    "version": "0.2.1",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -38,7 +38,7 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-encoding": "0.1.3",
+        "@basmilius/apple-encoding": "0.2.1",
         "@stablelib/chacha20poly1305": "^2.0.1",
         "fast-srp-hap": "^2.0.4",
         "node-dns-sd": "^1.0.1",