@camstack/addon-provider-reolink 1.1.9 → 1.1.11

package/dist/addon.mjs

@@ -14,7 +14,7 @@ import { format, promisify } from "util";
 import * as dgram2 from "dgram";
 import dgram from "dgram";
 import dns from "dns/promises";
-import { networkInterfaces } from "os";
+import { networkInterfaces, platform } from "os";
 import { setInterval as setInterval$1 } from "timers";
 import * as net2 from "net";
 import netImpl from "net";
@@ -4650,7 +4650,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#endregion
-//#region ../types/dist/sleep-B3AOslwX.mjs
+//#region ../types/dist/sleep-C2M2zF7x.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -6218,6 +6218,12 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Switch"] = "switch";
 	DeviceType["Sensor"] = "sensor";
 	DeviceType["Thermostat"] = "thermostat";
+	/** Air-conditioner / heat-pump climate device (HVAC) — shares the
+	*  `climate-control` cap surface with `Thermostat` but renders a
+	*  dedicated AC-appropriate control UI (mode chips, fan speed,
+	*  independent vertical/horizontal swing). Sources: native Gree, and
+	*  reusable by other AC integrations. */
+	DeviceType["Climate"] = "climate";
 	DeviceType["Button"] = "button";
 	/** Generic stateless event emitter — carries a device's EXACT declared
 	*  event vocabulary verbatim (no normalization). Installed with the
@@ -9239,7 +9245,7 @@ var climateControlCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Thermostat],
+	deviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
 	methods: {
 		setMode: method(object({
 			deviceId: number().int().nonnegative(),
@@ -13838,10 +13844,30 @@ var deviceProviderCapability = {
 			type: string()
 		}))),
 		supportsDiscovery: method(object({}), boolean()),
-		discoverDevices: method(object({}), array(DiscoveryCandidateSchema), {
+		/**
+		* Run a network scan. `params` carries optional provider-specific scan
+		* inputs (e.g. a broadcast address / subnet for cross-subnet discovery),
+		* shaped by `getDiscoveryParamsSchema`. Omitted for the generic scan
+		* (provider uses its local-network default).
+		*/
+		discoverDevices: method(object({ params: record(string(), unknown()).optional() }), array(DiscoveryCandidateSchema), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Optional form schema (`ConfigUISchema`) for the EXTRA per-scan inputs a
+		* provider accepts (e.g. Gree's broadcast address for a different subnet).
+		* `null` when the provider takes no extra scan params — the generic
+		* aggregated scan never renders this; the per-integration scan does.
+		*/
+		getDiscoveryParamsSchema: method(object({}), CreationSchemaOutputSchema),
+		/**
+		* The DeviceType this provider creates via manual add (Camera for
+		* Reolink/ONVIF, Container for Gree, Hub for Ecowitt). `null` when the
+		* provider does not support manual creation. Lets the Add-Device dialog
+		* pick the right type instead of assuming Camera.
+		*/
+		getManualCreationType: method(object({}), object({ deviceType: _enum(DeviceType).nullable() })),
 		adoptDiscoveredDevice: method(object({ candidate: DiscoveryCandidateSchema }), DeviceSummarySchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -13965,9 +13991,23 @@ var BaseDeviceProvider = class extends BaseAddon {
 	async supportsDiscovery() {
 		return false;
 	}
-	async discoverDevices() {
+	async discoverDevices(_input) {
 		return [];
 	}
+	/** Extra per-scan input form (e.g. a broadcast address for another subnet).
+	*  Null = no extra params. Override in providers that support scoped scans. */
+	async getDiscoveryParamsSchema() {
+		return null;
+	}
+	/**
+	* The DeviceType this provider creates via manual add — derived from the
+	* `deviceClasses` map (first registered type). `null` when manual creation is
+	* unsupported. Lets the Add-Device dialog pick the right type per provider.
+	*/
+	async getManualCreationType() {
+		if (!await this.supportsManualCreation()) return { deviceType: null };
+		return { deviceType: Object.values(DeviceType).find((t) => this.deviceClasses[t] !== void 0) ?? null };
+	}
 	async adoptDiscoveredDevice(_input) {
 		throw new Error(`${this.providerName} provider does not support discovery-based adoption`);
 	}
@@ -15824,7 +15864,10 @@ method(object({
 }), FieldProbeResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(ListCandidatesInputSchema.extend({ addonId: string() }), ListCandidatesOutputSchema, { auth: "admin" }), method(object({
+}), method(object({
+	addonId: string(),
+	integrationId: string()
+}), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }), method(ListCandidatesInputSchema.extend({ addonId: string() }), ListCandidatesOutputSchema, { auth: "admin" }), method(object({
 	addonId: string(),
 	integrationId: string()
 }), AdoptionStatusSchema, {
@@ -15839,7 +15882,24 @@ method(object({
 }), method(ResyncInputSchema, ResyncResultSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({}), object({ providers: array(object({
+	addonId: string(),
+	label: string()
+})).readonly() }), { auth: "admin" }), method(object({}), object({ groups: array(object({
+	addonId: string(),
+	label: string(),
+	candidates: array(DiscoveryCandidateSchema).readonly(),
+	error: string().nullable()
+})).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
+	addonId: string(),
+	params: record(string(), unknown()).optional()
+}), object({ candidates: array(DiscoveryCandidateSchema).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ addonId: string() }), object({ deviceType: _enum(DeviceType).nullable() }), { auth: "admin" }), method(object({ addonId: string() }), unknown(), { auth: "admin" }), method(object({
 	deviceId: number(),
 	key: string(),
 	value: unknown()
@@ -18534,6 +18594,17 @@ var AvailableIntegrationTypeSchema = object({
 	iconUrl: string().nullable(),
 	color: string(),
 	instanceMode: string(),
+	/**
+	* Integration wizard `mode` (LOCKED MODEL): `standalone` (create
+	* immediately then add devices, no config step/button), `account` (config
+	* step), or `broker` (broker step). Derived server-side by
+	* `getAvailableTypes` when the addon manifest omits an explicit `mode`.
+	*/
+	mode: _enum([
+		"standalone",
+		"account",
+		"broker"
+	]),
 	discoveryMode: string(),
 	/**
 	* Which integration-marker cap the addon declared, so the wizard can
@@ -21323,6 +21394,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionListCandidateFilters": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.adoptionListCandidates": {
 		capName: "device-manager",
 		capScope: "system",
@@ -21371,12 +21448,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.discoverAllProviders": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.discoverDevices": {
 		capName: "device-manager",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.discoverProvider": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceManager.discoveryProviders": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.enable": {
 		capName: "device-manager",
 		capScope: "system",
@@ -21527,6 +21622,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.providerCreationType": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceManager.providerDiscoveryParamsSchema": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.registerDevice": {
 		capName: "device-manager",
 		capScope: "system",
@@ -21743,6 +21850,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceProvider.getDiscoveryParamsSchema": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceProvider.getManualCreationType": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceProvider.getStatus": {
 		capName: "device-provider",
 		capScope: "system",
@@ -164340,7 +164459,7 @@ ${scheduleItems}
 		}), chimeId);
 	}
 };
-promisify(execFile);
+var execFileAsync = promisify(execFile);
 async function discoverViaUdpDirect(host, options) {
 	if (!options.enableUdpDiscovery) return [];
 	const logger = options.logger;
@@ -164410,6 +164529,170 @@ async function discoverViaUdpDirect(host, options) {
 		});
 	});
 }
+function getLocalNetworks() {
+	const networks = [];
+	const interfaces = networkInterfaces();
+	for (const ifaceName of Object.keys(interfaces)) {
+		const iface = interfaces[ifaceName];
+		if (!iface) continue;
+		for (const addr of iface) {
+			if (addr.internal || addr.family !== "IPv4" || !addr.netmask) continue;
+			addr.address.split(".").map(Number);
+			const maskParts = addr.netmask.split(".").map(Number);
+			let cidr = 0;
+			for (let i = 0; i < 4; i++) {
+				const maskValue = maskParts[i];
+				if (maskValue === void 0 || !Number.isFinite(maskValue)) break;
+				if (maskValue === 255) cidr += 8;
+				else if (maskValue === 0) break;
+				else {
+					let bits = 0;
+					let m = maskValue;
+					while (m > 0) {
+						if (m & 1) bits++;
+						m = m >> 1;
+					}
+					cidr += bits;
+					break;
+				}
+			}
+			const networkCidr = `${addr.address.split(".").slice(0, 3).join(".")}.0/${cidr}`;
+			if (!networks.includes(networkCidr)) networks.push(networkCidr);
+		}
+	}
+	return networks;
+}
+function parseCidr(cidr) {
+	const parts = cidr.split("/");
+	const network = parts[0];
+	const prefixStr = parts[1];
+	if (!network) return null;
+	const prefix = Number.parseInt(prefixStr ?? "24", 10);
+	if (!Number.isFinite(prefix) || prefix < 0 || prefix > 32) return null;
+	const ipParts = network.split(".").map(Number);
+	if (ipParts.length !== 4 || ipParts.some((p) => !Number.isFinite(p) || p < 0 || p > 255)) return null;
+	const networkBits = prefix;
+	const hostBits = 32 - networkBits;
+	let networkAddr = 0;
+	for (let i = 0; i < 4; i++) {
+		const part = ipParts[i];
+		if (part === void 0 || !Number.isFinite(part)) return null;
+		networkAddr = networkAddr << 8 | part & 255;
+	}
+	const mask = (1 << networkBits) - 1 << hostBits;
+	networkAddr &= mask;
+	const hostCount = 1 << hostBits;
+	const start = prefix >= 24 ? networkAddr + 1 : networkAddr;
+	const end = prefix >= 24 ? networkAddr + hostCount - 2 : networkAddr + hostCount - 1;
+	return {
+		start,
+		end,
+		count: end - start + 1
+	};
+}
+function ipNumberToString(ip) {
+	return `${ip >>> 24 & 255}.${ip >>> 16 & 255}.${ip >>> 8 & 255}.${ip & 255}`;
+}
+async function probeHttpDevice(ip, port, options) {
+	const { username, password, timeoutMs, logger, useHttps } = options;
+	try {
+		const cgi = new ReolinkCgiApi({
+			host: ip,
+			port,
+			useHttps: useHttps ?? false,
+			username: username ?? "admin",
+			password: password ?? "",
+			timeoutMs
+		});
+		try {
+			const info = await cgi.getInfo();
+			if (info?.type) {
+				logger?.log?.(`[Discovery] Found Reolink device at ${ip}:${port} (${useHttps ? "HTTPS" : "HTTP"}) - ${info.type}`);
+				const result = {
+					host: ip,
+					discoveryMethod: "http_probe",
+					supportsHttps: useHttps ?? false,
+					httpAccessible: !useHttps
+				};
+				if (port !== void 0) if (useHttps) result.httpsPort = port;
+				else result.httpPort = port;
+				if (info.type) result.model = info.type.trim();
+				if (info.name) result.name = info.name.trim();
+				if (info.firmwareVersion) result.firmwareVersion = info.firmwareVersion.trim();
+				return result;
+			}
+		} catch {
+			if (username && password) try {
+				await cgi.login();
+				const info = await cgi.getInfo();
+				if (info?.type) {
+					logger?.log?.(`[Discovery] Found authenticated Reolink device at ${ip}:${port} (${useHttps ? "HTTPS" : "HTTP"}) - ${info.type}`);
+					const result = {
+						host: ip,
+						discoveryMethod: "http_probe",
+						supportsHttps: useHttps ?? false,
+						httpAccessible: !useHttps
+					};
+					if (port !== void 0) if (useHttps) result.httpsPort = port;
+					else result.httpPort = port;
+					if (info.type) result.model = info.type.trim();
+					if (info.name) result.name = info.name.trim();
+					if (info.firmwareVersion) result.firmwareVersion = info.firmwareVersion.trim();
+					return result;
+				}
+			} catch {}
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (!msg.includes("ECONNREFUSED") && !msg.includes("ETIMEDOUT")) logger?.warn?.(`[Discovery] Error probing ${ip}:${port}: ${msg}`);
+	}
+	return null;
+}
+async function discoverViaHttpScan(options) {
+	if (!options.enableHttpScanning) return [];
+	const logger = options.logger;
+	const networkCidr = options.networkCidr ?? getLocalNetworks()[0];
+	const httpPorts = options.httpPorts ?? [80, 443];
+	const timeoutMs = options.httpProbeTimeoutMs ?? 2e3;
+	const maxConcurrent = options.maxConcurrentProbes ?? 50;
+	if (!networkCidr) {
+		logger?.warn?.("[Discovery] No network CIDR available for HTTP scanning");
+		return [];
+	}
+	logger?.log?.(`[Discovery] Starting HTTP scan on network ${networkCidr}...`);
+	const ipRange = parseCidr(networkCidr);
+	if (!ipRange) {
+		logger?.warn?.(`[Discovery] Invalid CIDR: ${networkCidr}`);
+		return [];
+	}
+	const discovered = [];
+	const ipAddresses = [];
+	for (let ipNum = ipRange.start; ipNum <= ipRange.end && ipNum <= ipRange.start + 254; ipNum++) {
+		const ip = ipNumberToString(ipNum);
+		for (const port of httpPorts) ipAddresses.push({
+			ip,
+			port,
+			useHttps: port === 443
+		});
+	}
+	logger?.log?.(`[Discovery] Scanning ${ipAddresses.length} IP:port combinations...`);
+	for (let i = 0; i < ipAddresses.length; i += maxConcurrent) {
+		const batch = ipAddresses.slice(i, i + maxConcurrent);
+		const batchResults = await Promise.allSettled(batch.map(({ ip, port, useHttps }) => {
+			const probeOptions = {
+				timeoutMs,
+				useHttps
+			};
+			if (options.username !== void 0) probeOptions.username = options.username;
+			if (options.password !== void 0) probeOptions.password = options.password;
+			if (logger !== void 0) probeOptions.logger = logger;
+			return probeHttpDevice(ip, port, probeOptions);
+		}));
+		for (const result of batchResults) if (result.status === "fulfilled" && result.value) discovered.push(result.value);
+	}
+	logger?.log?.(`[Discovery] HTTP scan complete. Found ${discovered.length} device(s).`);
+	return discovered;
+}
 async function discoverViaUdpBroadcast(options) {
 	if (!options.enableUdpDiscovery) return [];
 	const logger = options.logger;
@@ -164497,6 +164780,359 @@ async function discoverViaUdpBroadcast(options) {
 		});
 	});
 }
+var REOLINK_MAC_PREFIXES = [
+	"EC:71:DB",
+	"2C:1B:3A",
+	"18:2C:65",
+	"DC:E5:37",
+	"9C:8E:CD",
+	"B4:4B:D6",
+	"E4:3D:1A"
+];
+async function discoverViaArpTable(options) {
+	if (!options.enableArpLookup) return [];
+	const logger = options.logger;
+	logger?.log?.("[Discovery] Starting ARP table lookup for Reolink MAC prefix...");
+	const discovered = [];
+	try {
+		let entries = [];
+		if (platform() === "linux") try {
+			const { readFile } = await import("fs/promises");
+			const content = await readFile("/proc/net/arp", "utf8");
+			for (const line of content.split("\n").slice(1)) {
+				const parts = line.trim().split(/\s+/);
+				if (parts.length >= 4 && parts[0] && parts[3] && parts[3] !== "00:00:00:00:00:00") entries.push({
+					ip: parts[0],
+					mac: parts[3].toUpperCase()
+				});
+			}
+		} catch {
+			const { stdout } = await runArpCommand();
+			entries = parseArpOutput(stdout);
+		}
+		else {
+			const { stdout } = await runArpCommand();
+			entries = parseArpOutput(stdout);
+		}
+		logger?.log?.(`[Discovery] ARP table has ${entries.length} entries`);
+		for (const { ip, mac } of entries) if (REOLINK_MAC_PREFIXES.some((prefix) => mac.startsWith(prefix))) {
+			logger?.log?.(`[Discovery] Found Reolink device via ARP: ${ip} (MAC: ${mac})`);
+			discovered.push({
+				host: ip,
+				discoveryMethod: "arp"
+			});
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger?.warn?.(`[Discovery] ARP table lookup failed: ${msg}`);
+	}
+	logger?.log?.(`[Discovery] ARP lookup complete. Found ${discovered.length} device(s).`);
+	return discovered;
+}
+async function runArpCommand() {
+	for (const arpPath of [
+		"/usr/sbin/arp",
+		"/sbin/arp",
+		"/usr/bin/arp",
+		"arp"
+	]) try {
+		return await execFileAsync(arpPath, ["-an"], { timeout: 5e3 });
+	} catch {}
+	throw new Error("arp command not found");
+}
+function parseArpOutput(stdout) {
+	const results = [];
+	for (const line of stdout.split("\n")) {
+		const match = /\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-fA-F:]+)/i.exec(line);
+		if (match && match[1] && match[2] && match[2] !== "(incomplete)") results.push({
+			ip: match[1],
+			mac: match[2].toUpperCase()
+		});
+	}
+	return results;
+}
+async function discoverViaDhcpListener(options) {
+	if (!options.enableDhcpListener) return [];
+	const logger = options.logger;
+	const timeoutMs = options.dhcpListenerTimeoutMs ?? 1e4;
+	logger?.log?.(`[Discovery] Starting passive DHCP listener (${timeoutMs}ms)...`);
+	const discovered = /* @__PURE__ */ new Map();
+	return new Promise((resolve) => {
+		let socket;
+		let timeout;
+		try {
+			socket = dgram.createSocket({
+				type: "udp4",
+				reuseAddr: true
+			});
+		} catch (err) {
+			logger?.warn?.(`[Discovery] DHCP: failed to create socket: ${err instanceof Error ? err.message : String(err)}`);
+			resolve([]);
+			return;
+		}
+		socket.on("message", (msg) => {
+			try {
+				if (msg.length < 240) return;
+				const op = msg[0];
+				if (msg[2] !== 6) return;
+				const mac = [
+					msg[28]?.toString(16).padStart(2, "0"),
+					msg[29]?.toString(16).padStart(2, "0"),
+					msg[30]?.toString(16).padStart(2, "0"),
+					msg[31]?.toString(16).padStart(2, "0"),
+					msg[32]?.toString(16).padStart(2, "0"),
+					msg[33]?.toString(16).padStart(2, "0")
+				].join(":").toUpperCase();
+				const isReolinkMac = REOLINK_MAC_PREFIXES.some((p) => mac.startsWith(p));
+				let hostname = "";
+				let i = 240;
+				while (i < msg.length - 1) {
+					const optType = msg[i];
+					if (optType === 255) break;
+					if (optType === 0) {
+						i++;
+						continue;
+					}
+					const optLen = msg[i + 1] ?? 0;
+					if (optType === 12 && optLen > 0) hostname = msg.subarray(i + 2, i + 2 + optLen).toString("ascii").toLowerCase();
+					i += 2 + optLen;
+				}
+				const isReolinkHostname = hostname.startsWith("reolink");
+				if (!isReolinkMac && !isReolinkHostname) return;
+				const yiaddr = `${msg[16]}.${msg[17]}.${msg[18]}.${msg[19]}`;
+				const ciaddr = `${msg[12]}.${msg[13]}.${msg[14]}.${msg[15]}`;
+				const ip = yiaddr !== "0.0.0.0" ? yiaddr : ciaddr;
+				if (ip === "0.0.0.0" || !ip) return;
+				if (!discovered.has(ip)) {
+					logger?.log?.(`[Discovery] DHCP: found Reolink device ${ip} (MAC: ${mac}, hostname: ${hostname || "n/a"}, op: ${op === 1 ? "request" : "reply"})`);
+					const device = {
+						host: ip,
+						discoveryMethod: "dhcp"
+					};
+					if (hostname) device.name = hostname;
+					discovered.set(ip, device);
+				}
+			} catch {}
+		});
+		socket.on("error", (err) => {
+			logger?.warn?.(`[Discovery] DHCP socket error: ${err.message}`);
+			clearTimeout(timeout);
+			socket.close();
+			resolve(Array.from(discovered.values()));
+		});
+		socket.bind(67, "0.0.0.0", () => {
+			logger?.log?.("[Discovery] DHCP listener bound on port 67");
+			timeout = setTimeout(() => {
+				socket.close();
+				logger?.log?.(`[Discovery] DHCP listener complete. Found ${discovered.size} device(s).`);
+				resolve(Array.from(discovered.values()));
+			}, timeoutMs);
+		});
+	});
+}
+function probeTcpPort(ip, port, timeoutMs) {
+	return new Promise((resolve) => {
+		const socket = new net2.Socket();
+		let settled = false;
+		const done = (result) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			resolve(result);
+		};
+		socket.setTimeout(timeoutMs);
+		socket.on("connect", () => done(true));
+		socket.on("timeout", () => done(false));
+		socket.on("error", () => done(false));
+		socket.connect(port, ip);
+	});
+}
+async function discoverViaTcpPortScan(options) {
+	if (!options.enableTcpPortScan) return [];
+	const logger = options.logger;
+	const networkCidr = options.networkCidr ?? getLocalNetworks()[0];
+	const timeoutMs = options.tcpProbeTimeoutMs ?? 1500;
+	const maxConcurrent = options.maxConcurrentProbes ?? 80;
+	if (!networkCidr) {
+		logger?.warn?.("[Discovery] No network CIDR available for TCP port scan");
+		return [];
+	}
+	logger?.log?.(`[Discovery] Starting TCP port 9000 scan on network ${networkCidr}...`);
+	const ipRange = parseCidr(networkCidr);
+	if (!ipRange) {
+		logger?.warn?.(`[Discovery] Invalid CIDR: ${networkCidr}`);
+		return [];
+	}
+	const discovered = [];
+	const ipAddresses = [];
+	for (let ipNum = ipRange.start; ipNum <= ipRange.end && ipNum <= ipRange.start + 254; ipNum++) ipAddresses.push(ipNumberToString(ipNum));
+	logger?.log?.(`[Discovery] Scanning ${ipAddresses.length} IPs on port 9000...`);
+	for (let i = 0; i < ipAddresses.length; i += maxConcurrent) {
+		const batch = ipAddresses.slice(i, i + maxConcurrent);
+		const batchResults = await Promise.allSettled(batch.map(async (ip) => {
+			if (await probeTcpPort(ip, 9e3, timeoutMs)) {
+				logger?.log?.(`[Discovery] Found Baichuan device at ${ip}:9000`);
+				return {
+					host: ip,
+					discoveryMethod: "tcp_port_scan"
+				};
+			}
+			return null;
+		}));
+		for (const result of batchResults) if (result.status === "fulfilled" && result.value) discovered.push(result.value);
+	}
+	logger?.log?.(`[Discovery] TCP port scan complete. Found ${discovered.length} device(s).`);
+	return discovered;
+}
+async function discoverViaOnvif(options) {
+	if (!options.enableOnvifDiscovery) return [];
+	const logger = options.logger;
+	const timeoutMs = options.onvifDiscoveryTimeoutMs ?? 5e3;
+	logger?.log?.(`[Discovery] Starting ONVIF WS-Discovery (${timeoutMs}ms)...`);
+	const discovered = /* @__PURE__ */ new Map();
+	const MULTICAST_ADDR = "239.255.255.250";
+	const MULTICAST_PORT = 3702;
+	const probeMessage = [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+		"<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"",
+		"  xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\"",
+		"  xmlns:d=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\"",
+		"  xmlns:dn=\"http://www.onvif.org/ver10/network/wsdl\">",
+		"  <s:Header>",
+		`    <a:MessageID>${`uuid:${randomUUID()}`}</a:MessageID>`,
+		"    <a:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</a:To>",
+		"    <a:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</a:Action>",
+		"  </s:Header>",
+		"  <s:Body>",
+		"    <d:Probe>",
+		"      <d:Types>dn:NetworkVideoTransmitter</d:Types>",
+		"    </d:Probe>",
+		"  </s:Body>",
+		"</s:Envelope>"
+	].join("\n");
+	return new Promise((resolve) => {
+		const socket = dgram.createSocket({
+			type: "udp4",
+			reuseAddr: true
+		});
+		let timeout;
+		socket.on("message", (msg, rinfo) => {
+			try {
+				const xml = msg.toString("utf8");
+				const xaddrsMatch = /<[^:]*:?XAddrs>([^<]+)<\/[^:]*:?XAddrs>/i.exec(xml);
+				const scopesMatch = /<[^:]*:?Scopes>([^<]+)<\/[^:]*:?Scopes>/i.exec(xml);
+				let host = rinfo.address;
+				let httpPort;
+				if (xaddrsMatch?.[1]) {
+					const urls = xaddrsMatch[1].trim().split(/\s+/);
+					for (const url of urls) try {
+						const parsed = new URL(url);
+						if (parsed.hostname) {
+							host = parsed.hostname;
+							const p = Number.parseInt(parsed.port, 10);
+							if (p && p !== 80) httpPort = p;
+							break;
+						}
+					} catch {}
+				}
+				if (discovered.has(host)) return;
+				let model;
+				let name;
+				let manufacturer;
+				if (scopesMatch?.[1]) {
+					const scopes = scopesMatch[1].trim().split(/\s+/);
+					for (const scope of scopes) {
+						const hwMatch = /\/hardware\/(.+)$/i.exec(scope);
+						if (hwMatch?.[1]) model = decodeURIComponent(hwMatch[1]);
+						const nameMatch = /\/name\/(.+)$/i.exec(scope);
+						if (nameMatch?.[1]) name = decodeURIComponent(nameMatch[1]);
+						const mfgMatch = /\/manufacturer\/(.+)$/i.exec(scope);
+						if (mfgMatch?.[1]) manufacturer = decodeURIComponent(mfgMatch[1]);
+					}
+				}
+				const hasReolinkText = `${manufacturer ?? ""} ${model ?? ""} ${xaddrsMatch?.[1] ?? ""}`.toLowerCase().includes("reolink");
+				const hasReolinkModel = /^(rlc|rln|rl[ncb]|e1|cw|cx|duo|trackmix|argus|lumus|go|video doorbell|reolink)/i.test(model ?? "");
+				if (!(hasReolinkText || hasReolinkModel)) {
+					logger?.debug?.(`[Discovery] ONVIF: skipping non-Reolink device at ${host} (${model ?? "unknown"}, manufacturer: ${manufacturer ?? "unknown"})`);
+					return;
+				}
+				logger?.log?.(`[Discovery] ONVIF: found Reolink device at ${host}${model ? ` (${model})` : ""}${name ? ` name="${name}"` : ""}`);
+				const device = {
+					host,
+					discoveryMethod: "onvif"
+				};
+				if (model) device.model = model;
+				if (name && name !== "IPC") device.name = name;
+				else if (model) device.name = model;
+				if (httpPort) device.httpPort = httpPort;
+				discovered.set(host, device);
+			} catch {}
+		});
+		socket.on("error", (err) => {
+			logger?.warn?.(`[Discovery] ONVIF socket error: ${err.message}`);
+		});
+		socket.bind(0, "0.0.0.0", () => {
+			const buf = Buffer.from(probeMessage, "utf8");
+			socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR, (err) => {
+				if (err) logger?.warn?.(`[Discovery] ONVIF: failed to send probe: ${err.message}`);
+			});
+			setTimeout(() => {
+				try {
+					socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR);
+				} catch {}
+			}, 500);
+			timeout = setTimeout(() => {
+				try {
+					socket.close();
+				} catch {}
+				logger?.log?.(`[Discovery] ONVIF WS-Discovery complete. Found ${discovered.size} device(s).`);
+				resolve(Array.from(discovered.values()));
+			}, timeoutMs);
+		});
+		socket.on("close", () => {
+			if (timeout) clearTimeout(timeout);
+		});
+	});
+}
+async function discoverReolinkDevices(options = {}) {
+	const logger = options.logger;
+	logger?.log?.("[Discovery] Starting Reolink device discovery...");
+	const results = [];
+	const seenDevices = /* @__PURE__ */ new Map();
+	const mergeDevice = (device) => {
+		const key = device.host;
+		const existing = seenDevices.get(key);
+		if (existing) {
+			if (!existing.model && device.model) existing.model = device.model;
+			if (!existing.uid && device.uid) existing.uid = device.uid;
+			if (!existing.name && device.name) existing.name = device.name;
+			if (!existing.firmwareVersion && device.firmwareVersion) existing.firmwareVersion = device.firmwareVersion;
+			if (device.httpPort && !existing.httpPort) existing.httpPort = device.httpPort;
+			if (device.httpsPort && !existing.httpsPort) existing.httpsPort = device.httpsPort;
+			if (device.supportsHttps !== void 0) existing.supportsHttps = device.supportsHttps;
+			if (device.httpAccessible !== void 0) existing.httpAccessible = device.httpAccessible;
+		} else {
+			seenDevices.set(key, { ...device });
+			results.push(seenDevices.get(key));
+		}
+	};
+	const [httpDevices, udpDevices, tcpDevices, arpDevices, dhcpDevices, onvifDevices] = await Promise.all([
+		discoverViaHttpScan(options),
+		discoverViaUdpBroadcast(options),
+		discoverViaTcpPortScan(options),
+		discoverViaArpTable(options),
+		discoverViaDhcpListener(options),
+		discoverViaOnvif(options)
+	]);
+	for (const device of dhcpDevices) mergeDevice(device);
+	for (const device of arpDevices) mergeDevice(device);
+	for (const device of tcpDevices) mergeDevice(device);
+	for (const device of onvifDevices) mergeDevice(device);
+	for (const device of httpDevices) mergeDevice(device);
+	for (const device of udpDevices) mergeDevice(device);
+	logger?.log?.(`[Discovery] Discovery complete. Found ${results.length} unique device(s).`);
+	return results;
+}
 var ALL_UDP_DISCOVERY_METHODS = [
 	"local-direct",
 	"local-broadcast",
@@ -222148,6 +222784,62 @@ function discoveredStatusFor(d) {
 *   - NVR devices expose every channel via `ch{N}-main` / `ch{N}-sub`
 *     stream IDs (Slice 8); no operator choice is required
 */
+/**
+* Extra per-scan inputs for Reolink network discovery. Unlike Gree/Ecowitt, a Reolink camera needs
+* CREDENTIALS to be created — so the scan form collects them: the library uses them to enrich the
+* probe (model/UID via the authenticated API) and they are baked into each candidate so a one-click
+* adopt yields a working camera. `networkCidr` reaches cameras on another subnet (auto-detects the
+* local subnet when blank); ONVIF WS-Discovery is on by default since most Reolink cameras support it.
+*/
+function buildDiscoveryParamsFormSchema() {
+	return { sections: [{
+		id: "credentials",
+		title: "Credentials",
+		description: "Used to probe the cameras and pre-filled into each result so you can add it in one click. Assumes all cameras share these credentials.",
+		columns: 2,
+		fields: [{
+			type: "text",
+			key: "username",
+			label: "Username",
+			default: "admin",
+			required: true
+		}, {
+			type: "password",
+			key: "password",
+			label: "Password",
+			required: true,
+			showToggle: true
+		}]
+	}, {
+		id: "scan",
+		title: "Scan options",
+		description: "Leave the network blank to scan the local subnet. To find cameras on a different subnet, enter its CIDR (e.g. 192.168.20.0/24).",
+		columns: 1,
+		fields: [
+			{
+				type: "text",
+				key: "networkCidr",
+				label: "Network (CIDR)",
+				required: false,
+				placeholder: "192.168.20.0/24"
+			},
+			{
+				type: "boolean",
+				key: "enableOnvif",
+				label: "Include ONVIF discovery",
+				default: true
+			},
+			{
+				type: "number",
+				key: "timeoutMs",
+				label: "Scan timeout (ms)",
+				min: 1e3,
+				max: 3e4,
+				default: 5e3
+			}
+		]
+	}] };
+}
 function buildCreationFormSchema() {
 	return { sections: [
 		{
@@ -222759,6 +223451,11 @@ function isMeaningfulIdentifier(s) {
 	if (!s || s.length < 6) return false;
 	return new Set(s.toLowerCase().split("").filter((c) => c !== "0" && c !== "f")).size >= 1;
 }
+/** Flatten a host (IP / hostname) into a flat row-key slug — shared by `generateStableId` and the
+*  discovery candidate mapping so a host-keyed camera is detected as already onboarded on re-scan. */
+function slugifyReolinkHost(host) {
+	return host.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
 /**
 * Patch `detection.deviceInfo` + `hostNetworkInfo` in-place with the
 * post-login HOST identifiers. Two distinct gaps to fill:
@@ -222910,7 +223607,7 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 		if (isMeaningfulIdentifier(mac)) return `mac-${mac}`;
 		const host = typeof cfg["host"] === "string" ? cfg["host"].trim() : "";
 		if (host.length > 0) {
-			const slug = host.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+			const slug = slugifyReolinkHost(host);
 			if (slug.length > 0) return `host-${slug}`;
 		}
 		const hostLabel = host || "(unknown host)";
@@ -223024,6 +223721,61 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 		});
 		await dev.materializeStreamSocket(camStreamId);
 	}
+	async supportsDiscovery() {
+		return true;
+	}
+	async getDiscoveryParamsSchema() {
+		return buildDiscoveryParamsFormSchema();
+	}
+	async discoverDevices(input) {
+		const p = input?.params ?? {};
+		const username = typeof p["username"] === "string" ? p["username"].trim() : "";
+		const password = typeof p["password"] === "string" ? p["password"] : "";
+		const networkCidr = typeof p["networkCidr"] === "string" ? p["networkCidr"].trim() : "";
+		const enableOnvif = p["enableOnvif"] !== false;
+		const timeoutMs = typeof p["timeoutMs"] === "number" ? p["timeoutMs"] : void 0;
+		const devices = await discoverReolinkDevices({
+			logger: buildAutodetectLibLogger(this.ctx.logger),
+			enableOnvifDiscovery: enableOnvif,
+			...username ? { username } : {},
+			...password ? { password } : {},
+			...networkCidr ? { networkCidr } : {},
+			...timeoutMs !== void 0 ? {
+				udpBroadcastTimeoutMs: timeoutMs,
+				onvifDiscoveryTimeoutMs: timeoutMs
+			} : {}
+		});
+		this.ctx.logger.info("Reolink discovery complete", { meta: {
+			count: devices.length,
+			networkCidr: networkCidr || "local",
+			enableOnvif
+		} });
+		const byHost = /* @__PURE__ */ new Map();
+		for (const d of devices) if (!byHost.has(d.host)) byHost.set(d.host, d);
+		return [...byHost.values()].map((d) => {
+			const displayName = d.name ?? d.model ?? d.host;
+			return {
+				stableId: `host-${slugifyReolinkHost(d.host)}`,
+				type: DeviceType.Camera,
+				suggestedName: displayName,
+				prefilledConfig: {
+					name: displayName,
+					host: d.host,
+					transport: "auto",
+					...d.httpPort !== void 0 ? { port: d.httpPort } : {},
+					...d.uid ? { uid: d.uid } : {},
+					...username ? { username } : {},
+					...password ? { password } : {}
+				}
+			};
+		});
+	}
+	async adoptDiscoveredDevice(input) {
+		return this.createDevice({
+			type: DeviceType.Camera,
+			config: input.candidate.prefilledConfig
+		});
+	}
 	async onGetCreationSchema(type) {
 		if (type !== DeviceType.Camera && type !== DeviceType.Hub) return null;
 		return buildCreationFormSchema();