@mgcrea/mcp-unifi-protect 0.0.0

package/dist/server-iu_3JECB.js

@@ -0,0 +1,1743 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { Agent, fetch as fetch$1 } from "undici";
+//#region src/build-info.ts
+const readPackageJson = () => {
+	try {
+		const pkgUrl = new URL("../package.json", import.meta.url);
+		return JSON.parse(readFileSync(pkgUrl, "utf8"));
+	} catch {
+		return {
+			name: "@mgcrea/mcp-unifi-protect",
+			version: "0.0.0"
+		};
+	}
+};
+const pkg = readPackageJson();
+const BUILD_INFO = {
+	name: pkg.name,
+	version: pkg.version,
+	gitCommit: "b7fe70a",
+	gitCommitDate: "2026-08-30T10:17:29+02:00"
+};
+//#endregion
+//#region src/config.ts
+/**
+* The private (undocumented) Protect API, mounted under UniFi OS's proxy. This
+* server deliberately wraps this rather than the official Integration API at
+* `/proxy/protect/integration/v1`: the official one has NO historical query
+* capability at all — its only query parameters in the entire published OpenAPI
+* spec are `channel`, `highQuality` and `qualities` — so "what happened at the
+* front door last night" is unanswerable through it.
+*
+* The trade is real and accepted: nothing below is contractual, and Ubiquiti
+* moves these endpoints between Protect releases. `unifi_protect_get_system_info`
+* reports the running version so a mismatch is visible, and
+* `unifi_protect_request` reaches anything that moved without a code change.
+*/
+const PRIVATE_API_PATH = "/proxy/protect/api";
+/** UniFi OS's own auth surface, which is NOT under the Protect proxy path. */
+const LOGIN_PATH = "/api/auth/login";
+/** The realtime channel. Not used yet — see the WebSocket note in the README. */
+const UPDATES_WS_PATH = "/proxy/protect/ws/updates";
+const ConfigSchema = z.object({
+	/** Console origin, e.g. `https://192.168.1.1` or `https://10.0.0.1:8443`. */
+	baseUrl: z.string().min(1).optional(),
+	username: z.string().min(1).optional(),
+	password: z.string().min(1).optional(),
+	/**
+	* A 2FA code is single-use and expires in ~30s, so it is only ever useful
+	* for a one-shot `unifi_protect_auth_login`, never for an unattended start.
+	*/
+	totp: z.string().min(1).optional(),
+	/**
+	* On by default. Turning it off is scoped to this server's own requests via
+	* an undici dispatcher, not the whole process.
+	*
+	* Verifying takes two things together, and one alone does nothing: the
+	* console's certificate is self-signed (so NODE_EXTRA_CA_CERTS must point at
+	* it) AND it carries no IP SAN — `CN=unifi.local`, SANs for `unifi.local`,
+	* `localhost` and `127.0.0.1` — so UNIFI_PROTECT_HOST must be a host name
+	* that resolves to the console, never its IP address.
+	*/
+	verifyTls: z.boolean().default(true),
+	allowWrites: z.boolean().default(false),
+	sessionFile: z.string().min(1),
+	snapshotDir: z.string().min(1),
+	maxRetries: z.number().int().nonnegative().max(10).default(3),
+	/** Guards against an unexpectedly huge video export blowing up the process. */
+	maxDownloadBytes: z.number().int().positive().default(2e8),
+	/** How long a cached camera id→name index stays fresh, in seconds. */
+	deviceCacheTtlSeconds: z.number().int().nonnegative().max(3600).default(60)
+}).strict().superRefine((cfg, ctx) => {
+	if (cfg.baseUrl && !cfg.username) ctx.addIssue({
+		code: "custom",
+		path: ["username"],
+		message: "UNIFI_PROTECT_HOST is set but UNIFI_PROTECT_USERNAME is not. Both, plus UNIFI_PROTECT_PASSWORD, are needed to reach the console."
+	});
+	if (cfg.username && !cfg.password) ctx.addIssue({
+		code: "custom",
+		path: ["password"],
+		message: "UNIFI_PROTECT_USERNAME is set but UNIFI_PROTECT_PASSWORD is not."
+	});
+});
+/**
+* The on-disk config document. Keys are camelCase to mirror `Config` rather
+* than the env var names: this is a typed JSON file, not a shell.
+*
+* `.strict()` on purpose — a typo'd `userName` must be an error. Silently
+* ignoring an unknown key looks exactly like "that setting had no effect",
+* which is the worst way to learn your credentials came from somewhere else.
+*/
+const FileConfigSchema = z.object({
+	host: z.string().min(1).optional(),
+	username: z.string().min(1).optional(),
+	password: z.string().min(1).optional(),
+	verifyTls: z.boolean().optional(),
+	allowWrites: z.boolean().optional(),
+	sessionFile: z.string().min(1).optional(),
+	snapshotDir: z.string().min(1).optional(),
+	maxRetries: z.number().int().nonnegative().max(10).optional(),
+	maxDownloadBytes: z.number().int().positive().optional(),
+	deviceCacheTtlSeconds: z.number().int().nonnegative().max(3600).optional()
+}).strict();
+/**
+* Normalize whatever someone pasted into a console origin, preserving the port.
+*
+*   "192.168.1.1"              -> "https://192.168.1.1"
+*   "10.0.0.1:8443"            -> "https://10.0.0.1:8443"
+*   "https://udm.lan/protect/" -> "https://udm.lan"
+*
+* A port must survive: consoles are commonly reached on a non-443 port, and the
+* normalizers in mcp-keycloak and mcp-shopify both drop it. Everything after
+* the origin is discarded — the API paths are this server's business, and a
+* pasted `/protect/dashboard` URL would otherwise be prefixed onto every call.
+*
+* `https` is forced: UniFi OS redirects plain HTTP, and following that redirect
+* would send the session cookie over cleartext on the first hop.
+*/
+const normalizeBaseUrl = (raw) => {
+	const trimmedRaw = raw.trim().replace(/\/+$/, "");
+	const withScheme = /^https?:\/\//i.test(trimmedRaw) ? trimmedRaw : `https://${trimmedRaw}`;
+	return `https://${new URL(withScheme).host}`;
+};
+const parseBool = (value) => {
+	const t = trimmed(value);
+	if (t === void 0) return void 0;
+	return [
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(t.toLowerCase());
+};
+const parseIntOpt = (value) => {
+	if (value === void 0 || value.trim() === "") return void 0;
+	const n = Number(value);
+	return Number.isInteger(n) ? n : void 0;
+};
+/** Maps "" to undefined, so an empty env var means "unset" rather than "empty". */
+const trimmed = (value) => {
+	const t = value?.trim();
+	return t ? t : void 0;
+};
+const message = (err) => err instanceof Error ? err.message : String(err);
+/** `readFileSync` does not expand `~`, but it is the natural thing to write in a config file. */
+const expandTilde = (path) => path === "~" || path.startsWith("~/") ? join(homedir(), path.slice(1)) : path;
+/**
+* Where the config file lives, most specific first: an explicit override, then
+* the XDG location, then the conventional `~/.config`.
+*/
+const resolveConfigPath = (env = process.env) => {
+	const explicit = trimmed(env.UNIFI_PROTECT_CONFIG);
+	if (explicit) return expandTilde(explicit);
+	const base = trimmed(env.XDG_CONFIG_HOME) ?? join(homedir(), ".config");
+	return join(expandTilde(base), "unifi-protect", "config.json");
+};
+/** The session file sits beside the config file unless told otherwise. */
+const resolveSessionPath = (env = process.env) => join(dirname(resolveConfigPath(env)), "session.json");
+/**
+* The session file holds a live console cookie, so being readable by other
+* users is worth saying out loud. A warning and not an error: refusing to start
+* would be a worse trade for someone on a single-user machine.
+*/
+const warnIfGroupReadable = (path) => {
+	if (process.platform === "win32") return;
+	try {
+		if (statSync(path).mode & 63) process.stderr.write(`[unifi-protect] ${path} is readable by other users. Run: chmod 600 ${path}\n`);
+	} catch {}
+};
+/**
+* Read the config file, treating "absent" as "contributes nothing". Every other
+* failure throws and names the path, so a malformed file is never mistaken for
+* a missing one — that confusion sends you hunting for credentials that were
+* sitting right there.
+*/
+const readConfigFile = (path) => {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") return {};
+		throw new Error(`Could not read the config file (${path}): ${message(err)}`, { cause: err });
+	}
+	warnIfGroupReadable(path);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (err) {
+		throw new Error(`The config file (${path}) is not valid JSON: ${message(err)}`, { cause: err });
+	}
+	const result = FileConfigSchema.safeParse(parsed);
+	if (!result.success) {
+		const issues = result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+		throw new Error(`The config file (${path}) is not valid: ${issues}`);
+	}
+	return result.data;
+};
+/**
+* Environment first, config file second, **per field** — not whole-source.
+* Docker and CI inject the environment and must keep working untouched, while a
+* one-off `UNIFI_PROTECT_ALLOW_WRITES=0` still has to override a file that says
+* `true`. Merging field by field is the only rule that gives both.
+*/
+const loadConfig = (env = process.env, configPath = resolveConfigPath(env)) => {
+	const file = readConfigFile(configPath);
+	const host = trimmed(env.UNIFI_PROTECT_HOST) ?? file.host;
+	const sessionFile = trimmed(env.UNIFI_PROTECT_SESSION_FILE) ?? file.sessionFile ?? resolveSessionPath(env);
+	const snapshotDir = trimmed(env.UNIFI_PROTECT_SNAPSHOT_DIR) ?? file.snapshotDir ?? join(homedir(), ".cache", "unifi-protect");
+	return ConfigSchema.parse({
+		baseUrl: host ? normalizeBaseUrl(host) : void 0,
+		username: trimmed(env.UNIFI_PROTECT_USERNAME) ?? file.username,
+		password: trimmed(env.UNIFI_PROTECT_PASSWORD) ?? file.password,
+		totp: trimmed(env.UNIFI_PROTECT_TOTP),
+		verifyTls: parseBool(env.UNIFI_PROTECT_VERIFY_TLS) ?? file.verifyTls,
+		allowWrites: parseBool(env.UNIFI_PROTECT_ALLOW_WRITES) ?? file.allowWrites,
+		sessionFile: expandTilde(sessionFile),
+		snapshotDir: expandTilde(snapshotDir),
+		maxRetries: parseIntOpt(env.UNIFI_PROTECT_MAX_RETRIES) ?? file.maxRetries,
+		maxDownloadBytes: parseIntOpt(env.UNIFI_PROTECT_MAX_DOWNLOAD_BYTES) ?? file.maxDownloadBytes,
+		deviceCacheTtlSeconds: parseIntOpt(env.UNIFI_PROTECT_DEVICE_CACHE_TTL) ?? file.deviceCacheTtlSeconds
+	});
+};
+/** True once the server has everything it needs to reach a console. */
+const isConfigured = (config) => Boolean(config.baseUrl && config.username && config.password);
+/**
+* Returned by unifi_protect_auth_status and printed to stderr at startup. Prose
+* rather than a code, because this is the text someone acts on when nothing
+* works — and the server can no longer signal it by refusing to start.
+*/
+const setupInstructions = (config) => {
+	if (isConfigured(config)) return [];
+	return [
+		"No UniFi Protect console is configured, so only unifi_protect_auth_status is registered.",
+		"Set UNIFI_PROTECT_HOST to your console's address — the IP or hostname of the UDM Pro, UNVR or Cloud Key, e.g. 192.168.1.1 (https:// is assumed, and a :port is preserved).",
+		"Set UNIFI_PROTECT_USERNAME and UNIFI_PROTECT_PASSWORD to a console login.",
+		"Create a dedicated LOCAL user for this rather than reusing your own: UniFi OS → Settings → Admins & Users → Add User → Local Access Only, and give it Protect permissions only. A Ubiquiti cloud (SSO) account may fail local login entirely, and a local account keeps the blast radius to Protect.",
+		"Give that user View-Only rights unless you intend to set UNIFI_PROTECT_ALLOW_WRITES=1 — with writes off the mutating tools are not registered at all, so they cannot be called.",
+		"If the account has 2FA, pass a current code once via unifi_protect_auth_login; the session is then cached and reused. A code in UNIFI_PROTECT_TOTP expires in about 30 seconds, so it is no use for an unattended start.",
+		"Certificate verification is ON by default. A console reached by IP can never pass it: the certificate is self-signed AND has no IP SAN. Either set UNIFI_PROTECT_HOST to a host name that resolves to the console and point NODE_EXTRA_CA_CERTS at its certificate, or set UNIFI_PROTECT_VERIFY_TLS=false, which is scoped to this server's requests only. Set it to true only if you installed a certificate your machine already trusts."
+	];
+};
+//#endregion
+//#region src/client/errors.ts
+/** A non-2xx answer from the console. */
+var ProtectApiError = class extends Error {
+	name = "ProtectApiError";
+	status;
+	/** The request path, so an error names what failed without a stack trace. */
+	path;
+	errors;
+	constructor(message, opts) {
+		super(message);
+		this.status = opts.status;
+		this.path = opts.path;
+		this.errors = opts.errors;
+	}
+};
+/** The console rejected the credentials, or 2FA is required and was not supplied. */
+var ProtectAuthError = class extends Error {
+	name = "ProtectAuthError";
+	/** True when the console asked for a 2FA code rather than refusing the password. */
+	needsTwoFactor;
+	constructor(message, opts = {}) {
+		super(message);
+		this.needsTwoFactor = opts.needsTwoFactor ?? false;
+	}
+};
+/** Thrown when a write path is reached while UNIFI_PROTECT_ALLOW_WRITES is off. */
+var WritesDisabledError = class extends Error {
+	name = "WritesDisabledError";
+	constructor(what) {
+		super(`${what} is a write operation, but writes are disabled. Set UNIFI_PROTECT_ALLOW_WRITES=1 to register the mutating tools.`);
+	}
+};
+/** Thrown when the server is asked to reach a console it has no credentials for. */
+var NotConfiguredError = class extends Error {
+	name = "NotConfiguredError";
+	constructor() {
+		super("No UniFi Protect console is configured. Call unifi_protect_auth_status for the setup steps.");
+	}
+};
+//#endregion
+//#region src/client/session-store.ts
+/** Load a persisted session, or undefined if none / unreadable / not JSON. */
+const loadSession = async (path) => {
+	try {
+		const raw = await readFile(path, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed.cookie || !parsed.csrfToken || !parsed.baseUrl || !parsed.username) return;
+		return parsed;
+	} catch {
+		return;
+	}
+};
+/** Persist a session with owner-only permissions. */
+const saveSession = async (path, session) => {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify(session, null, 2), { mode: 384 });
+	await chmod(path, 384);
+};
+/** Remove a persisted session. Absent is success — logout is idempotent. */
+const clearSession = async (path) => {
+	try {
+		await unlink(path);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+};
+//#endregion
+//#region src/client/auth.ts
+/**
+* Read one header, collapsing undici's `string | string[] | undefined` shape.
+* Multi-value headers (the Set-Cookie shape) collapse to their first entry,
+* which is all the handshake needs — the session is a single cookie.
+*/
+const header = (res, name) => res.headers.get(name) ?? void 0;
+/**
+* Keep only the `TOKEN=value` pair, dropping the cookie's attributes (Path,
+* Expires, HttpOnly, …). Sending those attributes back on a request header is
+* malformed and the console rejects the session.
+*/
+const bareCookie = (setCookie) => {
+	const semicolon = setCookie.indexOf(";");
+	return semicolon === -1 ? setCookie : setCookie.slice(0, semicolon);
+};
+/**
+* Whether a login response is asking for a second factor rather than refusing
+* the password. Protect answers 499 for this; some firmwares use a 401 with a
+* body naming the requirement, so both are probed.
+*/
+const isTwoFactorChallenge = (status, body) => status === 499 || /2fa|two[- ]factor|mfa|otp/i.test(body);
+const createSessionProvider = (opts) => {
+	const { config } = opts;
+	const fetchImpl = opts.fetch ?? fetch;
+	const logger = opts.logger;
+	let session;
+	let source = "none";
+	let inflight;
+	let restored = false;
+	const requireCredentials = () => {
+		if (!config.baseUrl || !config.username || !config.password) throw new ProtectAuthError("No console credentials are configured. Call unifi_protect_auth_status for the setup steps.");
+		return {
+			baseUrl: config.baseUrl,
+			username: config.username,
+			password: config.password
+		};
+	};
+	/**
+	* Fetch a CSRF token from the console root. UniFi OS gates login behind CSRF
+	* protection, so a first login on a cold start has nothing to present until
+	* this runs.
+	*/
+	const fetchCsrfToken = async (baseUrl) => {
+		try {
+			const res = await fetchImpl(baseUrl, {
+				method: "GET",
+				redirect: "manual"
+			});
+			return header(res, "x-csrf-token");
+		} catch (err) {
+			logger?.debug?.(`could not prefetch a CSRF token: ${String(err)}`);
+			return;
+		}
+	};
+	/** Run the UniFi OS handshake and return a complete session. */
+	const handshake = async (totp) => {
+		const { baseUrl, username, password } = requireCredentials();
+		const url = `${baseUrl}${LOGIN_PATH}`;
+		const code = totp ?? config.totp;
+		const attempt = async (csrf) => fetchImpl(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json",
+				...csrf ? { "x-csrf-token": csrf } : {}
+			},
+			body: JSON.stringify({
+				username,
+				password,
+				...code ? { token: code } : {},
+				rememberMe: true
+			}),
+			redirect: "manual"
+		});
+		logger?.debug?.(`logging in to ${baseUrl} as ${username}`);
+		let res = await attempt(session?.csrfToken);
+		if (!res.ok && !session?.csrfToken) {
+			const csrf = await fetchCsrfToken(baseUrl);
+			if (csrf) {
+				logger?.debug?.("retrying login with a freshly fetched CSRF token");
+				res = await attempt(csrf);
+			}
+		}
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			if (isTwoFactorChallenge(res.status, body)) throw new ProtectAuthError("The console requires a two-factor code. Call unifi_protect_auth_login with a current code from your authenticator app — the session is cached afterwards, so this is a one-off.", { needsTwoFactor: true });
+			throw new ProtectAuthError(`Login to ${baseUrl} as ${username} failed: HTTP ${res.status} ${res.statusText}. Check the username and password, and note that a Ubiquiti cloud (SSO) account often cannot log in locally — create a Local Access Only user instead.`);
+		}
+		const csrfToken = header(res, "x-updated-csrf-token") ?? header(res, "x-csrf-token");
+		const setCookie = res.headers.getSetCookie()[0] ?? header(res, "set-cookie");
+		if (!csrfToken || !setCookie) throw new ProtectAuthError(`Login to ${baseUrl} succeeded (HTTP ${res.status}) but returned no ${!setCookie ? "session cookie" : "CSRF token"}. This usually means the host is not a UniFi OS console — check UNIFI_PROTECT_HOST points at the console itself, not at a reverse proxy in front of it.`);
+		const next = {
+			cookie: bareCookie(setCookie),
+			csrfToken,
+			baseUrl,
+			username,
+			savedAt: new Date(opts.now?.() ?? Date.now()).toISOString()
+		};
+		await saveSession(config.sessionFile, next).catch((err) => {
+			logger?.warn?.(`could not persist the session to ${config.sessionFile}: ${String(err)}`);
+		});
+		return next;
+	};
+	/**
+	* Reuse a session from disk when it belongs to the console and account we are
+	* configured for. A session for a different host or user is not merely
+	* useless, it would authenticate as the wrong identity.
+	*/
+	const restore = async () => {
+		if (restored) return void 0;
+		restored = true;
+		const persisted = await loadSession(config.sessionFile);
+		if (!persisted) return void 0;
+		if (persisted.baseUrl !== config.baseUrl || persisted.username !== config.username) {
+			logger?.debug?.("ignoring a persisted session issued for a different console or user");
+			return;
+		}
+		logger?.debug?.(`restored a session from ${config.sessionFile}`);
+		return persisted;
+	};
+	const ensure = async (totp) => {
+		if (session) return session;
+		const fromDisk = await restore();
+		if (fromDisk) {
+			session = fromDisk;
+			source = "restored";
+			return session;
+		}
+		if (!inflight) inflight = handshake(totp).finally(() => {
+			inflight = void 0;
+		});
+		session = await inflight;
+		source = "login";
+		return session;
+	};
+	return {
+		async headers() {
+			const live = await ensure();
+			return {
+				cookie: live.cookie,
+				"x-csrf-token": live.csrfToken
+			};
+		},
+		invalidate() {
+			session = void 0;
+			restored = true;
+		},
+		async login(totp) {
+			session = void 0;
+			restored = true;
+			session = await handshake(totp);
+			source = "login";
+			return this.describe();
+		},
+		async logout() {
+			session = void 0;
+			restored = true;
+			source = "none";
+			await clearSession(config.sessionFile);
+		},
+		describe() {
+			return {
+				authenticated: session !== void 0,
+				source,
+				username: session?.username ?? config.username,
+				savedAt: session?.savedAt
+			};
+		}
+	};
+};
+/** For tests: fixed headers, no network, no disk. */
+const staticSessionProvider = (headers = {
+	cookie: "TOKEN=test",
+	"x-csrf-token": "csrf-test"
+}) => ({
+	headers: async () => headers,
+	invalidate: () => {},
+	login: async () => ({
+		authenticated: true,
+		source: "login",
+		username: "test",
+		savedAt: void 0
+	}),
+	logout: async () => {},
+	describe: () => ({
+		authenticated: true,
+		source: "login",
+		username: "test",
+		savedAt: void 0
+	})
+});
+//#endregion
+//#region src/client/shape.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const str = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+/** Apply a summarizer across an array, passing non-arrays through untouched. */
+const summarizeEach = (value, fn) => Array.isArray(value) ? value.filter(isRecord).map(fn) : value;
+/**
+* Protect timestamps are milliseconds since the Unix epoch. Rendering them as
+* ISO 8601 costs a few characters and saves the model from having to reason
+* about a bare 13-digit integer — which it does get wrong, usually by reading
+* it as seconds and landing in 1970.
+*/
+const isoTime = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+	return new Date(value).toISOString();
+};
+const buildNameIndex = (devices) => {
+	const index = /* @__PURE__ */ new Map();
+	if (!Array.isArray(devices)) return index;
+	for (const device of devices) {
+		if (!isRecord(device)) continue;
+		const id = str(device.id);
+		const name = str(device.name);
+		if (id && name) index.set(id, name);
+	}
+	return index;
+};
+const summarizeCamera = (camera) => {
+	const flags = isRecord(camera.featureFlags) ? camera.featureFlags : {};
+	const recording = isRecord(camera.recordingSettings) ? camera.recordingSettings : {};
+	const smart = isRecord(camera.smartDetectSettings) ? camera.smartDetectSettings : {};
+	return {
+		id: camera.id,
+		name: camera.name,
+		type: camera.type,
+		mac: camera.mac,
+		host: camera.host,
+		isConnected: camera.isConnected,
+		state: camera.state,
+		isRecording: camera.isRecording,
+		recordingMode: recording.mode,
+		hasPtz: flags.canOpticalZoom ?? flags.hasPtz ?? false,
+		hasPackageCamera: flags.hasPackageCamera ?? false,
+		hasSmartDetect: flags.hasSmartDetect ?? false,
+		smartDetectTypes: smart.objectTypes ?? [],
+		firmwareVersion: camera.firmwareVersion,
+		isUpdating: camera.isUpdating,
+		lastSeen: isoTime(camera.lastSeen)
+	};
+};
+/**
+* Events reference their camera by id. Resolving that to a name server-side is
+* the single most useful thing this layer does: it removes a join the model
+* would otherwise have to perform against a separate camera list, and get
+* silently wrong. The id is kept too, since the write and snapshot tools need it.
+*/
+const summarizeEvent = (event, cameras) => {
+	const cameraId = str(event.camera);
+	const metadata = isRecord(event.metadata) ? event.metadata : void 0;
+	const plate = metadata && isRecord(metadata.licensePlate) ? str(metadata.licensePlate.name) : void 0;
+	return {
+		id: event.id,
+		type: event.type,
+		start: isoTime(event.start),
+		end: isoTime(event.end),
+		...cameraId ? { cameraId } : {},
+		...cameraId && cameras?.get(cameraId) ? { camera: cameras.get(cameraId) } : {},
+		...Array.isArray(event.smartDetectTypes) && event.smartDetectTypes.length > 0 ? { smartDetectTypes: event.smartDetectTypes } : {},
+		...plate ? { licensePlate: plate } : {},
+		...typeof event.score === "number" ? { score: event.score } : {},
+		...str(event.thumbnail) ? { hasThumbnail: true } : {}
+	};
+};
+const summarizeLight = (light) => {
+	const settings = isRecord(light.lightDeviceSettings) ? light.lightDeviceSettings : {};
+	return {
+		id: light.id,
+		name: light.name,
+		isConnected: light.isConnected,
+		isLightOn: light.isLightOn,
+		isPirMotionDetected: light.isPirMotionDetected,
+		ledLevel: settings.ledLevel,
+		isIndicatorEnabled: settings.isIndicatorEnabled,
+		firmwareVersion: light.firmwareVersion,
+		lastSeen: isoTime(light.lastSeen)
+	};
+};
+const summarizeSensor = (sensor) => {
+	const stats = isRecord(sensor.stats) ? sensor.stats : {};
+	const reading = (key) => {
+		const block = stats[key];
+		return isRecord(block) ? block.value : void 0;
+	};
+	return {
+		id: sensor.id,
+		name: sensor.name,
+		type: sensor.type,
+		isConnected: sensor.isConnected,
+		mountType: sensor.mountType,
+		batteryStatus: isRecord(sensor.batteryStatus) ? sensor.batteryStatus.percentage : void 0,
+		isOpened: sensor.isOpened,
+		isMotionDetected: sensor.isMotionDetected,
+		temperature: reading("temperature"),
+		humidity: reading("humidity"),
+		light: reading("light"),
+		firmwareVersion: sensor.firmwareVersion,
+		lastSeen: isoTime(sensor.lastSeen)
+	};
+};
+const summarizeViewer = (viewer) => ({
+	id: viewer.id,
+	name: viewer.name,
+	isConnected: viewer.isConnected,
+	liveview: viewer.liveview,
+	streamLimit: viewer.streamLimit,
+	firmwareVersion: viewer.firmwareVersion,
+	lastSeen: isoTime(viewer.lastSeen)
+});
+const summarizeChime = (chime) => ({
+	id: chime.id,
+	name: chime.name,
+	isConnected: chime.isConnected,
+	volume: chime.volume,
+	cameraIds: chime.cameraIds,
+	firmwareVersion: chime.firmwareVersion,
+	lastSeen: isoTime(chime.lastSeen)
+});
+const summarizeLiveview = (liveview) => ({
+	id: liveview.id,
+	name: liveview.name,
+	isDefault: liveview.isDefault,
+	owner: liveview.owner,
+	slotCount: Array.isArray(liveview.slots) ? liveview.slots.length : void 0
+});
+const summarizeUser = (user) => ({
+	id: user.id,
+	name: user.name,
+	firstName: user.firstName,
+	lastName: user.lastName,
+	email: user.email,
+	role: user.role,
+	isOwner: user.isOwner,
+	lastLoginTime: isoTime(user.lastLoginTime)
+});
+const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const rec = (value) => isRecord(value) ? value : void 0;
+/**
+* Storage moved between Protect releases, so both layouts are read.
+*
+* Protect 6.x exposed `nvr.storageInfo` with `totalSize` / `totalSpaceUsed` and a
+* `devices[]` array carrying full SMART tables. By 7.2 that key is gone entirely:
+* the same numbers live under `nvr.systemInfo.storage` as `size` / `used` /
+* `available`, the per-disk detail moved to `systemInfo.ustorage.disks`, and a
+* separate `nvr.storageStats` carries utilization. Reading only one shape gives
+* an empty `storage: {}` on the other, which is how this was found.
+*/
+const summarizeStorage = (nvr) => {
+	const system = rec(nvr.systemInfo);
+	const modern = rec(system?.storage);
+	const legacy = rec(nvr.storageInfo);
+	const stats = rec(nvr.storageStats);
+	const ustorage = rec(system?.ustorage);
+	const disks = Array.isArray(ustorage?.disks) ? ustorage.disks.filter(isRecord) : void 0;
+	const total = num(modern?.size) ?? num(legacy?.totalSize);
+	const used = num(modern?.used) ?? num(legacy?.totalSpaceUsed);
+	const available = num(modern?.available) ?? (total !== void 0 && used !== void 0 ? total - used : void 0);
+	return {
+		...total !== void 0 ? { totalBytes: total } : {},
+		...used !== void 0 ? { usedBytes: used } : {},
+		...available !== void 0 ? { availableBytes: available } : {},
+		...num(stats?.utilization) !== void 0 ? { utilizationPercent: Math.round(stats.utilization * 10) / 10 } : {},
+		...str(modern?.type) ? { type: modern.type } : {},
+		...str(ustorage?.raid) ? { raid: ustorage.raid } : {},
+		...str(modern?.capability) ?? str(nvr.hardDriveState) ? { health: modern?.capability ?? nvr.hardDriveState } : {},
+		...disks ? {
+			disks: disks.length,
+			disksUnhealthy: disks.filter((d) => d.healthy !== void 0 && d.healthy !== "good").length
+		} : {},
+		...nvr.isRecycling === true ? {
+			isRecycling: true,
+			note: "Near-full with recycling on is normal: the console overwrites the oldest footage continuously rather than stopping."
+		} : {}
+	};
+};
+const summarizeNvr = (nvr) => {
+	const system = rec(nvr.systemInfo);
+	const memory = rec(system?.memory);
+	const cpu = rec(system?.cpu);
+	const upSince = num(nvr.upSince);
+	return {
+		id: nvr.id,
+		name: nvr.name,
+		host: nvr.host,
+		type: nvr.type,
+		version: nvr.version,
+		firmwareVersion: nvr.firmwareVersion,
+		...str(nvr.marketName) ? { model: nvr.marketName } : {},
+		timezone: nvr.timezone,
+		isRecordingDisabled: nvr.isRecordingDisabled,
+		storage: summarizeStorage(nvr),
+		...memory ? { memory: {
+			available: memory.available,
+			total: memory.total
+		} } : {},
+		...cpu ? { cpu: {
+			load: cpu.averageLoad,
+			temperature: cpu.temperature
+		} } : {},
+		...upSince !== void 0 ? {
+			upSince: new Date(upSince).toISOString(),
+			uptimeSeconds: Math.round((Date.now() - upSince) / 1e3)
+		} : num(nvr.uptime) !== void 0 ? { uptimeSeconds: Math.round(nvr.uptime / 1e3) } : {},
+		lastSeen: isoTime(nvr.lastSeen)
+	};
+};
+/**
+* The bootstrap document is the entire console state and must never be returned
+* raw — it is the single largest context bomb this API offers. This reduces it
+* to the NVR summary plus per-type counts, which is what "tell me about my
+* system" actually wants.
+*/
+const summarizeBootstrap = (bootstrap) => {
+	const count = (key) => Array.isArray(bootstrap[key]) ? bootstrap[key].length : 0;
+	return {
+		nvr: isRecord(bootstrap.nvr) ? summarizeNvr(bootstrap.nvr) : void 0,
+		devices: {
+			cameras: count("cameras"),
+			lights: count("lights"),
+			sensors: count("sensors"),
+			viewers: count("viewers"),
+			chimes: count("chimes"),
+			bridges: count("bridges"),
+			doorlocks: count("doorlocks")
+		},
+		liveviews: count("liveviews"),
+		users: count("users"),
+		lastUpdateId: bootstrap.lastUpdateId
+	};
+};
+//#endregion
+//#region src/client/device-cache.ts
+const createDeviceCache = (opts) => {
+	const now = opts.now ?? Date.now;
+	const ttlMs = opts.ttlSeconds * 1e3;
+	let cached;
+	let inflight;
+	const fetchIndex = async () => {
+		const cameras = await opts.client.get("cameras");
+		const index = buildNameIndex(cameras);
+		cached = {
+			index,
+			expiresAt: now() + ttlMs
+		};
+		return index;
+	};
+	return {
+		async cameras() {
+			if (cached && now() < cached.expiresAt) return cached.index;
+			if (!inflight) inflight = fetchIndex().finally(() => {
+				inflight = void 0;
+			});
+			try {
+				return await inflight;
+			} catch {
+				return /* @__PURE__ */ new Map();
+			}
+		},
+		invalidate() {
+			cached = void 0;
+		}
+	};
+};
+//#endregion
+//#region src/client/protect.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const backoffMs = (attempt) => Math.min(1e3 * 2 ** attempt, 8e3);
+const retryAfterMs = (res) => {
+	const value = res.headers.get("Retry-After");
+	if (value === null) return void 0;
+	const seconds = Number(value);
+	return Number.isFinite(seconds) ? Math.max(seconds, 0) * 1e3 : void 0;
+};
+const safeJsonParse = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+const buildQuery = (query) => {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) params.append(key, item);
+		else params.append(key, String(value));
+	}
+	const qs = params.toString();
+	return qs ? `?${qs}` : "";
+};
+/**
+* The private Protect API client. Every path passed in is relative to
+* `/proxy/protect/api` — callers write `cameras/abc123`, not the full path.
+*/
+var ProtectClient = class {
+	baseUrl;
+	session;
+	maxRetries;
+	userAgent;
+	maxDownloadBytes;
+	fetchImpl;
+	logger;
+	constructor(opts) {
+		this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+		this.session = opts.session;
+		this.maxRetries = opts.maxRetries;
+		this.userAgent = opts.userAgent;
+		this.maxDownloadBytes = opts.maxDownloadBytes;
+		this.fetchImpl = opts.fetch ?? fetch;
+		this.logger = opts.logger;
+	}
+	/** Absolute URL for a path relative to the private API root. */
+	url(path, query) {
+		const clean = path.replace(/^\/+/, "");
+		return `${this.baseUrl}${PRIVATE_API_PATH}/${clean}${buildQuery(query)}`;
+	}
+	/**
+	* Perform one authenticated request, retrying on 401 (re-login), 429 and 5xx.
+	* Returns the raw Response so callers can decide between JSON and bytes.
+	*/
+	async send(method, url, opts = {}) {
+		const hasBody = opts.body !== void 0;
+		const bodyText = hasBody ? JSON.stringify(opts.body) : void 0;
+		let attempt = 0;
+		for (;;) {
+			const auth = await this.session.headers();
+			this.logger?.debug?.(`${method} ${url} (attempt ${attempt + 1})`);
+			const res = await this.fetchImpl(url, {
+				method,
+				headers: {
+					...auth,
+					Accept: opts.accept ?? "application/json",
+					"User-Agent": this.userAgent,
+					...hasBody ? { "Content-Type": "application/json" } : {}
+				},
+				...bodyText !== void 0 ? { body: bodyText } : {},
+				redirect: "manual"
+			});
+			if (res.status === 401 && attempt < this.maxRetries) {
+				this.logger?.warn?.("HTTP 401 — re-authenticating and retrying");
+				this.session.invalidate();
+				attempt += 1;
+				continue;
+			}
+			if ((res.status === 429 || res.status >= 500) && attempt < this.maxRetries) {
+				const delay = retryAfterMs(res) ?? backoffMs(attempt);
+				this.logger?.warn?.(`HTTP ${res.status} — retrying in ${delay}ms`);
+				await sleep(delay);
+				attempt += 1;
+				continue;
+			}
+			return res;
+		}
+	}
+	/** A JSON request against the private API. */
+	async request(method, path, opts = {}) {
+		const url = this.url(path, opts.query);
+		const res = await this.send(method, url, opts.body !== void 0 ? { body: opts.body } : {});
+		const text = await res.text();
+		if (!res.ok) throw new ProtectApiError(this.errorMessage(res, method, path, text), {
+			status: res.status,
+			path,
+			errors: safeJsonParse(text)
+		});
+		if (res.status === 204 || text.trim() === "") return null;
+		return safeJsonParse(text);
+	}
+	get(path, query) {
+		return this.request("GET", path, query ? { query } : {});
+	}
+	post(path, body, query) {
+		return this.request("POST", path, {
+			...body !== void 0 ? { body } : {},
+			...query ? { query } : {}
+		});
+	}
+	patch(path, body, query) {
+		return this.request("PATCH", path, {
+			...body !== void 0 ? { body } : {},
+			...query ? { query } : {}
+		});
+	}
+	del(path, query) {
+		return this.request("DELETE", path, query ? { query } : {});
+	}
+	/**
+	* Fetch a binary asset — a snapshot JPEG, an event thumbnail, an exported
+	* MP4. Size is checked against `maxDownloadBytes` from Content-Length where
+	* the console supplies one, and again after reading where it does not, so an
+	* unexpectedly huge export fails with a clear message rather than by
+	* exhausting the heap.
+	*/
+	async requestBytes(path, opts = {}) {
+		const url = this.url(path, opts.query);
+		const res = await this.send("GET", url, { accept: opts.accept ?? "application/octet-stream" });
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new ProtectApiError(this.errorMessage(res, "GET", path, text), {
+				status: res.status,
+				path,
+				errors: safeJsonParse(text)
+			});
+		}
+		const declared = Number(res.headers.get("Content-Length"));
+		if (Number.isFinite(declared) && declared > this.maxDownloadBytes) throw new ProtectApiError(`${path} would return ${declared} bytes, over the ${this.maxDownloadBytes}-byte limit. Narrow the time range, or raise UNIFI_PROTECT_MAX_DOWNLOAD_BYTES.`, {
+			status: res.status,
+			path
+		});
+		const bytes = new Uint8Array(await res.arrayBuffer());
+		if (bytes.byteLength > this.maxDownloadBytes) throw new ProtectApiError(`${path} returned ${bytes.byteLength} bytes, over the ${this.maxDownloadBytes}-byte limit. Narrow the time range, or raise UNIFI_PROTECT_MAX_DOWNLOAD_BYTES.`, {
+			status: res.status,
+			path
+		});
+		return {
+			bytes,
+			contentType: res.headers.get("Content-Type") ?? "application/octet-stream"
+		};
+	}
+	/** Status-aware prose, because this is the text someone acts on. */
+	errorMessage(res, method, path, body) {
+		const detail = safeJsonParse(body);
+		const upstream = typeof detail === "object" && detail !== null && "error" in detail ? String(detail.error) : typeof detail === "string" && detail.length > 0 && detail.length < 200 ? detail : void 0;
+		const base = `Protect ${method} ${path} failed: HTTP ${res.status} ${res.statusText}`.trim() + (upstream ? ` — ${upstream}` : "");
+		if (res.status === 401 || res.status === 403) return `${base}. The account may lack Protect permissions for this device, or may be view-only while this call needs write access.`;
+		if (res.status === 404) return `${base}. Check the id came from a list tool on THIS console. Note also that the private Protect API is undocumented and Ubiquiti moves endpoints between releases — unifi_protect_get_system_info reports the version actually running.`;
+		if (res.status >= 300 && res.status < 400) return `${base}. The console redirected the request, which usually means the session was rejected.`;
+		return base;
+	}
+};
+//#endregion
+//#region src/client/tls.ts
+/**
+* The one place TLS is decided.
+*
+* UniFi consoles ship a self-signed certificate, and Node's native `fetch`
+* ignores a `node:https` Agent — the only scoped way to relax verification is an
+* undici dispatcher. That is why this server carries a third runtime dependency:
+* the alternative, NODE_TLS_REJECT_UNAUTHORIZED=0, is process-global and
+* disables verification for every other request the process ever makes.
+*
+* This replaced exactly that process-wide switch, which had been adopted on the
+* belief that undici could not be imported and a dispatcher therefore could not
+* be scoped. It can — see below.
+*
+* **The `fetch` here must be undici's own, not the global one.** Node's built-in
+* fetch is a *bundled copy* of undici, and it rejects a dispatcher constructed
+* from the separately-installed package with a bare `UND_ERR_INVALID_ARG`,
+* surfacing as an unexplained "fetch failed". Passing undici's own fetch keeps
+* both sides on one class. Verification is on by default, so the platform fetch
+* remains the common path.
+*
+* Note what a pinned certificate can and cannot fix. These consoles present
+* `CN=unifi.local` with SANs for `unifi.local`, `localhost` and `127.0.0.1` —
+* and **no IP SAN**. Reached by IP, verification fails on the host name however
+* the certificate is trusted. Measured with `curl --cacert`: by host name
+* `ssl_verify=0`, by IP `ssl_verify=1`. So verifying requires BOTH
+* NODE_EXTRA_CA_CERTS and a host name that resolves to the console.
+*/
+const createHttpFetch = (opts) => {
+	if (!opts.insecureTls) return fetch;
+	opts.logger?.warn?.("TLS certificate verification is DISABLED for this server's requests (UNIFI_PROTECT_VERIFY_TLS=false). To verify instead, address the console by a host name that resolves to it — its certificate has no IP SAN — and point NODE_EXTRA_CA_CERTS at the console's certificate.");
+	const dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+	return ((input, init) => fetch$1(input, {
+		...init,
+		dispatcher
+	}));
+};
+//#endregion
+//#region src/tools/util.ts
+const ok = (data) => ({ content: [{
+	type: "text",
+	text: JSON.stringify(data ?? { ok: true }, null, 2)
+}] });
+const fail = (message, extra) => ({
+	content: [{
+		type: "text",
+		text: JSON.stringify({
+			error: message,
+			...extra ? { details: extra } : {}
+		}, null, 2)
+	}],
+	isError: true
+});
+/** Render a thrown value as a tool error, preserving upstream detail. */
+const toFailure = (err) => {
+	if (err instanceof ProtectApiError) return fail(err.message, {
+		status: err.status,
+		...err.path ? { path: err.path } : {},
+		errors: err.errors
+	});
+	if (err instanceof ProtectAuthError) return fail(err.message, err.needsTwoFactor ? { needsTwoFactor: true } : void 0);
+	if (err instanceof WritesDisabledError || err instanceof NotConfiguredError) return fail(err.message);
+	if (err instanceof Error) return fail(err.message);
+	return fail("Unknown error", err);
+};
+/** Run a tool body, JSON-formatting the result and turning errors into a tool error. */
+const wrap = async (fn) => {
+	try {
+		return ok(await fn());
+	} catch (err) {
+		return toFailure(err);
+	}
+};
+/** Like `wrap`, but the body chooses its own result shape (e.g. an image block). */
+const wrapResult = async (fn) => {
+	try {
+		return await fn();
+	} catch (err) {
+		return toFailure(err);
+	}
+};
+/** Drop undefined values so we never send `{"name": undefined}` to the console. */
+const compact = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+/** `{}` is not a no-op PATCH body — send undefined instead. */
+const compactOrUndefined = (obj) => {
+	const out = compact(obj);
+	return Object.keys(out).length > 0 ? out : void 0;
+};
+const RELATIVE = /^(\d+(?:\.\d+)?)\s*(s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?|w|weeks?)(?:\s+ago)?$/i;
+const UNIT_MS = {
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+/**
+* Convert a time expression to milliseconds since the Unix epoch.
+*
+* This exists because the console's `/events` endpoint takes JavaScript
+* millisecond timestamps — not ISO 8601, and NOT Unix seconds. A seconds value
+* is not rejected: it is interpreted as a moment in January 1970, so the query
+* succeeds and returns an empty list. That reads as "nothing happened last
+* night", which is the most expensive possible failure for this server.
+*
+* Accepts ISO 8601, a relative expression like "2h ago" or "30m", the literal
+* "now", or a raw millisecond number.
+*/
+const toEpochMs = (value, now = Date.now()) => {
+	if (typeof value === "number") return Math.round(value);
+	const text = value.trim();
+	if (text === "" || text.toLowerCase() === "now") return now;
+	const relative = RELATIVE.exec(text);
+	if (relative) {
+		const amount = Number(relative[1]);
+		const unit = relative[2].toLowerCase()[0];
+		const scale = UNIT_MS[unit];
+		if (scale === void 0) throw new Error(`Unrecognised time unit in "${value}".`);
+		return Math.round(now - amount * scale);
+	}
+	if (/^\d+$/.test(text)) {
+		const n = Number(text);
+		if (text.length <= 10) throw new Error(`"${value}" looks like Unix SECONDS. This API takes milliseconds — pass ${n * 1e3}, or better, an ISO 8601 timestamp or a relative expression like "2h ago".`);
+		return n;
+	}
+	const parsed = Date.parse(text);
+	if (Number.isNaN(parsed)) throw new Error(`Could not read "${value}" as a time. Use ISO 8601 (2026-08-29T22:00:00Z), a relative expression ("2h ago", "30m", "7d"), or "now".`);
+	return parsed;
+};
+const confirmArg = z.literal(true).describe("Must be true. Explicit acknowledgement that this changes the console's state.");
+const cameraIdArg = z.string().min(1).describe("Camera id — the `id` from unifi_protect_list_cameras, a 24-character hex string. Not the camera's name and not its MAC address.");
+/** The shared prose for every time argument, so the trap is stated everywhere it applies. */
+const timeHelp = (role) => `${role} Accepts ISO 8601 ("2026-08-29T22:00:00Z"), a relative expression ("2h ago", "30m", "7d"), or "now". Converted to the millisecond epoch the console requires — do not pass Unix seconds, which would silently query 1970 and return nothing.`;
+const timeArg = (role) => z.string().optional().describe(timeHelp(role));
+const requiredTimeArg = (role) => z.string().min(1).describe(timeHelp(role));
+const limitArg = z.number().int().min(1).max(500).default(50).describe("Maximum number of items to return (1-500). Defaults to 50. A busy system logs thousands of motion events a day, so raise this deliberately.");
+//#endregion
+//#region src/tools/cameras.ts
+const RECORDING_MODES = [
+	"always",
+	"never",
+	"detections",
+	"schedule"
+];
+/** Filesystem-safe stem for a snapshot file, derived from the camera name. */
+const slug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "camera";
+const registerCameraTools = (server, client, ctx) => {
+	server.registerTool("unifi_protect_list_cameras", {
+		description: "List every camera on the console with its id, name, connection state, recording mode, firmware and what it can do (PTZ, package camera, smart detection, and which object types it detects). Returns a summary rather than the console's full camera record, which runs to thousands of fields across encoder profiles, zones and feature flags — use unifi_protect_get_camera when you need all of it for one camera.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("cameras"), summarizeCamera)));
+	server.registerTool("unifi_protect_get_camera", {
+		description: "Get one camera's complete record — every setting the console holds, including encoder channels, motion and smart-detection zones, privacy masks, OSD and LED settings, ISP tuning and live statistics. This is large (roughly 8-15 KB of JSON). Prefer unifi_protect_list_cameras unless you specifically need a field it does not carry.",
+		inputSchema: { cameraId: cameraIdArg },
+		annotations: { readOnlyHint: true }
+	}, async ({ cameraId }) => wrap(() => client.get(`cameras/${encodeURIComponent(cameraId)}`)));
+	server.registerTool("unifi_protect_get_camera_snapshot", {
+		description: "Capture a still frame from a camera as it looks right now. Writes the JPEG to disk and returns its path, size and content type by default. Set output=\"image\" to get the frame inline instead so a vision model can actually look at it — that costs roughly 300,000 to 700,000 characters of context per call, so choose it deliberately rather than by default. A fresh capture is forced; without that the console can hand back a cached frame that is minutes old.",
+		inputSchema: {
+			cameraId: cameraIdArg,
+			output: z.enum(["file", "image"]).default("file").describe("Where the frame goes. \"file\" writes it to disk and returns the path — cheap, and you can read the file later if it turns out to matter. \"image\" returns it inline for a model to look at, at a large cost in context."),
+			highQuality: z.boolean().default(false).describe("Request the camera's full resolution rather than a scaled frame. Larger and slower; with output=\"image\" it multiplies an already expensive call."),
+			savePath: z.string().optional().describe("Absolute path to write the JPEG to. Defaults to a timestamped file under UNIFI_PROTECT_SNAPSHOT_DIR. Parent directories are created.")
+		},
+		annotations: { readOnlyHint: true }
+	}, async ({ cameraId, output, highQuality, savePath }) => wrapResult(async () => {
+		const { bytes, contentType } = await client.requestBytes(`cameras/${encodeURIComponent(cameraId)}/snapshot`, {
+			query: {
+				force: "true",
+				...highQuality ? { highQuality: "true" } : {},
+				ts: Date.now()
+			},
+			accept: "image/jpeg"
+		});
+		if (output === "image") return { content: [{
+			type: "image",
+			data: Buffer.from(bytes).toString("base64"),
+			mimeType: contentType.startsWith("image/") ? contentType : "image/jpeg"
+		}] };
+		const name = (await ctx.devices.cameras()).get(cameraId) ?? cameraId;
+		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+		const path = savePath ?? join(ctx.config.snapshotDir, `${slug(name)}-${stamp}.jpg`);
+		await mkdir(join(path, ".."), { recursive: true });
+		await writeFile(path, bytes);
+		return ok({
+			path,
+			bytes: bytes.byteLength,
+			contentType,
+			camera: name,
+			capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			note: "Call again with output=\"image\" if a model needs to see the frame itself."
+		});
+	}));
+	server.registerTool("unifi_protect_list_ptz_presets", {
+		description: "List a PTZ camera's saved preset positions, with the slot number each one lives at. Only meaningful for cameras reporting hasPtz: true in unifi_protect_list_cameras. There is no tool to MOVE a PTZ camera or run a patrol: those commands exist only on Ubiquiti's official Integration API (a separate X-API-KEY auth this server does not use), not on the private API this server wraps — presets are created and driven from the Protect app itself.",
+		inputSchema: { cameraId: cameraIdArg },
+		annotations: { readOnlyHint: true }
+	}, async ({ cameraId }) => wrap(() => client.get(`cameras/${encodeURIComponent(cameraId)}/ptz/preset`)));
+	server.registerTool("unifi_protect_list_ptz_patrols", {
+		description: "List a PTZ camera's saved patrol routes. See unifi_protect_list_ptz_presets for why there is no tool to start or stop one.",
+		inputSchema: { cameraId: cameraIdArg },
+		annotations: { readOnlyHint: true }
+	}, async ({ cameraId }) => wrap(() => client.get(`cameras/${encodeURIComponent(cameraId)}/ptz/patrol`)));
+	if (!ctx.allowWrites) return;
+	server.registerTool("unifi_protect_update_camera", {
+		description: "Change a camera's settings in place. Only the fields you pass are sent, and the console merges them — sibling settings inside the same block are preserved, so setting osdDate alone does not clear osdName. Use unifi_protect_set_camera_recording_mode for recording mode alone — it is the setting people mean most often and it is easy to send wrongly here.",
+		inputSchema: {
+			cameraId: cameraIdArg,
+			name: z.string().min(1).optional().describe("Display name shown throughout Protect."),
+			micVolume: z.number().int().min(0).max(100).optional().describe("Microphone sensitivity, 0-100. 0 mutes the microphone."),
+			isMicEnabled: z.boolean().optional().describe("Whether the microphone records at all."),
+			statusLedEnabled: z.boolean().optional().describe("Whether the camera's status LED lights up at all."),
+			osdName: z.boolean().optional().describe("Overlay the camera name on the video."),
+			osdDate: z.boolean().optional().describe("Overlay the date and time on the video.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ cameraId, name, micVolume, isMicEnabled, statusLedEnabled, osdName, osdDate }) => wrap(async () => {
+		const ledSettings = compactOrUndefined({ isEnabled: statusLedEnabled });
+		const osdSettings = compactOrUndefined({
+			isNameEnabled: osdName,
+			isDateEnabled: osdDate
+		});
+		const body = compactOrUndefined({
+			name,
+			micVolume,
+			isMicEnabled,
+			ledSettings,
+			osdSettings
+		});
+		if (!body) throw new Error("Nothing to update — pass at least one of name, micVolume, isMicEnabled, statusLedEnabled, osdName, osdDate.");
+		return summarizeCamera(await client.patch(`cameras/${encodeURIComponent(cameraId)}`, body));
+	}));
+	server.registerTool("unifi_protect_set_camera_recording_mode", {
+		description: "Set what a camera records. `never` stops recording entirely — the camera stays online and streams live, but nothing is written, so there will be no footage to search later. `detections` records only motion and smart detections; `always` records continuously; `schedule` follows the schedule configured in Protect.",
+		inputSchema: {
+			cameraId: cameraIdArg,
+			mode: z.enum(RECORDING_MODES).describe("Recording mode. `never` means no footage is kept from now on — this is the one worth pausing over.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ cameraId, mode }) => wrap(async () => summarizeCamera(await client.patch(`cameras/${encodeURIComponent(cameraId)}`, { recordingSettings: { mode } }))));
+	server.registerTool("unifi_protect_reboot_camera", {
+		description: "Reboot a camera. It stops recording and goes offline for roughly a minute, and any footage during that window is lost. Useful for a camera that has stopped responding.",
+		inputSchema: {
+			cameraId: cameraIdArg,
+			confirm: confirmArg
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false
+		}
+	}, async ({ cameraId }) => wrap(() => client.post(`cameras/${encodeURIComponent(cameraId)}/reboot`)));
+};
+//#endregion
+//#region src/tools/devices.ts
+const idArg = (kind, listTool) => z.string().min(1).describe(`${kind} id — the \`id\` from ${listTool}.`);
+const registerDeviceTools = (server, client, ctx) => {
+	server.registerTool("unifi_protect_list_lights", {
+		description: "List UniFi Protect floodlights with their connection state, whether the light is currently on, whether PIR motion is being detected, and brightness.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("lights"), summarizeLight)));
+	server.registerTool("unifi_protect_list_sensors", {
+		description: "List UniFi Protect sensors with their current readings — temperature, humidity, light level — plus open/closed state, motion, and battery percentage. The readings are lifted out of the console's per-metric history arrays, which are far larger than the values themselves.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("sensors"), summarizeSensor)));
+	server.registerTool("unifi_protect_list_viewers", {
+		description: "List UniFi Protect Viewport devices and which live view each is currently displaying.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("viewers"), summarizeViewer)));
+	server.registerTool("unifi_protect_list_chimes", {
+		description: "List UniFi Protect chimes, their volume, and which doorbell cameras each is paired to.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("chimes"), summarizeChime)));
+	if (!ctx.allowWrites) return;
+	server.registerTool("unifi_protect_update_light", {
+		description: "Change a floodlight's settings — brightness, whether the light is on, and the PIR sensitivity that decides when it triggers. Only the fields you pass are sent, and the console merges them, so the PIR duration and lux sensitivity you do not pass survive.",
+		inputSchema: {
+			lightId: idArg("Light", "unifi_protect_list_lights"),
+			isLightOn: z.boolean().optional().describe("Turn the light on or off right now."),
+			ledLevel: z.number().int().min(1).max(6).optional().describe("Brightness, 1 (dimmest) to 6 (brightest)."),
+			pirSensitivity: z.number().int().min(0).max(100).optional().describe("Motion sensitivity, 0-100. Higher triggers on smaller movement.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ lightId, isLightOn, ledLevel, pirSensitivity }) => wrap(async () => {
+		const lightOnSettings = compactOrUndefined({ isLedForceOn: isLightOn });
+		const lightDeviceSettings = compactOrUndefined({
+			ledLevel,
+			pirSensitivity
+		});
+		const body = compactOrUndefined({
+			lightOnSettings,
+			lightDeviceSettings
+		});
+		if (!body) throw new Error("Nothing to update — pass at least one of isLightOn, ledLevel, pirSensitivity.");
+		return summarizeLight(await client.patch(`lights/${encodeURIComponent(lightId)}`, body));
+	}));
+	server.registerTool("unifi_protect_update_sensor", {
+		description: "Rename a sensor or change which of its capabilities are enabled. Only the fields you pass are sent.",
+		inputSchema: {
+			sensorId: idArg("Sensor", "unifi_protect_list_sensors"),
+			name: z.string().min(1).optional().describe("Display name for the sensor."),
+			motionEnabled: z.boolean().optional().describe("Whether motion detection reports events."),
+			temperatureEnabled: z.boolean().optional().describe("Whether temperature is reported."),
+			humidityEnabled: z.boolean().optional().describe("Whether humidity is reported."),
+			lightEnabled: z.boolean().optional().describe("Whether the light level is reported.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ sensorId, name, motionEnabled, temperatureEnabled, humidityEnabled, lightEnabled }) => wrap(async () => {
+		const body = compactOrUndefined({
+			name,
+			motionSettings: compactOrUndefined({ isEnabled: motionEnabled }),
+			temperatureSettings: compactOrUndefined({ isEnabled: temperatureEnabled }),
+			humiditySettings: compactOrUndefined({ isEnabled: humidityEnabled }),
+			lightSettings: compactOrUndefined({ isEnabled: lightEnabled })
+		});
+		if (!body) throw new Error("Nothing to update — pass at least one of name, motionEnabled, temperatureEnabled, humidityEnabled, lightEnabled.");
+		return summarizeSensor(await client.patch(`sensors/${encodeURIComponent(sensorId)}`, body));
+	}));
+	server.registerTool("unifi_protect_update_viewer", {
+		description: "Put a saved live view on a Viewport screen, or rename the viewer. The liveview id comes from unifi_protect_list_liveviews — this changes what is displayed on a physical screen, so someone watching will see it switch.",
+		inputSchema: {
+			viewerId: idArg("Viewer", "unifi_protect_list_viewers"),
+			liveview: z.string().min(1).optional().describe("Live view id from unifi_protect_list_liveviews — the layout to display."),
+			name: z.string().min(1).optional().describe("Display name for the viewer.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ viewerId, liveview, name }) => wrap(async () => {
+		const body = compactOrUndefined({
+			liveview,
+			name
+		});
+		if (!body) throw new Error("Nothing to update — pass liveview or name.");
+		return summarizeViewer(await client.patch(`viewers/${encodeURIComponent(viewerId)}`, body));
+	}));
+	server.registerTool("unifi_protect_update_chime", {
+		description: "Change a chime's volume or rename it. Volume 0 silences it, so a doorbell press will make no sound.",
+		inputSchema: {
+			chimeId: idArg("Chime", "unifi_protect_list_chimes"),
+			volume: z.number().int().min(0).max(100).optional().describe("Volume, 0-100. 0 means the chime stays silent when the doorbell is pressed."),
+			name: z.string().min(1).optional().describe("Display name for the chime.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ chimeId, volume, name }) => wrap(async () => {
+		const body = compactOrUndefined({
+			volume,
+			name
+		});
+		if (!body) throw new Error("Nothing to update — pass volume or name.");
+		return summarizeChime(await client.patch(`chimes/${encodeURIComponent(chimeId)}`, body));
+	}));
+};
+//#endregion
+//#region src/tools/events.ts
+/**
+* The event types worth searching. Protect emits far more — disk health,
+* firmware updates, adoption, connection churn — but they are noise in an
+* event search and swamp the interesting ones.
+*/
+const EVENT_TYPES = [
+	"motion",
+	"smartDetectZone",
+	"smartDetectLine",
+	"smartAudioDetect",
+	"ring",
+	"doorAccess",
+	"nfcCardScanned",
+	"fingerprintIdentified",
+	"disconnect",
+	"cameraConnected",
+	"cameraDisconnected",
+	"recordingDeleted"
+];
+/**
+* The default set: what a person means by "what happened". Motion, anything the
+* camera classified, and doorbell rings — with the device-health chatter left out.
+*/
+const DEFAULT_EVENT_TYPES = [
+	"motion",
+	"smartDetectZone",
+	"smartDetectLine",
+	"smartAudioDetect",
+	"ring"
+];
+const SMART_DETECT_TYPES = [
+	"person",
+	"vehicle",
+	"animal",
+	"package",
+	"licensePlate",
+	"face",
+	"alrmSmoke",
+	"alrmCmonx",
+	"alrmSiren",
+	"alrmBabyCry",
+	"alrmSpeak",
+	"alrmBark",
+	"alrmBurglar",
+	"alrmCarHorn",
+	"alrmGlassBreak"
+];
+const registerEventTools = (server, client, ctx) => {
+	server.registerTool("unifi_protect_list_events", {
+		description: "Search recorded events over any time range — motion, smart detections (person, vehicle, animal, package, licence plate), doorbell rings, and camera connection changes. This is the tool for questions like \"what happened at the front door last night\". Each result carries its camera's NAME as well as its id, so no second lookup is needed. Narrow with `types`, `smartDetectTypes` and `cameraId` wherever you can: a busy system logs thousands of motion events a day, and an unfiltered query returns the newest slice of that rather than the interesting part.",
+		inputSchema: {
+			start: timeArg("Beginning of the search window."),
+			end: timeArg("End of the search window."),
+			types: z.array(z.enum(EVENT_TYPES)).optional().describe("Event types to include. Defaults to motion, smart detections and rings. `smartDetectZone` is the object-detection type — pair it with smartDetectTypes to ask for people or vehicles specifically."),
+			smartDetectTypes: z.array(z.enum(SMART_DETECT_TYPES)).optional().describe("What the camera classified, e.g. [\"person\"] or [\"vehicle\",\"licensePlate\"]. Only meaningful for smartDetectZone / smartDetectLine events; the alrm* values are audio detections. Cameras without smart detection never produce these."),
+			cameraId: cameraIdArg.optional().describe("Restrict to one camera — the `id` from unifi_protect_list_cameras. Omit for all cameras."),
+			limit: limitArg,
+			order: z.enum(["newest", "oldest"]).default("newest").describe("Which end of the window to return first.")
+		},
+		annotations: { readOnlyHint: true }
+	}, async ({ start, end, types, smartDetectTypes, cameraId, limit, order }) => wrap(async () => {
+		const endMs = end === void 0 ? Date.now() : toEpochMs(end);
+		const startMs = start === void 0 ? endMs - 864e5 : toEpochMs(start);
+		if (startMs >= endMs) throw new Error(`The window is empty: start (${new Date(startMs).toISOString()}) is not before end (${new Date(endMs).toISOString()}).`);
+		const requestedTypes = types && types.length > 0 ? types : [...DEFAULT_EVENT_TYPES];
+		const raw = await client.get("events", {
+			start: startMs,
+			end: endMs,
+			limit,
+			orderDirection: order === "newest" ? "DESC" : "ASC",
+			types: [...requestedTypes],
+			...smartDetectTypes && smartDetectTypes.length > 0 ? { smartDetectTypes: [...smartDetectTypes] } : {},
+			withoutDescriptions: "true"
+		});
+		const cameras = await ctx.devices.cameras();
+		const events = Array.isArray(raw) ? raw : [];
+		const shaped = events.filter((e) => typeof e === "object" && e !== null).filter((e) => cameraId === void 0 || e.camera === cameraId).map((e) => summarizeEvent(e, cameras));
+		return {
+			window: {
+				start: new Date(startMs).toISOString(),
+				end: new Date(endMs).toISOString()
+			},
+			types: requestedTypes,
+			count: shaped.length,
+			...events.length >= limit ? {
+				truncated: true,
+				note: `Returned the ${order === "newest" ? "newest" : "oldest"} ${limit} events; more exist in this window. Narrow the range or raise limit.`
+			} : {},
+			events: shaped
+		};
+	}));
+	server.registerTool("unifi_protect_get_event", {
+		description: "Get one event's full record, including detection metadata the search results leave out — per-object tracking, detected zones, licence plate text and vehicle attributes where the camera captured them. Use the `id` from unifi_protect_list_events.",
+		inputSchema: { eventId: z.string().min(1).describe("Event id — the `id` from unifi_protect_list_events.") },
+		annotations: { readOnlyHint: true }
+	}, async ({ eventId }) => wrap(() => client.get(`events/${encodeURIComponent(eventId)}`)));
+	server.registerTool("unifi_protect_get_event_thumbnail", {
+		description: "Fetch the still image Protect captured for an event — the frame that triggered the detection. Writes it to disk and returns the path by default; set output=\"image\" to return it inline for a vision model to look at, which costs a large amount of context. Pass the event's `id` from unifi_protect_list_events; results showing `hasThumbnail: true` have one.",
+		inputSchema: {
+			eventId: z.string().min(1).describe("Event id — the `id` from unifi_protect_list_events. Results with `hasThumbnail: true` have an image; others return 404. A raw `e-…` value from the console's own payload is also accepted."),
+			output: z.enum(["file", "image"]).default("file").describe("\"file\" writes it to disk and returns the path; \"image\" returns it inline."),
+			savePath: z.string().optional().describe("Absolute path to write the JPEG to. Defaults to a file under UNIFI_PROTECT_SNAPSHOT_DIR. Parent directories are created.")
+		},
+		annotations: { readOnlyHint: true }
+	}, async ({ eventId, output, savePath }) => wrapResult(async () => {
+		const id = eventId.startsWith("e-") ? eventId.slice(2) : eventId;
+		const { bytes, contentType } = await client.requestBytes(`events/${encodeURIComponent(id)}/thumbnail`, { accept: "image/jpeg" });
+		if (output === "image") return { content: [{
+			type: "image",
+			data: Buffer.from(bytes).toString("base64"),
+			mimeType: contentType.startsWith("image/") ? contentType : "image/jpeg"
+		}] };
+		const path = savePath ?? join(ctx.config.snapshotDir, `event-${slugId(id)}.jpg`);
+		await mkdir(join(path, ".."), { recursive: true });
+		await writeFile(path, bytes);
+		return ok({
+			path,
+			bytes: bytes.byteLength,
+			contentType
+		});
+	}));
+	server.registerTool("unifi_protect_export_video", {
+		description: "Export recorded footage from one camera over a time range as an MP4 file on disk. Always writes to a file and returns the path — video is never returned inline. Size grows quickly with the window: expect tens of megabytes per minute at full quality, and the call fails rather than exhausting memory if the export exceeds UNIFI_PROTECT_MAX_DOWNLOAD_BYTES. Footage only exists if the camera was recording at the time, so check the recording mode before concluding that nothing happened.",
+		inputSchema: {
+			cameraId: cameraIdArg,
+			start: requiredTimeArg("Beginning of the footage to export."),
+			end: requiredTimeArg("End of the footage to export."),
+			savePath: z.string().optional().describe("Absolute path to write the MP4 to. Defaults to a timestamped file under UNIFI_PROTECT_SNAPSHOT_DIR. Parent directories are created."),
+			channel: z.number().int().min(0).max(3).default(0).describe("Encoder channel: 0 is the high-quality stream, higher numbers are progressively lower bitrate. Use a higher channel to keep a long export manageable.")
+		},
+		annotations: { readOnlyHint: true }
+	}, async ({ cameraId, start, end, savePath, channel }) => wrap(async () => {
+		const startMs = toEpochMs(start);
+		const endMs = toEpochMs(end);
+		if (startMs >= endMs) throw new Error(`The window is empty: start (${new Date(startMs).toISOString()}) is not before end (${new Date(endMs).toISOString()}).`);
+		const { bytes, contentType } = await client.requestBytes("video/export", {
+			query: {
+				camera: cameraId,
+				start: startMs,
+				end: endMs,
+				channel
+			},
+			accept: "video/mp4"
+		});
+		const name = (await ctx.devices.cameras()).get(cameraId) ?? cameraId;
+		const stamp = new Date(startMs).toISOString().replace(/[:.]/g, "-");
+		const path = savePath ?? join(ctx.config.snapshotDir, `${slugId(name)}-${stamp}.mp4`);
+		await mkdir(join(path, ".."), { recursive: true });
+		await writeFile(path, bytes);
+		return {
+			path,
+			bytes: bytes.byteLength,
+			contentType,
+			camera: name,
+			window: {
+				start: new Date(startMs).toISOString(),
+				end: new Date(endMs).toISOString()
+			}
+		};
+	}));
+};
+const slugId = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "export";
+//#endregion
+//#region src/tools/request.ts
+/**
+* Reject anything that is not a plain relative path. The server decides the
+* host and the `/proxy/protect/api` prefix; letting a caller supply either
+* would send the console session somewhere it does not belong.
+*/
+const assertSafePath = (path) => {
+	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(path)) throw new Error("`path` must be a path, not an absolute URL — the server sets the host.");
+	if (path.split("/").includes("..")) throw new Error("`path` must not contain `..` segments.");
+};
+const registerRequestTool = (server, client, allowWrites) => {
+	const methods = allowWrites ? [
+		"GET",
+		"POST",
+		"PATCH",
+		"DELETE"
+	] : ["GET"];
+	server.registerTool("unifi_protect_request", {
+		description: "Escape hatch: call any private Protect API endpoint directly, relative to /proxy/protect/api. This exists because the private API is undocumented and Ubiquiti moves endpoints between Protect releases — when a wrapped tool starts returning 404, this reaches the replacement without waiting for a new version of this server. Responses are returned RAW and unshaped, so a broad endpoint like `bootstrap` can return hundreds of kilobytes; prefer the wrapped tools, which summarize. " + (allowWrites ? "Writes are ENABLED, so POST, PATCH and DELETE are permitted — there is no confirmation step here, so check the path before you call it." : "Writes are DISABLED: only GET is permitted. Set UNIFI_PROTECT_ALLOW_WRITES=1 to allow mutations."),
+		inputSchema: {
+			path: z.string().min(1).describe("Path relative to /proxy/protect/api, without a leading slash, e.g. \"cameras\", \"nvr\", \"events/abc123\". Not an absolute URL."),
+			method: z.enum(methods).default("GET").describe("HTTP method."),
+			query: z.record(z.string(), z.string()).optional().describe("Query parameters as a flat string map, e.g. {\"start\":\"1756500000000\"}. Remember that Protect times are milliseconds since the epoch."),
+			body: z.record(z.string(), z.unknown()).optional().describe("JSON request body, for POST and PATCH.")
+		},
+		annotations: {
+			readOnlyHint: !allowWrites,
+			destructiveHint: allowWrites
+		}
+	}, async ({ path, method, query, body }) => wrap(async () => {
+		if (!allowWrites && method !== "GET") throw new WritesDisabledError(`unifi_protect_request with method ${method}`);
+		assertSafePath(path);
+		return client.request(method, path, {
+			...query ? { query } : {},
+			...body ? { body } : {}
+		});
+	}));
+};
+//#endregion
+//#region src/tools/status.ts
+const fileMode = (path) => {
+	try {
+		return statSync(path).mode & 511;
+	} catch {
+		return;
+	}
+};
+const registerStatusTools = (server, client, ctx) => {
+	server.registerTool("unifi_protect_auth_status", {
+		description: "Check whether this server can actually reach your UniFi Protect console. By default it logs in and makes a real call, so the answer reflects the console rather than cached state — this is the tool to run when something is not working. Reports the host, the account, the Protect version, whether TLS is verified, and whether writes are enabled; when nothing is configured it returns the exact setup steps instead. Call this first when a tool you expected is not listed: an absent tool means missing configuration or writes being off, not a bug.",
+		inputSchema: { probe: z.boolean().default(true).describe("Actually contact the console (logging in if needed) rather than only reporting what is already cached. Set false for a fast, purely local answer.") },
+		annotations: { readOnlyHint: true }
+	}, async ({ probe }) => wrap(async () => {
+		if (!isConfigured(ctx.config)) return {
+			configured: false,
+			host: ctx.config.baseUrl ?? null,
+			available_without_credentials: ["unifi_protect_auth_status"],
+			setup: setupInstructions(ctx.config)
+		};
+		let reachable;
+		let version;
+		let failure;
+		if (probe) try {
+			const nvr = (await client.get("bootstrap"))?.nvr;
+			version = typeof nvr === "object" && nvr !== null ? nvr.version : void 0;
+			reachable = true;
+		} catch (err) {
+			reachable = false;
+			failure = err instanceof Error ? err.message : String(err);
+		}
+		const status = ctx.session.describe();
+		const mode = fileMode(ctx.config.sessionFile);
+		return {
+			configured: true,
+			host: ctx.config.baseUrl,
+			username: status.username ?? null,
+			...probe ? {
+				reachable,
+				...version !== void 0 ? { protectVersion: version } : {},
+				...failure ? { failure } : {}
+			} : {},
+			session: {
+				authenticated: status.authenticated,
+				source: status.source,
+				established_at: status.savedAt ?? null,
+				file: ctx.config.sessionFile,
+				file_mode: mode === void 0 ? "absent" : `0${mode.toString(8)}`,
+				...mode !== void 0 && (mode & 63) !== 0 ? { warning: `Readable by other users. Run: chmod 600 ${ctx.config.sessionFile}` } : {}
+			},
+			tls: ctx.config.verifyTls ? "verified" : "UNVERIFIED — certificate checks are off for this server's requests only. Verifying needs both NODE_EXTRA_CA_CERTS pointing at the console certificate and UNIFI_PROTECT_HOST set to a host name: the certificate carries no IP SAN.",
+			writes: ctx.allowWrites ? "enabled" : "disabled",
+			api: "private (undocumented). Ubiquiti moves these endpoints between Protect releases, so the Protect version reported above is the first thing to check if a tool that used to work starts returning 404."
+		};
+	}));
+	if (!isConfigured(ctx.config)) return;
+	server.registerTool("unifi_protect_auth_login", {
+		description: "Force a fresh login to the console, replacing any cached session. Normally unnecessary — the server logs in on demand and re-authenticates automatically on a 401. Use it to supply a two-factor code, which cannot be done unattended: the code is single-use and expires in about 30 seconds, so it is passed here once and the resulting session is then cached and reused.",
+		inputSchema: { totp: z.string().regex(/^\d{6,8}$/, "A two-factor code is 6 to 8 digits.").optional().describe("Current code from your authenticator app. Omit if the account has no 2FA.") },
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false
+		}
+	}, async ({ totp }) => wrap(async () => {
+		const status = await ctx.session.login(totp);
+		return {
+			authenticated: status.authenticated,
+			username: status.username,
+			established_at: status.savedAt,
+			session_file: ctx.config.sessionFile,
+			note: "The session is stored with mode 600 and reused until the console rejects it."
+		};
+	}));
+	server.registerTool("unifi_protect_auth_logout", {
+		description: "Drop the cached session and delete the session file. The next call logs in again from the configured username and password, so this does not lock anything out — use it to clear a session after changing accounts, or to remove the cookie from disk.",
+		inputSchema: { confirm: confirmArg },
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: true
+		}
+	}, async () => wrap(async () => {
+		await ctx.session.logout();
+		return {
+			logged_out: true,
+			note: "Credentials are unchanged; the next tool call will log in again."
+		};
+	}));
+};
+//#endregion
+//#region src/tools/system.ts
+const registerSystemTools = (server, client, ctx) => {
+	server.registerTool("unifi_protect_get_system_info", {
+		description: "Overview of the console: model, Protect version, firmware, timezone, uptime, storage use and how many devices of each type are adopted. Worth calling first on an unfamiliar system. The reported Protect version matters: this server talks to Protect's private API, which Ubiquiti changes between releases, so a version that differs from the one in the README is the first thing to check if a tool starts returning 404.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeBootstrap(await client.get("bootstrap"))));
+	server.registerTool("unifi_protect_list_users", {
+		description: "List the accounts that can sign in to Protect, with their role and last login. Useful for auditing who has access to the cameras.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("users"), summarizeUser)));
+	server.registerTool("unifi_protect_list_liveviews", {
+		description: "List the saved live views — the named camera grid layouts shown on viewers and in the Protect app. The returned id is what unifi_protect_update_viewer needs to put a layout on a screen.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(async () => summarizeEach(await client.get("liveviews"), summarizeLiveview)));
+	if (!ctx.allowWrites) return;
+	server.registerTool("unifi_protect_update_nvr_settings", {
+		description: "Change console-wide settings. `isRecordingDisabled` is the significant one: turning it on stops recording on EVERY camera at once, so nothing is written until it is turned back off. Only the fields you pass are sent.",
+		inputSchema: {
+			name: z.string().min(1).optional().describe("Display name for the console."),
+			timezone: z.string().min(1).optional().describe("IANA timezone, e.g. \"Europe/Paris\". Affects event timestamps and schedules."),
+			isRecordingDisabled: z.boolean().optional().describe("Disable recording across every camera. True means no footage is kept, system-wide.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: true
+		}
+	}, async ({ name, timezone, isRecordingDisabled }) => wrap(async () => {
+		const body = compactOrUndefined({
+			name,
+			timezone,
+			isRecordingDisabled
+		});
+		if (!body) throw new Error("Nothing to update — pass at least one of name, timezone, isRecordingDisabled.");
+		return client.patch("nvr", body);
+	}));
+	server.registerTool("unifi_protect_reboot_nvr", {
+		description: "REBOOT THE CONSOLE. Every camera stops recording for the two to five minutes it takes to come back, and footage from that window is lost permanently. This also drops the network if the console is your router (a UDM or UDM Pro), taking down everything behind it. Reboot a single unresponsive camera with unifi_protect_reboot_camera instead wherever that would do.",
+		inputSchema: { confirm: confirmArg },
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false
+		}
+	}, async () => wrap(() => client.post("nvr/reboot")));
+};
+//#endregion
+//#region src/tools/index.ts
+/**
+* Register the UniFi Protect tools.
+*
+* unifi_protect_auth_status comes first and unconditionally, so a server with no
+* console configured is still a useful one — it can say what to set — rather
+* than a connection that closes with its own error message swallowed.
+*
+* Read tools are then always registered; the write tools only when
+* `allowWrites` is set, so with the flag off they are not merely refused — they
+* are absent from tools/list and cannot be called at all. A refusal still lets a
+* model try, retry, and reason about how to get around it; a tool that does not
+* exist ends the conversation.
+*/
+const registerTools = (server, client, ctx) => {
+	registerStatusTools(server, client, ctx);
+	if (!isConfigured(ctx.config)) return;
+	registerSystemTools(server, client, ctx);
+	registerCameraTools(server, client, ctx);
+	registerEventTools(server, client, ctx);
+	registerDeviceTools(server, client, ctx);
+	registerRequestTool(server, client, ctx.allowWrites);
+};
+//#endregion
+//#region src/server.ts
+const SERVER_NAME = BUILD_INFO.name;
+const SERVER_VERSION = BUILD_INFO.version;
+const USER_AGENT = `mcp-unifi-protect-js/${BUILD_INFO.version}`;
+const createServer = (opts) => {
+	const { config } = opts;
+	const server = new McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	});
+	const fetchImpl = opts.fetch ?? createHttpFetch({
+		insecureTls: !config.verifyTls,
+		...opts.logger ? { logger: opts.logger } : {}
+	});
+	const session = opts.session ?? createSessionProvider({
+		config,
+		fetch: fetchImpl,
+		...opts.logger ? { logger: opts.logger } : {}
+	});
+	const client = new ProtectClient({
+		baseUrl: config.baseUrl ?? "https://unconfigured.invalid",
+		session,
+		maxRetries: config.maxRetries,
+		userAgent: USER_AGENT,
+		maxDownloadBytes: config.maxDownloadBytes,
+		fetch: fetchImpl,
+		...opts.logger ? { logger: opts.logger } : {}
+	});
+	const devices = createDeviceCache({
+		client,
+		ttlSeconds: config.deviceCacheTtlSeconds
+	});
+	registerTools(server, client, {
+		config,
+		allowWrites: config.allowWrites,
+		session,
+		devices
+	});
+	return {
+		server,
+		client,
+		session,
+		devices
+	};
+};
+//#endregion
+export { saveSession as A, loadConfig as B, summarizeSensor as C, staticSessionProvider as D, createSessionProvider as E, LOGIN_PATH as F, BUILD_INFO as G, resolveConfigPath as H, PRIVATE_API_PATH as I, UPDATES_WS_PATH as L, ProtectApiError as M, ProtectAuthError as N, clearSession as O, WritesDisabledError as P, expandTilde as R, summarizeNvr as S, summarizeViewer as T, resolveSessionPath as U, normalizeBaseUrl as V, setupInstructions as W, summarizeChime as _, registerTools as a, summarizeLight as b, ProtectClient as c, retryAfterMs as d, createDeviceCache as f, summarizeCamera as g, summarizeBootstrap as h, createServer as i, NotConfiguredError as j, loadSession as k, backoffMs as l, isoTime as m, SERVER_VERSION as n, assertSafePath as o, buildNameIndex as p, USER_AGENT as r, toEpochMs as s, SERVER_NAME as t, buildQuery as u, summarizeEach as v, summarizeUser as w, summarizeLiveview as x, summarizeEvent as y, isConfigured as z };
+
+//# sourceMappingURL=server-iu_3JECB.js.map