@aigne/afs-synology 1.11.0-beta.12

package/dist/synology-afs.mjs

@@ -0,0 +1,1687 @@
+import { AFSSynologyConfigSchema, KINDS } from "./types.mjs";
+import { SynologyClient } from "./client.mjs";
+import { formatBackupTaskInfo, formatBytes, formatContainerInfo, formatDiskInfo, formatHardwareInfo, formatImageInfo, formatPackageInfo, formatPoolInfo, formatShareInfo, formatSystemStatus, formatSystemUtilization, formatVolumeInfo } from "./formatters.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { AFSBaseProvider, AFSError, AFSNotFoundError, Actions, Explain, List, Meta, Read, Search, Stat } from "@aigne/afs";
+import { z } from "zod";
+import { joinURL } from "ufo";
+
+//#region src/synology-afs.ts
+/**
+* AFSSynology - Synology NAS AFS Provider
+*
+* Maps Synology DSM management capabilities to AFS filesystem interface.
+* File read/write goes through afs-fs (NFS/SMB); this provider focuses on:
+* - System health monitoring
+* - Storage status (disks, pools, volumes)
+* - Docker container management (including start/stop/restart)
+* - Backup monitoring and task triggering
+* - Package management (start/stop)
+*/
+/**
+* Synology NAS AFS Provider
+*
+* Readwrite mode: supports exec operations (container start/stop/restart,
+* backup trigger, package start/stop). Write and delete are never supported.
+*/
+var AFSSynology = class AFSSynology extends AFSBaseProvider {
+	static securityProfiles() {
+		return {
+			admin: {
+				actionPolicy: "full",
+				sensitivity: "full"
+			},
+			user: {
+				actionPolicy: "standard",
+				sensitiveFields: ["serial_number"],
+				sensitivity: "redacted"
+			},
+			kid: {
+				actionPolicy: "safe",
+				accessMode: "readonly",
+				blockedActions: ["stop", "restart"],
+				sensitiveFields: ["serial_number"],
+				sensitivity: "redacted"
+			},
+			guest: {
+				actionPolicy: "safe",
+				accessMode: "readonly",
+				sensitiveFields: ["serial_number"],
+				sensitivity: "redacted"
+			}
+		};
+	}
+	name;
+	description;
+	accessMode = "readwrite";
+	client;
+	systemInfo = null;
+	utilization = null;
+	disks = null;
+	pools = null;
+	volumes = null;
+	containers = null;
+	images = null;
+	shares = null;
+	packages = null;
+	backupTasks = null;
+	constructor(config) {
+		super();
+		const { uri: _uri, ...cleanConfig } = config;
+		const validated = AFSSynologyConfigSchema.parse(cleanConfig);
+		if (!validated.url.startsWith("http://") && !validated.url.startsWith("https://")) throw new AFSError("URL must start with http:// or https://", "AFS_INVALID_PARAMETER");
+		this.name = validated.name || "synology";
+		this.description = validated.description || `Synology NAS at ${validated.url}`;
+		this.client = new SynologyClient({
+			url: validated.url,
+			account: validated.account,
+			password: validated.password,
+			otpCode: validated.otpCode,
+			deviceId: validated.deviceId,
+			verifySsl: validated.verifySsl
+		});
+	}
+	static schema() {
+		return AFSSynologyConfigSchema;
+	}
+	static manifest() {
+		return {
+			name: "synology",
+			description: "Synology NAS management — system health, storage status, Docker containers, backup monitoring.\n- Monitor CPU, RAM, disk health, temperature\n- View Docker containers, images, networks\n- Start/stop/restart Docker containers\n- Check Hyper Backup task status and trigger backups\n- Start/stop DSM packages\n- Path structure: `/system/`, `/storage/`, `/docker/`, `/shares/`, `/packages/`, `/backup/`",
+			uriTemplate: "synology://{host}",
+			category: "storage",
+			schema: z.object({ host: z.string().optional() }),
+			tags: [
+				"synology",
+				"nas",
+				"docker",
+				"storage",
+				"backup"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"on-premise"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet", "local-network"],
+				requires: ["docker"],
+				dataSensitivity: ["system-config", "media"],
+				notes: ["Manages NAS system — can start/stop Docker containers and DSM packages"]
+			},
+			capabilities: {
+				network: { egress: true },
+				secrets: ["synology/password"]
+			}
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"search",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": { kind: "nas:root" },
+				"/system": {
+					kind: "nas:system-group",
+					operations: ["list"]
+				},
+				"/system/status": {
+					kind: "nas:system-info",
+					operations: ["read"]
+				},
+				"/system/utilization": {
+					kind: "nas:system-info",
+					operations: ["read"]
+				},
+				"/system/hardware": {
+					kind: "nas:system-info",
+					operations: ["read"]
+				},
+				"/storage": {
+					kind: "nas:storage-group",
+					operations: ["list"]
+				},
+				"/storage/disks": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/storage/disks/{diskId}": {
+					kind: "nas:disk",
+					operations: ["read"]
+				},
+				"/storage/pools": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/storage/pools/{poolId}": {
+					kind: "nas:storage-pool",
+					operations: ["read"]
+				},
+				"/storage/volumes": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/storage/volumes/{volumeId}": {
+					kind: "nas:volume",
+					operations: ["read"]
+				},
+				"/docker": {
+					kind: "nas:docker-group",
+					operations: ["list"]
+				},
+				"/docker/containers": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/docker/containers/{name}": {
+					kind: "nas:container",
+					operations: ["read", "exec"],
+					actions: [
+						"start",
+						"stop",
+						"restart"
+					],
+					destructive: ["stop"]
+				},
+				"/docker/images": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/docker/images/{name}": {
+					kind: "nas:docker-image",
+					operations: ["read"]
+				},
+				"/docker/networks": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/docker/projects": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/shares": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/shares/{name}": {
+					kind: "nas:shared-folder",
+					operations: ["read"]
+				},
+				"/packages": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/packages/{name}": {
+					kind: "nas:package",
+					operations: ["read", "exec"],
+					actions: ["start", "stop"]
+				},
+				"/backup": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/backup/tasks": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/backup/tasks/{taskId}": {
+					kind: "nas:backup-task",
+					operations: ["read", "exec"],
+					actions: ["run"]
+				}
+			},
+			auth: {
+				type: "custom",
+				env: [
+					"SYNOLOGY_URL",
+					"SYNOLOGY_ACCOUNT",
+					"SYNOLOGY_PASSWORD"
+				]
+			},
+			bestFor: [
+				"NAS monitoring",
+				"Docker management",
+				"backup monitoring"
+			],
+			notFor: ["file read/write", "database queries"]
+		};
+	}
+	static async load({ config } = {}) {
+		return new AFSSynology(AFSSynologyConfigSchema.parse(config ?? {}));
+	}
+	async getSystemInfo() {
+		if (!this.systemInfo) this.systemInfo = await this.client.request({
+			api: "SYNO.Core.System",
+			method: "info",
+			version: 1
+		});
+		return this.systemInfo;
+	}
+	async getUtilization() {
+		if (!this.utilization) this.utilization = await this.client.request({
+			api: "SYNO.Core.System.Utilization",
+			method: "get",
+			version: 1
+		});
+		return this.utilization;
+	}
+	async getDisks() {
+		if (!this.disks) this.disks = (await this.client.request({
+			api: "SYNO.Storage.CGI.Storage",
+			method: "load_info",
+			version: 1
+		})).disks || [];
+		return this.disks;
+	}
+	async getPools() {
+		if (!this.pools) this.pools = (await this.client.request({
+			api: "SYNO.Storage.CGI.Storage",
+			method: "load_info",
+			version: 1
+		})).storagePools || [];
+		return this.pools;
+	}
+	async getVolumes() {
+		if (!this.volumes) this.volumes = (await this.client.request({
+			api: "SYNO.Storage.CGI.Storage",
+			method: "load_info",
+			version: 1
+		})).volumes || [];
+		return this.volumes;
+	}
+	async getContainers() {
+		if (!this.containers) this.containers = (await this.client.request({
+			api: "SYNO.Docker.Container",
+			method: "list",
+			version: 1,
+			extra: {
+				limit: -1,
+				offset: 0,
+				type: "all"
+			}
+		})).containers || [];
+		return this.containers;
+	}
+	async getImages() {
+		if (!this.images) this.images = (await this.client.request({
+			api: "SYNO.Docker.Image",
+			method: "list",
+			version: 1,
+			extra: {
+				limit: -1,
+				offset: 0
+			}
+		})).images || [];
+		return this.images;
+	}
+	async getShares() {
+		if (!this.shares) this.shares = (await this.client.request({
+			api: "SYNO.Core.Share",
+			method: "list",
+			version: 1
+		})).shares || [];
+		return this.shares;
+	}
+	async getPackages() {
+		if (!this.packages) this.packages = (await this.client.request({
+			api: "SYNO.Core.Package",
+			method: "list",
+			version: 1
+		})).packages || [];
+		return this.packages;
+	}
+	async getBackupTasks() {
+		if (!this.backupTasks) this.backupTasks = (await this.client.request({
+			api: "SYNO.Backup.Task",
+			method: "list",
+			version: 1
+		})).tasks || [];
+		return this.backupTasks;
+	}
+	/** Sanitize image name for use as path segment (replace / with -) */
+	sanitizeImageName(repository, _tag) {
+		return `${repository.replace(/\//g, "-")}`;
+	}
+	/** Invalidate container cache after exec operations */
+	invalidateContainerCache() {
+		this.containers = null;
+		this.client.invalidateCache();
+	}
+	/** Invalidate package cache after exec operations */
+	invalidatePackageCache() {
+		this.packages = null;
+	}
+	/** Invalidate backup task cache after exec operations */
+	invalidateBackupTaskCache() {
+		this.backupTasks = null;
+	}
+	async readCapabilities(_ctx) {
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description || "Synology NAS management provider",
+				tools: [],
+				actions: [],
+				operations: this.getOperationsDeclaration()
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async metaRoot(_ctx) {
+		const info = await this.getSystemInfo();
+		return {
+			id: "",
+			path: "/.meta",
+			meta: {
+				kind: KINDS.NAS,
+				model: info.model,
+				version: info.version,
+				serial: info.serial,
+				childrenCount: 6,
+				description: `Synology ${info.model} running DSM ${info.version}`
+			}
+		};
+	}
+	async metaSystem(_ctx) {
+		return {
+			id: "system",
+			path: "/system/.meta",
+			meta: {
+				kind: KINDS.SYSTEM_GROUP,
+				childrenCount: 3,
+				description: "System health and resource monitoring"
+			}
+		};
+	}
+	async metaSystemItem(ctx) {
+		const { item } = ctx.params;
+		const descriptions = {
+			status: "System health status summary",
+			utilization: "CPU, RAM, disk I/O, network statistics",
+			hardware: "Temperature, fan speed, power status"
+		};
+		if (!descriptions[item]) throw new AFSNotFoundError(joinURL("/system", item));
+		return {
+			id: item,
+			path: joinURL("/system", item, ".meta"),
+			meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: descriptions[item]
+			}
+		};
+	}
+	async metaStorage(_ctx) {
+		return {
+			id: "storage",
+			path: "/storage/.meta",
+			meta: {
+				kind: KINDS.STORAGE_GROUP,
+				childrenCount: 3,
+				description: "Physical disks, storage pools, and volumes"
+			}
+		};
+	}
+	async metaDisks(_ctx) {
+		return {
+			id: "disks",
+			path: "/storage/disks/.meta",
+			meta: {
+				childrenCount: (await this.getDisks()).length,
+				description: "Physical disk drives"
+			}
+		};
+	}
+	async metaDisk(ctx) {
+		const disk = (await this.getDisks()).find((d) => d.id === ctx.params.diskId);
+		if (!disk) throw new AFSNotFoundError(joinURL("/storage/disks", ctx.params.diskId));
+		return {
+			id: disk.id,
+			path: joinURL("/storage/disks", disk.id, ".meta"),
+			meta: {
+				kind: KINDS.DISK,
+				id: disk.id,
+				childrenCount: 0,
+				description: `${disk.model} - ${formatBytes(disk.size_total)} - ${disk.smart_status || disk.status}`
+			}
+		};
+	}
+	async metaPools(_ctx) {
+		return {
+			id: "pools",
+			path: "/storage/pools/.meta",
+			meta: {
+				childrenCount: (await this.getPools()).length,
+				description: "RAID storage pools"
+			}
+		};
+	}
+	async metaPool(ctx) {
+		const pool = (await this.getPools()).find((p) => p.id === ctx.params.poolId);
+		if (!pool) throw new AFSNotFoundError(joinURL("/storage/pools", ctx.params.poolId));
+		return {
+			id: pool.id,
+			path: joinURL("/storage/pools", pool.id, ".meta"),
+			meta: {
+				kind: KINDS.STORAGE_POOL,
+				id: pool.id,
+				childrenCount: 0,
+				description: `${pool.raidType || "unknown"} pool - ${pool.status}`
+			}
+		};
+	}
+	async metaVolumes(_ctx) {
+		return {
+			id: "volumes",
+			path: "/storage/volumes/.meta",
+			meta: {
+				childrenCount: (await this.getVolumes()).length,
+				description: "Logical volumes"
+			}
+		};
+	}
+	async metaVolume(ctx) {
+		const volume = (await this.getVolumes()).find((v) => v.id === ctx.params.volumeId);
+		if (!volume) throw new AFSNotFoundError(joinURL("/storage/volumes", ctx.params.volumeId));
+		const usedPercent = Math.round(volume.size.used / volume.size.total * 100);
+		return {
+			id: volume.id,
+			path: joinURL("/storage/volumes", volume.id, ".meta"),
+			meta: {
+				kind: KINDS.VOLUME,
+				id: volume.id,
+				childrenCount: 0,
+				description: `${volume.fs_type} - ${usedPercent}% used`
+			}
+		};
+	}
+	async metaDocker(_ctx) {
+		return {
+			id: "docker",
+			path: "/docker/.meta",
+			meta: {
+				kind: KINDS.DOCKER_GROUP,
+				childrenCount: 4,
+				description: "Docker containers, images, networks, and projects"
+			}
+		};
+	}
+	async metaContainers(_ctx) {
+		return {
+			id: "containers",
+			path: "/docker/containers/.meta",
+			meta: {
+				childrenCount: -1,
+				description: "Running and stopped containers"
+			}
+		};
+	}
+	async metaContainer(ctx) {
+		const container = (await this.getContainers()).find((c) => c.name === ctx.params.containerName);
+		if (!container) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		return {
+			id: container.name,
+			path: joinURL("/docker/containers", container.name, ".meta"),
+			meta: {
+				kind: KINDS.CONTAINER,
+				id: container.name,
+				childrenCount: 0,
+				description: `${container.image} - ${container.status}`
+			}
+		};
+	}
+	async metaImages(_ctx) {
+		return {
+			id: "images",
+			path: "/docker/images/.meta",
+			meta: {
+				childrenCount: -1,
+				description: "Local Docker images"
+			}
+		};
+	}
+	async metaImage(ctx) {
+		const image = (await this.getImages()).find((i) => this.sanitizeImageName(i.repository, i.tag) === ctx.params.imageName);
+		if (!image) throw new AFSNotFoundError(joinURL("/docker/images", ctx.params.imageName));
+		return {
+			id: `${image.repository}:${image.tag}`,
+			path: joinURL("/docker/images", ctx.params.imageName, ".meta"),
+			meta: {
+				kind: KINDS.DOCKER_IMAGE,
+				id: `${image.repository}:${image.tag}`,
+				childrenCount: 0
+			}
+		};
+	}
+	async metaNetworks(_ctx) {
+		return {
+			id: "networks",
+			path: "/docker/networks/.meta",
+			meta: {
+				childrenCount: 0,
+				description: "Docker networks"
+			}
+		};
+	}
+	async metaProjects(_ctx) {
+		return {
+			id: "projects",
+			path: "/docker/projects/.meta",
+			meta: {
+				childrenCount: 0,
+				description: "Docker Compose projects (DSM 7.2+)"
+			}
+		};
+	}
+	async metaShares(_ctx) {
+		return {
+			id: "shares",
+			path: "/shares/.meta",
+			meta: {
+				childrenCount: (await this.getShares()).length,
+				description: "Shared folders"
+			}
+		};
+	}
+	async metaShare(ctx) {
+		const share = (await this.getShares()).find((s) => s.name === ctx.params.shareName);
+		if (!share) throw new AFSNotFoundError(joinURL("/shares", ctx.params.shareName));
+		return {
+			id: share.name,
+			path: joinURL("/shares", share.name, ".meta"),
+			meta: {
+				kind: KINDS.SHARED_FOLDER,
+				id: share.name,
+				childrenCount: 0,
+				description: share.path
+			}
+		};
+	}
+	async metaPackages(_ctx) {
+		return {
+			id: "packages",
+			path: "/packages/.meta",
+			meta: {
+				childrenCount: (await this.getPackages()).length,
+				description: "Installed DSM packages"
+			}
+		};
+	}
+	async metaPackage(ctx) {
+		const pkg = (await this.getPackages()).find((p) => p.id === ctx.params.packageName);
+		if (!pkg) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		const updateStr = pkg.has_update ? " (update available)" : "";
+		return {
+			id: pkg.id,
+			path: joinURL("/packages", pkg.id, ".meta"),
+			meta: {
+				kind: KINDS.PACKAGE,
+				id: pkg.id,
+				childrenCount: 0,
+				description: `${pkg.name} v${pkg.version} - ${pkg.status}${updateStr}`
+			}
+		};
+	}
+	async metaBackup(_ctx) {
+		return {
+			id: "backup",
+			path: "/backup/.meta",
+			meta: {
+				childrenCount: 1,
+				description: "Backup management"
+			}
+		};
+	}
+	async metaBackupTasks(_ctx) {
+		return {
+			id: "tasks",
+			path: "/backup/tasks/.meta",
+			meta: {
+				childrenCount: (await this.getBackupTasks()).length,
+				description: "Hyper Backup tasks"
+			}
+		};
+	}
+	async metaBackupTask(ctx) {
+		const task = (await this.getBackupTasks()).find((t) => t.name === ctx.params.taskName);
+		if (!task) throw new AFSNotFoundError(joinURL("/backup/tasks", ctx.params.taskName));
+		const lastRunDate = task.last_run ? task.last_run.split("T")[0] : "never";
+		return {
+			id: task.name,
+			path: joinURL("/backup/tasks", task.name, ".meta"),
+			meta: {
+				kind: KINDS.BACKUP_TASK,
+				id: task.name,
+				childrenCount: 0,
+				description: `${task.status} - last run ${lastRunDate}`
+			}
+		};
+	}
+	async listRoot(_ctx) {
+		return { data: [
+			this.buildEntry("/system", { meta: {
+				kind: KINDS.SYSTEM_GROUP,
+				childrenCount: 3,
+				description: "System health and resource monitoring"
+			} }),
+			this.buildEntry("/storage", { meta: {
+				kind: KINDS.STORAGE_GROUP,
+				childrenCount: 3,
+				description: "Physical disks, storage pools, and volumes"
+			} }),
+			this.buildEntry("/docker", { meta: {
+				kind: KINDS.DOCKER_GROUP,
+				childrenCount: 4,
+				description: "Docker containers, images, networks, and projects"
+			} }),
+			this.buildEntry("/shares", { meta: {
+				kind: "nas:shared-folder-group",
+				childrenCount: -1,
+				description: "Shared folders"
+			} }),
+			this.buildEntry("/packages", { meta: {
+				kind: "nas:package-group",
+				childrenCount: -1,
+				description: "Installed DSM packages"
+			} }),
+			this.buildEntry("/backup", { meta: {
+				kind: "nas:backup-group",
+				childrenCount: 1,
+				description: "Backup management"
+			} })
+		] };
+	}
+	async listSystem(_ctx) {
+		return { data: [
+			this.buildEntry("/system/status", { meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "System health status summary"
+			} }),
+			this.buildEntry("/system/utilization", { meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "CPU, RAM, disk I/O, network statistics"
+			} }),
+			this.buildEntry("/system/hardware", { meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "Temperature, fan speed, power status"
+			} })
+		] };
+	}
+	async listStorage(_ctx) {
+		const [disks, pools, volumes] = await Promise.all([
+			this.getDisks(),
+			this.getPools(),
+			this.getVolumes()
+		]);
+		return { data: [
+			this.buildEntry("/storage/disks", { meta: {
+				childrenCount: disks.length,
+				description: "Physical disk drives"
+			} }),
+			this.buildEntry("/storage/pools", { meta: {
+				childrenCount: pools.length,
+				description: "RAID storage pools"
+			} }),
+			this.buildEntry("/storage/volumes", { meta: {
+				childrenCount: volumes.length,
+				description: "Logical volumes"
+			} })
+		] };
+	}
+	async listDisks(_ctx) {
+		return { data: (await this.getDisks()).map((d) => this.buildEntry(joinURL("/storage/disks", d.id), { meta: {
+			kind: KINDS.DISK,
+			id: d.id,
+			childrenCount: 0,
+			description: `${d.model} - ${formatBytes(d.size_total)} - ${d.smart_status || d.status}`
+		} })) };
+	}
+	async listPools(_ctx) {
+		return { data: (await this.getPools()).map((p) => this.buildEntry(joinURL("/storage/pools", p.id), { meta: {
+			kind: KINDS.STORAGE_POOL,
+			id: p.id,
+			childrenCount: 0,
+			description: `${p.raidType || "unknown"} pool - ${p.status}`
+		} })) };
+	}
+	async listVolumes(_ctx) {
+		return { data: (await this.getVolumes()).map((v) => {
+			const usedPercent = Math.round(v.size.used / v.size.total * 100);
+			return this.buildEntry(joinURL("/storage/volumes", v.id), { meta: {
+				kind: KINDS.VOLUME,
+				id: v.id,
+				childrenCount: 0,
+				description: `${v.fs_type} - ${usedPercent}% used`
+			} });
+		}) };
+	}
+	async listDocker(_ctx) {
+		return { data: [
+			this.buildEntry("/docker/containers", { meta: {
+				childrenCount: -1,
+				description: "Running and stopped containers"
+			} }),
+			this.buildEntry("/docker/images", { meta: {
+				childrenCount: -1,
+				description: "Local Docker images"
+			} }),
+			this.buildEntry("/docker/networks", { meta: {
+				childrenCount: 0,
+				description: "Docker networks"
+			} }),
+			this.buildEntry("/docker/projects", { meta: {
+				childrenCount: 0,
+				description: "Docker Compose projects (DSM 7.2+)"
+			} })
+		] };
+	}
+	async listContainers(_ctx) {
+		return { data: (await this.getContainers()).map((c) => this.buildEntry(joinURL("/docker/containers", c.name), { meta: {
+			kind: KINDS.CONTAINER,
+			id: c.name,
+			childrenCount: 0,
+			description: `${c.image} - ${c.status}`
+		} })) };
+	}
+	async listImages(_ctx) {
+		return { data: (await this.getImages()).map((i) => {
+			const safeName = this.sanitizeImageName(i.repository, i.tag);
+			return this.buildEntry(joinURL("/docker/images", safeName), { meta: {
+				kind: KINDS.DOCKER_IMAGE,
+				id: `${i.repository}:${i.tag}`,
+				childrenCount: 0
+			} });
+		}) };
+	}
+	async listNetworks(_ctx) {
+		return { data: [] };
+	}
+	async listProjects(_ctx) {
+		return { data: [] };
+	}
+	async listShares(_ctx) {
+		return { data: (await this.getShares()).map((s) => this.buildEntry(joinURL("/shares", s.name), { meta: {
+			kind: KINDS.SHARED_FOLDER,
+			id: s.name,
+			childrenCount: 0,
+			description: s.path
+		} })) };
+	}
+	async listPackages(_ctx) {
+		return { data: (await this.getPackages()).map((p) => {
+			const updateStr = p.has_update ? " (update available)" : "";
+			return this.buildEntry(joinURL("/packages", p.id), { meta: {
+				kind: KINDS.PACKAGE,
+				id: p.id,
+				childrenCount: 0,
+				description: `${p.name} v${p.version} - ${p.status}${updateStr}`
+			} });
+		}) };
+	}
+	async listBackup(_ctx) {
+		const tasks = await this.getBackupTasks();
+		return { data: [this.buildEntry("/backup/tasks", { meta: {
+			childrenCount: tasks.length,
+			description: "Hyper Backup tasks"
+		} })] };
+	}
+	async listBackupTasks(_ctx) {
+		return { data: (await this.getBackupTasks()).map((t) => {
+			const lastRunDate = t.last_run ? t.last_run.split("T")[0] : "never";
+			return this.buildEntry(joinURL("/backup/tasks", t.name), { meta: {
+				kind: KINDS.BACKUP_TASK,
+				id: t.name,
+				childrenCount: 0,
+				description: `${t.status} - last run ${lastRunDate}`
+			} });
+		}) };
+	}
+	async listSystemLeaf(_ctx) {
+		if (![
+			"status",
+			"utilization",
+			"hardware"
+		].includes(_ctx.params.item)) throw new AFSNotFoundError(joinURL("/system", _ctx.params.item));
+		return { data: [] };
+	}
+	async listDiskLeaf(ctx) {
+		if (!(await this.getDisks()).find((d) => d.id === ctx.params.diskId)) throw new AFSNotFoundError(joinURL("/storage/disks", ctx.params.diskId));
+		return { data: [] };
+	}
+	async listPoolLeaf(ctx) {
+		if (!(await this.getPools()).find((p) => p.id === ctx.params.poolId)) throw new AFSNotFoundError(joinURL("/storage/pools", ctx.params.poolId));
+		return { data: [] };
+	}
+	async listVolumeLeaf(ctx) {
+		if (!(await this.getVolumes()).find((v) => v.id === ctx.params.volumeId)) throw new AFSNotFoundError(joinURL("/storage/volumes", ctx.params.volumeId));
+		return { data: [] };
+	}
+	async listContainerLeaf(ctx) {
+		if (!(await this.getContainers()).find((c) => c.name === ctx.params.containerName)) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		return { data: [] };
+	}
+	async listImageLeaf(ctx) {
+		if (!(await this.getImages()).find((i) => this.sanitizeImageName(i.repository, i.tag) === ctx.params.imageName)) throw new AFSNotFoundError(joinURL("/docker/images", ctx.params.imageName));
+		return { data: [] };
+	}
+	async listShareLeaf(ctx) {
+		if (!(await this.getShares()).find((s) => s.name === ctx.params.shareName)) throw new AFSNotFoundError(joinURL("/shares", ctx.params.shareName));
+		return { data: [] };
+	}
+	async listPackageLeaf(ctx) {
+		if (!(await this.getPackages()).find((p) => p.id === ctx.params.packageName)) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		return { data: [] };
+	}
+	async listBackupTaskLeaf(ctx) {
+		if (!(await this.getBackupTasks()).find((t) => t.name === ctx.params.taskName)) throw new AFSNotFoundError(joinURL("/backup/tasks", ctx.params.taskName));
+		return { data: [] };
+	}
+	async readRoot(_ctx) {
+		const info = await this.getSystemInfo();
+		return this.buildEntry("/", {
+			content: `model: "${info.model}"\nversion: "${info.version}"\nserial: "${info.serial}"\nuptime_seconds: ${info.uptime}`,
+			meta: {
+				kind: KINDS.NAS,
+				model: info.model,
+				version: info.version,
+				serial: info.serial,
+				childrenCount: 6,
+				description: `Synology ${info.model} running DSM ${info.version}`
+			}
+		});
+	}
+	async readSystem(_ctx) {
+		return this.buildEntry("/system", { meta: {
+			kind: KINDS.SYSTEM_GROUP,
+			childrenCount: 3,
+			description: "System health and resource monitoring"
+		} });
+	}
+	async readSystemStatus(_ctx) {
+		const info = await this.getSystemInfo();
+		return this.buildEntry("/system/status", {
+			content: formatSystemStatus(info),
+			meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "System health status summary"
+			}
+		});
+	}
+	async readSystemUtilization(_ctx) {
+		const util = await this.getUtilization();
+		return this.buildEntry("/system/utilization", {
+			content: formatSystemUtilization(util),
+			meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "CPU, RAM, disk I/O, network statistics"
+			}
+		});
+	}
+	async readSystemHardware(_ctx) {
+		const info = await this.getSystemInfo();
+		return this.buildEntry("/system/hardware", {
+			content: formatHardwareInfo(info),
+			meta: {
+				kind: KINDS.SYSTEM_INFO,
+				childrenCount: 0,
+				description: "Temperature, fan speed, power status"
+			}
+		});
+	}
+	async readStorage(_ctx) {
+		return this.buildEntry("/storage", { meta: {
+			kind: KINDS.STORAGE_GROUP,
+			childrenCount: 3,
+			description: "Physical disks, storage pools, and volumes"
+		} });
+	}
+	async readStorageDisks(_ctx) {
+		const disks = await this.getDisks();
+		return this.buildEntry("/storage/disks", { meta: {
+			childrenCount: disks.length,
+			description: "Physical disk drives"
+		} });
+	}
+	async readDisk(ctx) {
+		const disk = (await this.getDisks()).find((d) => d.id === ctx.params.diskId);
+		if (!disk) throw new AFSNotFoundError(joinURL("/storage/disks", ctx.params.diskId));
+		return this.buildEntry(joinURL("/storage/disks", disk.id), {
+			content: formatDiskInfo(disk),
+			meta: {
+				kind: KINDS.DISK,
+				id: disk.id,
+				childrenCount: 0,
+				description: `${disk.model} - ${formatBytes(disk.size_total)} - ${disk.smart_status || disk.status}`
+			}
+		});
+	}
+	async readStoragePools(_ctx) {
+		const pools = await this.getPools();
+		return this.buildEntry("/storage/pools", { meta: {
+			childrenCount: pools.length,
+			description: "RAID storage pools"
+		} });
+	}
+	async readPool(ctx) {
+		const pool = (await this.getPools()).find((p) => p.id === ctx.params.poolId);
+		if (!pool) throw new AFSNotFoundError(joinURL("/storage/pools", ctx.params.poolId));
+		return this.buildEntry(joinURL("/storage/pools", pool.id), {
+			content: formatPoolInfo(pool),
+			meta: {
+				kind: KINDS.STORAGE_POOL,
+				id: pool.id,
+				childrenCount: 0,
+				description: `${pool.raidType || "unknown"} pool - ${pool.status}`
+			}
+		});
+	}
+	async readStorageVolumes(_ctx) {
+		const volumes = await this.getVolumes();
+		return this.buildEntry("/storage/volumes", { meta: {
+			childrenCount: volumes.length,
+			description: "Logical volumes"
+		} });
+	}
+	async readVolume(ctx) {
+		const volume = (await this.getVolumes()).find((v) => v.id === ctx.params.volumeId);
+		if (!volume) throw new AFSNotFoundError(joinURL("/storage/volumes", ctx.params.volumeId));
+		const usedPercent = Math.round(volume.size.used / volume.size.total * 100);
+		return this.buildEntry(joinURL("/storage/volumes", volume.id), {
+			content: formatVolumeInfo(volume),
+			meta: {
+				kind: KINDS.VOLUME,
+				id: volume.id,
+				childrenCount: 0,
+				description: `${volume.fs_type} - ${usedPercent}% used`
+			}
+		});
+	}
+	async readDocker(_ctx) {
+		return this.buildEntry("/docker", { meta: {
+			kind: KINDS.DOCKER_GROUP,
+			childrenCount: 4,
+			description: "Docker containers, images, networks, and projects"
+		} });
+	}
+	async readDockerContainers(_ctx) {
+		return this.buildEntry("/docker/containers", { meta: {
+			childrenCount: -1,
+			description: "Running and stopped containers"
+		} });
+	}
+	async readContainer(ctx) {
+		const container = (await this.getContainers()).find((c) => c.name === ctx.params.containerName);
+		if (!container) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		return this.buildEntry(joinURL("/docker/containers", container.name), {
+			content: formatContainerInfo(container),
+			meta: {
+				kind: KINDS.CONTAINER,
+				id: container.name,
+				childrenCount: 0,
+				description: `${container.image} - ${container.status}`
+			}
+		});
+	}
+	async readDockerImages(_ctx) {
+		return this.buildEntry("/docker/images", { meta: {
+			childrenCount: -1,
+			description: "Local Docker images"
+		} });
+	}
+	async readImage(ctx) {
+		const image = (await this.getImages()).find((i) => this.sanitizeImageName(i.repository, i.tag) === ctx.params.imageName);
+		if (!image) throw new AFSNotFoundError(joinURL("/docker/images", ctx.params.imageName));
+		const safeName = this.sanitizeImageName(image.repository, image.tag);
+		return this.buildEntry(joinURL("/docker/images", safeName), {
+			content: formatImageInfo(image),
+			meta: {
+				kind: KINDS.DOCKER_IMAGE,
+				id: `${image.repository}:${image.tag}`,
+				childrenCount: 0
+			}
+		});
+	}
+	async readDockerNetworks(_ctx) {
+		return this.buildEntry("/docker/networks", { meta: {
+			childrenCount: 0,
+			description: "Docker networks"
+		} });
+	}
+	async readDockerProjects(_ctx) {
+		return this.buildEntry("/docker/projects", { meta: {
+			childrenCount: 0,
+			description: "Docker Compose projects (DSM 7.2+)"
+		} });
+	}
+	async readSharesDir(_ctx) {
+		const shares = await this.getShares();
+		return this.buildEntry("/shares", { meta: {
+			childrenCount: shares.length,
+			description: "Shared folders"
+		} });
+	}
+	async readShare(ctx) {
+		const share = (await this.getShares()).find((s) => s.name === ctx.params.shareName);
+		if (!share) throw new AFSNotFoundError(joinURL("/shares", ctx.params.shareName));
+		return this.buildEntry(joinURL("/shares", share.name), {
+			content: formatShareInfo(share),
+			meta: {
+				kind: KINDS.SHARED_FOLDER,
+				id: share.name,
+				childrenCount: 0,
+				description: share.path
+			}
+		});
+	}
+	async readPackagesDir(_ctx) {
+		const packages = await this.getPackages();
+		return this.buildEntry("/packages", { meta: {
+			childrenCount: packages.length,
+			description: "Installed DSM packages"
+		} });
+	}
+	async readPackage(ctx) {
+		const pkg = (await this.getPackages()).find((p) => p.id === ctx.params.packageName);
+		if (!pkg) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		const updateStr = pkg.has_update ? " (update available)" : "";
+		return this.buildEntry(joinURL("/packages", pkg.id), {
+			content: formatPackageInfo(pkg),
+			meta: {
+				kind: KINDS.PACKAGE,
+				id: pkg.id,
+				childrenCount: 0,
+				description: `${pkg.name} v${pkg.version} - ${pkg.status}${updateStr}`
+			}
+		});
+	}
+	async readBackupDir(_ctx) {
+		return this.buildEntry("/backup", { meta: {
+			childrenCount: 1,
+			description: "Backup management"
+		} });
+	}
+	async readBackupTasksDir(_ctx) {
+		const tasks = await this.getBackupTasks();
+		return this.buildEntry("/backup/tasks", { meta: {
+			childrenCount: tasks.length,
+			description: "Hyper Backup tasks"
+		} });
+	}
+	async readBackupTask(ctx) {
+		const task = (await this.getBackupTasks()).find((t) => t.name === ctx.params.taskName);
+		if (!task) throw new AFSNotFoundError(joinURL("/backup/tasks", ctx.params.taskName));
+		const lastRunDate = task.last_run ? task.last_run.split("T")[0] : "never";
+		return this.buildEntry(joinURL("/backup/tasks", task.name), {
+			content: formatBackupTaskInfo(task),
+			meta: {
+				kind: KINDS.BACKUP_TASK,
+				id: task.name,
+				childrenCount: 0,
+				description: `${task.status} - last run ${lastRunDate}`
+			}
+		});
+	}
+	async statHandler(ctx) {
+		const entry = (await this.read(ctx.path)).data;
+		if (!entry) throw new AFSNotFoundError(ctx.path);
+		return { data: {
+			id: entry.id,
+			path: entry.path,
+			meta: entry.meta
+		} };
+	}
+	async explainRoot(_ctx) {
+		const info = await this.getSystemInfo();
+		return {
+			format: "markdown",
+			content: `# Synology NAS: ${info.model}
+
+- **Model**: ${info.model}
+- **DSM Version**: ${info.version}
+- **Serial**: ${info.serial}
+- **Uptime**: ${Math.floor(info.uptime / 3600)}h ${Math.floor(info.uptime % 3600 / 60)}m
+
+## Navigation
+
+- \`/system/\` - System health and resource monitoring
+- \`/storage/\` - Physical disks, storage pools, and volumes
+- \`/docker/\` - Docker containers, images, networks
+- \`/shares/\` - Shared folders
+- \`/packages/\` - Installed DSM packages
+- \`/backup/\` - Hyper Backup task management
+`
+		};
+	}
+	async explainSystem(_ctx) {
+		return {
+			format: "markdown",
+			content: `# System Monitoring
+
+System health and resource monitoring for the Synology NAS.
+
+## Sub-items
+
+- \`/system/status\` - Overall system health (temperature, uptime)
+- \`/system/utilization\` - Real-time CPU, RAM, disk I/O, network stats
+- \`/system/hardware\` - Hardware sensors (temperature, fan speed, power)
+
+Data sourced from SYNO.Core.System and SYNO.Core.System.Utilization APIs.
+`
+		};
+	}
+	async explainStorage(_ctx) {
+		return {
+			format: "markdown",
+			content: `# Storage Overview
+
+Hierarchical view of physical storage:
+
+\`\`\`
+Physical Disks  -->  Storage Pools (RAID)  -->  Volumes (filesystem)
+\`\`\`
+
+## Sub-items
+
+- \`/storage/disks/\` - Physical disk drives with SMART status
+- \`/storage/pools/\` - RAID storage pools
+- \`/storage/volumes/\` - Logical volumes with usage info
+
+Data sourced from SYNO.Storage.CGI.Storage API.
+`
+		};
+	}
+	async explainDocker(_ctx) {
+		const containers = await this.getContainers();
+		const running = containers.filter((c) => c.status === "running").length;
+		return {
+			format: "markdown",
+			content: `# Docker Environment
+
+Container management for the Synology NAS.
+
+- **Running containers**: ${running}
+- **Stopped containers**: ${containers.length - running}
+
+## Sub-items
+
+- \`/docker/containers/\` - Container list and details
+- \`/docker/images/\` - Local Docker images
+- \`/docker/networks/\` - Docker networks
+- \`/docker/projects/\` - Docker Compose projects (DSM 7.2+)
+
+## Actions
+
+Containers support the following actions via exec:
+- \`start\` - Start a stopped container
+- \`stop\` - Stop a running container
+- \`restart\` - Restart a container
+`
+		};
+	}
+	async explainGeneric(ctx) {
+		const entry = (await this.read(ctx.path)).data;
+		if (!entry) throw new AFSNotFoundError(ctx.path);
+		const name = ctx.path.split("/").filter(Boolean).pop() || ctx.path;
+		const desc = entry.meta?.description || "No description available";
+		const kind = entry.meta?.kind || "unknown";
+		let content = `# ${name}\n\n- **Path**: \`${ctx.path}\`\n- **Kind**: ${kind}\n- **Description**: ${desc}\n`;
+		if (entry.content && typeof entry.content === "string") content += `\n## Data\n\n\`\`\`yaml\n${entry.content}\n\`\`\`\n`;
+		return {
+			format: "markdown",
+			content
+		};
+	}
+	async searchHandler(ctx, query, options) {
+		const searchPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const limit = options?.limit ?? 100;
+		const searchQuery = query.toLowerCase();
+		const entries = [];
+		const collectEntries = async (listPath) => {
+			try {
+				const result = await this.list(listPath, { maxDepth: 10 });
+				for (const entry of result.data) entries.push(entry);
+			} catch {}
+		};
+		await collectEntries(searchPath);
+		return { data: entries.filter((entry) => {
+			if (!searchQuery) return true;
+			return [
+				entry.path.split("/").filter(Boolean).pop() || "",
+				String(entry.meta?.id || entry.id || ""),
+				String(entry.meta?.description || ""),
+				String(entry.meta?.kind || "")
+			].join(" ").toLowerCase().includes(searchQuery);
+		}).slice(0, limit) };
+	}
+	async listContainerActions(ctx) {
+		if (!(await this.getContainers()).find((c) => c.name === ctx.params.containerName)) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		return { data: [
+			{
+				id: "start",
+				path: joinURL(ctx.path, "start"),
+				summary: "Start the container",
+				meta: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"],
+					severity: "boundary",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}
+			},
+			{
+				id: "stop",
+				path: joinURL(ctx.path, "stop"),
+				summary: "Stop the container",
+				meta: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"],
+					severity: "boundary",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}
+			},
+			{
+				id: "restart",
+				path: joinURL(ctx.path, "restart"),
+				summary: "Restart the container",
+				meta: {
+					kind: "afs:executable",
+					kinds: ["afs:executable", "afs:node"],
+					severity: "boundary",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}
+			}
+		] };
+	}
+	async startContainerAction(ctx, _args) {
+		if (!(await this.getContainers()).find((c) => c.name === ctx.params.containerName)) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		try {
+			await this.client.request({
+				api: "SYNO.Docker.Container",
+				method: "start",
+				version: 1,
+				extra: { name: ctx.params.containerName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "CONTAINER_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidateContainerCache();
+		return {
+			success: true,
+			data: {
+				container: ctx.params.containerName,
+				action: "start",
+				status: "running"
+			}
+		};
+	}
+	async stopContainerAction(ctx, _args) {
+		if (!(await this.getContainers()).find((c) => c.name === ctx.params.containerName)) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		try {
+			await this.client.request({
+				api: "SYNO.Docker.Container",
+				method: "stop",
+				version: 1,
+				extra: { name: ctx.params.containerName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "CONTAINER_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidateContainerCache();
+		return {
+			success: true,
+			data: {
+				container: ctx.params.containerName,
+				action: "stop",
+				status: "stopped"
+			}
+		};
+	}
+	async restartContainerAction(ctx, _args) {
+		if (!(await this.getContainers()).find((c) => c.name === ctx.params.containerName)) throw new AFSNotFoundError(joinURL("/docker/containers", ctx.params.containerName));
+		try {
+			await this.client.request({
+				api: "SYNO.Docker.Container",
+				method: "restart",
+				version: 1,
+				extra: { name: ctx.params.containerName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "CONTAINER_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidateContainerCache();
+		return {
+			success: true,
+			data: {
+				container: ctx.params.containerName,
+				action: "restart",
+				status: "running"
+			}
+		};
+	}
+	async listBackupTaskActions(ctx) {
+		if (!(await this.getBackupTasks()).find((t) => t.name === ctx.params.taskName)) throw new AFSNotFoundError(joinURL("/backup/tasks", ctx.params.taskName));
+		return { data: [{
+			id: "run",
+			path: joinURL(ctx.path, "run"),
+			summary: "Trigger backup execution",
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				severity: "boundary",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				}
+			}
+		}] };
+	}
+	async runBackupTaskAction(ctx, _args) {
+		if (!(await this.getBackupTasks()).find((t) => t.name === ctx.params.taskName)) throw new AFSNotFoundError(joinURL("/backup/tasks", ctx.params.taskName));
+		try {
+			await this.client.request({
+				api: "SYNO.Backup.Task",
+				method: "run",
+				version: 1,
+				extra: { name: ctx.params.taskName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "BACKUP_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidateBackupTaskCache();
+		return {
+			success: true,
+			data: {
+				task: ctx.params.taskName,
+				action: "run",
+				status: "running"
+			}
+		};
+	}
+	async listPackageActions(ctx) {
+		if (!(await this.getPackages()).find((p) => p.id === ctx.params.packageName)) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		return { data: [{
+			id: "start",
+			path: joinURL(ctx.path, "start"),
+			summary: "Start the package",
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				severity: "boundary",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				}
+			}
+		}, {
+			id: "stop",
+			path: joinURL(ctx.path, "stop"),
+			summary: "Stop the package",
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				severity: "boundary",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				}
+			}
+		}] };
+	}
+	async startPackageAction(ctx, _args) {
+		if (!(await this.getPackages()).find((p) => p.id === ctx.params.packageName)) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		try {
+			await this.client.request({
+				api: "SYNO.Core.Package",
+				method: "start",
+				version: 1,
+				extra: { id: ctx.params.packageName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "PACKAGE_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidatePackageCache();
+		return {
+			success: true,
+			data: {
+				package: ctx.params.packageName,
+				action: "start",
+				status: "running"
+			}
+		};
+	}
+	async stopPackageAction(ctx, _args) {
+		if (!(await this.getPackages()).find((p) => p.id === ctx.params.packageName)) throw new AFSNotFoundError(joinURL("/packages", ctx.params.packageName));
+		try {
+			await this.client.request({
+				api: "SYNO.Core.Package",
+				method: "stop",
+				version: 1,
+				extra: { id: ctx.params.packageName }
+			});
+		} catch (error) {
+			if (error instanceof AFSError) return {
+				success: false,
+				error: {
+					code: "PACKAGE_ERROR",
+					message: error.message
+				}
+			};
+			throw error;
+		}
+		this.invalidatePackageCache();
+		return {
+			success: true,
+			data: {
+				package: ctx.params.packageName,
+				action: "stop",
+				status: "stopped"
+			}
+		};
+	}
+	async destroy() {
+		await this.client.destroy();
+	}
+};
+__decorate([Read("/.meta/.capabilities")], AFSSynology.prototype, "readCapabilities", null);
+__decorate([Meta("/")], AFSSynology.prototype, "metaRoot", null);
+__decorate([Meta("/system")], AFSSynology.prototype, "metaSystem", null);
+__decorate([Meta("/system/:item")], AFSSynology.prototype, "metaSystemItem", null);
+__decorate([Meta("/storage")], AFSSynology.prototype, "metaStorage", null);
+__decorate([Meta("/storage/disks")], AFSSynology.prototype, "metaDisks", null);
+__decorate([Meta("/storage/disks/:diskId")], AFSSynology.prototype, "metaDisk", null);
+__decorate([Meta("/storage/pools")], AFSSynology.prototype, "metaPools", null);
+__decorate([Meta("/storage/pools/:poolId")], AFSSynology.prototype, "metaPool", null);
+__decorate([Meta("/storage/volumes")], AFSSynology.prototype, "metaVolumes", null);
+__decorate([Meta("/storage/volumes/:volumeId")], AFSSynology.prototype, "metaVolume", null);
+__decorate([Meta("/docker")], AFSSynology.prototype, "metaDocker", null);
+__decorate([Meta("/docker/containers")], AFSSynology.prototype, "metaContainers", null);
+__decorate([Meta("/docker/containers/:containerName")], AFSSynology.prototype, "metaContainer", null);
+__decorate([Meta("/docker/images")], AFSSynology.prototype, "metaImages", null);
+__decorate([Meta("/docker/images/:imageName")], AFSSynology.prototype, "metaImage", null);
+__decorate([Meta("/docker/networks")], AFSSynology.prototype, "metaNetworks", null);
+__decorate([Meta("/docker/projects")], AFSSynology.prototype, "metaProjects", null);
+__decorate([Meta("/shares")], AFSSynology.prototype, "metaShares", null);
+__decorate([Meta("/shares/:shareName")], AFSSynology.prototype, "metaShare", null);
+__decorate([Meta("/packages")], AFSSynology.prototype, "metaPackages", null);
+__decorate([Meta("/packages/:packageName")], AFSSynology.prototype, "metaPackage", null);
+__decorate([Meta("/backup")], AFSSynology.prototype, "metaBackup", null);
+__decorate([Meta("/backup/tasks")], AFSSynology.prototype, "metaBackupTasks", null);
+__decorate([Meta("/backup/tasks/:taskName")], AFSSynology.prototype, "metaBackupTask", null);
+__decorate([List("/")], AFSSynology.prototype, "listRoot", null);
+__decorate([List("/system")], AFSSynology.prototype, "listSystem", null);
+__decorate([List("/storage")], AFSSynology.prototype, "listStorage", null);
+__decorate([List("/storage/disks")], AFSSynology.prototype, "listDisks", null);
+__decorate([List("/storage/pools")], AFSSynology.prototype, "listPools", null);
+__decorate([List("/storage/volumes")], AFSSynology.prototype, "listVolumes", null);
+__decorate([List("/docker")], AFSSynology.prototype, "listDocker", null);
+__decorate([List("/docker/containers")], AFSSynology.prototype, "listContainers", null);
+__decorate([List("/docker/images")], AFSSynology.prototype, "listImages", null);
+__decorate([List("/docker/networks")], AFSSynology.prototype, "listNetworks", null);
+__decorate([List("/docker/projects")], AFSSynology.prototype, "listProjects", null);
+__decorate([List("/shares")], AFSSynology.prototype, "listShares", null);
+__decorate([List("/packages")], AFSSynology.prototype, "listPackages", null);
+__decorate([List("/backup")], AFSSynology.prototype, "listBackup", null);
+__decorate([List("/backup/tasks")], AFSSynology.prototype, "listBackupTasks", null);
+__decorate([List("/system/:item")], AFSSynology.prototype, "listSystemLeaf", null);
+__decorate([List("/storage/disks/:diskId")], AFSSynology.prototype, "listDiskLeaf", null);
+__decorate([List("/storage/pools/:poolId")], AFSSynology.prototype, "listPoolLeaf", null);
+__decorate([List("/storage/volumes/:volumeId")], AFSSynology.prototype, "listVolumeLeaf", null);
+__decorate([List("/docker/containers/:containerName")], AFSSynology.prototype, "listContainerLeaf", null);
+__decorate([List("/docker/images/:imageName")], AFSSynology.prototype, "listImageLeaf", null);
+__decorate([List("/shares/:shareName")], AFSSynology.prototype, "listShareLeaf", null);
+__decorate([List("/packages/:packageName")], AFSSynology.prototype, "listPackageLeaf", null);
+__decorate([List("/backup/tasks/:taskName")], AFSSynology.prototype, "listBackupTaskLeaf", null);
+__decorate([Read("/")], AFSSynology.prototype, "readRoot", null);
+__decorate([Read("/system")], AFSSynology.prototype, "readSystem", null);
+__decorate([Read("/system/status")], AFSSynology.prototype, "readSystemStatus", null);
+__decorate([Read("/system/utilization")], AFSSynology.prototype, "readSystemUtilization", null);
+__decorate([Read("/system/hardware")], AFSSynology.prototype, "readSystemHardware", null);
+__decorate([Read("/storage")], AFSSynology.prototype, "readStorage", null);
+__decorate([Read("/storage/disks")], AFSSynology.prototype, "readStorageDisks", null);
+__decorate([Read("/storage/disks/:diskId")], AFSSynology.prototype, "readDisk", null);
+__decorate([Read("/storage/pools")], AFSSynology.prototype, "readStoragePools", null);
+__decorate([Read("/storage/pools/:poolId")], AFSSynology.prototype, "readPool", null);
+__decorate([Read("/storage/volumes")], AFSSynology.prototype, "readStorageVolumes", null);
+__decorate([Read("/storage/volumes/:volumeId")], AFSSynology.prototype, "readVolume", null);
+__decorate([Read("/docker")], AFSSynology.prototype, "readDocker", null);
+__decorate([Read("/docker/containers")], AFSSynology.prototype, "readDockerContainers", null);
+__decorate([Read("/docker/containers/:containerName")], AFSSynology.prototype, "readContainer", null);
+__decorate([Read("/docker/images")], AFSSynology.prototype, "readDockerImages", null);
+__decorate([Read("/docker/images/:imageName")], AFSSynology.prototype, "readImage", null);
+__decorate([Read("/docker/networks")], AFSSynology.prototype, "readDockerNetworks", null);
+__decorate([Read("/docker/projects")], AFSSynology.prototype, "readDockerProjects", null);
+__decorate([Read("/shares")], AFSSynology.prototype, "readSharesDir", null);
+__decorate([Read("/shares/:shareName")], AFSSynology.prototype, "readShare", null);
+__decorate([Read("/packages")], AFSSynology.prototype, "readPackagesDir", null);
+__decorate([Read("/packages/:packageName")], AFSSynology.prototype, "readPackage", null);
+__decorate([Read("/backup")], AFSSynology.prototype, "readBackupDir", null);
+__decorate([Read("/backup/tasks")], AFSSynology.prototype, "readBackupTasksDir", null);
+__decorate([Read("/backup/tasks/:taskName")], AFSSynology.prototype, "readBackupTask", null);
+__decorate([
+	Stat("/"),
+	Stat("/system"),
+	Stat("/system/:item"),
+	Stat("/storage"),
+	Stat("/storage/disks"),
+	Stat("/storage/disks/:diskId"),
+	Stat("/storage/pools"),
+	Stat("/storage/pools/:poolId"),
+	Stat("/storage/volumes"),
+	Stat("/storage/volumes/:volumeId"),
+	Stat("/docker"),
+	Stat("/docker/containers"),
+	Stat("/docker/containers/:containerName"),
+	Stat("/docker/images"),
+	Stat("/docker/images/:imageName"),
+	Stat("/docker/networks"),
+	Stat("/docker/projects"),
+	Stat("/shares"),
+	Stat("/shares/:shareName"),
+	Stat("/packages"),
+	Stat("/packages/:packageName"),
+	Stat("/backup"),
+	Stat("/backup/tasks"),
+	Stat("/backup/tasks/:taskName")
+], AFSSynology.prototype, "statHandler", null);
+__decorate([Explain("/")], AFSSynology.prototype, "explainRoot", null);
+__decorate([Explain("/system")], AFSSynology.prototype, "explainSystem", null);
+__decorate([Explain("/storage")], AFSSynology.prototype, "explainStorage", null);
+__decorate([Explain("/docker")], AFSSynology.prototype, "explainDocker", null);
+__decorate([
+	Explain("/system/:item"),
+	Explain("/storage/disks"),
+	Explain("/storage/disks/:diskId"),
+	Explain("/storage/pools"),
+	Explain("/storage/pools/:poolId"),
+	Explain("/storage/volumes"),
+	Explain("/storage/volumes/:volumeId"),
+	Explain("/docker/containers"),
+	Explain("/docker/containers/:containerName"),
+	Explain("/docker/images"),
+	Explain("/docker/images/:imageName"),
+	Explain("/docker/networks"),
+	Explain("/docker/projects"),
+	Explain("/shares"),
+	Explain("/shares/:shareName"),
+	Explain("/packages"),
+	Explain("/packages/:packageName"),
+	Explain("/backup"),
+	Explain("/backup/tasks"),
+	Explain("/backup/tasks/:taskName")
+], AFSSynology.prototype, "explainGeneric", null);
+__decorate([Search("/"), Search("/:path*")], AFSSynology.prototype, "searchHandler", null);
+__decorate([Actions("/docker/containers/:containerName")], AFSSynology.prototype, "listContainerActions", null);
+__decorate([Actions.Exec("/docker/containers/:containerName", "start")], AFSSynology.prototype, "startContainerAction", null);
+__decorate([Actions.Exec("/docker/containers/:containerName", "stop")], AFSSynology.prototype, "stopContainerAction", null);
+__decorate([Actions.Exec("/docker/containers/:containerName", "restart")], AFSSynology.prototype, "restartContainerAction", null);
+__decorate([Actions("/backup/tasks/:taskName")], AFSSynology.prototype, "listBackupTaskActions", null);
+__decorate([Actions.Exec("/backup/tasks/:taskName", "run")], AFSSynology.prototype, "runBackupTaskAction", null);
+__decorate([Actions("/packages/:packageName")], AFSSynology.prototype, "listPackageActions", null);
+__decorate([Actions.Exec("/packages/:packageName", "start")], AFSSynology.prototype, "startPackageAction", null);
+__decorate([Actions.Exec("/packages/:packageName", "stop")], AFSSynology.prototype, "stopPackageAction", null);
+
+//#endregion
+export { AFSSynology };
+//# sourceMappingURL=synology-afs.mjs.map