@aigne/afs-omada 1.11.0-beta.12

package/dist/omada-afs.cjs

@@ -0,0 +1,2076 @@
+const require_client = require('./client.cjs');
+const require_types = require('./types.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let ufo = require("ufo");
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let zod = require("zod");
+
+//#region src/omada-afs.ts
+/** Validate an ID parameter (siteId, ssidId, networkId) is safe for URL construction. */
+function validateIdParam(value, name) {
+	if (!/^[\w-]+$/.test(value)) throw new _aigne_afs.AFSNotFoundError(`Invalid ${name}: ${value}`);
+}
+/** Parse write payload content, normalizing JSON parse errors. */
+function parseWritePayload(payload) {
+	if (typeof payload.content === "string") try {
+		return JSON.parse(payload.content);
+	} catch {
+		throw new Error("Invalid JSON in write payload");
+	}
+	return payload.content;
+}
+/** Validate portId is a positive integer. */
+function validatePortId(portId) {
+	const num = Number.parseInt(portId, 10);
+	if (!Number.isFinite(num) || num < 1 || String(num) !== portId) throw new _aigne_afs.AFSNotFoundError(`Invalid port: ${portId}`);
+	return num;
+}
+const ssidWriteSchema = zod.z.object({
+	name: zod.z.string().optional(),
+	enable: zod.z.boolean().optional(),
+	band: zod.z.number().int().min(0).max(2).optional(),
+	security: zod.z.string().optional(),
+	vlanId: zod.z.number().int().min(0).max(4094).optional(),
+	guestNetwork: zod.z.boolean().optional()
+}).strict();
+const wiredNetworkWriteSchema = zod.z.object({
+	name: zod.z.string().optional(),
+	vlanId: zod.z.number().int().min(0).max(4094).optional(),
+	subnet: zod.z.string().optional(),
+	gateway: zod.z.string().optional(),
+	dhcpEnabled: zod.z.boolean().optional()
+}).strict();
+const wifiOptimizationWriteSchema = zod.z.object({
+	autoChannel: zod.z.boolean().optional(),
+	roaming: zod.z.boolean().optional(),
+	bandSteering: zod.z.boolean().optional()
+}).strict();
+const portConfigWriteSchema = zod.z.object({
+	enable: zod.z.boolean().optional(),
+	poeEnabled: zod.z.boolean().optional(),
+	vlanId: zod.z.number().int().min(0).max(4094).optional(),
+	profileName: zod.z.string().optional()
+}).strict();
+const deviceConfigWriteSchema = zod.z.object({
+	name: zod.z.string().optional(),
+	poeEnabled: zod.z.boolean().optional(),
+	txPower: zod.z.number().int().min(0).max(30).optional(),
+	channel: zod.z.number().int().min(0).optional()
+}).strict();
+const DEVICE_TYPE_MAP = {
+	gateway: "gateways",
+	switch: "switches",
+	ap: "aps"
+};
+const DEVICE_KIND_MAP = {
+	gateways: "network:gateway",
+	switches: "network:switch",
+	aps: "network:access-point"
+};
+const VALID_DEVICE_CATEGORIES = [
+	"gateways",
+	"switches",
+	"aps"
+];
+/**
+* AFSOmadaProvider maps TP-Link Omada SDN Controller as an AFS filesystem.
+*
+* Controller -> Sites -> Devices (Gateways/Switches/APs) -> Clients
+* are mapped to a directory hierarchy accessible via standard AFS operations.
+*/
+var AFSOmadaProvider = class AFSOmadaProvider extends _aigne_afs_provider.AFSBaseProvider {
+	static securityProfiles() {
+		return {
+			admin: {
+				actionPolicy: "full",
+				sensitivity: "full"
+			},
+			user: {
+				actionPolicy: "standard",
+				sensitiveFields: ["mac", "ip"],
+				sensitivity: "redacted"
+			},
+			guest: {
+				actionPolicy: "safe",
+				accessMode: "readonly",
+				sensitiveFields: ["mac", "ip"],
+				sensitivity: "redacted"
+			}
+		};
+	}
+	static schema() {
+		return require_types.afsOmadaOptionsSchema;
+	}
+	static manifest() {
+		return {
+			name: "omada",
+			description: "TP-Link Omada SDN Controller — network devices as filesystem.\n- Controller -> Sites -> Devices (Gateways/Switches/APs) -> Clients\n- Read device status, manage ports, view dashboard, configure networks\n- VPN, firewall, routing, NAT, logs, firmware management\n- Path structure: `/sites/{siteId}/devices/{type}/{mac}`",
+			uriTemplate: "omada://{host}",
+			category: "network",
+			schema: zod.z.object({ host: zod.z.string() }),
+			tags: [
+				"omada",
+				"network",
+				"sdn",
+				"device"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"on-premise"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet", "local-network"],
+				dataSensitivity: ["system-config"],
+				notes: ["Manages network infrastructure — misconfiguration can cause network outages"]
+			},
+			capabilities: {
+				network: { egress: true },
+				secrets: ["omada/password"]
+			}
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"write",
+				"search",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "network:controller",
+					actions: ["create-site"]
+				},
+				"/sites": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/sites/{siteId}": {
+					kind: "network:site",
+					operations: ["list", "read"]
+				},
+				"/sites/{siteId}/devices": {
+					kind: "network:device-group",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/devices/gateways": {
+					kind: "network:device-group",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/devices/gateways/{mac}": {
+					kind: "network:gateway",
+					operations: [
+						"read",
+						"write",
+						"exec"
+					],
+					actions: ["reboot", "upgrade-firmware"],
+					destructive: ["reboot"]
+				},
+				"/sites/{siteId}/devices/gateways/{mac}/firmware": {
+					kind: "network:firmware",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/devices/switches": {
+					kind: "network:device-group",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/devices/switches/{mac}": {
+					kind: "network:switch",
+					operations: [
+						"read",
+						"write",
+						"exec"
+					],
+					actions: ["reboot", "upgrade-firmware"],
+					destructive: ["reboot"]
+				},
+				"/sites/{siteId}/devices/switches/{mac}/ports": {
+					kind: "network:port-group",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/devices/switches/{mac}/firmware": {
+					kind: "network:firmware",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/devices/aps": {
+					kind: "network:device-group",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/devices/aps/{mac}": {
+					kind: "network:access-point",
+					operations: [
+						"read",
+						"write",
+						"exec"
+					],
+					actions: ["reboot", "upgrade-firmware"],
+					destructive: ["reboot"]
+				},
+				"/sites/{siteId}/devices/aps/{mac}/firmware": {
+					kind: "network:firmware",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/clients": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/clients/{mac}": {
+					kind: "network:client",
+					operations: ["read", "exec"],
+					actions: ["block", "unblock"]
+				},
+				"/sites/{siteId}/dashboard": {
+					kind: "network:dashboard",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/networks": {
+					kind: "network:network",
+					operations: ["list", "read"]
+				},
+				"/sites/{siteId}/networks/wireless": {
+					kind: "network:wireless",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/networks/wireless/{ssidId}": {
+					kind: "network:ssid",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/networks/wired": {
+					kind: "network:wired",
+					operations: ["list"]
+				},
+				"/sites/{siteId}/networks/wired/{netId}": {
+					kind: "network:vlan",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/networks/wifi-optimization": {
+					kind: "network:wifi-optimization",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/vpn": {
+					kind: "network:vpn",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/firewall": {
+					kind: "network:firewall",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/routing": {
+					kind: "network:routing",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/nat": {
+					kind: "network:nat",
+					operations: ["read"]
+				},
+				"/sites/{siteId}/logs": {
+					kind: "network:logs",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "custom",
+				env: ["OMADA_CLIENT_ID", "OMADA_CLIENT_SECRET"]
+			},
+			bestFor: [
+				"network monitoring",
+				"SDN management",
+				"device control"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	static async load({ config } = {}) {
+		return new AFSOmadaProvider(require_types.afsOmadaOptionsSchema.parse(config));
+	}
+	name;
+	description;
+	accessMode;
+	client;
+	constructor(options) {
+		super();
+		const parsed = require_types.afsOmadaOptionsSchema.parse(options);
+		this.name = parsed.name;
+		this.description = parsed.description;
+		this.accessMode = parsed.accessMode;
+		this.client = new require_client.OmadaApiClient(parsed.baseUrl, parsed.clientId, parsed.clientSecret, parsed.omadacId, parsed.strictSsl);
+	}
+	async readCapabilities(_ctx) {
+		const manifest = {
+			schemaVersion: 1,
+			provider: this.name,
+			description: this.description || "TP-Link Omada SDN Controller — network devices as filesystem",
+			tools: [],
+			actions: [],
+			operations: this.getOperationsDeclaration()
+		};
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: manifest,
+			meta: {
+				kind: "afs:capabilities",
+				operations: [
+					"list",
+					"read",
+					"stat",
+					"explain",
+					"search",
+					"write",
+					"exec",
+					"delete"
+				].filter((op) => {
+					return manifest.operations[op];
+				})
+			}
+		};
+	}
+	async listRoot(_ctx) {
+		const sites = (await this.client.request("/sites"))?.data ?? [];
+		return { data: [this.buildEntry("/sites", { meta: {
+			kind: "network:container",
+			childrenCount: sites.length
+		} })] };
+	}
+	async readRoot(_ctx) {
+		return this.buildEntry("/", {
+			content: "Omada SDN Controller",
+			meta: {
+				kind: "network:controller",
+				childrenCount: 1,
+				description: "Omada SDN Controller"
+			}
+		});
+	}
+	async metaRoot(_ctx) {
+		return this.buildEntry("/.meta", { meta: {
+			kind: "network:controller",
+			childrenCount: 1,
+			description: "Omada SDN Controller",
+			events: [
+				{
+					type: "omada:device_reboot",
+					description: "Device reboot initiated"
+				},
+				{
+					type: "omada:firmware_upgrade",
+					description: "Device firmware upgrade initiated"
+				},
+				{
+					type: "omada:client_blocked",
+					description: "Client blocked from network"
+				},
+				{
+					type: "omada:client_unblocked",
+					description: "Client unblocked from network"
+				},
+				{
+					type: "omada:network_updated",
+					description: "Network configuration updated"
+				},
+				{
+					type: "omada:device_config_updated",
+					description: "Device configuration updated"
+				}
+			]
+		} });
+	}
+	async statRoot(_ctx) {
+		return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: "network:controller",
+				childrenCount: 1,
+				description: "Omada SDN Controller"
+			}
+		} };
+	}
+	async listSites(_ctx) {
+		return { data: ((await this.client.request("/sites"))?.data ?? []).map((site) => this.buildEntry((0, ufo.joinURL)("/sites", site.siteId), {
+			id: site.siteId,
+			meta: {
+				kind: "network:site",
+				childrenCount: 9,
+				description: site.name
+			}
+		})) };
+	}
+	async readSites(_ctx) {
+		const sites = (await this.client.request("/sites"))?.data ?? [];
+		return this.buildEntry("/sites", {
+			content: sites.map((s) => `${s.siteId}: ${s.name}`).join("\n"),
+			meta: {
+				kind: "network:container",
+				childrenCount: sites.length
+			}
+		});
+	}
+	async metaSites(_ctx) {
+		const sites = (await this.client.request("/sites"))?.data ?? [];
+		return this.buildEntry("/sites/.meta", { meta: {
+			kind: "network:container",
+			childrenCount: sites.length
+		} });
+	}
+	async statSites(_ctx) {
+		return { data: {
+			id: "/sites",
+			path: "/sites",
+			meta: {
+				kind: "network:container",
+				childrenCount: ((await this.client.request("/sites"))?.data ?? []).length
+			}
+		} };
+	}
+	async listSite(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: [
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices"), { meta: {
+				kind: "network:device-group",
+				childrenCount: 3
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients"), { meta: { childrenCount: -1 } }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "dashboard"), { meta: {
+				kind: "network:dashboard",
+				childrenCount: 0
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks"), { meta: {
+				kind: "network:network",
+				childrenCount: 3
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "vpn"), { meta: {
+				kind: "network:vpn",
+				childrenCount: 0
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "firewall"), { meta: {
+				kind: "network:firewall",
+				childrenCount: 0
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "routing"), { meta: {
+				kind: "network:routing",
+				childrenCount: 0
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "nat"), { meta: {
+				kind: "network:nat",
+				childrenCount: 0
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "logs"), { meta: {
+				kind: "network:logs",
+				childrenCount: 0
+			} })
+		] };
+	}
+	async readSite(ctx) {
+		const { siteId } = ctx.params;
+		const site = await this.getSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId), {
+			id: site.siteId,
+			content: `${site.name} (${site.region || "default"})`,
+			meta: {
+				kind: "network:site",
+				childrenCount: 9,
+				description: site.name
+			}
+		});
+	}
+	async metaSite(ctx) {
+		const { siteId } = ctx.params;
+		const site = await this.getSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, ".meta"), { meta: {
+			kind: "network:site",
+			childrenCount: 9,
+			description: site.name
+		} });
+	}
+	async statSite(ctx) {
+		const { siteId } = ctx.params;
+		const site = await this.getSite(siteId);
+		return { data: {
+			id: site.siteId,
+			path: (0, ufo.joinURL)("/sites", siteId),
+			meta: {
+				kind: "network:site",
+				childrenCount: 9,
+				description: site.name
+			}
+		} };
+	}
+	async listDevicesContainer(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const devices = await this.getAllDevices(siteId);
+		const gateways = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "gateways");
+		const switches = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "switches");
+		const aps = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "aps");
+		return { data: [
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/gateways"), { meta: {
+				kind: "network:device-group",
+				childrenCount: gateways.length
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches"), { meta: {
+				kind: "network:device-group",
+				childrenCount: switches.length
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/aps"), { meta: {
+				kind: "network:device-group",
+				childrenCount: aps.length
+			} })
+		] };
+	}
+	async readDevicesContainer(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const devices = await this.getAllDevices(siteId);
+		const gateways = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "gateways");
+		const switches = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "switches");
+		const aps = devices.filter((d) => DEVICE_TYPE_MAP[d.type] === "aps");
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices"), {
+			content: `Devices: ${devices.length} total\nGateways: ${gateways.length} | Switches: ${switches.length} | APs: ${aps.length}`,
+			meta: {
+				kind: "network:device-group",
+				childrenCount: 3
+			}
+		});
+	}
+	async metaDevicesContainer(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/.meta"), { meta: {
+			kind: "network:device-group",
+			childrenCount: 3
+		} });
+	}
+	async statDevicesContainer(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "devices"),
+			path: (0, ufo.joinURL)("/sites", siteId, "devices"),
+			meta: {
+				kind: "network:device-group",
+				childrenCount: 3
+			}
+		} };
+	}
+	async listDeviceCategory(ctx) {
+		const { siteId, category } = ctx.params;
+		this.validateDeviceCategory(category);
+		await this.validateSite(siteId);
+		return { data: (await this.getDevicesByCategory(siteId, category)).map((device) => {
+			const mac = require_types.normalizeMac(device.mac);
+			const kind = DEVICE_KIND_MAP[category];
+			const status = require_types.mapDeviceStatus(device.status);
+			return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, mac), {
+				id: mac,
+				content: this.formatDeviceContent(device, category),
+				meta: {
+					kind,
+					childrenCount: this.deviceChildrenCount(category),
+					model: device.model,
+					status,
+					firmware: device.firmwareVersion
+				}
+			});
+		}) };
+	}
+	async readDeviceCategory(ctx) {
+		const { siteId, category } = ctx.params;
+		this.validateDeviceCategory(category);
+		await this.validateSite(siteId);
+		const devices = await this.getDevicesByCategory(siteId, category);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category), {
+			content: devices.map((d) => `${require_types.normalizeMac(d.mac)}: ${d.name} (${d.model})`).join("\n"),
+			meta: {
+				kind: "network:device-group",
+				childrenCount: devices.length
+			}
+		});
+	}
+	async metaDeviceCategory(ctx) {
+		const { siteId, category } = ctx.params;
+		this.validateDeviceCategory(category);
+		await this.validateSite(siteId);
+		const devices = await this.getDevicesByCategory(siteId, category);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, ".meta"), { meta: {
+			kind: "network:device-group",
+			childrenCount: devices.length
+		} });
+	}
+	async statDeviceCategory(ctx) {
+		const { siteId, category } = ctx.params;
+		this.validateDeviceCategory(category);
+		await this.validateSite(siteId);
+		const devices = await this.getDevicesByCategory(siteId, category);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "devices", category),
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category),
+			meta: {
+				kind: "network:device-group",
+				childrenCount: devices.length
+			}
+		} };
+	}
+	async listDevice(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		const basePath = (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac);
+		const children = [];
+		if (category === "switches") children.push(this.buildEntry((0, ufo.joinURL)(basePath, "ports"), { meta: { kind: "network:port-group" } }));
+		children.push(this.buildEntry((0, ufo.joinURL)(basePath, "firmware"), { meta: {
+			kind: "network:firmware",
+			childrenCount: 0
+		} }));
+		return { data: children };
+	}
+	async readDevice(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		const device = await this.getDevice(siteId, category, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac), {
+			id: normalizedMac,
+			content: this.formatDeviceContent(device, category),
+			meta: {
+				kind: DEVICE_KIND_MAP[category],
+				childrenCount: this.deviceChildrenCount(category),
+				model: device.model,
+				status: require_types.mapDeviceStatus(device.status),
+				firmware: device.firmwareVersion
+			}
+		});
+	}
+	async metaDevice(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		const device = await this.getDevice(siteId, category, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, ".meta"), { meta: {
+			kind: DEVICE_KIND_MAP[category],
+			childrenCount: this.deviceChildrenCount(category),
+			model: device.model,
+			status: require_types.mapDeviceStatus(device.status),
+			firmware: device.firmwareVersion
+		} });
+	}
+	async statDevice(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		const device = await this.getDevice(siteId, category, normalizedMac);
+		return { data: {
+			id: normalizedMac,
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac),
+			meta: {
+				kind: DEVICE_KIND_MAP[category],
+				childrenCount: this.deviceChildrenCount(category),
+				model: device.model,
+				status: require_types.mapDeviceStatus(device.status),
+				firmware: device.firmwareVersion
+			}
+		} };
+	}
+	async listClients(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "clients")))?.data ?? []).map((c) => {
+			const mac = require_types.normalizeMac(c.mac);
+			return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients", mac), {
+				id: mac,
+				content: this.formatClientContent(c),
+				meta: {
+					kind: "network:client",
+					childrenCount: 0,
+					ip: c.ip,
+					ssid: c.ssid
+				}
+			});
+		}) };
+	}
+	async readClients(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const clients = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "clients")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients"), {
+			content: clients.map((c) => `${require_types.normalizeMac(c.mac)}: ${c.name} (${c.ip})`).join("\n"),
+			meta: { childrenCount: -1 }
+		});
+	}
+	async metaClients(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients/.meta"), { meta: { childrenCount: -1 } });
+	}
+	async statClients(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "clients"),
+			path: (0, ufo.joinURL)("/sites", siteId, "clients"),
+			meta: { childrenCount: -1 }
+		} };
+	}
+	async listClient(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getClient(siteId, normalizedMac);
+		return { data: [] };
+	}
+	async readClient(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const client = await this.getClient(siteId, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac), {
+			id: normalizedMac,
+			content: this.formatClientContent(client),
+			meta: {
+				kind: "network:client",
+				childrenCount: 0,
+				ip: client.ip,
+				ssid: client.ssid
+			}
+		});
+	}
+	async metaClient(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const client = await this.getClient(siteId, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac, ".meta"), { meta: {
+			kind: "network:client",
+			childrenCount: 0,
+			ip: client.ip,
+			ssid: client.ssid
+		} });
+	}
+	async statClient(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const client = await this.getClient(siteId, normalizedMac);
+		return { data: {
+			id: normalizedMac,
+			path: (0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac),
+			meta: {
+				kind: "network:client",
+				childrenCount: 0,
+				ip: client.ip,
+				ssid: client.ssid
+			}
+		} };
+	}
+	async listDashboard(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readDashboard(ctx) {
+		const { siteId } = ctx.params;
+		const site = await this.getSite(siteId);
+		const dashboard = await this.client.request((0, ufo.joinURL)("/sites", siteId, "dashboard"));
+		const totalDevices = dashboard?.totalDevices ?? 0;
+		const connectedDevices = dashboard?.connectedDevices ?? 0;
+		const totalClients = dashboard?.totalClients ?? 0;
+		const gatewayNum = dashboard?.gatewayNum ?? 0;
+		const switchNum = dashboard?.switchNum ?? 0;
+		const apNum = dashboard?.apNum ?? 0;
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "dashboard"), {
+			content: `${site.name} Dashboard\nDevices: ${totalDevices} (${connectedDevices} connected) | Clients: ${totalClients}\nGateways: ${gatewayNum} | Switches: ${switchNum} | APs: ${apNum}`,
+			meta: {
+				kind: "network:dashboard",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaDashboard(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "dashboard/.meta"), { meta: {
+			kind: "network:dashboard",
+			childrenCount: 0
+		} });
+	}
+	async statDashboard(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "dashboard"),
+			path: (0, ufo.joinURL)("/sites", siteId, "dashboard"),
+			meta: {
+				kind: "network:dashboard",
+				childrenCount: 0
+			}
+		} };
+	}
+	async listNetworks(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssidCount = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data?.length ?? 0;
+		const netCount = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data?.length ?? 0;
+		return { data: [
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless"), { meta: {
+				kind: "network:wireless",
+				childrenCount: ssidCount
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired"), { meta: {
+				kind: "network:wired",
+				childrenCount: netCount
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization"), { meta: {
+				kind: "network:wifi-optimization",
+				childrenCount: 0
+			} })
+		] };
+	}
+	async readNetworks(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks"), {
+			content: "Network configuration summary",
+			meta: {
+				kind: "network:network",
+				childrenCount: 3
+			}
+		});
+	}
+	async metaNetworks(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/.meta"), { meta: {
+			kind: "network:network",
+			childrenCount: 3
+		} });
+	}
+	async statNetworks(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "networks"),
+			path: (0, ufo.joinURL)("/sites", siteId, "networks"),
+			meta: {
+				kind: "network:network",
+				childrenCount: 3
+			}
+		} };
+	}
+	async listWirelessSsids(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data ?? []).map((ssid) => this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssid.id), {
+			id: ssid.id,
+			content: this.formatSsidContent(ssid),
+			meta: {
+				kind: "network:ssid",
+				name: ssid.name,
+				band: this.mapBand(ssid.band),
+				security: ssid.security,
+				vlanId: ssid.vlanId,
+				enabled: ssid.enable,
+				childrenCount: 0
+			}
+		})) };
+	}
+	async readWireless(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssids = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless"), {
+			content: ssids.map((s) => `${s.id}: ${s.name} (${this.mapBand(s.band)})`).join("\n"),
+			meta: {
+				kind: "network:wireless",
+				childrenCount: ssids.length
+			}
+		});
+	}
+	async metaWireless(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssids = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless/.meta"), { meta: {
+			kind: "network:wireless",
+			childrenCount: ssids.length
+		} });
+	}
+	async statWireless(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssids = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data ?? [];
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "networks/wireless"),
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wireless"),
+			meta: {
+				kind: "network:wireless",
+				childrenCount: ssids.length
+			}
+		} };
+	}
+	async readSsid(ctx) {
+		const { siteId, ssidId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssid = await this.getSsid(siteId, ssidId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId), {
+			id: ssidId,
+			content: this.formatSsidContent(ssid),
+			meta: {
+				kind: "network:ssid",
+				name: ssid.name,
+				band: this.mapBand(ssid.band),
+				security: ssid.security,
+				vlanId: ssid.vlanId,
+				enabled: ssid.enable,
+				childrenCount: 0
+			}
+		});
+	}
+	async listSsid(ctx) {
+		const { siteId, ssidId } = ctx.params;
+		await this.validateSite(siteId);
+		await this.getSsid(siteId, ssidId);
+		return { data: [] };
+	}
+	async metaSsid(ctx) {
+		const { siteId, ssidId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssid = await this.getSsid(siteId, ssidId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId, ".meta"), { meta: {
+			kind: "network:ssid",
+			name: ssid.name,
+			childrenCount: 0
+		} });
+	}
+	async statSsid(ctx) {
+		const { siteId, ssidId } = ctx.params;
+		await this.validateSite(siteId);
+		const ssid = await this.getSsid(siteId, ssidId);
+		return { data: {
+			id: ssidId,
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId),
+			meta: {
+				kind: "network:ssid",
+				name: ssid.name,
+				childrenCount: 0
+			}
+		} };
+	}
+	async writeSsid(ctx, payload) {
+		const { siteId, ssidId } = ctx.params;
+		await this.validateSite(siteId);
+		await this.getSsid(siteId, ssidId);
+		const raw = parseWritePayload(payload);
+		const config = ssidWriteSchema.parse(raw);
+		await this.client.patch((0, ufo.joinURL)("/sites", siteId, "setting/ssids", ssidId), config);
+		this.emit({
+			type: "omada:network_updated",
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId),
+			data: {
+				siteId,
+				ssidId,
+				networkType: "wireless"
+			}
+		});
+		return {
+			data: this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId), {
+				content: JSON.stringify(config),
+				meta: { kind: "network:ssid" }
+			}),
+			message: "SSID config updated"
+		};
+	}
+	async listWiredNetworks(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data ?? []).map((net) => this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired", net.id), {
+			id: net.id,
+			content: this.formatWiredNetworkContent(net),
+			meta: {
+				kind: "network:vlan",
+				name: net.name,
+				vlanId: net.vlanId,
+				subnet: net.subnet,
+				childrenCount: 0
+			}
+		})) };
+	}
+	async readWired(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const networks = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired"), {
+			content: networks.map((n) => `${n.id}: ${n.name} (VLAN ${n.vlanId})`).join("\n"),
+			meta: {
+				kind: "network:wired",
+				childrenCount: networks.length
+			}
+		});
+	}
+	async metaWired(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const networks = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired/.meta"), { meta: {
+			kind: "network:wired",
+			childrenCount: networks.length
+		} });
+	}
+	async statWired(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const networks = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data ?? [];
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "networks/wired"),
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wired"),
+			meta: {
+				kind: "network:wired",
+				childrenCount: networks.length
+			}
+		} };
+	}
+	async readWiredNetwork(ctx) {
+		const { siteId, networkId } = ctx.params;
+		await this.validateSite(siteId);
+		const net = await this.getWiredNetwork(siteId, networkId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired", networkId), {
+			id: networkId,
+			content: this.formatWiredNetworkContent(net),
+			meta: {
+				kind: "network:vlan",
+				name: net.name,
+				vlanId: net.vlanId,
+				subnet: net.subnet,
+				childrenCount: 0
+			}
+		});
+	}
+	async listWiredNetwork(ctx) {
+		const { siteId, networkId } = ctx.params;
+		await this.validateSite(siteId);
+		await this.getWiredNetwork(siteId, networkId);
+		return { data: [] };
+	}
+	async metaWiredNetwork(ctx) {
+		const { siteId, networkId } = ctx.params;
+		await this.validateSite(siteId);
+		const net = await this.getWiredNetwork(siteId, networkId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired", networkId, ".meta"), { meta: {
+			kind: "network:vlan",
+			name: net.name,
+			childrenCount: 0
+		} });
+	}
+	async statWiredNetwork(ctx) {
+		const { siteId, networkId } = ctx.params;
+		await this.validateSite(siteId);
+		const net = await this.getWiredNetwork(siteId, networkId);
+		return { data: {
+			id: networkId,
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wired", networkId),
+			meta: {
+				kind: "network:vlan",
+				name: net.name,
+				childrenCount: 0
+			}
+		} };
+	}
+	async writeWiredNetwork(ctx, payload) {
+		const { siteId, networkId } = ctx.params;
+		await this.validateSite(siteId);
+		await this.getWiredNetwork(siteId, networkId);
+		const raw = parseWritePayload(payload);
+		const config = wiredNetworkWriteSchema.parse(raw);
+		await this.client.patch((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks", networkId), config);
+		return {
+			data: this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wired", networkId), {
+				content: JSON.stringify(config),
+				meta: { kind: "network:vlan" }
+			}),
+			message: "Wired network config updated"
+		};
+	}
+	async listWifiOptimization(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readWifiOptimization(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const opt = await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/wlan/optimization"));
+		const lines = [
+			`Auto Channel: ${opt?.autoChannel ? "enabled" : "disabled"}`,
+			`Roaming: ${opt?.roaming ? "enabled" : "disabled"}`,
+			`Band Steering: ${opt?.bandSteering ? "enabled" : "disabled"}`
+		];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization"), {
+			content: lines.join("\n"),
+			meta: {
+				kind: "network:wifi-optimization",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaWifiOptimization(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization/.meta"), { meta: {
+			kind: "network:wifi-optimization",
+			childrenCount: 0
+		} });
+	}
+	async statWifiOptimization(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization"),
+			path: (0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization"),
+			meta: {
+				kind: "network:wifi-optimization",
+				childrenCount: 0
+			}
+		} };
+	}
+	async writeWifiOptimization(ctx, payload) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const raw = parseWritePayload(payload);
+		const config = wifiOptimizationWriteSchema.parse(raw);
+		await this.client.patch((0, ufo.joinURL)("/sites", siteId, "setting/wlan/optimization"), config);
+		return {
+			data: this.buildEntry((0, ufo.joinURL)("/sites", siteId, "networks/wifi-optimization"), {
+				content: JSON.stringify(config),
+				meta: { kind: "network:wifi-optimization" }
+			}),
+			message: "WiFi optimization config updated"
+		};
+	}
+	async listVpn(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readVpn(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const vpn = await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/vpn"));
+		const lines = [
+			`IPsec: ${vpn?.ipsec?.enabled ? "enabled" : "disabled"}`,
+			`L2TP: ${vpn?.l2tp?.enabled ? "enabled" : "disabled"}`,
+			`WireGuard: ${vpn?.wireguard?.enabled ? "enabled" : "disabled"}`
+		];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "vpn"), {
+			content: lines.join("\n"),
+			meta: {
+				kind: "network:vpn",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVpn(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "vpn/.meta"), { meta: {
+			kind: "network:vpn",
+			childrenCount: 0
+		} });
+	}
+	async statVpn(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "vpn"),
+			path: (0, ufo.joinURL)("/sites", siteId, "vpn"),
+			meta: {
+				kind: "network:vpn",
+				childrenCount: 0
+			}
+		} };
+	}
+	async listFirewall(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readFirewall(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const rules = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/firewall/acl")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "firewall"), {
+			content: `Firewall ACL rules: ${rules.length}`,
+			meta: {
+				kind: "network:firewall",
+				childrenCount: 0,
+				ruleCount: rules.length
+			}
+		});
+	}
+	async metaFirewall(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "firewall/.meta"), { meta: {
+			kind: "network:firewall",
+			childrenCount: 0
+		} });
+	}
+	async statFirewall(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "firewall"),
+			path: (0, ufo.joinURL)("/sites", siteId, "firewall"),
+			meta: {
+				kind: "network:firewall",
+				childrenCount: 0
+			}
+		} };
+	}
+	async listRouting(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readRouting(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const routing = await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/routing"));
+		const staticCount = routing?.staticRoutes?.length ?? 0;
+		const policyCount = routing?.policyRoutes?.length ?? 0;
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "routing"), {
+			content: `Static routes: ${staticCount} | Policy routes: ${policyCount}`,
+			meta: {
+				kind: "network:routing",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaRouting(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "routing/.meta"), { meta: {
+			kind: "network:routing",
+			childrenCount: 0
+		} });
+	}
+	async statRouting(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "routing"),
+			path: (0, ufo.joinURL)("/sites", siteId, "routing"),
+			meta: {
+				kind: "network:routing",
+				childrenCount: 0
+			}
+		} };
+	}
+	async listNat(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readNat(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const rules = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/nat")))?.data ?? [];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "nat"), {
+			content: `NAT rules: ${rules.length}`,
+			meta: {
+				kind: "network:nat",
+				childrenCount: 0,
+				ruleCount: rules.length
+			}
+		});
+	}
+	async metaNat(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "nat/.meta"), { meta: {
+			kind: "network:nat",
+			childrenCount: 0
+		} });
+	}
+	async statNat(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "nat"),
+			path: (0, ufo.joinURL)("/sites", siteId, "nat"),
+			meta: {
+				kind: "network:nat",
+				childrenCount: 0
+			}
+		} };
+	}
+	async listLogs(ctx) {
+		await this.validateSite(ctx.params.siteId);
+		return { data: [] };
+	}
+	async readLogs(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		const entries = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "logs")))?.data ?? [];
+		const content = entries.map((e) => `[${new Date(e.timestamp).toISOString()}] ${e.level}: ${e.message}`).join("\n");
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "logs"), {
+			content: content || "No log entries",
+			meta: {
+				kind: "network:logs",
+				childrenCount: 0,
+				entryCount: entries.length
+			}
+		});
+	}
+	async metaLogs(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "logs/.meta"), { meta: {
+			kind: "network:logs",
+			childrenCount: 0
+		} });
+	}
+	async statLogs(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "logs"),
+			path: (0, ufo.joinURL)("/sites", siteId, "logs"),
+			meta: {
+				kind: "network:logs",
+				childrenCount: 0
+			}
+		} };
+	}
+	async readSwitchPorts(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, "switches", normalizedMac);
+		const ports = await this.getSwitchPorts(siteId, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports"), {
+			content: ports.map((p) => `Port ${p.port}: ${p.name} (${p.linkSpeed})`).join("\n"),
+			meta: {
+				kind: "network:port-group",
+				childrenCount: ports.length
+			}
+		});
+	}
+	async metaSwitchPorts(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, "switches", normalizedMac);
+		const ports = await this.getSwitchPorts(siteId, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports/.meta"), { meta: {
+			kind: "network:port-group",
+			childrenCount: ports.length
+		} });
+	}
+	async statSwitchPorts(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, "switches", normalizedMac);
+		const ports = await this.getSwitchPorts(siteId, normalizedMac);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports"),
+			path: (0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports"),
+			meta: {
+				kind: "network:port-group",
+				childrenCount: ports.length
+			}
+		} };
+	}
+	async listSwitchPorts(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, "switches", normalizedMac);
+		return { data: (await this.getSwitchPorts(siteId, normalizedMac)).map((port) => this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", String(port.port)), {
+			id: String(port.port),
+			content: this.formatPortContent(port),
+			meta: {
+				kind: "network:port",
+				port: port.port,
+				childrenCount: 0,
+				linkSpeed: port.linkSpeed,
+				poeEnabled: port.poeEnabled,
+				vlanId: port.vlanId
+			}
+		})) };
+	}
+	async listNonSwitchPorts(ctx) {
+		const { category } = ctx.params;
+		if (category === "switches") return { data: [] };
+		throw new _aigne_afs.AFSNotFoundError(`Ports are only available on switches, not ${category}`);
+	}
+	async readSwitchPort(ctx) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, "switches", normalizedMac);
+		const port = await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", portId), {
+			id: portId,
+			content: this.formatPortContent(port),
+			meta: {
+				kind: "network:port",
+				port: port.port,
+				childrenCount: 0,
+				linkSpeed: port.linkSpeed,
+				poeEnabled: port.poeEnabled,
+				vlanId: port.vlanId
+			}
+		});
+	}
+	async listSwitchPort(ctx) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		return { data: [] };
+	}
+	async metaSwitchPort(ctx) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const port = await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", portId, ".meta"), { meta: {
+			kind: "network:port",
+			port: port.port,
+			childrenCount: 0
+		} });
+	}
+	async statSwitchPort(ctx) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const port = await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		return { data: {
+			id: portId,
+			path: (0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", portId),
+			meta: {
+				kind: "network:port",
+				port: port.port,
+				childrenCount: 0
+			}
+		} };
+	}
+	async readSwitchPortConfig(ctx) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		const port = await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		const config = {
+			enable: port.enable,
+			poeEnabled: port.poeEnabled,
+			vlanId: port.vlanId,
+			profileName: port.profileName
+		};
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", portId, "config"), {
+			content: JSON.stringify(config),
+			meta: { kind: "network:port-config" }
+		});
+	}
+	async writeSwitchPortConfig(ctx, payload) {
+		const { siteId, mac, portId } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getSwitchPort(siteId, normalizedMac, validatePortId(portId));
+		const raw = parseWritePayload(payload);
+		const config = portConfigWriteSchema.parse(raw);
+		await this.client.patch((0, ufo.joinURL)("/sites", siteId, "devices", normalizedMac, "ports", portId), config);
+		return {
+			data: this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", portId, "config"), {
+				content: JSON.stringify(config),
+				meta: { kind: "network:port-config" }
+			}),
+			message: "Port config updated"
+		};
+	}
+	async listFirmware(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		return { data: [] };
+	}
+	async readFirmware(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		const fw = await this.client.request((0, ufo.joinURL)("/sites", siteId, "devices", normalizedMac, "firmware"));
+		const lines = [
+			`Current: ${fw?.currentVersion ?? "unknown"}`,
+			`Latest: ${fw?.latestVersion ?? "unknown"}`,
+			`Update available: ${fw?.hasUpdate ? "yes" : "no"}`
+		];
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "firmware"), {
+			content: lines.join("\n"),
+			meta: {
+				kind: "network:firmware",
+				childrenCount: 0,
+				currentVersion: fw?.currentVersion,
+				latestVersion: fw?.latestVersion,
+				hasUpdate: fw?.hasUpdate ?? false
+			}
+		});
+	}
+	async metaFirmware(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "firmware/.meta"), { meta: {
+			kind: "network:firmware",
+			childrenCount: 0
+		} });
+	}
+	async statFirmware(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		return { data: {
+			id: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "firmware"),
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "firmware"),
+			meta: {
+				kind: "network:firmware",
+				childrenCount: 0
+			}
+		} };
+	}
+	async explainRoot(_ctx) {
+		const sites = (await this.client.request("/sites"))?.data ?? [];
+		let totalDevices = 0;
+		for (const site of sites) try {
+			const dashboard = await this.client.request((0, ufo.joinURL)("/sites", site.siteId, "dashboard"));
+			totalDevices += dashboard?.totalDevices ?? 0;
+		} catch {}
+		return {
+			content: [
+				"# Omada SDN Controller",
+				"",
+				`**Sites:** ${sites.length}`,
+				`**Total Devices:** ${totalDevices}`,
+				"",
+				"## Sites",
+				"",
+				...sites.map((s) => `- **${s.name}** (${s.siteId})`)
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async explainSite(ctx) {
+		const { siteId } = ctx.params;
+		const site = await this.getSite(siteId);
+		const dashboard = await this.client.request((0, ufo.joinURL)("/sites", siteId, "dashboard"));
+		const clientCount = (await this.client.request((0, ufo.joinURL)("/sites", siteId, "clients")))?.data?.length ?? 0;
+		return {
+			content: [
+				`# ${site.name}`,
+				"",
+				`**Site ID:** ${siteId}`,
+				`**Devices:** ${dashboard?.totalDevices ?? 0} (${dashboard?.connectedDevices ?? 0} connected)`,
+				`**Clients:** ${clientCount}`,
+				`**Gateways:** ${dashboard?.gatewayNum ?? 0}`,
+				`**Switches:** ${dashboard?.switchNum ?? 0}`,
+				`**APs:** ${dashboard?.apNum ?? 0}`
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async explainSiteChild(ctx) {
+		const { siteId } = ctx.params;
+		await this.validateSite(siteId);
+		return {
+			content: `Path: ${ctx.path}`,
+			format: "text"
+		};
+	}
+	async searchAll(ctx, query, options) {
+		const basePath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const searchQuery = query.toLowerCase();
+		const limit = options?.limit ?? 100;
+		const results = [];
+		let sitesToSearch = [];
+		const allSites = (await this.client.request("/sites"))?.data ?? [];
+		const siteMatch = basePath.match(/^\/sites\/([^/]+)/);
+		if (siteMatch) {
+			const matchedSite = allSites.find((s) => s.siteId === siteMatch[1]);
+			if (!matchedSite) throw new _aigne_afs.AFSNotFoundError(basePath);
+			sitesToSearch = [matchedSite];
+		} else sitesToSearch = allSites;
+		for (const site of sitesToSearch) {
+			if (results.length >= limit) break;
+			const devices = await this.getAllDevices(site.siteId);
+			for (const device of devices) {
+				if (results.length >= limit) break;
+				const mac = require_types.normalizeMac(device.mac);
+				const category = DEVICE_TYPE_MAP[device.type] || "unknown";
+				if ([
+					device.name,
+					device.model,
+					mac,
+					device.firmwareVersion
+				].join(" ").toLowerCase().includes(searchQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/sites", site.siteId, "devices", category, mac), {
+					id: mac,
+					content: this.formatDeviceContent(device, category),
+					meta: {
+						kind: DEVICE_KIND_MAP[category],
+						childrenCount: 0,
+						model: device.model,
+						status: require_types.mapDeviceStatus(device.status),
+						firmware: device.firmwareVersion
+					}
+				}));
+			}
+			const clients = (await this.client.request((0, ufo.joinURL)("/sites", site.siteId, "clients")))?.data ?? [];
+			for (const c of clients) {
+				if (results.length >= limit) break;
+				const mac = require_types.normalizeMac(c.mac);
+				if ([
+					c.name,
+					c.ip,
+					mac,
+					c.ssid
+				].join(" ").toLowerCase().includes(searchQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/sites", site.siteId, "clients", mac), {
+					id: mac,
+					content: this.formatClientContent(c),
+					meta: {
+						kind: "network:client",
+						childrenCount: 0,
+						ip: c.ip,
+						ssid: c.ssid
+					}
+				}));
+			}
+		}
+		return { data: results };
+	}
+	async listRootActions(_ctx) {
+		return { data: [this.buildEntry("/.actions/create-site", {
+			id: "create-site",
+			meta: {
+				kind: "network:action",
+				name: "create-site",
+				severity: "boundary",
+				description: "Create a new site on the Omada controller"
+			}
+		})] };
+	}
+	async execCreateSite(_ctx, args) {
+		const name = args.name;
+		if (!name) throw new Error("create-site requires 'name' argument");
+		const region = args.region || "default";
+		const result = await this.client.post("/sites", {
+			name,
+			region
+		});
+		return {
+			success: true,
+			data: {
+				siteId: result.siteId,
+				name: result.name
+			}
+		};
+	}
+	async listDeviceActions(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		const basePath = (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac);
+		return { data: [this.buildEntry((0, ufo.joinURL)(basePath, ".actions/reboot"), {
+			id: "reboot",
+			meta: {
+				kind: "network:action",
+				name: "reboot",
+				severity: "boundary",
+				description: "Reboot this device"
+			}
+		}), this.buildEntry((0, ufo.joinURL)(basePath, ".actions/upgrade-firmware"), {
+			id: "upgrade-firmware",
+			meta: {
+				kind: "network:action",
+				name: "upgrade-firmware",
+				severity: "critical",
+				description: "Upgrade this device's firmware to latest version"
+			}
+		})] };
+	}
+	async execDeviceReboot(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		await this.client.post((0, ufo.joinURL)("/sites", siteId, "cmd/devices", normalizedMac, "reboot"));
+		this.emit({
+			type: "omada:device_reboot",
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac),
+			data: {
+				mac: normalizedMac,
+				siteId
+			}
+		});
+		return {
+			success: true,
+			data: {
+				mac: normalizedMac,
+				action: "reboot"
+			}
+		};
+	}
+	async execDeviceUpgradeFirmware(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		await this.client.post((0, ufo.joinURL)("/sites", siteId, "cmd/devices", normalizedMac, "upgrade"));
+		this.emit({
+			type: "omada:firmware_upgrade",
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac),
+			data: {
+				mac: normalizedMac,
+				siteId
+			}
+		});
+		return {
+			success: true,
+			data: {
+				mac: normalizedMac,
+				action: "upgrade-firmware"
+			}
+		};
+	}
+	async listClientActions(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getClient(siteId, normalizedMac);
+		const basePath = (0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac);
+		return { data: [this.buildEntry((0, ufo.joinURL)(basePath, ".actions/block"), {
+			id: "block",
+			meta: {
+				kind: "network:action",
+				name: "block",
+				severity: "boundary",
+				description: "Block this client"
+			}
+		}), this.buildEntry((0, ufo.joinURL)(basePath, ".actions/unblock"), {
+			id: "unblock",
+			meta: {
+				kind: "network:action",
+				name: "unblock",
+				severity: "boundary",
+				description: "Unblock this client"
+			}
+		})] };
+	}
+	async execClientBlock(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getClient(siteId, normalizedMac);
+		await this.client.post((0, ufo.joinURL)("/sites", siteId, "cmd/clients", normalizedMac, "block"));
+		this.emit({
+			type: "omada:client_blocked",
+			path: (0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac),
+			data: {
+				mac: normalizedMac,
+				siteId
+			}
+		});
+		return {
+			success: true,
+			data: {
+				mac: normalizedMac,
+				action: "block"
+			}
+		};
+	}
+	async execClientUnblock(ctx) {
+		const { siteId, mac } = ctx.params;
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getClient(siteId, normalizedMac);
+		await this.client.post((0, ufo.joinURL)("/sites", siteId, "cmd/clients", normalizedMac, "unblock"));
+		this.emit({
+			type: "omada:client_unblocked",
+			path: (0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac),
+			data: {
+				mac: normalizedMac,
+				siteId
+			}
+		});
+		return {
+			success: true,
+			data: {
+				mac: normalizedMac,
+				action: "unblock"
+			}
+		};
+	}
+	async readDeviceConfig(ctx) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		const device = await this.getDevice(siteId, category, normalizedMac);
+		const configData = {
+			name: device.name,
+			model: device.model,
+			firmwareVersion: device.firmwareVersion
+		};
+		return this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "config"), {
+			content: JSON.stringify(configData),
+			meta: { kind: "network:config" }
+		});
+	}
+	async writeDeviceConfig(ctx, payload) {
+		const { siteId, category, mac } = ctx.params;
+		this.validateDeviceCategory(category);
+		const normalizedMac = require_types.normalizeMac(mac);
+		await this.getDevice(siteId, category, normalizedMac);
+		const raw = parseWritePayload(payload);
+		const config = deviceConfigWriteSchema.parse(raw);
+		await this.client.patch((0, ufo.joinURL)("/sites", siteId, "devices", normalizedMac), config);
+		this.emit({
+			type: "omada:device_config_updated",
+			path: (0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac),
+			data: {
+				mac: normalizedMac,
+				siteId,
+				category
+			}
+		});
+		return {
+			data: this.buildEntry((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac, "config"), {
+				content: JSON.stringify(config),
+				meta: { kind: "network:config" }
+			}),
+			message: "Device config updated"
+		};
+	}
+	async getSite(siteId) {
+		validateIdParam(siteId, "siteId");
+		const site = ((await this.client.request("/sites"))?.data ?? []).find((s) => s.siteId === siteId);
+		if (!site) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId));
+		return site;
+	}
+	async validateSite(siteId) {
+		await this.getSite(siteId);
+	}
+	validateDeviceCategory(category) {
+		if (!VALID_DEVICE_CATEGORIES.includes(category)) throw new _aigne_afs.AFSNotFoundError(`Invalid device category: ${category}. Valid: ${VALID_DEVICE_CATEGORIES.join(", ")}`);
+	}
+	async getAllDevices(siteId) {
+		return (await this.client.request((0, ufo.joinURL)("/sites", siteId, "devices")))?.data ?? [];
+	}
+	async getDevicesByCategory(siteId, category) {
+		return (await this.getAllDevices(siteId)).filter((d) => DEVICE_TYPE_MAP[d.type] === category);
+	}
+	async getDevice(siteId, category, normalizedMac) {
+		const device = (await this.getDevicesByCategory(siteId, category)).find((d) => require_types.normalizeMac(d.mac) === normalizedMac);
+		if (!device) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId, "devices", category, normalizedMac));
+		return device;
+	}
+	async getClient(siteId, normalizedMac) {
+		const client = ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "clients")))?.data ?? []).find((c) => require_types.normalizeMac(c.mac) === normalizedMac);
+		if (!client) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId, "clients", normalizedMac));
+		return client;
+	}
+	formatDeviceContent(device, category) {
+		const status = require_types.mapDeviceStatus(device.status);
+		const lines = [`${device.name} \u2014 ${device.model} (${status})`];
+		if (category === "gateways") {
+			const cpu = device.cpuUtil ?? 0;
+			const mem = device.memUtil ?? 0;
+			const uptime = device.uptime ?? "unknown";
+			lines.push(`CPU: ${cpu}% | Mem: ${mem}% | Uptime: ${uptime}`);
+		} else if (category === "switches") {
+			if (device.poeRemain !== void 0) lines.push(`PoE remaining: ${device.poeRemain}W`);
+		} else if (category === "aps") {
+			const parts = [];
+			if (device.radioSetting2g) parts.push(`2.4G: ch${device.radioSetting2g.channel} @${device.radioSetting2g.txPower}dBm`);
+			if (device.radioSetting5g) parts.push(`5G: ch${device.radioSetting5g.channel} @${device.radioSetting5g.txPower}dBm`);
+			if (parts.length > 0) lines.push(parts.join(" | "));
+		}
+		return lines.join("\n");
+	}
+	formatClientContent(client) {
+		const lines = [`${client.name} \u2014 ${client.ip}`];
+		const parts = [];
+		if (client.ssid) parts.push(`SSID: ${client.ssid}`);
+		if (client.signalLevel !== void 0) parts.push(`Signal: ${client.signalLevel}dBm`);
+		if (parts.length > 0) lines.push(parts.join(" | "));
+		return lines.join("\n");
+	}
+	async getSsid(siteId, ssidId) {
+		validateIdParam(ssidId, "ssidId");
+		const ssid = ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/ssids")))?.data ?? []).find((s) => s.id === ssidId);
+		if (!ssid) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId, "networks/wireless", ssidId));
+		return ssid;
+	}
+	async getWiredNetwork(siteId, networkId) {
+		validateIdParam(networkId, "networkId");
+		const net = ((await this.client.request((0, ufo.joinURL)("/sites", siteId, "setting/lan/networks")))?.data ?? []).find((n) => n.id === networkId);
+		if (!net) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId, "networks/wired", networkId));
+		return net;
+	}
+	mapBand(band) {
+		switch (band) {
+			case 0: return "2.4GHz";
+			case 1: return "2.4GHz+5GHz";
+			case 2: return "5GHz";
+			default: return `unknown(${band})`;
+		}
+	}
+	formatSsidContent(ssid) {
+		return [`${ssid.name} \u2014 ${this.mapBand(ssid.band)}`, `Security: ${ssid.security} | VLAN: ${ssid.vlanId} | Guest: ${ssid.guestNetwork ? "yes" : "no"}`].join("\n");
+	}
+	deviceChildrenCount(category) {
+		return category === "switches" ? 2 : 1;
+	}
+	async getSwitchPorts(siteId, normalizedMac) {
+		return (await this.client.request((0, ufo.joinURL)("/sites", siteId, "devices", normalizedMac, "ports")))?.data ?? [];
+	}
+	async getSwitchPort(siteId, normalizedMac, portId) {
+		const port = (await this.getSwitchPorts(siteId, normalizedMac)).find((p) => p.port === portId);
+		if (!port) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/sites", siteId, "devices/switches", normalizedMac, "ports", String(portId)));
+		return port;
+	}
+	formatPortContent(port) {
+		return [`${port.name} \u2014 ${port.linkSpeed} (${port.duplex})`, `VLAN: ${port.vlanId} | PoE: ${port.poeEnabled ? `enabled (${port.poePower}W)` : "disabled"}`].join("\n");
+	}
+	formatWiredNetworkContent(net) {
+		return [`${net.name} \u2014 VLAN ${net.vlanId}`, `Subnet: ${net.subnet} | Gateway: ${net.gateway} | DHCP: ${net.dhcpEnabled ? "enabled" : "disabled"}`].join("\n");
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], AFSOmadaProvider.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/")], AFSOmadaProvider.prototype, "listRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/")], AFSOmadaProvider.prototype, "readRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/")], AFSOmadaProvider.prototype, "metaRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/")], AFSOmadaProvider.prototype, "statRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites")], AFSOmadaProvider.prototype, "listSites", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites")], AFSOmadaProvider.prototype, "readSites", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites")], AFSOmadaProvider.prototype, "metaSites", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites")], AFSOmadaProvider.prototype, "statSites", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId")], AFSOmadaProvider.prototype, "listSite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId")], AFSOmadaProvider.prototype, "readSite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId")], AFSOmadaProvider.prototype, "metaSite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId")], AFSOmadaProvider.prototype, "statSite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices")], AFSOmadaProvider.prototype, "listDevicesContainer", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices")], AFSOmadaProvider.prototype, "readDevicesContainer", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices")], AFSOmadaProvider.prototype, "metaDevicesContainer", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices")], AFSOmadaProvider.prototype, "statDevicesContainer", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/:category")], AFSOmadaProvider.prototype, "listDeviceCategory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/:category")], AFSOmadaProvider.prototype, "readDeviceCategory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices/:category")], AFSOmadaProvider.prototype, "metaDeviceCategory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices/:category")], AFSOmadaProvider.prototype, "statDeviceCategory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/:category/:mac")], AFSOmadaProvider.prototype, "listDevice", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/:category/:mac")], AFSOmadaProvider.prototype, "readDevice", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices/:category/:mac")], AFSOmadaProvider.prototype, "metaDevice", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices/:category/:mac")], AFSOmadaProvider.prototype, "statDevice", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/clients")], AFSOmadaProvider.prototype, "listClients", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/clients")], AFSOmadaProvider.prototype, "readClients", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/clients")], AFSOmadaProvider.prototype, "metaClients", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/clients")], AFSOmadaProvider.prototype, "statClients", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/clients/:mac")], AFSOmadaProvider.prototype, "listClient", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/clients/:mac")], AFSOmadaProvider.prototype, "readClient", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/clients/:mac")], AFSOmadaProvider.prototype, "metaClient", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/clients/:mac")], AFSOmadaProvider.prototype, "statClient", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/dashboard")], AFSOmadaProvider.prototype, "listDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/dashboard")], AFSOmadaProvider.prototype, "readDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/dashboard")], AFSOmadaProvider.prototype, "metaDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/dashboard")], AFSOmadaProvider.prototype, "statDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks")], AFSOmadaProvider.prototype, "listNetworks", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks")], AFSOmadaProvider.prototype, "readNetworks", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks")], AFSOmadaProvider.prototype, "metaNetworks", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks")], AFSOmadaProvider.prototype, "statNetworks", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks/wireless")], AFSOmadaProvider.prototype, "listWirelessSsids", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks/wireless")], AFSOmadaProvider.prototype, "readWireless", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks/wireless")], AFSOmadaProvider.prototype, "metaWireless", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks/wireless")], AFSOmadaProvider.prototype, "statWireless", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks/wireless/:ssidId")], AFSOmadaProvider.prototype, "readSsid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks/wireless/:ssidId")], AFSOmadaProvider.prototype, "listSsid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks/wireless/:ssidId")], AFSOmadaProvider.prototype, "metaSsid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks/wireless/:ssidId")], AFSOmadaProvider.prototype, "statSsid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/sites/:siteId/networks/wireless/:ssidId")], AFSOmadaProvider.prototype, "writeSsid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks/wired")], AFSOmadaProvider.prototype, "listWiredNetworks", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks/wired")], AFSOmadaProvider.prototype, "readWired", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks/wired")], AFSOmadaProvider.prototype, "metaWired", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks/wired")], AFSOmadaProvider.prototype, "statWired", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks/wired/:networkId")], AFSOmadaProvider.prototype, "readWiredNetwork", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks/wired/:networkId")], AFSOmadaProvider.prototype, "listWiredNetwork", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks/wired/:networkId")], AFSOmadaProvider.prototype, "metaWiredNetwork", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks/wired/:networkId")], AFSOmadaProvider.prototype, "statWiredNetwork", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/sites/:siteId/networks/wired/:networkId")], AFSOmadaProvider.prototype, "writeWiredNetwork", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/networks/wifi-optimization")], AFSOmadaProvider.prototype, "listWifiOptimization", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/networks/wifi-optimization")], AFSOmadaProvider.prototype, "readWifiOptimization", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/networks/wifi-optimization")], AFSOmadaProvider.prototype, "metaWifiOptimization", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/networks/wifi-optimization")], AFSOmadaProvider.prototype, "statWifiOptimization", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/sites/:siteId/networks/wifi-optimization")], AFSOmadaProvider.prototype, "writeWifiOptimization", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/vpn")], AFSOmadaProvider.prototype, "listVpn", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/vpn")], AFSOmadaProvider.prototype, "readVpn", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/vpn")], AFSOmadaProvider.prototype, "metaVpn", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/vpn")], AFSOmadaProvider.prototype, "statVpn", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/firewall")], AFSOmadaProvider.prototype, "listFirewall", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/firewall")], AFSOmadaProvider.prototype, "readFirewall", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/firewall")], AFSOmadaProvider.prototype, "metaFirewall", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/firewall")], AFSOmadaProvider.prototype, "statFirewall", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/routing")], AFSOmadaProvider.prototype, "listRouting", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/routing")], AFSOmadaProvider.prototype, "readRouting", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/routing")], AFSOmadaProvider.prototype, "metaRouting", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/routing")], AFSOmadaProvider.prototype, "statRouting", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/nat")], AFSOmadaProvider.prototype, "listNat", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/nat")], AFSOmadaProvider.prototype, "readNat", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/nat")], AFSOmadaProvider.prototype, "metaNat", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/nat")], AFSOmadaProvider.prototype, "statNat", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/logs")], AFSOmadaProvider.prototype, "listLogs", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/logs")], AFSOmadaProvider.prototype, "readLogs", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/logs")], AFSOmadaProvider.prototype, "metaLogs", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/logs")], AFSOmadaProvider.prototype, "statLogs", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/switches/:mac/ports")], AFSOmadaProvider.prototype, "readSwitchPorts", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices/switches/:mac/ports")], AFSOmadaProvider.prototype, "metaSwitchPorts", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices/switches/:mac/ports")], AFSOmadaProvider.prototype, "statSwitchPorts", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/switches/:mac/ports")], AFSOmadaProvider.prototype, "listSwitchPorts", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/:category/:mac/ports")], AFSOmadaProvider.prototype, "listNonSwitchPorts", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/switches/:mac/ports/:portId")], AFSOmadaProvider.prototype, "readSwitchPort", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/switches/:mac/ports/:portId")], AFSOmadaProvider.prototype, "listSwitchPort", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices/switches/:mac/ports/:portId")], AFSOmadaProvider.prototype, "metaSwitchPort", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices/switches/:mac/ports/:portId")], AFSOmadaProvider.prototype, "statSwitchPort", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/switches/:mac/ports/:portId/config")], AFSOmadaProvider.prototype, "readSwitchPortConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/sites/:siteId/devices/switches/:mac/ports/:portId/config")], AFSOmadaProvider.prototype, "writeSwitchPortConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/sites/:siteId/devices/:category/:mac/firmware")], AFSOmadaProvider.prototype, "listFirmware", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/:category/:mac/firmware")], AFSOmadaProvider.prototype, "readFirmware", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/sites/:siteId/devices/:category/:mac/firmware")], AFSOmadaProvider.prototype, "metaFirmware", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/sites/:siteId/devices/:category/:mac/firmware")], AFSOmadaProvider.prototype, "statFirmware", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/")], AFSOmadaProvider.prototype, "explainRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/sites/:siteId")], AFSOmadaProvider.prototype, "explainSite", null);
+require_decorate.__decorate([
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices/:category"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices/:category/:mac"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices/:category/:mac/ports"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices/:category/:mac/ports/:portId"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/devices/:category/:mac/firmware"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/clients"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/clients/:mac"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/dashboard"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks/wireless"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks/wireless/:ssidId"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks/wired"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks/wired/:networkId"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/networks/wifi-optimization"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/vpn"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/firewall"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/routing"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/nat"),
+	(0, _aigne_afs_provider.Explain)("/sites/:siteId/logs")
+], AFSOmadaProvider.prototype, "explainSiteChild", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path*")], AFSOmadaProvider.prototype, "searchAll", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSOmadaProvider.prototype, "listRootActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "create-site")], AFSOmadaProvider.prototype, "execCreateSite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/sites/:siteId/devices/:category/:mac")], AFSOmadaProvider.prototype, "listDeviceActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/sites/:siteId/devices/:category/:mac", "reboot")], AFSOmadaProvider.prototype, "execDeviceReboot", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/sites/:siteId/devices/:category/:mac", "upgrade-firmware")], AFSOmadaProvider.prototype, "execDeviceUpgradeFirmware", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/sites/:siteId/clients/:mac")], AFSOmadaProvider.prototype, "listClientActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/sites/:siteId/clients/:mac", "block")], AFSOmadaProvider.prototype, "execClientBlock", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/sites/:siteId/clients/:mac", "unblock")], AFSOmadaProvider.prototype, "execClientUnblock", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/sites/:siteId/devices/:category/:mac/config")], AFSOmadaProvider.prototype, "readDeviceConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/sites/:siteId/devices/:category/:mac/config")], AFSOmadaProvider.prototype, "writeDeviceConfig", null);
+
+//#endregion
+exports.AFSOmadaProvider = AFSOmadaProvider;