@wingman-ai/gateway 0.1.0

package/dist/gateway/discovery/index.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "./mdns.js" (module) {
+        module.exports = require("./mdns.cjs");
+    },
+    "./tailscale.js" (module) {
+        module.exports = require("./tailscale.cjs");
+    },
+    "./types.js" (module) {
+        module.exports = require("./types.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _types_js__rspack_import_0 = __webpack_require__("./types.js");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_js__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types_js__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _mdns_js__rspack_import_1 = __webpack_require__("./mdns.js");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _mdns_js__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_mdns_js__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _tailscale_js__rspack_import_2 = __webpack_require__("./tailscale.js");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _tailscale_js__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tailscale_js__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/discovery/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./mdns.js";
+export * from "./tailscale.js";

package/dist/gateway/discovery/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./mdns.js";
+export * from "./tailscale.js";

package/dist/gateway/discovery/mdns.cjs

@@ -0,0 +1,221 @@
+"use strict";
+var __webpack_modules__ = {
+    os (module) {
+        module.exports = require("os");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        MDNSDiscoveryService: ()=>MDNSDiscoveryService
+    });
+    const external_multicast_dns_namespaceObject = require("multicast-dns");
+    var external_multicast_dns_default = /*#__PURE__*/ __webpack_require__.n(external_multicast_dns_namespaceObject);
+    var external_os_ = __webpack_require__("os");
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const SERVICE_TYPE = "_wingman-gateway._tcp.local";
+    class MDNSDiscoveryService {
+        async announce(config) {
+            if (this.isAnnouncing) throw new Error("Already announcing");
+            this.config = config;
+            this.mdnsInstance = external_multicast_dns_default()();
+            this.mdnsInstance.on("query", (query)=>{
+                const isOurService = query.questions.some((q)=>q.name === SERVICE_TYPE || q.name === `${config.name}.${SERVICE_TYPE}`);
+                if (isOurService && this.mdnsInstance) {
+                    const hostname = this.getLocalHostname();
+                    const addresses = this.getLocalAddresses();
+                    const txt = [
+                        `version=${config.version}`,
+                        `auth=${config.requireAuth ? "required" : "optional"}`,
+                        `transport=${config.transport}`,
+                        `capabilities=${config.capabilities.join(",")}`
+                    ];
+                    this.mdnsInstance.respond({
+                        answers: [
+                            {
+                                name: SERVICE_TYPE,
+                                type: "PTR",
+                                ttl: 120,
+                                data: `${config.name}.${SERVICE_TYPE}`
+                            },
+                            {
+                                name: `${config.name}.${SERVICE_TYPE}`,
+                                type: "SRV",
+                                ttl: 120,
+                                data: {
+                                    priority: 0,
+                                    weight: 0,
+                                    port: config.port,
+                                    target: hostname
+                                }
+                            },
+                            {
+                                name: `${config.name}.${SERVICE_TYPE}`,
+                                type: "TXT",
+                                ttl: 120,
+                                data: Buffer.from(txt.join("\n"))
+                            },
+                            ...addresses.map((addr)=>({
+                                    name: hostname,
+                                    type: "A",
+                                    ttl: 120,
+                                    data: addr
+                                }))
+                        ]
+                    });
+                }
+            });
+            this.isAnnouncing = true;
+        }
+        async stopAnnouncing() {
+            if (this.mdnsInstance) {
+                this.mdnsInstance.destroy();
+                this.mdnsInstance = null;
+            }
+            this.isAnnouncing = false;
+            this.config = null;
+        }
+        async discover(timeout = 5000) {
+            return new Promise((resolve)=>{
+                const discovered = new Map();
+                const mdnsClient = external_multicast_dns_default()();
+                const timer = setTimeout(()=>{
+                    mdnsClient.destroy();
+                    resolve(Array.from(discovered.values()));
+                }, timeout);
+                mdnsClient.on("response", (response)=>{
+                    try {
+                        const gateway = this.parseResponse(response);
+                        if (gateway) discovered.set(gateway.name, gateway);
+                    } catch (error) {}
+                });
+                mdnsClient.query({
+                    questions: [
+                        {
+                            name: SERVICE_TYPE,
+                            type: "PTR"
+                        }
+                    ]
+                });
+                const cleanup = ()=>{
+                    clearTimeout(timer);
+                    mdnsClient.destroy();
+                };
+                setTimeout(cleanup, timeout);
+            });
+        }
+        parseResponse(response) {
+            const ptrRecords = response.answers.filter((a)=>"PTR" === a.type);
+            const srvRecords = response.answers.filter((a)=>"SRV" === a.type);
+            const txtRecords = response.answers.filter((a)=>"TXT" === a.type);
+            const aRecords = response.answers.filter((a)=>"A" === a.type);
+            if (0 === ptrRecords.length) return null;
+            const instanceName = ptrRecords[0].data.replace(`.${SERVICE_TYPE}`, "");
+            const srv = srvRecords.find((r)=>r.name === `${instanceName}.${SERVICE_TYPE}`);
+            const txt = txtRecords.find((r)=>r.name === `${instanceName}.${SERVICE_TYPE}`);
+            if (!srv || !txt) return null;
+            const txtData = this.parseTxtRecord(txt.data);
+            const aRecord = aRecords.find((r)=>r.name === srv.data.target);
+            const host = aRecord?.data || "localhost";
+            const port = srv.data.port;
+            const transport = txtData.transport || "ws";
+            const url = `${transport}://${host}:${port}/ws`;
+            return {
+                name: instanceName,
+                url,
+                host,
+                port,
+                requireAuth: "required" === txtData.auth,
+                capabilities: txtData.capabilities ? txtData.capabilities.split(",") : [],
+                version: txtData.version || "1.0.0",
+                transport: transport
+            };
+        }
+        parseTxtRecord(data) {
+            const result = {};
+            const text = data.toString();
+            const lines = text.split("\n");
+            for (const line of lines){
+                const [key, value] = line.split("=");
+                if (key && value) result[key.trim()] = value.trim();
+            }
+            return result;
+        }
+        getLocalHostname() {
+            return `${__webpack_require__("os").hostname()}.local`;
+        }
+        getLocalAddresses() {
+            const addresses = [];
+            const interfaces = (0, external_os_.networkInterfaces)();
+            for (const name of Object.keys(interfaces)){
+                const nets = interfaces[name];
+                if (nets) {
+                    for (const net of nets)if ("IPv4" === net.family && !net.internal) addresses.push(net.address);
+                }
+            }
+            return addresses;
+        }
+        constructor(){
+            _define_property(this, "mdnsInstance", null);
+            _define_property(this, "isAnnouncing", false);
+            _define_property(this, "config", null);
+        }
+    }
+})();
+exports.MDNSDiscoveryService = __webpack_exports__.MDNSDiscoveryService;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MDNSDiscoveryService"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/discovery/mdns.d.ts

@@ -0,0 +1,37 @@
+import type { DiscoveryService, DiscoveryConfig, DiscoveredGateway } from "./types.js";
+/**
+ * mDNS/Bonjour discovery service for local network
+ */
+export declare class MDNSDiscoveryService implements DiscoveryService {
+    private mdnsInstance;
+    private isAnnouncing;
+    private config;
+    /**
+     * Start announcing this gateway on the local network
+     */
+    announce(config: DiscoveryConfig): Promise<void>;
+    /**
+     * Stop announcing this gateway
+     */
+    stopAnnouncing(): Promise<void>;
+    /**
+     * Discover available gateways on the local network
+     */
+    discover(timeout?: number): Promise<DiscoveredGateway[]>;
+    /**
+     * Parse mDNS response into DiscoveredGateway
+     */
+    private parseResponse;
+    /**
+     * Parse TXT record data
+     */
+    private parseTxtRecord;
+    /**
+     * Get local hostname
+     */
+    private getLocalHostname;
+    /**
+     * Get local IP addresses
+     */
+    private getLocalAddresses;
+}

package/dist/gateway/discovery/mdns.js

@@ -0,0 +1,177 @@
+import * as __rspack_external_os from "os";
+import multicast_dns from "multicast-dns";
+var __webpack_modules__ = {
+    os (module) {
+        module.exports = __rspack_external_os;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+var external_os_ = __webpack_require__("os");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const SERVICE_TYPE = "_wingman-gateway._tcp.local";
+class MDNSDiscoveryService {
+    async announce(config) {
+        if (this.isAnnouncing) throw new Error("Already announcing");
+        this.config = config;
+        this.mdnsInstance = multicast_dns();
+        this.mdnsInstance.on("query", (query)=>{
+            const isOurService = query.questions.some((q)=>q.name === SERVICE_TYPE || q.name === `${config.name}.${SERVICE_TYPE}`);
+            if (isOurService && this.mdnsInstance) {
+                const hostname = this.getLocalHostname();
+                const addresses = this.getLocalAddresses();
+                const txt = [
+                    `version=${config.version}`,
+                    `auth=${config.requireAuth ? "required" : "optional"}`,
+                    `transport=${config.transport}`,
+                    `capabilities=${config.capabilities.join(",")}`
+                ];
+                this.mdnsInstance.respond({
+                    answers: [
+                        {
+                            name: SERVICE_TYPE,
+                            type: "PTR",
+                            ttl: 120,
+                            data: `${config.name}.${SERVICE_TYPE}`
+                        },
+                        {
+                            name: `${config.name}.${SERVICE_TYPE}`,
+                            type: "SRV",
+                            ttl: 120,
+                            data: {
+                                priority: 0,
+                                weight: 0,
+                                port: config.port,
+                                target: hostname
+                            }
+                        },
+                        {
+                            name: `${config.name}.${SERVICE_TYPE}`,
+                            type: "TXT",
+                            ttl: 120,
+                            data: Buffer.from(txt.join("\n"))
+                        },
+                        ...addresses.map((addr)=>({
+                                name: hostname,
+                                type: "A",
+                                ttl: 120,
+                                data: addr
+                            }))
+                    ]
+                });
+            }
+        });
+        this.isAnnouncing = true;
+    }
+    async stopAnnouncing() {
+        if (this.mdnsInstance) {
+            this.mdnsInstance.destroy();
+            this.mdnsInstance = null;
+        }
+        this.isAnnouncing = false;
+        this.config = null;
+    }
+    async discover(timeout = 5000) {
+        return new Promise((resolve)=>{
+            const discovered = new Map();
+            const mdnsClient = multicast_dns();
+            const timer = setTimeout(()=>{
+                mdnsClient.destroy();
+                resolve(Array.from(discovered.values()));
+            }, timeout);
+            mdnsClient.on("response", (response)=>{
+                try {
+                    const gateway = this.parseResponse(response);
+                    if (gateway) discovered.set(gateway.name, gateway);
+                } catch (error) {}
+            });
+            mdnsClient.query({
+                questions: [
+                    {
+                        name: SERVICE_TYPE,
+                        type: "PTR"
+                    }
+                ]
+            });
+            const cleanup = ()=>{
+                clearTimeout(timer);
+                mdnsClient.destroy();
+            };
+            setTimeout(cleanup, timeout);
+        });
+    }
+    parseResponse(response) {
+        const ptrRecords = response.answers.filter((a)=>"PTR" === a.type);
+        const srvRecords = response.answers.filter((a)=>"SRV" === a.type);
+        const txtRecords = response.answers.filter((a)=>"TXT" === a.type);
+        const aRecords = response.answers.filter((a)=>"A" === a.type);
+        if (0 === ptrRecords.length) return null;
+        const instanceName = ptrRecords[0].data.replace(`.${SERVICE_TYPE}`, "");
+        const srv = srvRecords.find((r)=>r.name === `${instanceName}.${SERVICE_TYPE}`);
+        const txt = txtRecords.find((r)=>r.name === `${instanceName}.${SERVICE_TYPE}`);
+        if (!srv || !txt) return null;
+        const txtData = this.parseTxtRecord(txt.data);
+        const aRecord = aRecords.find((r)=>r.name === srv.data.target);
+        const host = aRecord?.data || "localhost";
+        const port = srv.data.port;
+        const transport = txtData.transport || "ws";
+        const url = `${transport}://${host}:${port}/ws`;
+        return {
+            name: instanceName,
+            url,
+            host,
+            port,
+            requireAuth: "required" === txtData.auth,
+            capabilities: txtData.capabilities ? txtData.capabilities.split(",") : [],
+            version: txtData.version || "1.0.0",
+            transport: transport
+        };
+    }
+    parseTxtRecord(data) {
+        const result = {};
+        const text = data.toString();
+        const lines = text.split("\n");
+        for (const line of lines){
+            const [key, value] = line.split("=");
+            if (key && value) result[key.trim()] = value.trim();
+        }
+        return result;
+    }
+    getLocalHostname() {
+        return `${__webpack_require__("os").hostname()}.local`;
+    }
+    getLocalAddresses() {
+        const addresses = [];
+        const interfaces = (0, external_os_.networkInterfaces)();
+        for (const name of Object.keys(interfaces)){
+            const nets = interfaces[name];
+            if (nets) {
+                for (const net of nets)if ("IPv4" === net.family && !net.internal) addresses.push(net.address);
+            }
+        }
+        return addresses;
+    }
+    constructor(){
+        _define_property(this, "mdnsInstance", null);
+        _define_property(this, "isAnnouncing", false);
+        _define_property(this, "config", null);
+    }
+}
+export { MDNSDiscoveryService };

package/dist/gateway/discovery/tailscale.cjs

@@ -0,0 +1,140 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TailscaleDiscoveryService: ()=>TailscaleDiscoveryService
+});
+const external_child_process_namespaceObject = require("child_process");
+const external_util_namespaceObject = require("util");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const execAsync = (0, external_util_namespaceObject.promisify)(external_child_process_namespaceObject.exec);
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+class TailscaleDiscoveryService {
+    async announce(config) {
+        this.isAnnouncing = true;
+        this.config = config;
+    }
+    async stopAnnouncing() {
+        this.isAnnouncing = false;
+        this.config = null;
+    }
+    async discover(timeout = 5000) {
+        try {
+            const devices = await this.getTailscaleDevices();
+            const gateways = [];
+            for (const device of devices){
+                if (!device.online) continue;
+                const isGateway = device.tags?.some((tag)=>tag.toLowerCase().includes("wingman-gateway")) || device.hostname.toLowerCase().includes("gateway");
+                if (!isGateway) continue;
+                const gatewayInfo = await this.probeGateway(device.ip, 3000);
+                if (gatewayInfo) gateways.push(gatewayInfo);
+            }
+            return gateways;
+        } catch (error) {
+            logger.error("Tailscale discovery failed", error);
+            return [];
+        }
+    }
+    async getTailscaleDevices() {
+        try {
+            const { stdout } = await execAsync("tailscale status --json");
+            const status = JSON.parse(stdout);
+            const devices = [];
+            if (status.Peer) for (const [id, peerData] of Object.entries(status.Peer)){
+                const peer = peerData;
+                devices.push({
+                    id,
+                    hostname: peer.HostName || peer.DNSName?.split(".")[0] || id,
+                    ip: peer.TailscaleIPs?.[0] || peer.Addrs?.[0]?.split(":")[0] || "",
+                    online: peer.Online ?? false,
+                    tags: peer.Tags || []
+                });
+            }
+            return devices;
+        } catch (error) {
+            logger.error("Failed to get Tailscale devices", error);
+            return [];
+        }
+    }
+    async probeGateway(ip, port) {
+        try {
+            const response = await fetch(`http://${ip}:${port}/health`, {
+                signal: AbortSignal.timeout(2000)
+            });
+            if (!response.ok) return null;
+            const health = await response.json();
+            if ("wingman-gateway" !== health.service) return null;
+            let capabilities = [
+                "broadcast",
+                "direct",
+                "groups"
+            ];
+            let version = "1.0.0";
+            try {
+                const statsResponse = await fetch(`http://${ip}:${port}/stats`, {
+                    signal: AbortSignal.timeout(2000)
+                });
+                if (statsResponse.ok) {
+                    const stats = await statsResponse.json();
+                    if (stats.capabilities) capabilities = stats.capabilities;
+                    if (stats.version) version = stats.version;
+                }
+            } catch  {}
+            return {
+                name: health.name || `Gateway-${ip}`,
+                url: `ws://${ip}:${port}/ws`,
+                host: ip,
+                port,
+                requireAuth: health.requireAuth ?? false,
+                capabilities,
+                version,
+                transport: "ws"
+            };
+        } catch (error) {
+            return null;
+        }
+    }
+    constructor(){
+        _define_property(this, "isAnnouncing", false);
+        _define_property(this, "config", null);
+    }
+}
+exports.TailscaleDiscoveryService = __webpack_exports__.TailscaleDiscoveryService;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TailscaleDiscoveryService"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/discovery/tailscale.d.ts

@@ -0,0 +1,31 @@
+import type { DiscoveryService, DiscoveryConfig, DiscoveredGateway } from "./types.js";
+/**
+ * Tailscale discovery service
+ * Uses Tailscale CLI to discover gateways on the Tailnet
+ */
+export declare class TailscaleDiscoveryService implements DiscoveryService {
+    private isAnnouncing;
+    private config;
+    /**
+     * Announce this gateway on Tailscale
+     * Note: Tailscale announcement is done via tags set in Tailscale admin console
+     * This method is a no-op but maintains interface compatibility
+     */
+    announce(config: DiscoveryConfig): Promise<void>;
+    /**
+     * Stop announcing this gateway
+     */
+    stopAnnouncing(): Promise<void>;
+    /**
+     * Discover gateways on the Tailscale network
+     */
+    discover(timeout?: number): Promise<DiscoveredGateway[]>;
+    /**
+     * Get list of Tailscale devices on the network
+     */
+    private getTailscaleDevices;
+    /**
+     * Probe a device to check if it's running a Wingman gateway
+     */
+    private probeGateway;
+}