@aigne/afs-frigate 1.11.0-beta.12

package/dist/index.cjs

@@ -0,0 +1,2333 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let ufo = require("ufo");
+let zod = require("zod");
+
+//#region src/index.ts
+/**
+* AFSFrigate - AFS Provider for Frigate NVR
+*
+* Maps Frigate NVR into a virtual filesystem.
+* Phases:
+* - 0a: Core skeleton + conformance (cameras, events, dashboard, config)
+* - 0b (Phase 1): Full readonly (binary content, recordings, reviews, search, summaries)
+* - 0c (Phase 2): MQTT cache optimization (optional, graceful fallback)
+* - 1 (Phase 3): Event management + camera control (readwrite actions)
+* - 2 (Phase 4): Exports + semantic search + AI + PTZ
+* - 3 (Phase 5): Configuration management + logs + users + restart
+*/
+const afsFrigateOptionsSchema = zod.z.object({
+	name: zod.z.string().default("frigate"),
+	description: zod.z.string().optional(),
+	url: zod.z.string(),
+	username: zod.z.string().optional(),
+	password: zod.z.string().optional(),
+	mqttUrl: zod.z.string().optional(),
+	mqttTopicPrefix: zod.z.string().default("frigate"),
+	cacheTtl: zod.z.number().default(30),
+	accessMode: zod.z.enum(["readonly", "readwrite"]).default("readwrite")
+});
+var FrigateHttpClient = class {
+	baseUrl;
+	headers;
+	cache = /* @__PURE__ */ new Map();
+	cacheTtl;
+	pendingRequests = /* @__PURE__ */ new Map();
+	constructor(options) {
+		const urlLower = options.url.toLowerCase();
+		if (!urlLower.startsWith("http://") && !urlLower.startsWith("https://")) throw new Error("Frigate URL must use http:// or https:// protocol");
+		if (urlLower.startsWith("javascript:") || urlLower.startsWith("file:") || urlLower.startsWith("data:")) throw new Error("Invalid URL protocol");
+		this.baseUrl = options.url.replace(/\/$/, "");
+		this.cacheTtl = (options.cacheTtl ?? 30) * 1e3;
+		this.headers = {};
+		if (options.username && options.password) {
+			const credentials = btoa(`${options.username}:${options.password}`);
+			this.headers.Authorization = `Basic ${credentials}`;
+		}
+	}
+	getBaseUrl() {
+		return this.baseUrl;
+	}
+	invalidateCache(prefix) {
+		if (!prefix) {
+			this.cache.clear();
+			return;
+		}
+		for (const key of this.cache.keys()) if (key.includes(prefix)) this.cache.delete(key);
+	}
+	async fetchJSON(path, params) {
+		const url = new URL((0, ufo.joinURL)(this.baseUrl, path));
+		if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+		const cacheKey = url.toString();
+		const cached = this.cache.get(cacheKey);
+		if (cached && cached.expiresAt > Date.now()) return cached.data;
+		const pending = this.pendingRequests.get(cacheKey);
+		if (pending) return pending;
+		const requestPromise = (async () => {
+			try {
+				const response = await fetch(url.toString(), {
+					headers: this.headers,
+					signal: AbortSignal.timeout(1e4)
+				});
+				if (response.status === 401 || response.status === 403) throw new FrigateApiError("Authentication failed", "AFS_AUTH_FAILED", response.status);
+				if (response.status === 404) throw new FrigateApiError("Not found", "AFS_NOT_FOUND", 404);
+				if (response.status >= 500) throw new FrigateApiError("Upstream server error", "AFS_UPSTREAM_ERROR", response.status);
+				if (!response.ok) throw new FrigateApiError("Unexpected response", "AFS_UPSTREAM_ERROR", response.status);
+				const data = await response.json();
+				this.cache.set(cacheKey, {
+					data,
+					expiresAt: Date.now() + this.cacheTtl
+				});
+				return data;
+			} catch (error) {
+				if (error instanceof FrigateApiError) throw error;
+				if (error instanceof TypeError || error?.code === "ECONNREFUSED") throw new FrigateApiError("Connection failed", "AFS_CONNECTION_ERROR", 0);
+				if (error?.name === "TimeoutError" || error?.name === "AbortError") throw new FrigateApiError("Connection timed out", "AFS_CONNECTION_ERROR", 0);
+				throw error;
+			} finally {
+				this.pendingRequests.delete(cacheKey);
+			}
+		})();
+		this.pendingRequests.set(cacheKey, requestPromise);
+		return requestPromise;
+	}
+	async fetchRaw(path, options) {
+		const url = (0, ufo.joinURL)(this.baseUrl, path);
+		const method = options?.method ?? "GET";
+		const fetchHeaders = { ...this.headers };
+		let body;
+		if (options?.body) if (typeof options.body === "string") {
+			body = options.body;
+			fetchHeaders["Content-Type"] = "text/plain";
+		} else {
+			body = JSON.stringify(options.body);
+			fetchHeaders["Content-Type"] = "application/json";
+		}
+		try {
+			const response = await fetch(url, {
+				method,
+				headers: fetchHeaders,
+				body,
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (response.status === 401 || response.status === 403) throw new FrigateApiError("Authentication failed", "AFS_AUTH_FAILED", response.status);
+			if (response.status === 404) throw new FrigateApiError("Not found", "AFS_NOT_FOUND", 404);
+			if (response.status >= 500) throw new FrigateApiError("Upstream server error", "AFS_UPSTREAM_ERROR", response.status);
+			if (!response.ok) throw new FrigateApiError("Unexpected response", "AFS_UPSTREAM_ERROR", response.status);
+			return response;
+		} catch (error) {
+			if (error instanceof FrigateApiError) throw error;
+			if (error instanceof TypeError || error?.code === "ECONNREFUSED") throw new FrigateApiError("Connection failed", "AFS_CONNECTION_ERROR", 0);
+			if (error?.name === "TimeoutError" || error?.name === "AbortError") throw new FrigateApiError("Connection timed out", "AFS_CONNECTION_ERROR", 0);
+			throw error;
+		}
+	}
+	async fetchBinary(path) {
+		return (await this.fetchRaw(path)).arrayBuffer();
+	}
+	async fetchText(path) {
+		return (await this.fetchRaw(path)).text();
+	}
+	async postJSON(path, body) {
+		return await (await this.fetchRaw(path, {
+			method: "POST",
+			body
+		})).json();
+	}
+	async postText(path, body) {
+		return (await this.fetchRaw(path, {
+			method: "POST",
+			body
+		})).json();
+	}
+	async putJSON(path, body) {
+		return await (await this.fetchRaw(path, {
+			method: "PUT",
+			body
+		})).json();
+	}
+	async patchJSON(path, body) {
+		return await (await this.fetchRaw(path, {
+			method: "PATCH",
+			body
+		})).json();
+	}
+	async deleteRequest(path) {
+		return await (await this.fetchRaw(path, { method: "DELETE" })).json();
+	}
+	async getConfig() {
+		return this.fetchJSON("/api/config");
+	}
+	async getStats() {
+		return this.fetchJSON("/api/stats");
+	}
+	async getEvents(params) {
+		return this.fetchJSON("/api/events", params);
+	}
+	async getEvent(id) {
+		return this.fetchJSON(`/api/events/${id}`);
+	}
+	async getEventsSummary() {
+		return this.fetchJSON("/api/events/summary");
+	}
+	async searchEvents(params) {
+		return this.fetchJSON("/api/events/search", params);
+	}
+	async getReviews(params) {
+		return this.fetchJSON("/api/review", params);
+	}
+	async getReview(id) {
+		return this.fetchJSON(`/api/review/${id}`);
+	}
+	async getReviewSummary() {
+		return this.fetchJSON("/api/review/summary");
+	}
+	async getRecordings(camera) {
+		return this.fetchJSON(`/api/${camera}/recordings`);
+	}
+	async getRecordingsSummary(camera) {
+		return this.fetchJSON(`/api/${camera}/recordings/summary`);
+	}
+	async getRecordingsStorage() {
+		return this.fetchJSON("/api/recordings/storage");
+	}
+	async getExports() {
+		return this.fetchJSON("/api/exports");
+	}
+	async getExport(id) {
+		return this.fetchJSON(`/api/exports/${id}`);
+	}
+	async getUsers() {
+		return this.fetchJSON("/api/users");
+	}
+	async getPtzInfo(camera) {
+		return this.fetchJSON(`/api/${camera}/ptz/info`);
+	}
+	async getReviewActivitySummary() {
+		return this.fetchJSON("/api/review/activity/summary");
+	}
+};
+var FrigateApiError = class extends Error {
+	code;
+	statusCode;
+	constructor(message, code, statusCode) {
+		super(message);
+		this.name = "FrigateApiError";
+		this.code = code;
+		this.statusCode = statusCode;
+	}
+};
+function isPathTraversal(segment) {
+	return segment.includes("..") || segment.includes("./") || segment.startsWith("/");
+}
+function createMqttManager(_mqttUrl, _topicPrefix, _onInvalidate) {
+	try {
+		return null;
+	} catch {
+		return null;
+	}
+}
+var AFSFrigate = class AFSFrigate extends _aigne_afs_provider.AFSBaseProvider {
+	static securityProfiles() {
+		return {
+			admin: {
+				actionPolicy: "full",
+				sensitivity: "full"
+			},
+			user: {
+				actionPolicy: "standard",
+				blockedActions: ["restart", "delete"],
+				sensitivity: "redacted"
+			},
+			guest: {
+				actionPolicy: "safe",
+				accessMode: "readonly",
+				sensitivity: "redacted"
+			}
+		};
+	}
+	static schema() {
+		return afsFrigateOptionsSchema;
+	}
+	static manifest() {
+		return {
+			name: "frigate",
+			description: "Frigate NVR — cameras, events, and recordings as filesystem",
+			uriTemplate: "frigate://{host}",
+			category: "iot",
+			schema: zod.z.object({ host: zod.z.string() }),
+			tags: [
+				"frigate",
+				"nvr",
+				"camera",
+				"security",
+				"surveillance"
+			],
+			capabilityTags: [
+				"read-only",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"on-premise",
+				"real-time"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet", "local-network"],
+				dataSensitivity: ["media", "personal-data"],
+				notes: ["Accesses surveillance cameras and recordings — contains video of people and property"]
+			},
+			capabilities: { network: { egress: true } }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"write",
+				"search",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "frigate:nvr",
+					actions: ["restart"],
+					destructive: ["restart"]
+				},
+				"/cameras": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/cameras/{camera}": {
+					kind: "frigate:camera",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: [
+						"detect-on",
+						"detect-off",
+						"recordings-on",
+						"recordings-off",
+						"snapshots-on",
+						"snapshots-off",
+						"motion-on",
+						"motion-off",
+						"create-event"
+					]
+				},
+				"/cameras/{camera}/events": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/cameras/{camera}/events/{eventId}": {
+					kind: "frigate:detection-event",
+					operations: ["read"]
+				},
+				"/cameras/{camera}/recordings": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/cameras/{camera}/reviews": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/events": {
+					kind: "afs:directory",
+					operations: ["list", "search"]
+				},
+				"/events/{eventId}": {
+					kind: "frigate:detection-event",
+					operations: [
+						"read",
+						"exec",
+						"delete"
+					],
+					actions: [
+						"retain",
+						"unretain",
+						"set-sub-label",
+						"set-description",
+						"regenerate-description"
+					],
+					destructive: ["delete"]
+				},
+				"/reviews": {
+					kind: "afs:directory",
+					operations: ["list", "exec"],
+					actions: ["summarize"]
+				},
+				"/reviews/{reviewId}": {
+					kind: "frigate:review",
+					operations: ["read", "exec"],
+					actions: ["mark-viewed", "unmark-viewed"]
+				},
+				"/exports": {
+					kind: "afs:directory",
+					operations: ["list", "exec"]
+				},
+				"/exports/{exportId}": {
+					kind: "frigate:export",
+					operations: [
+						"read",
+						"exec",
+						"delete"
+					],
+					actions: ["rename"],
+					destructive: ["delete"]
+				},
+				"/dashboard": {
+					kind: "frigate:dashboard",
+					operations: ["read"]
+				},
+				"/config": {
+					kind: "frigate:config",
+					operations: ["read", "write"]
+				},
+				"/logs": {
+					kind: "afs:directory",
+					operations: ["list"]
+				},
+				"/users": {
+					kind: "afs:directory",
+					operations: ["list"]
+				}
+			},
+			auth: {
+				type: "custom",
+				env: ["FRIGATE_URL"]
+			},
+			bestFor: [
+				"NVR surveillance",
+				"event detection",
+				"camera monitoring"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	static async load({ config } = {}) {
+		return new AFSFrigate(await AFSFrigate.schema().parseAsync(config));
+	}
+	name;
+	description;
+	accessMode;
+	client;
+	parsedOptions;
+	constructor(options) {
+		super();
+		this.parsedOptions = afsFrigateOptionsSchema.parse(options);
+		this.name = this.parsedOptions.name ?? "frigate";
+		this.description = this.parsedOptions.description;
+		this.accessMode = this.parsedOptions.accessMode ?? "readwrite";
+		this.client = new FrigateHttpClient({
+			url: this.parsedOptions.url,
+			username: this.parsedOptions.username,
+			password: this.parsedOptions.password,
+			cacheTtl: this.parsedOptions.cacheTtl
+		});
+		if (this.parsedOptions.mqttUrl) createMqttManager(this.parsedOptions.mqttUrl, this.parsedOptions.mqttTopicPrefix ?? "frigate", (topic) => this.handleMqttInvalidation(topic));
+	}
+	handleMqttInvalidation(topic) {
+		if (topic.includes("events")) this.client.invalidateCache("/api/events");
+		else if (topic.includes("reviews") || topic.includes("review")) this.client.invalidateCache("/api/review");
+		else if (topic.includes("stats")) this.client.invalidateCache("/api/stats");
+		else this.client.invalidateCache("/api/config");
+	}
+	async readCameraEventsMeta(ctx) {
+		return this.buildMetaForPath((0, ufo.joinURL)("/cameras", ctx.params.camera, "events"));
+	}
+	async readCameraMeta(ctx) {
+		return this.buildMetaForPath((0, ufo.joinURL)("/cameras", ctx.params.camera));
+	}
+	async readMetaHandler(ctx) {
+		const nodePath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		return this.buildMetaForPath(nodePath);
+	}
+	async buildMetaForPath(nodePath) {
+		const metaPath = (0, ufo.joinURL)(nodePath, ".meta");
+		let meta;
+		try {
+			const pathParam = nodePath === "/" ? void 0 : nodePath.slice(1);
+			meta = (await this.statHandler({
+				path: nodePath,
+				params: { path: pathParam },
+				options: {}
+			})).data?.meta ?? {};
+		} catch {
+			throw new _aigne_afs.AFSNotFoundError(nodePath);
+		}
+		return {
+			id: metaPath,
+			path: metaPath,
+			content: meta,
+			meta
+		};
+	}
+	async readCapabilities(_ctx) {
+		const operations = this.getOperationsDeclaration();
+		const actions = [];
+		if (this.accessMode === "readwrite") actions.push({
+			kind: "frigate:detection-event",
+			description: "Event management actions",
+			catalog: [
+				{
+					name: "retain",
+					description: "Mark event for indefinite retention"
+				},
+				{
+					name: "unretain",
+					description: "Remove retention flag"
+				},
+				{
+					name: "delete",
+					description: "Delete event"
+				},
+				{
+					name: "set-sub-label",
+					description: "Set sub-label",
+					inputSchema: {
+						type: "object",
+						properties: { subLabel: { type: "string" } },
+						required: ["subLabel"]
+					}
+				},
+				{
+					name: "set-description",
+					description: "Set description",
+					inputSchema: {
+						type: "object",
+						properties: { description: { type: "string" } },
+						required: ["description"]
+					}
+				},
+				{
+					name: "regenerate-description",
+					description: "AI regenerate description"
+				}
+			],
+			discovery: { pathTemplate: "/events/:id/.actions" }
+		}, {
+			kind: "frigate:camera",
+			description: "Camera control actions",
+			catalog: [
+				{
+					name: "detect-on",
+					description: "Enable object detection"
+				},
+				{
+					name: "detect-off",
+					description: "Disable object detection"
+				},
+				{
+					name: "recordings-on",
+					description: "Enable recording"
+				},
+				{
+					name: "recordings-off",
+					description: "Disable recording"
+				},
+				{
+					name: "snapshots-on",
+					description: "Enable snapshots"
+				},
+				{
+					name: "snapshots-off",
+					description: "Disable snapshots"
+				},
+				{
+					name: "motion-on",
+					description: "Enable motion detection"
+				},
+				{
+					name: "motion-off",
+					description: "Disable motion detection"
+				},
+				{
+					name: "create-event",
+					description: "Create manual event"
+				},
+				{
+					name: "export",
+					description: "Export recording range"
+				},
+				{
+					name: "ptz",
+					description: "PTZ control"
+				},
+				{
+					name: "notifications-on",
+					description: "Enable notifications"
+				},
+				{
+					name: "notifications-off",
+					description: "Disable notifications"
+				}
+			],
+			discovery: { pathTemplate: "/cameras/:name/.actions" }
+		}, {
+			kind: "frigate:review",
+			description: "Review actions",
+			catalog: [{
+				name: "mark-viewed",
+				description: "Mark review as viewed"
+			}, {
+				name: "unmark-viewed",
+				description: "Unmark review as viewed"
+			}],
+			discovery: { pathTemplate: "/reviews/:id/.actions" }
+		}, {
+			kind: "frigate:export",
+			description: "Export actions",
+			catalog: [{
+				name: "delete",
+				description: "Delete export"
+			}, {
+				name: "rename",
+				description: "Rename export"
+			}],
+			discovery: { pathTemplate: "/exports/:id/.actions" }
+		});
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: "frigate",
+				description: "Frigate NVR — cameras, events, and recordings as filesystem",
+				operations,
+				tools: [],
+				actions
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async listRoot(_ctx) {
+		const config = await this.client.getConfig();
+		const cameraCount = Object.keys(config.cameras).length;
+		return { data: [
+			this.buildEntry("/cameras", { meta: {
+				kind: "afs:directory",
+				childrenCount: cameraCount,
+				description: "Frigate cameras"
+			} }),
+			this.buildEntry("/events", { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: "Detection events"
+			} }),
+			this.buildEntry("/reviews", { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: "Review segments"
+			} }),
+			this.buildEntry("/exports", { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: "Exported clips"
+			} }),
+			this.buildEntry("/dashboard", { meta: {
+				kind: "frigate:dashboard",
+				childrenCount: 0,
+				description: "System dashboard"
+			} }),
+			this.buildEntry("/config", { meta: {
+				kind: "frigate:config",
+				childrenCount: 0,
+				description: "Frigate configuration"
+			} }),
+			this.buildEntry("/logs", { meta: {
+				kind: "afs:directory",
+				childrenCount: 3,
+				description: "Service logs"
+			} }),
+			this.buildEntry("/users", { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: "User management"
+			} })
+		] };
+	}
+	async readRoot(_ctx) {
+		return this.buildEntry("/", {
+			content: "Frigate NVR instance",
+			meta: {
+				kind: "frigate:nvr",
+				childrenCount: 8,
+				description: "Frigate NVR instance"
+			}
+		});
+	}
+	async listCameras(_ctx) {
+		const config = await this.client.getConfig();
+		return { data: Object.keys(config.cameras).map((name) => {
+			const cam = config.cameras[name];
+			const description = `${this.formatCameraName(name)} camera`;
+			return this.buildEntry((0, ufo.joinURL)("/cameras", name), {
+				id: name,
+				meta: {
+					kind: "frigate:camera",
+					id: name,
+					childrenCount: 3,
+					description,
+					detect: cam.detect,
+					record: cam.record,
+					snapshots: cam.snapshots
+				}
+			});
+		}) };
+	}
+	async readCamerasDir(_ctx) {
+		const config = await this.client.getConfig();
+		const count = Object.keys(config.cameras).length;
+		return this.buildEntry("/cameras", { meta: {
+			kind: "afs:directory",
+			childrenCount: count
+		} });
+	}
+	async listCamera(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return { data: [
+			this.buildEntry((0, ufo.joinURL)("/cameras", cameraName, "events"), { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: `Events for ${cameraName}`
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/cameras", cameraName, "recordings"), { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: `Recordings for ${cameraName}`
+			} }),
+			this.buildEntry((0, ufo.joinURL)("/cameras", cameraName, "reviews"), { meta: {
+				kind: "afs:directory",
+				childrenCount: -1,
+				description: `Reviews for ${cameraName}`
+			} })
+		] };
+	}
+	async readCamera(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const cam = (await this.client.getConfig()).cameras[cameraName];
+		if (!cam) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const lines = [];
+		lines.push(`Camera: ${cameraName}`);
+		if (cam.detect) {
+			lines.push(`Resolution: ${cam.detect.width}x${cam.detect.height} @ ${cam.detect.fps} FPS`);
+			lines.push(`Detection: ${cam.detect.enabled ? "enabled" : "disabled"}`);
+		}
+		if (cam.record) lines.push(`Recording: ${cam.record.enabled ? "enabled" : "disabled"}`);
+		if (cam.snapshots) lines.push(`Snapshots: ${cam.snapshots.enabled ? "enabled" : "disabled"}`);
+		if (cam.zones && Object.keys(cam.zones).length > 0) lines.push(`Zones: ${Object.keys(cam.zones).join(", ")}`);
+		return this.buildEntry(ctx.path, {
+			id: cameraName,
+			content: lines.join("\n"),
+			meta: {
+				kind: "frigate:camera",
+				id: cameraName,
+				childrenCount: 3,
+				description: `${this.formatCameraName(cameraName)} camera`
+			}
+		});
+	}
+	async listCameraEvents(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const events = await this.client.getEvents({ camera: cameraName });
+		return { data: this.eventsToEntries(events, (0, ufo.joinURL)("/cameras", cameraName, "events")) };
+	}
+	async readCameraEventsDir(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "afs:directory",
+			childrenCount: -1,
+			description: `Events for ${cameraName}`
+		} });
+	}
+	async readCameraEvent(ctx) {
+		const { camera, eventId } = ctx.params;
+		if (isPathTraversal(camera) || isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const event = await this.client.getEvent(eventId);
+			if (event.camera !== camera) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			return this.eventToEntry(event, (0, ufo.joinURL)("/cameras", camera, "events"));
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraLatest(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const bytes = await this.client.fetchBinary(`/api/${cameraName}/latest.jpg`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/jpeg",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraGrid(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const bytes = await this.client.fetchBinary(`/api/${cameraName}/grid.jpg`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/jpeg",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraBestSnapshot(ctx) {
+		const { camera, label } = ctx.params;
+		if (isPathTraversal(camera) || isPathTraversal(label)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[camera]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const bytes = await this.client.fetchBinary(`/api/${camera}/${label}/best.jpg`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/jpeg",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraPtz(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const ptzInfo = await this.client.getPtzInfo(cameraName);
+			const lines = [];
+			lines.push(`PTZ Info for ${cameraName}`);
+			lines.push(`Features: ${ptzInfo.features.join(", ") || "none"}`);
+			lines.push(`Presets: ${ptzInfo.presets.join(", ") || "none"}`);
+			return this.buildEntry(ctx.path, {
+				content: lines.join("\n"),
+				meta: {
+					kind: "frigate:ptz",
+					childrenCount: 0,
+					features: ptzInfo.features,
+					presets: ptzInfo.presets
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listCameraRecordings(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			return { data: (await this.client.getRecordings(cameraName)).map((rec) => this.buildEntry((0, ufo.joinURL)("/cameras", cameraName, "recordings", rec.id), {
+				id: rec.id,
+				meta: {
+					kind: "frigate:recording",
+					childrenCount: 0,
+					camera: cameraName,
+					startTime: rec.start_time,
+					endTime: rec.end_time,
+					duration: rec.duration,
+					motion: rec.motion,
+					objects: rec.objects
+				}
+			})) };
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraRecordingsDir(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "afs:directory",
+			childrenCount: -1,
+			description: `Recordings for ${cameraName}`
+		} });
+	}
+	async readCameraRecordingsSummary(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const summary = await this.client.getRecordingsSummary(cameraName);
+			return this.buildEntry(ctx.path, {
+				content: summary,
+				meta: {
+					kind: "frigate:recording-summary",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readRecordingSnapshot(ctx) {
+		const { camera, time } = ctx.params;
+		if (isPathTraversal(camera) || isPathTraversal(time)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[camera]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const bytes = await this.client.fetchBinary(`/api/${camera}/recordings/${time}/snapshot.png`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/png",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listCameraReviews(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const reviews = await this.client.getReviews({ camera: cameraName });
+			return { data: this.reviewsToEntries(reviews) };
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readCameraReviewsDir(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "afs:directory",
+			childrenCount: -1,
+			description: `Reviews for ${cameraName}`
+		} });
+	}
+	async listEvents(ctx) {
+		const options = ctx.options;
+		const params = {};
+		if (options?.limit) params.limit = String(options.limit);
+		const events = await this.client.getEvents(params);
+		return { data: this.eventsToEntries(events, "/events") };
+	}
+	async readEventsDir(_ctx) {
+		return this.buildEntry("/events", { meta: {
+			kind: "afs:directory",
+			childrenCount: -1
+		} });
+	}
+	async readEventsSummary(_ctx) {
+		const lines = (await this.client.getEventsSummary()).map((s) => `${s.camera}: ${s.label} x${s.count} (${s.day})`);
+		return this.buildEntry("/events/summary", {
+			content: lines.join("\n"),
+			meta: {
+				kind: "frigate:summary",
+				childrenCount: 0
+			}
+		});
+	}
+	async readEvent(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const event = await this.client.getEvent(eventId);
+			return this.eventToEntry(event, "/events");
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readEventSnapshot(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			if (!(await this.client.getEvent(eventId)).has_snapshot) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			const bytes = await this.client.fetchBinary(`/api/events/${eventId}/snapshot.jpg`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				id: `${eventId}/snapshot`,
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/jpeg",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readEventThumbnail(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.getEvent(eventId);
+			const bytes = await this.client.fetchBinary(`/api/events/${eventId}/thumbnail.jpg`);
+			const base64 = this.arrayBufferToBase64(bytes);
+			return this.buildEntry(ctx.path, {
+				id: `${eventId}/thumbnail`,
+				content: base64,
+				meta: {
+					kind: "frigate:image",
+					contentType: "image/jpeg",
+					encoding: "base64",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readEventClip(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			if (!(await this.client.getEvent(eventId)).has_clip) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			const clipUrl = `${this.client.getBaseUrl()}/api/events/${eventId}/clip.mp4`;
+			return this.buildEntry(ctx.path, {
+				id: `${eventId}/clip`,
+				content: clipUrl,
+				meta: {
+					kind: "frigate:video-clip",
+					contentType: "video/mp4",
+					encoding: "url",
+					childrenCount: 0
+				}
+			});
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listReviews(ctx) {
+		const options = ctx.options;
+		const params = {};
+		if (options?.limit) params.limit = String(options.limit);
+		if (options?.severity) params.severity = options.severity;
+		const reviews = await this.client.getReviews(params);
+		return { data: this.reviewsToEntries(reviews) };
+	}
+	async readReviewsDir(_ctx) {
+		return this.buildEntry("/reviews", { meta: {
+			kind: "afs:directory",
+			childrenCount: -1
+		} });
+	}
+	async readReviewsSummary(_ctx) {
+		const summary = await this.client.getReviewSummary();
+		return this.buildEntry("/reviews/summary", {
+			content: summary,
+			meta: {
+				kind: "frigate:summary",
+				childrenCount: 0
+			}
+		});
+	}
+	async readReview(ctx) {
+		const reviewId = ctx.params.reviewId;
+		if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const review = await this.client.getReview(reviewId);
+			return this.reviewToEntry(review);
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listExports(_ctx) {
+		return { data: (await this.client.getExports()).map((exp) => this.buildEntry((0, ufo.joinURL)("/exports", exp.id), {
+			id: exp.id,
+			meta: {
+				kind: "frigate:export",
+				childrenCount: 0,
+				camera: exp.camera,
+				name: exp.name,
+				date: exp.date,
+				inProgress: exp.in_progress
+			}
+		})) };
+	}
+	async readExportsDir(_ctx) {
+		return this.buildEntry("/exports", { meta: {
+			kind: "afs:directory",
+			childrenCount: -1
+		} });
+	}
+	async readExport(ctx) {
+		const exportId = ctx.params.exportId;
+		if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const exp = await this.client.getExport(exportId);
+			return this.buildEntry(ctx.path, {
+				id: exp.id,
+				content: `Export: ${exp.name}\nCamera: ${exp.camera}\nStatus: ${exp.in_progress ? "in_progress" : "complete"}`,
+				meta: {
+					kind: "frigate:export",
+					childrenCount: 0,
+					camera: exp.camera,
+					name: exp.name,
+					date: exp.date,
+					inProgress: exp.in_progress
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readDashboard(_ctx) {
+		const stats = await this.client.getStats();
+		const lines = [];
+		lines.push("Frigate NVR Status");
+		lines.push("");
+		lines.push(`Version: ${stats.service.version}`);
+		lines.push(`Uptime: ${this.formatUptime(stats.service.uptime)}`);
+		lines.push("");
+		const detectorEntries = Object.entries(stats.detectors);
+		if (detectorEntries.length > 0) {
+			lines.push("Detectors:");
+			for (const [name, det] of detectorEntries) lines.push(`  ${name}: inference ${det.inference_speed}ms`);
+			lines.push("");
+		}
+		const cameraEntries = Object.entries(stats.cameras);
+		if (cameraEntries.length > 0) {
+			lines.push("Cameras:");
+			for (const [name, cam] of cameraEntries) lines.push(`  ${name}: ${cam.camera_fps} fps, detection ${cam.detection_fps} fps`);
+		}
+		return this.buildEntry("/dashboard", {
+			content: lines.join("\n"),
+			meta: {
+				kind: "frigate:dashboard",
+				childrenCount: 0
+			}
+		});
+	}
+	async readConfig(_ctx) {
+		const config = await this.client.getConfig();
+		const cameraNames = Object.keys(config.cameras);
+		const lines = [];
+		lines.push("Frigate configuration summary");
+		lines.push("");
+		lines.push(`Cameras: ${cameraNames.length}`);
+		for (const name of cameraNames) {
+			const cam = config.cameras[name];
+			const features = [
+				cam.detect?.enabled ? "detect" : "",
+				cam.record?.enabled ? "record" : "",
+				cam.snapshots?.enabled ? "snapshot" : ""
+			].filter(Boolean).join(", ");
+			lines.push(`  ${name}: ${features || "none"}`);
+		}
+		return this.buildEntry("/config", {
+			content: lines.join("\n"),
+			meta: {
+				kind: "frigate:config",
+				childrenCount: 0
+			}
+		});
+	}
+	async readConfigRaw(_ctx) {
+		try {
+			const rawConfig = await this.client.fetchText("/api/config/raw");
+			return this.buildEntry("/config/raw", {
+				content: rawConfig,
+				meta: {
+					kind: "frigate:config",
+					childrenCount: 0,
+					contentType: "text/yaml"
+				}
+			});
+		} catch (error) {
+			throw this.mapFrigateError(error, "/config/raw");
+		}
+	}
+	async writeConfig(ctx, payload) {
+		const content = typeof payload.content === "string" ? payload.content : JSON.stringify(payload.content);
+		if (!content || content.trim() === "") throw new Error("Config content cannot be empty");
+		try {
+			await this.client.postJSON("/api/config/save", { content });
+		} catch {}
+		try {
+			if (!(await fetch((0, ufo.joinURL)(this.client.getBaseUrl(), "/api/config/save"), {
+				method: "POST",
+				headers: { "Content-Type": "text/plain" },
+				body: content
+			})).ok) throw new Error("Failed to save config");
+		} catch (error) {
+			throw this.mapFrigateError(error, ctx.path);
+		}
+		this.client.invalidateCache("/api/config");
+		return { data: this.buildEntry("/config", {
+			content,
+			meta: {
+				kind: "frigate:config",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async readLogsDir(_ctx) {
+		return this.buildEntry("/logs", { meta: {
+			kind: "afs:directory",
+			childrenCount: 3,
+			description: "Service logs"
+		} });
+	}
+	async listLogs(_ctx) {
+		return { data: [
+			this.buildEntry("/logs/frigate", { meta: {
+				kind: "frigate:log",
+				childrenCount: 0,
+				description: "Frigate service logs"
+			} }),
+			this.buildEntry("/logs/nginx", { meta: {
+				kind: "frigate:log",
+				childrenCount: 0,
+				description: "Nginx logs"
+			} }),
+			this.buildEntry("/logs/go2rtc", { meta: {
+				kind: "frigate:log",
+				childrenCount: 0,
+				description: "go2rtc logs"
+			} })
+		] };
+	}
+	async readLog(ctx) {
+		const service = ctx.params.service;
+		if (![
+			"frigate",
+			"nginx",
+			"go2rtc"
+		].includes(service)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const logContent = await this.client.fetchText(`/api/logs/${service}`);
+			return this.buildEntry(ctx.path, {
+				content: logContent,
+				meta: {
+					kind: "frigate:log",
+					childrenCount: 0,
+					service
+				}
+			});
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listUsers(_ctx) {
+		try {
+			return { data: (await this.client.getUsers()).map((user) => this.buildEntry((0, ufo.joinURL)("/users", user.username), {
+				id: user.username,
+				meta: {
+					kind: "frigate:user",
+					childrenCount: 0,
+					username: user.username,
+					role: user.role
+				}
+			})) };
+		} catch (error) {
+			throw this.mapFrigateError(error, "/users");
+		}
+	}
+	async readUsersDir(_ctx) {
+		return this.buildEntry("/users", { meta: {
+			kind: "afs:directory",
+			childrenCount: -1
+		} });
+	}
+	async readUser(ctx) {
+		const username = ctx.params.username;
+		if (isPathTraversal(username)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const user = (await this.client.getUsers()).find((u) => u.username === username);
+			if (!user) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			return this.buildEntry(ctx.path, {
+				id: user.username,
+				content: `User: ${user.username}\nRole: ${user.role}`,
+				meta: {
+					kind: "frigate:user",
+					childrenCount: 0,
+					username: user.username,
+					role: user.role
+				}
+			});
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async readRecordingsStorage(_ctx) {
+		const storage = await this.client.getRecordingsStorage();
+		const lines = ["Recording Storage"];
+		for (const [cam, data] of Object.entries(storage)) {
+			const s = data;
+			lines.push(`  ${cam}: ${s.usage}MB (${s.usage_percent}%), bandwidth: ${s.bandwidth}Mbps`);
+		}
+		return this.buildEntry("/recordings/storage", {
+			content: lines.join("\n"),
+			meta: {
+				kind: "frigate:storage",
+				childrenCount: 0
+			}
+		});
+	}
+	async listEventLeaf(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.getEvent(eventId);
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+		return { data: [] };
+	}
+	async listCameraEventLeaf(ctx) {
+		const { camera, eventId } = ctx.params;
+		if (isPathTraversal(camera) || isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			if ((await this.client.getEvent(eventId)).camera !== camera) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		} catch (error) {
+			if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+		return { data: [] };
+	}
+	async listDashboard(_ctx) {
+		return { data: [] };
+	}
+	async listConfig(_ctx) {
+		return { data: [] };
+	}
+	async listReviewLeaf(ctx) {
+		const reviewId = ctx.params.reviewId;
+		if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.getReview(reviewId);
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+		return { data: [] };
+	}
+	async listExportLeaf(ctx) {
+		const exportId = ctx.params.exportId;
+		if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.getExport(exportId);
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+		return { data: [] };
+	}
+	async searchEvents(_ctx, query, options) {
+		const meta = options?.meta;
+		if (options?.type === "semantic" || meta?.semantic) try {
+			const params$1 = {};
+			if (query) params$1.query = query;
+			const events$1 = await this.client.searchEvents(params$1);
+			return { data: this.eventsToEntries(events$1, "/events") };
+		} catch {
+			return {
+				data: [],
+				message: "Semantic search unavailable"
+			};
+		}
+		const params = {};
+		if (query) params.label = query;
+		if (meta?.camera) params.camera = meta.camera;
+		if (meta?.zone) params.zone = meta.zone;
+		if (meta?.minScore) params.min_score = String(meta.minScore);
+		if (meta?.after) params.after = String(meta.after);
+		if (meta?.before) params.before = String(meta.before);
+		const events = await this.client.getEvents(params);
+		return { data: this.eventsToEntries(events, "/events") };
+	}
+	async searchGeneric(_ctx, _query, _options) {
+		return { data: [] };
+	}
+	async listEventActions(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const basePath = (0, ufo.joinURL)("/events", eventId, ".actions");
+		return { data: [
+			this.buildActionEntry(basePath, "retain", "Mark event for indefinite retention", void 0, "ambient"),
+			this.buildActionEntry(basePath, "unretain", "Remove retention flag", void 0, "ambient"),
+			this.buildActionEntry(basePath, "delete", "Delete event", void 0, "critical"),
+			this.buildActionEntry(basePath, "set-sub-label", "Set sub-label", {
+				type: "object",
+				properties: { subLabel: { type: "string" } },
+				required: ["subLabel"]
+			}, "ambient"),
+			this.buildActionEntry(basePath, "set-description", "Set description", {
+				type: "object",
+				properties: { description: { type: "string" } },
+				required: ["description"]
+			}, "ambient"),
+			this.buildActionEntry(basePath, "regenerate-description", "AI regenerate description", void 0, "ambient")
+		] };
+	}
+	async retainEvent(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.postJSON(`/api/events/${eventId}/retain`);
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: { message: "Event retained" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async unretainEvent(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.deleteRequest(`/api/events/${eventId}/retain`);
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: { message: "Event unretained" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async deleteEvent(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.deleteRequest(`/api/events/${eventId}`);
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: { message: "Event deleted" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async setEventSubLabel(ctx, args) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (args.subLabel === void 0) throw new Error("subLabel is required");
+		try {
+			await this.client.postJSON(`/api/events/${eventId}/sub_label`, { subLabel: String(args.subLabel) });
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: { message: "Sub-label updated" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async setEventDescription(ctx, args) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (args.description === void 0) throw new Error("description is required");
+		try {
+			await this.client.putJSON(`/api/events/${eventId}/description`, { description: String(args.description) });
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: { message: "Description updated" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async regenerateEventDescription(ctx) {
+		const eventId = ctx.params.eventId;
+		if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const result = await this.client.putJSON(`/api/events/${eventId}/description/regenerate`, {});
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: {
+					message: "Description regenerated",
+					description: result.description
+				}
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listCameraActions(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const basePath = (0, ufo.joinURL)("/cameras", cameraName, ".actions");
+		return { data: [
+			this.buildActionEntry(basePath, "detect-on", "Enable object detection", void 0, "ambient"),
+			this.buildActionEntry(basePath, "detect-off", "Disable object detection", void 0, "ambient"),
+			this.buildActionEntry(basePath, "recordings-on", "Enable recording", void 0, "ambient"),
+			this.buildActionEntry(basePath, "recordings-off", "Disable recording", void 0, "ambient"),
+			this.buildActionEntry(basePath, "snapshots-on", "Enable snapshots", void 0, "ambient"),
+			this.buildActionEntry(basePath, "snapshots-off", "Disable snapshots", void 0, "ambient"),
+			this.buildActionEntry(basePath, "motion-on", "Enable motion detection", void 0, "ambient"),
+			this.buildActionEntry(basePath, "motion-off", "Disable motion detection", void 0, "ambient"),
+			this.buildActionEntry(basePath, "create-event", "Create manual event", {
+				type: "object",
+				properties: {
+					label: { type: "string" },
+					sub_label: { type: "string" },
+					duration: { type: "number" },
+					score: { type: "number" }
+				}
+			}, "boundary"),
+			this.buildActionEntry(basePath, "export", "Export recording range", {
+				type: "object",
+				properties: {
+					start_time: { type: "number" },
+					end_time: { type: "number" },
+					name: { type: "string" }
+				},
+				required: ["start_time", "end_time"]
+			}, "boundary"),
+			this.buildActionEntry(basePath, "ptz", "PTZ control", {
+				type: "object",
+				properties: {
+					command: { type: "string" },
+					preset: { type: "string" }
+				}
+			}, "boundary"),
+			this.buildActionEntry(basePath, "notifications-on", "Enable notifications", void 0, "ambient"),
+			this.buildActionEntry(basePath, "notifications-off", "Disable notifications", void 0, "ambient")
+		] };
+	}
+	async cameraDetectOn(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "detect", true, ctx.path);
+	}
+	async cameraDetectOff(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "detect", false, ctx.path);
+	}
+	async cameraRecordingsOn(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "recordings", true, ctx.path);
+	}
+	async cameraRecordingsOff(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "recordings", false, ctx.path);
+	}
+	async cameraSnapshotsOn(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "snapshots", true, ctx.path);
+	}
+	async cameraSnapshotsOff(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "snapshots", false, ctx.path);
+	}
+	async cameraMotionOn(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "motion", true, ctx.path);
+	}
+	async cameraMotionOff(ctx) {
+		return this.toggleCameraFeature(ctx.params.camera, "motion", false, ctx.path);
+	}
+	async cameraCreateEvent(ctx, args) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			const result = await this.client.postJSON(`/api/${cameraName}/events/create`, {
+				label: args.label,
+				sub_label: args.sub_label,
+				duration: args.duration,
+				score: args.score
+			});
+			this.client.invalidateCache("/api/events");
+			return {
+				success: true,
+				data: {
+					message: "Manual event created",
+					eventId: result.event_id
+				}
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async cameraExport(ctx, args) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!args.start_time || !args.end_time) throw new Error("start_time and end_time are required");
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			return {
+				success: true,
+				data: {
+					message: "Export started",
+					exportId: (await this.client.postJSON(`/api/${cameraName}/export`, {
+						start_time: args.start_time,
+						end_time: args.end_time,
+						name: args.name
+					})).id
+				}
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async cameraPtz(ctx, args) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.postJSON(`/api/${cameraName}/ptz`, {
+				command: args.command,
+				preset: args.preset
+			});
+			return {
+				success: true,
+				data: { message: "PTZ command executed" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError) {
+				if (error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+				if (error.statusCode === 400) throw new Error("Camera does not support PTZ");
+			}
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async cameraNotificationsOn(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.postText(`/api/${cameraName}/notifications/set`, "ON");
+			return {
+				success: true,
+				data: { message: "Notifications enabled" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async cameraNotificationsOff(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.postText(`/api/${cameraName}/notifications/set`, "OFF");
+			return {
+				success: true,
+				data: { message: "Notifications disabled" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listReviewActions(ctx) {
+		const reviewId = ctx.params.reviewId;
+		if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const basePath = (0, ufo.joinURL)("/reviews", reviewId, ".actions");
+		return { data: [this.buildActionEntry(basePath, "mark-viewed", "Mark review as viewed", void 0, "ambient"), this.buildActionEntry(basePath, "unmark-viewed", "Unmark review as viewed", void 0, "ambient")] };
+	}
+	async markReviewViewed(ctx) {
+		const reviewId = ctx.params.reviewId;
+		if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.postJSON(`/api/review/${reviewId}/viewed`);
+			this.client.invalidateCache("/api/review");
+			return {
+				success: true,
+				data: { message: "Marked as viewed" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async unmarkReviewViewed(ctx) {
+		const reviewId = ctx.params.reviewId;
+		if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.deleteRequest(`/api/review/${reviewId}/viewed`);
+			this.client.invalidateCache("/api/review");
+			return {
+				success: true,
+				data: { message: "Unmarked as viewed" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listExportActions(ctx) {
+		const exportId = ctx.params.exportId;
+		if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const basePath = (0, ufo.joinURL)("/exports", exportId, ".actions");
+		return { data: [this.buildActionEntry(basePath, "delete", "Delete export", void 0, "critical"), this.buildActionEntry(basePath, "rename", "Rename export", {
+			type: "object",
+			properties: { name: { type: "string" } },
+			required: ["name"]
+		}, "boundary")] };
+	}
+	async deleteExport(ctx) {
+		const exportId = ctx.params.exportId;
+		if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.deleteRequest(`/api/exports/${exportId}`);
+			return {
+				success: true,
+				data: { message: "Export deleted" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async renameExport(ctx, args) {
+		const exportId = ctx.params.exportId;
+		if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!args.name) throw new Error("name is required");
+		const name = String(args.name);
+		if (name.includes("..") || name.includes("/") || name.includes("\\")) throw new Error("Invalid export name");
+		try {
+			await this.client.patchJSON(`/api/exports/${exportId}/rename`, { name });
+			return {
+				success: true,
+				data: { message: "Export renamed" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async listReviewsActions(_ctx) {
+		return { data: [this.buildActionEntry("/reviews/.actions", "summarize", "AI generate review summary", void 0, "ambient")] };
+	}
+	async summarizeReviews(_ctx) {
+		try {
+			return {
+				success: true,
+				data: {
+					message: "Summary generated",
+					summary: (await this.client.getReviewActivitySummary()).summary
+				}
+			};
+		} catch (_error) {
+			return {
+				success: true,
+				data: {
+					message: "No reviews to summarize",
+					summary: ""
+				}
+			};
+		}
+	}
+	async listRootActions(_ctx) {
+		return { data: [this.buildActionEntry("/.actions", "restart", "Restart Frigate", void 0, "critical"), this.buildActionEntry("/.actions", "create-user", "Create user", {
+			type: "object",
+			properties: {
+				username: { type: "string" },
+				password: { type: "string" },
+				role: { type: "string" }
+			},
+			required: ["username", "password"]
+		}, "boundary")] };
+	}
+	async restartFrigate(_ctx) {
+		try {
+			await this.client.postJSON("/api/restart");
+			return {
+				success: true,
+				data: { message: "Frigate restart initiated" }
+			};
+		} catch (error) {
+			throw this.mapFrigateError(error, "/");
+		}
+	}
+	async createUser(_ctx, args) {
+		if (!args.username || !args.password) throw new Error("username and password are required");
+		try {
+			await this.client.postJSON("/api/users", {
+				username: String(args.username),
+				password: String(args.password),
+				role: args.role ? String(args.role) : "viewer"
+			});
+			return {
+				success: true,
+				data: { message: "User created" }
+			};
+		} catch (error) {
+			throw this.mapFrigateError(error, "/");
+		}
+	}
+	async listUserActions(ctx) {
+		const basePath = (0, ufo.joinURL)("/users", ctx.params.username, ".actions");
+		return { data: [this.buildActionEntry(basePath, "delete", "Delete user", void 0, "critical")] };
+	}
+	async deleteUser(ctx) {
+		const username = ctx.params.username;
+		if (isPathTraversal(username)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		try {
+			await this.client.deleteRequest(`/api/users/${username}`);
+			return {
+				success: true,
+				data: { message: "User deleted" }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(ctx.path);
+			throw this.mapFrigateError(error, ctx.path);
+		}
+	}
+	async statHandler(ctx) {
+		const path = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		if (path === "/") return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: "frigate:nvr",
+				childrenCount: 8,
+				description: "Frigate NVR instance"
+			}
+		} };
+		const staticDirs = {
+			"/cameras": {
+				kind: "afs:directory",
+				childrenCount: -1
+			},
+			"/events": {
+				kind: "afs:directory",
+				childrenCount: -1
+			},
+			"/reviews": {
+				kind: "afs:directory",
+				childrenCount: -1
+			},
+			"/exports": {
+				kind: "afs:directory",
+				childrenCount: -1
+			},
+			"/dashboard": {
+				kind: "frigate:dashboard",
+				childrenCount: 0
+			},
+			"/config": {
+				kind: "frigate:config",
+				childrenCount: 0
+			},
+			"/logs": {
+				kind: "afs:directory",
+				childrenCount: 3
+			},
+			"/users": {
+				kind: "afs:directory",
+				childrenCount: -1
+			}
+		};
+		if (path === "/cameras") {
+			const config = await this.client.getConfig();
+			return { data: {
+				id: "/cameras",
+				path: "/cameras",
+				meta: {
+					kind: "afs:directory",
+					childrenCount: Object.keys(config.cameras).length
+				}
+			} };
+		}
+		if (staticDirs[path]) return { data: {
+			id: path,
+			path,
+			meta: staticDirs[path]
+		} };
+		const cameraMatch = path.match(/^\/cameras\/([^/]+)$/);
+		if (cameraMatch) {
+			const cameraName = cameraMatch[1];
+			if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(path);
+			if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(path);
+			return { data: {
+				id: cameraName,
+				path,
+				meta: {
+					kind: "frigate:camera",
+					id: cameraName,
+					childrenCount: 3,
+					description: `${this.formatCameraName(cameraName)} camera`
+				}
+			} };
+		}
+		const cameraSubMatch = path.match(/^\/cameras\/([^/]+)\/(events|recordings|reviews)$/);
+		if (cameraSubMatch) {
+			const cameraName = cameraSubMatch[1];
+			if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(path);
+			if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(path);
+			return { data: {
+				id: path,
+				path,
+				meta: {
+					kind: "afs:directory",
+					childrenCount: -1
+				}
+			} };
+		}
+		const cameraEventMatch = path.match(/^\/cameras\/([^/]+)\/events\/([^/]+)$/);
+		if (cameraEventMatch) {
+			const cameraName = cameraEventMatch[1];
+			const eventId = cameraEventMatch[2];
+			if (isPathTraversal(cameraName) || isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(path);
+			try {
+				const event = await this.client.getEvent(eventId);
+				if (event.camera !== cameraName) throw new _aigne_afs.AFSNotFoundError(path);
+				return { data: {
+					id: event.id,
+					path,
+					meta: {
+						kind: "frigate:detection-event",
+						childrenCount: 0,
+						label: event.label,
+						score: event.score,
+						camera: event.camera
+					}
+				} };
+			} catch (error) {
+				if (error instanceof _aigne_afs.AFSNotFoundError) throw error;
+				if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+				throw this.mapFrigateError(error, path);
+			}
+		}
+		const eventMatch = path.match(/^\/events\/([^/]+)$/);
+		if (eventMatch) {
+			const eventId = eventMatch[1];
+			if (eventId === "summary") return { data: {
+				id: path,
+				path,
+				meta: {
+					kind: "frigate:summary",
+					childrenCount: 0
+				}
+			} };
+			if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(path);
+			try {
+				const event = await this.client.getEvent(eventId);
+				return { data: {
+					id: event.id,
+					path,
+					meta: {
+						kind: "frigate:detection-event",
+						childrenCount: 0,
+						label: event.label,
+						score: event.score,
+						camera: event.camera
+					}
+				} };
+			} catch (error) {
+				if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+				throw this.mapFrigateError(error, path);
+			}
+		}
+		const eventBinaryMatch = path.match(/^\/events\/([^/]+)\/(snapshot|thumbnail|clip)$/);
+		if (eventBinaryMatch) {
+			const eventId = eventBinaryMatch[1];
+			const type = eventBinaryMatch[2];
+			if (isPathTraversal(eventId)) throw new _aigne_afs.AFSNotFoundError(path);
+			try {
+				await this.client.getEvent(eventId);
+				const kind = type === "clip" ? "frigate:video-clip" : "frigate:image";
+				return { data: {
+					id: `${eventId}/${type}`,
+					path,
+					meta: {
+						kind,
+						childrenCount: 0
+					}
+				} };
+			} catch (error) {
+				if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+				throw this.mapFrigateError(error, path);
+			}
+		}
+		const reviewMatch = path.match(/^\/reviews\/([^/]+)$/);
+		if (reviewMatch) {
+			const reviewId = reviewMatch[1];
+			if (reviewId === "summary") return { data: {
+				id: path,
+				path,
+				meta: {
+					kind: "frigate:summary",
+					childrenCount: 0
+				}
+			} };
+			if (isPathTraversal(reviewId)) throw new _aigne_afs.AFSNotFoundError(path);
+			try {
+				const review = await this.client.getReview(reviewId);
+				return { data: {
+					id: review.id,
+					path,
+					meta: {
+						kind: "frigate:review",
+						childrenCount: 0,
+						camera: review.camera,
+						severity: review.severity
+					}
+				} };
+			} catch (error) {
+				if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+				throw this.mapFrigateError(error, path);
+			}
+		}
+		const exportMatch = path.match(/^\/exports\/([^/]+)$/);
+		if (exportMatch) {
+			const exportId = exportMatch[1];
+			if (isPathTraversal(exportId)) throw new _aigne_afs.AFSNotFoundError(path);
+			try {
+				const exp = await this.client.getExport(exportId);
+				return { data: {
+					id: exp.id,
+					path,
+					meta: {
+						kind: "frigate:export",
+						childrenCount: 0,
+						camera: exp.camera
+					}
+				} };
+			} catch (error) {
+				if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+				throw this.mapFrigateError(error, path);
+			}
+		}
+		const logMatch = path.match(/^\/logs\/(frigate|nginx|go2rtc)$/);
+		if (logMatch) return { data: {
+			id: path,
+			path,
+			meta: {
+				kind: "frigate:log",
+				childrenCount: 0,
+				service: logMatch[1]
+			}
+		} };
+		if (path === "/config/raw") return { data: {
+			id: path,
+			path,
+			meta: {
+				kind: "frigate:config",
+				childrenCount: 0
+			}
+		} };
+		if (path === "/recordings/storage") return { data: {
+			id: path,
+			path,
+			meta: {
+				kind: "frigate:storage",
+				childrenCount: 0
+			}
+		} };
+		if (path === "/recordings") return { data: {
+			id: path,
+			path,
+			meta: {
+				kind: "afs:directory",
+				childrenCount: -1
+			}
+		} };
+		throw new _aigne_afs.AFSNotFoundError(path);
+	}
+	async explainRoot(_ctx) {
+		const config = await this.client.getConfig();
+		const stats = await this.client.getStats();
+		const cameraNames = Object.keys(config.cameras);
+		const lines = [];
+		lines.push("Frigate NVR instance");
+		lines.push(`Version: ${stats.service.version}`);
+		lines.push(`Cameras: ${cameraNames.length} (${cameraNames.join(", ")})`);
+		const detectorEntries = Object.entries(stats.detectors);
+		for (const [name, det] of detectorEntries) lines.push(`Detector: ${name} (inference: ${det.inference_speed}ms)`);
+		lines.push(`Uptime: ${this.formatUptime(stats.service.uptime)}`);
+		return {
+			content: lines.join("\n"),
+			format: "text"
+		};
+	}
+	async explainCamera(ctx) {
+		const cameraName = ctx.params.camera;
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const cam = (await this.client.getConfig()).cameras[cameraName];
+		if (!cam) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const lines = [];
+		lines.push(`Camera: ${cameraName}`);
+		if (cam.detect) {
+			lines.push(`Resolution: ${cam.detect.width}x${cam.detect.height} @ ${cam.detect.fps} FPS`);
+			lines.push(`Detection: ${cam.detect.enabled ? "enabled" : "disabled"}`);
+		}
+		if (cam.record) lines.push(`Recording: ${cam.record.enabled ? "enabled" : "disabled"}`);
+		if (cam.zones && Object.keys(cam.zones).length > 0) lines.push(`Zones: ${Object.keys(cam.zones).join(", ")}`);
+		return {
+			content: lines.join("\n"),
+			format: "text"
+		};
+	}
+	async explainGeneric(ctx) {
+		const path = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		try {
+			await this.statHandler(ctx);
+		} catch {
+			throw new _aigne_afs.AFSNotFoundError(path);
+		}
+		return {
+			content: `Frigate NVR path: ${path}`,
+			format: "text"
+		};
+	}
+	eventsToEntries(events, basePath) {
+		return events.map((event) => this.eventToEntry(event, basePath));
+	}
+	eventToEntry(event, basePath) {
+		const content = event.description || `${event.label} detected on ${event.camera}`;
+		return this.buildEntry((0, ufo.joinURL)(basePath, event.id), {
+			id: event.id,
+			content,
+			meta: {
+				kind: "frigate:detection-event",
+				id: event.id,
+				childrenCount: 0,
+				label: event.label,
+				score: event.score,
+				camera: event.camera,
+				topScore: event.top_score,
+				zones: event.zones,
+				startTime: event.start_time,
+				endTime: event.end_time,
+				hasClip: event.has_clip,
+				hasSnapshot: event.has_snapshot
+			}
+		});
+	}
+	reviewsToEntries(reviews) {
+		return reviews.map((review) => this.reviewToEntry(review));
+	}
+	reviewToEntry(review) {
+		return this.buildEntry((0, ufo.joinURL)("/reviews", review.id), {
+			id: review.id,
+			content: `Review: ${review.severity} on ${review.camera} (${review.data.objects.join(", ")})`,
+			meta: {
+				kind: "frigate:review",
+				id: review.id,
+				childrenCount: 0,
+				camera: review.camera,
+				severity: review.severity,
+				labels: review.data.objects,
+				zones: review.data.zones,
+				startTime: review.start_time,
+				endTime: review.end_time,
+				hasBeenReviewed: review.has_been_reviewed
+			}
+		});
+	}
+	buildActionEntry(basePath, name, description, inputSchema, severity) {
+		return {
+			id: name,
+			path: (0, ufo.joinURL)(basePath, name),
+			summary: name,
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				name,
+				description,
+				...severity ? { severity } : {},
+				...inputSchema ? { inputSchema } : {}
+			}
+		};
+	}
+	async toggleCameraFeature(cameraName, feature, enabled, path) {
+		if (isPathTraversal(cameraName)) throw new _aigne_afs.AFSNotFoundError(path);
+		if (!(await this.client.getConfig()).cameras[cameraName]) throw new _aigne_afs.AFSNotFoundError(path);
+		try {
+			await this.client.postText(`/api/${cameraName}/${feature}/set`, enabled ? "ON" : "OFF");
+			this.client.invalidateCache("/api/config");
+			return {
+				success: true,
+				data: { message: `${feature} ${enabled ? "enabled" : "disabled"} for ${cameraName}` }
+			};
+		} catch (error) {
+			if (error instanceof FrigateApiError && error.code === "AFS_NOT_FOUND") throw new _aigne_afs.AFSNotFoundError(path);
+			throw this.mapFrigateError(error, path);
+		}
+	}
+	arrayBufferToBase64(buffer) {
+		const bytes = new Uint8Array(buffer);
+		let binary = "";
+		for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	formatCameraName(name) {
+		return name.replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+	}
+	formatUptime(seconds) {
+		const days = Math.floor(seconds / 86400);
+		const hours = Math.floor(seconds % 86400 / 3600);
+		if (days > 0) return `${days} days${hours > 0 ? `, ${hours} hours` : ""}`;
+		if (hours > 0) return `${hours} hours`;
+		return `${Math.floor(seconds / 60)} minutes`;
+	}
+	mapFrigateError(error, path) {
+		if (error instanceof FrigateApiError) {
+			if (error.code === "AFS_NOT_FOUND") return new _aigne_afs.AFSNotFoundError(path);
+			const afsError = new Error(error.message);
+			afsError.code = error.code;
+			return afsError;
+		}
+		return error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown error");
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/cameras/:camera/events")], AFSFrigate.prototype, "readCameraEventsMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/cameras/:camera")], AFSFrigate.prototype, "readCameraMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/:path*")], AFSFrigate.prototype, "readMetaHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], AFSFrigate.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/")], AFSFrigate.prototype, "listRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/")], AFSFrigate.prototype, "readRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras")], AFSFrigate.prototype, "listCameras", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras")], AFSFrigate.prototype, "readCamerasDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras/:camera")], AFSFrigate.prototype, "listCamera", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera")], AFSFrigate.prototype, "readCamera", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras/:camera/events")], AFSFrigate.prototype, "listCameraEvents", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/events")], AFSFrigate.prototype, "readCameraEventsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/events/:eventId")], AFSFrigate.prototype, "readCameraEvent", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/latest")], AFSFrigate.prototype, "readCameraLatest", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/grid")], AFSFrigate.prototype, "readCameraGrid", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/:label/best")], AFSFrigate.prototype, "readCameraBestSnapshot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/ptz")], AFSFrigate.prototype, "readCameraPtz", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras/:camera/recordings")], AFSFrigate.prototype, "listCameraRecordings", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/recordings")], AFSFrigate.prototype, "readCameraRecordingsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/recordings/summary")], AFSFrigate.prototype, "readCameraRecordingsSummary", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/recordings/:time/snapshot")], AFSFrigate.prototype, "readRecordingSnapshot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras/:camera/reviews")], AFSFrigate.prototype, "listCameraReviews", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/cameras/:camera/reviews")], AFSFrigate.prototype, "readCameraReviewsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/events")], AFSFrigate.prototype, "listEvents", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events")], AFSFrigate.prototype, "readEventsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events/summary")], AFSFrigate.prototype, "readEventsSummary", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events/:eventId")], AFSFrigate.prototype, "readEvent", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events/:eventId/snapshot")], AFSFrigate.prototype, "readEventSnapshot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events/:eventId/thumbnail")], AFSFrigate.prototype, "readEventThumbnail", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/events/:eventId/clip")], AFSFrigate.prototype, "readEventClip", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/reviews")], AFSFrigate.prototype, "listReviews", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/reviews")], AFSFrigate.prototype, "readReviewsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/reviews/summary")], AFSFrigate.prototype, "readReviewsSummary", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/reviews/:reviewId")], AFSFrigate.prototype, "readReview", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/exports")], AFSFrigate.prototype, "listExports", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/exports")], AFSFrigate.prototype, "readExportsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/exports/:exportId")], AFSFrigate.prototype, "readExport", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/dashboard")], AFSFrigate.prototype, "readDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/config")], AFSFrigate.prototype, "readConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/config/raw")], AFSFrigate.prototype, "readConfigRaw", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/config")], AFSFrigate.prototype, "writeConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/logs")], AFSFrigate.prototype, "readLogsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/logs")], AFSFrigate.prototype, "listLogs", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/logs/:service")], AFSFrigate.prototype, "readLog", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/users")], AFSFrigate.prototype, "listUsers", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/users")], AFSFrigate.prototype, "readUsersDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/users/:username")], AFSFrigate.prototype, "readUser", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/recordings/storage")], AFSFrigate.prototype, "readRecordingsStorage", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/events/:eventId")], AFSFrigate.prototype, "listEventLeaf", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/cameras/:camera/events/:eventId")], AFSFrigate.prototype, "listCameraEventLeaf", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/dashboard")], AFSFrigate.prototype, "listDashboard", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/config")], AFSFrigate.prototype, "listConfig", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/reviews/:reviewId")], AFSFrigate.prototype, "listReviewLeaf", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/exports/:exportId")], AFSFrigate.prototype, "listExportLeaf", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/events")], AFSFrigate.prototype, "searchEvents", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path*")], AFSFrigate.prototype, "searchGeneric", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/events/:eventId")], AFSFrigate.prototype, "listEventActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "retain")], AFSFrigate.prototype, "retainEvent", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "unretain")], AFSFrigate.prototype, "unretainEvent", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "delete")], AFSFrigate.prototype, "deleteEvent", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "set-sub-label")], AFSFrigate.prototype, "setEventSubLabel", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "set-description")], AFSFrigate.prototype, "setEventDescription", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/events/:eventId", "regenerate-description")], AFSFrigate.prototype, "regenerateEventDescription", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/cameras/:camera")], AFSFrigate.prototype, "listCameraActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "detect-on")], AFSFrigate.prototype, "cameraDetectOn", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "detect-off")], AFSFrigate.prototype, "cameraDetectOff", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "recordings-on")], AFSFrigate.prototype, "cameraRecordingsOn", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "recordings-off")], AFSFrigate.prototype, "cameraRecordingsOff", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "snapshots-on")], AFSFrigate.prototype, "cameraSnapshotsOn", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "snapshots-off")], AFSFrigate.prototype, "cameraSnapshotsOff", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "motion-on")], AFSFrigate.prototype, "cameraMotionOn", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "motion-off")], AFSFrigate.prototype, "cameraMotionOff", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "create-event")], AFSFrigate.prototype, "cameraCreateEvent", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "export")], AFSFrigate.prototype, "cameraExport", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "ptz")], AFSFrigate.prototype, "cameraPtz", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "notifications-on")], AFSFrigate.prototype, "cameraNotificationsOn", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/cameras/:camera", "notifications-off")], AFSFrigate.prototype, "cameraNotificationsOff", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/reviews/:reviewId")], AFSFrigate.prototype, "listReviewActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/reviews/:reviewId", "mark-viewed")], AFSFrigate.prototype, "markReviewViewed", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/reviews/:reviewId", "unmark-viewed")], AFSFrigate.prototype, "unmarkReviewViewed", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/exports/:exportId")], AFSFrigate.prototype, "listExportActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/exports/:exportId", "delete")], AFSFrigate.prototype, "deleteExport", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/exports/:exportId", "rename")], AFSFrigate.prototype, "renameExport", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/reviews")], AFSFrigate.prototype, "listReviewsActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/reviews", "summarize")], AFSFrigate.prototype, "summarizeReviews", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSFrigate.prototype, "listRootActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "restart")], AFSFrigate.prototype, "restartFrigate", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "create-user")], AFSFrigate.prototype, "createUser", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/users/:username")], AFSFrigate.prototype, "listUserActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/users/:username", "delete")], AFSFrigate.prototype, "deleteUser", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/:path*")], AFSFrigate.prototype, "statHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/")], AFSFrigate.prototype, "explainRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/cameras/:camera")], AFSFrigate.prototype, "explainCamera", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/:path*")], AFSFrigate.prototype, "explainGeneric", null);
+var src_default = AFSFrigate;
+
+//#endregion
+exports.AFSFrigate = AFSFrigate;
+exports.default = src_default;