zidane 7.2.4 → 8.0.4

package/dist/ws-CIHMvlSh.js

@@ -0,0 +1,952 @@
+import { t as projectUserPaths } from "./project-user-paths-BSgtrRxl.js";
+import { i as writeJsonFileAtomic, t as OWNER_ONLY } from "./atomic-write-Ijgf2Mhc.js";
+import { n as displayHostUrl, u as DEFAULT_SETTINGS } from "./url-D8HCl65b.js";
+import { B as parseMcpsFile, Ot as readProjects, P as userSystemMdPath, i as probeUnsavedHost, rt as loadState, t as createHostRegistry } from "./registry-D6ShBWJU.js";
+import { a as readProviderCredential } from "./credentials-JttEuRON.js";
+import { f as HostIdentityError, i as SYNC_MODES, n as SYNC_CATEGORIES, s as fieldCategory } from "./types-CH5XpIHw.js";
+import { g as hostRefOf, i as IpcVersionMismatchError, n as hashValue, r as isRecord, t as isSyncableSetting } from "./settings-keys-Ckf29NeM.js";
+import { t as keepHostConnected } from "./connection-loop-gdh22LTI.js";
+import { n as connectWsClient, t as HostAuthError } from "./ws-client-N7NxzvQp.js";
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync, watch } from "node:fs";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { hostname } from "node:os";
+import { randomUUID } from "node:crypto";
+//#region src/chat/sync/collect.ts
+const MAX_FILE_BYTES = 1048576;
+const MAX_SKILL_BYTES = 4194304;
+const MAX_SKILL_FILES = 200;
+const MAX_DEPTH = 8;
+/** Not part of a skill: version control and installed dependencies. */
+const SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function userPaths(sources, subPath) {
+	return projectUserPaths({
+		subPath,
+		cwd: sources.home,
+		home: sources.home,
+		prefix: sources.prefix
+	}).filter((p) => p.source === "user").map((p) => p.path);
+}
+/** Every file and folder a category reads: what the watchers watch. */
+function syncWatchTargets(sources) {
+	return [
+		{
+			category: "settings",
+			path: sources.statePath,
+			recursive: false
+		},
+		{
+			category: "safelists",
+			path: join(sources.dataDir, "projects.json"),
+			recursive: false
+		},
+		{
+			category: "files",
+			path: userSystemMdPath({
+				home: sources.home,
+				prefix: sources.prefix
+			}),
+			recursive: false
+		},
+		...userPaths(sources, "skills").map((path) => ({
+			category: "files",
+			path,
+			recursive: true
+		})),
+		...userPaths(sources, "mcps.json").map((path) => ({
+			category: "mcps",
+			path,
+			recursive: false
+		})),
+		...userPaths(sources, "extensions").map((path) => ({
+			category: "extensions",
+			path,
+			recursive: true
+		})),
+		{
+			category: "keys",
+			path: join(sources.dataDir, "credentials.json"),
+			recursive: false
+		}
+	];
+}
+function settingsPayload(sources) {
+	const stored = loadState(sources.statePath).settings ?? {};
+	const merged = {
+		...DEFAULT_SETTINGS,
+		...stored
+	};
+	return { values: Object.fromEntries(Object.entries(merged).filter(([key]) => key in DEFAULT_SETTINGS && isSyncableSetting(key))) };
+}
+function safelistsPayload(sources) {
+	const projects = readProjects(sources.dataDir);
+	return { projects: Object.fromEntries(Object.entries(projects).flatMap(([path, entry]) => Array.isArray(entry?.safelist) ? [[path, [...entry.safelist]]] : [])) };
+}
+/** A skill folder's files, or null when it is over the bounds (or not a plain folder). */
+function skillFiles(dir) {
+	const files = [];
+	let total = 0;
+	const walk = (at, depth) => {
+		if (depth > MAX_DEPTH) return false;
+		for (const name of readdirSync(at).sort()) {
+			const path = join(at, name);
+			const stat = lstatSync(path);
+			if (stat.isDirectory()) {
+				if (SKIPPED_DIRS.has(name)) continue;
+				if (!walk(path, depth + 1)) return false;
+			} else if (stat.isFile()) {
+				if (stat.size > MAX_FILE_BYTES || files.length >= MAX_SKILL_FILES) return false;
+				total += stat.size;
+				if (total > MAX_SKILL_BYTES) return false;
+				files.push({
+					path: relative(dir, path).split(sep).join("/"),
+					data: readFileSync(path).toString("base64")
+				});
+			}
+		}
+		return true;
+	};
+	try {
+		return walk(dir, 1) && files.length > 0 ? files : null;
+	} catch {
+		return null;
+	}
+}
+/** The user-scope skills: name → folder, the first root of a name winning (as discovery does). */
+function userSkillDirs(sources) {
+	const found = /* @__PURE__ */ new Map();
+	for (const root of userPaths(sources, "skills")) {
+		let names;
+		try {
+			names = readdirSync(root).sort();
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			const dir = join(root, name);
+			if (!found.has(name) && !name.startsWith(".") && existsSync(join(dir, "SKILL.md")) && lstatSync(dir).isDirectory()) found.set(name, dir);
+		}
+	}
+	return found;
+}
+function filesPayload(sources) {
+	const mdPath = userSystemMdPath({
+		home: sources.home,
+		prefix: sources.prefix
+	});
+	const systemMd = existsSync(mdPath) ? readFileSync(mdPath, "utf8") : null;
+	const skills = [];
+	for (const [name, dir] of userSkillDirs(sources)) {
+		const files = skillFiles(dir);
+		if (files) skills.push({
+			name,
+			files
+		});
+	}
+	return {
+		systemMd,
+		skills
+	};
+}
+function mcpsPayload(sources) {
+	const servers = /* @__PURE__ */ new Map();
+	for (const path of userPaths(sources, "mcps.json")) {
+		if (!existsSync(path)) continue;
+		try {
+			for (const server of parseMcpsFile(readFileSync(path, "utf8"))) if (!servers.has(server.name)) servers.set(server.name, server);
+		} catch {}
+	}
+	return { servers: [...servers.values()] };
+}
+/** User-scope extensions: those with a source (syncable) and the local ones (not). */
+function userExtensions(sources) {
+	const syncable = [];
+	const local = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of userPaths(sources, "extensions")) {
+		let names;
+		try {
+			names = readdirSync(root).sort();
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			const dir = join(root, name);
+			if (name.startsWith(".") || seen.has(name) || !lstatSync(dir).isDirectory()) continue;
+			seen.add(name);
+			let provenance = null;
+			try {
+				provenance = JSON.parse(readFileSync(join(dir, ".install.json"), "utf8"));
+			} catch {}
+			if (provenance && typeof provenance.spec === "string" && provenance.spec.trim() !== "") syncable.push({
+				name,
+				spec: provenance.spec,
+				...typeof provenance.extension === "string" ? { extension: provenance.extension } : {}
+			});
+			else local.push(name);
+		}
+	}
+	return {
+		syncable,
+		local
+	};
+}
+/** Providers with an API key stored here: what the keys category can offer. */
+function storedApiKeyProviders(sources) {
+	return Object.values(sources.providers()).flatMap((descriptor) => {
+		const credential = readProviderCredential(sources.dataDir, descriptor);
+		return credential?.kind === "apikey" && credential.value ? [{
+			key: descriptor.key,
+			label: descriptor.label
+		}] : [];
+	});
+}
+function keysPayload(sources, optedIn) {
+	const providers = sources.providers();
+	return { keys: optedIn.flatMap((provider) => {
+		const descriptor = providers[provider];
+		const credential = descriptor ? readProviderCredential(sources.dataDir, descriptor) : void 0;
+		return credential?.kind === "apikey" && credential.value ? [{
+			provider,
+			key: credential.value
+		}] : [];
+	}) };
+}
+function collectSyncPayload(category, sources, optedInKeys = []) {
+	switch (category) {
+		case "settings": return settingsPayload(sources);
+		case "safelists": return safelistsPayload(sources);
+		case "files": return filesPayload(sources);
+		case "mcps": return mcpsPayload(sources);
+		case "extensions": return { extensions: userExtensions(sources).syncable };
+		case "keys": return keysPayload(sources, optedInKeys);
+	}
+}
+//#endregion
+//#region src/chat/sync/local.ts
+const DEFAULT_SERVER_SYNC = {
+	mode: "off",
+	categories: ["settings"],
+	keys: [],
+	pending: [],
+	sent: {},
+	results: {}
+};
+function hostsSyncPath(dataDir) {
+	return join(dataDir, "hosts-sync.json");
+}
+function deviceIdentityPath(dataDir) {
+	return join(dataDir, "device.json");
+}
+function readJson(path) {
+	if (!existsSync(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+/** This computer's device id and name, made on first use. */
+function readDeviceIdentity(dataDir, name) {
+	const raw = readJson(deviceIdentityPath(dataDir));
+	if (isRecord(raw) && typeof raw.id === "string" && raw.id !== "") return {
+		id: raw.id,
+		name: name ?? (typeof raw.name === "string" && raw.name ? raw.name : hostname())
+	};
+	const identity = {
+		id: randomUUID(),
+		name: name ?? hostname()
+	};
+	writeJsonFileAtomic(deviceIdentityPath(dataDir), identity, OWNER_ONLY);
+	return identity;
+}
+function categoriesOf(value) {
+	return Array.isArray(value) ? SYNC_CATEGORIES.filter((c) => value.includes(c)) : [];
+}
+function serverConfigOf(raw) {
+	if (!isRecord(raw)) return { ...DEFAULT_SERVER_SYNC };
+	return {
+		mode: SYNC_MODES.includes(raw.mode) ? raw.mode : "off",
+		categories: categoriesOf(raw.categories),
+		keys: Array.isArray(raw.keys) ? raw.keys.filter((k) => typeof k === "string") : [],
+		pending: categoriesOf(raw.pending),
+		sent: isRecord(raw.sent) ? Object.fromEntries(Object.entries(raw.sent).filter(([c, h]) => SYNC_CATEGORIES.includes(c) && typeof h === "string")) : {},
+		...typeof raw.lastSyncAt === "number" ? { lastSyncAt: raw.lastSyncAt } : {},
+		...typeof raw.lastError === "string" ? { lastError: raw.lastError } : {},
+		results: isRecord(raw.results) ? raw.results : {}
+	};
+}
+function readSyncConfigs(dataDir) {
+	const raw = readJson(hostsSyncPath(dataDir));
+	if (!isRecord(raw) || !isRecord(raw.servers)) return {};
+	return Object.fromEntries(Object.entries(raw.servers).map(([key, value]) => [key, serverConfigOf(value)]));
+}
+function writeSyncConfigs(dataDir, servers) {
+	const file = {
+		version: 1,
+		servers
+	};
+	writeJsonFileAtomic(hostsSyncPath(dataDir), file, OWNER_ONLY);
+}
+//#endregion
+//#region src/chat/sync/pusher.ts
+const errorText = (err) => err instanceof Error ? err.message : String(err);
+function createSyncPusher({ sources, device, emit }) {
+	const configs = readSyncConfigs(sources.dataDir);
+	const clients = /* @__PURE__ */ new Map();
+	const statuses = /* @__PURE__ */ new Map();
+	const conflicts = /* @__PURE__ */ new Map();
+	const flushing = /* @__PURE__ */ new Map();
+	const again = /* @__PURE__ */ new Set();
+	let stopped = false;
+	const configOf = (key) => configs[key] ?? {
+		...DEFAULT_SERVER_SYNC,
+		categories: [...DEFAULT_SERVER_SYNC.categories]
+	};
+	const save = (key, config) => {
+		configs[key] = config;
+		writeSyncConfigs(sources.dataDir, configs);
+		emit();
+	};
+	const fail = (key, err) => save(key, {
+		...configOf(key),
+		lastError: errorText(err)
+	});
+	/** Categories whose snapshot here differs from what was last pushed to the server. */
+	const changedCategories = (config, only) => config.categories.filter((category) => {
+		if (only && category !== only) return false;
+		try {
+			return hashValue(collectSyncPayload(category, sources, config.keys)) !== config.sent[category];
+		} catch {
+			return true;
+		}
+	});
+	const queue = (key, categories) => {
+		const config = configOf(key);
+		const pending = SYNC_CATEGORIES.filter((c) => config.pending.includes(c) || categories.includes(c));
+		if (pending.length !== config.pending.length) save(key, {
+			...config,
+			pending
+		});
+	};
+	async function claim(key, client, takeover) {
+		const config = configOf(key);
+		const result = await client.request("sync.claim", {
+			deviceId: device.id,
+			deviceName: device.name,
+			categories: config.categories,
+			keys: config.keys,
+			...takeover ? { takeover: true } : {}
+		});
+		statuses.set(key, result.status);
+		if (result.claimed) conflicts.delete(key);
+		else conflicts.set(key, result.status.source?.deviceName ?? "another device");
+		return result.claimed;
+	}
+	async function flushOnce(key, takeover) {
+		const client = clients.get(key);
+		let config = configOf(key);
+		if (!client || !client.hello.sync || config.mode === "off" || config.pending.length === 0 && !takeover || stopped) return;
+		try {
+			if (!await claim(key, client, takeover)) return;
+			for (const category of [...configOf(key).pending]) {
+				config = configOf(key);
+				if (!config.categories.includes(category)) {
+					save(key, {
+						...config,
+						pending: config.pending.filter((c) => c !== category)
+					});
+					continue;
+				}
+				const payload = collectSyncPayload(category, sources, config.keys);
+				const result = await client.request("sync.push", {
+					deviceId: device.id,
+					category,
+					payload
+				});
+				config = configOf(key);
+				const { lastError: _dropped, ...rest } = config;
+				save(key, {
+					...rest,
+					pending: config.pending.filter((c) => c !== category),
+					sent: {
+						...config.sent,
+						[category]: hashValue(payload)
+					},
+					results: {
+						...config.results,
+						[category]: result
+					},
+					lastSyncAt: Date.now()
+				});
+			}
+			statuses.set(key, await client.request("sync.status", {}));
+		} catch (err) {
+			fail(key, err);
+		}
+	}
+	/** Push the queue if the server is connected and this device is its source; `takeover` claims it first. */
+	function flush(key, takeover = false) {
+		const running = flushing.get(key);
+		if (running && !takeover) {
+			again.add(key);
+			return running;
+		}
+		const run = (async () => {
+			if (running) await running;
+			await flushOnce(key, takeover);
+			while (again.delete(key)) await flushOnce(key, false);
+		})().finally(() => {
+			if (flushing.get(key) === run) flushing.delete(key);
+			emit();
+		});
+		flushing.set(key, run);
+		emit();
+		return run;
+	}
+	/** Read the server's record: who syncs there now. */
+	async function refresh(key) {
+		const client = clients.get(key);
+		if (!client?.hello.sync) return;
+		try {
+			const status = await client.request("sync.status", {});
+			statuses.set(key, status);
+			if (!status.source || status.source.deviceId === device.id) conflicts.delete(key);
+			else if (configOf(key).mode !== "off") conflicts.set(key, status.source.deviceName);
+		} catch {}
+		emit();
+	}
+	/** This device stops being the server's source (the server keeps what it has). */
+	async function release(key) {
+		const client = clients.get(key);
+		conflicts.delete(key);
+		if (!client?.hello.sync) return;
+		await client.request("sync.release", { deviceId: device.id }).catch(() => void 0);
+		const status = await client.request("sync.status", {}).catch(() => null);
+		if (status) statuses.set(key, status);
+	}
+	function forget(key) {
+		clients.delete(key);
+		statuses.delete(key);
+		conflicts.delete(key);
+		if (configs[key]) {
+			delete configs[key];
+			writeSyncConfigs(sources.dataDir, configs);
+		}
+	}
+	return {
+		configs,
+		clients,
+		statuses,
+		conflicts,
+		flushing,
+		configOf,
+		save,
+		fail,
+		changedCategories,
+		queue,
+		claim,
+		flush,
+		refresh,
+		release,
+		forget,
+		stop: () => {
+			stopped = true;
+			clients.clear();
+		}
+	};
+}
+//#endregion
+//#region src/chat/sync/watchers.ts
+function createSyncWatchers({ sources, debounceMs, check }) {
+	let watchers = [];
+	let timer = null;
+	let closed = false;
+	const dirty = /* @__PURE__ */ new Set();
+	const closeAll = () => {
+		for (const w of watchers) w.close();
+		watchers = [];
+	};
+	const schedule = (category) => {
+		if (closed) return;
+		dirty.add(category ?? "all");
+		if (timer) return;
+		timer = setTimeout(() => {
+			timer = null;
+			const which = [...dirty];
+			dirty.clear();
+			check(which);
+		}, debounceMs);
+	};
+	return {
+		schedule,
+		refresh(active) {
+			closeAll();
+			if (closed || !active) return;
+			for (const target of syncWatchTargets(sources)) {
+				const isDir = existsSync(target.path) && statSync(target.path).isDirectory();
+				const at = isDir ? target.path : dirname(target.path);
+				if (!existsSync(at)) continue;
+				const name = basename(target.path);
+				try {
+					watchers.push(watch(at, {
+						recursive: isDir && target.recursive,
+						persistent: false
+					}, (_event, changed) => {
+						if (isDir || changed === null || String(changed) === name) schedule(target.category);
+					}));
+				} catch {}
+			}
+		},
+		count: () => watchers.length,
+		close() {
+			closed = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+			closeAll();
+		}
+	};
+}
+//#endregion
+//#region src/chat/sync/engine.ts
+/**
+* Engines CREATED in this process so far: monotonic (never decremented when
+* one stops), not a live count. The containment tests compare it before and
+* after a mount to prove an engine did, or did not, start.
+*/
+let engines = 0;
+function createSyncEngine(options) {
+	engines++;
+	const sources = {
+		dataDir: options.dataDir,
+		statePath: options.statePath,
+		home: options.home,
+		prefix: options.prefix,
+		providers: options.providers
+	};
+	const device = readDeviceIdentity(options.dataDir, options.deviceName);
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => {
+		for (const listener of [...listeners]) try {
+			listener();
+		} catch {}
+	};
+	const pusher = createSyncPusher({
+		sources,
+		device,
+		emit
+	});
+	const { configOf, save, queue, flush, clients, statuses, conflicts } = pusher;
+	const keeping = () => Object.entries(pusher.configs).filter(([, c]) => c.mode === "keep").map(([key]) => key);
+	const watchers = createSyncWatchers({
+		sources,
+		debounceMs: options.debounceMs ?? 500,
+		check: (which) => {
+			for (const key of keeping()) {
+				const config = configOf(key);
+				const changed = which.includes("all") ? pusher.changedCategories(config) : which.flatMap((c) => pusher.changedCategories(config, c));
+				if (changed.length > 0) {
+					queue(key, changed);
+					flush(key);
+				}
+			}
+			refreshWatchers();
+		}
+	});
+	function refreshWatchers() {
+		watchers.refresh(options.watch !== false && keeping().length > 0);
+		emit();
+	}
+	/** A config patch applied: what it turns on gets pushed (all of it when a mode starts). */
+	async function apply(key, before, next, patch) {
+		if (next.mode === "off") {
+			const turnedOff = before.mode !== "off";
+			save(key, turnedOff ? {
+				...next,
+				pending: [],
+				sent: {}
+			} : next);
+			if (turnedOff) {
+				refreshWatchers();
+				await pusher.release(key);
+				emit();
+			}
+			return;
+		}
+		const fresh = before.mode === "off" || patch.mode === "once";
+		const added = next.categories.filter((c) => !before.categories.includes(c));
+		const keysChanged = patch.keys !== void 0 && hashValue(before.keys) !== hashValue(next.keys);
+		const toPush = fresh ? next.categories : [...added, ...keysChanged && next.categories.includes("keys") ? ["keys"] : []];
+		next.pending = SYNC_CATEGORIES.filter((c) => next.categories.includes(c) && (next.pending.includes(c) || toPush.includes(c)));
+		if (fresh) next.sent = {};
+		save(key, next);
+		refreshWatchers();
+		const client = clients.get(key);
+		if (client?.hello.sync && next.pending.length === 0 && (added.length > 0 || keysChanged)) {
+			await pusher.claim(key, client, false).catch((err) => pusher.fail(key, err));
+			emit();
+		}
+		await flush(key);
+	}
+	const engine = {
+		device,
+		view: (key) => ({
+			config: configOf(key),
+			connected: clients.has(key),
+			supported: clients.get(key)?.hello.sync === true,
+			status: statuses.get(key) ?? null,
+			conflict: conflicts.get(key) ?? null,
+			busy: pusher.flushing.has(key)
+		}),
+		configure(key, patch) {
+			const before = configOf(key);
+			return apply(key, before, {
+				...before,
+				...patch.mode ? { mode: patch.mode } : {},
+				...patch.categories ? { categories: SYNC_CATEGORIES.filter((c) => patch.categories.includes(c)) } : {},
+				...patch.keys ? { keys: [...new Set(patch.keys)] } : {}
+			}, patch);
+		},
+		async pushAll(key) {
+			const config = configOf(key);
+			if (config.mode === "off") return;
+			save(key, {
+				...config,
+				pending: [...config.categories],
+				sent: {}
+			});
+			await flush(key);
+		},
+		async takeOver(key) {
+			const config = configOf(key);
+			if (config.mode === "off") return;
+			save(key, {
+				...config,
+				pending: [...config.categories],
+				sent: {}
+			});
+			await flush(key, true);
+		},
+		async reset(key, field) {
+			const client = clients.get(key);
+			if (!client) throw new Error("The server is not connected.");
+			await client.request("sync.reset", { field });
+			await pusher.refresh(key);
+			const category = fieldCategory(field);
+			const config = configOf(key);
+			if (category && config.categories.includes(category) && config.mode !== "off") {
+				save(key, {
+					...config,
+					sent: {
+						...config.sent,
+						[category]: ""
+					}
+				});
+				queue(key, [category]);
+				await flush(key);
+			}
+		},
+		refresh: (key) => pusher.refresh(key),
+		connected(key, client) {
+			clients.set(key, client);
+			emit();
+			if (!client.hello.sync) return;
+			const config = configOf(key);
+			if (config.mode === "keep") {
+				const changed = pusher.changedCategories(config);
+				if (changed.length > 0) queue(key, changed);
+			}
+			pusher.refresh(key).then(() => flush(key));
+		},
+		disconnected(key) {
+			clients.delete(key);
+			emit();
+		},
+		serverChanged: (key) => {
+			const before = statuses.get(key);
+			pusher.refresh(key).then(() => {
+				const after = statuses.get(key);
+				const config = configOf(key);
+				if (!before || !after || after.source?.deviceId !== device.id || config.mode === "off") return;
+				const back = Object.keys(before.overrides).filter((field) => !after.overrides[field]).map(fieldCategory).filter((c) => c !== void 0 && config.categories.includes(c));
+				if (back.length === 0) return;
+				save(key, {
+					...config,
+					sent: Object.fromEntries(Object.entries(config.sent).filter(([c]) => !back.includes(c)))
+				});
+				queue(key, back);
+				flush(key);
+			});
+		},
+		removed(key) {
+			if (configOf(key).mode !== "off") pusher.release(key);
+			pusher.forget(key);
+			refreshWatchers();
+		},
+		notifyLocalChange(category) {
+			if (keeping().length > 0) watchers.schedule(category);
+		},
+		localInfo: () => syncLocalInfo(sources),
+		watching: () => watchers.count() > 0,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		stop() {
+			watchers.close();
+			pusher.stop();
+			listeners.clear();
+		}
+	};
+	refreshWatchers();
+	return engine;
+}
+function syncLocalInfo(sources) {
+	const read = (fn, fallback) => {
+		try {
+			return fn();
+		} catch {
+			return fallback;
+		}
+	};
+	return {
+		keyProviders: read(() => storedApiKeyProviders(sources), []),
+		localExtensions: read(() => userExtensions(sources).local, []),
+		stdioMcps: read(() => collectSyncPayload("mcps", sources).servers.filter((s) => typeof s.command === "string" && s.command !== "").map((s) => String(s.name)), [])
+	};
+}
+//#endregion
+//#region src/ipc/hosts/probe.ts
+/** Bound on one probe: the upgrade, the handshake and `daemon.info`. */
+const HOST_PROBE_TIMEOUT_MS = 1e4;
+const TLS_FAILURE = /certificate|self[- ]signed|\btls\b|\bssl\b|UNABLE_TO_VERIFY|CERT_|ERR_TLS/i;
+function classify(err) {
+	if (err instanceof HostAuthError) return err.status === 401 ? {
+		error: "auth",
+		message: "The host refused the token (401). Create a new one on the server: zidane server token create --name <device>."
+	} : {
+		error: "auth",
+		message: err.message
+	};
+	if (err instanceof IpcVersionMismatchError) return {
+		error: "protocol",
+		message: err.message
+	};
+	const message = err instanceof Error ? err.message : String(err);
+	if (TLS_FAILURE.test(message)) return {
+		error: "tls",
+		message: `TLS failed: ${message}`
+	};
+	return {
+		error: "unreachable",
+		message
+	};
+}
+/**
+* A failed WebSocket says nothing about why. For `wss://`, ask the same
+* address over HTTPS: a certificate or handshake failure there is a TLS
+* problem, anything else stays "unreachable".
+*/
+async function tlsFailure(url, signal) {
+	if (!url.startsWith("wss:")) return null;
+	try {
+		(await fetch(`https:${url.slice(4)}`, {
+			redirect: "manual",
+			signal: AbortSignal.any([signal, AbortSignal.timeout(5e3)])
+		})).body?.cancel().catch(() => {});
+		return null;
+	} catch (err) {
+		const e = err;
+		const detail = `${typeof e.code === "string" ? e.code : ""} ${typeof e.message === "string" ? e.message : ""}`;
+		return TLS_FAILURE.test(detail) ? `TLS failed: ${String(e.message ?? e.code)}` : null;
+	}
+}
+/** Connect, read the host's identity and `daemon.info`, disconnect. Never throws. */
+async function probeWsHost(target) {
+	const started = performance.now();
+	const signal = AbortSignal.timeout(target.timeoutMs ?? 1e4);
+	let client;
+	try {
+		client = await connectWsClient({
+			url: target.url,
+			token: target.token,
+			heartbeatMs: 0,
+			signal
+		});
+		const hostRef = hostRefOf(client.hello);
+		if (!hostRef) return {
+			ok: false,
+			error: "protocol",
+			message: `${displayHostUrl(target.url)} runs a zidane too old to say which host it is. Upgrade the server.`
+		};
+		const info = await client.request("daemon.info", {});
+		const serverVersion = info.codeVersion ?? info.appVersion;
+		return {
+			ok: true,
+			hostRef,
+			...serverVersion ? { serverVersion } : {},
+			latencyMs: Math.round(performance.now() - started)
+		};
+	} catch (err) {
+		if (signal.aborted && !(err instanceof HostAuthError)) return {
+			ok: false,
+			error: "unreachable",
+			message: `No answer from ${displayHostUrl(target.url)} within ${target.timeoutMs ?? 1e4} ms.`
+		};
+		const classified = classify(err);
+		if (classified.error === "unreachable") {
+			const tls = await tlsFailure(target.url, signal).catch(() => null);
+			if (tls) return {
+				ok: false,
+				error: "tls",
+				message: tls
+			};
+		}
+		return {
+			ok: false,
+			...classified
+		};
+	} finally {
+		client?.close();
+	}
+}
+/** The registry in `dataDir`, connecting over WebSocket. */
+function createWsHostRegistry(options) {
+	return createHostRegistry({
+		dataDir: options.dataDir,
+		probe: probeWsHost
+	});
+}
+//#endregion
+//#region src/ipc/hosts/saved-hosts.ts
+/** No token is saved for this server (removed by hand, or another window removed it). */
+var MissingHostTokenError = class extends Error {
+	constructor() {
+		super("No token saved for this server: add it again.");
+		this.name = "MissingHostTokenError";
+	}
+};
+function startSavedHosts(options) {
+	const { registry, directory, skip = () => false } = options;
+	const classify = (err) => err instanceof MissingHostTokenError ? "auth" : err instanceof HostIdentityError ? "identity" : options.classify?.(err) ?? "retry";
+	/** The saved server, or nobody: a connection from another host is closed before anyone sees it. */
+	const dial = async (entry, token, attempt) => {
+		const client = await options.connect(entry, token, attempt);
+		const ref = hostRefOf(client.hello);
+		if (ref?.id === entry.id) return client;
+		client.close();
+		throw new HostIdentityError(displayHostUrl(entry.url), ref?.name);
+	};
+	const loops = /* @__PURE__ */ new Map();
+	const disconnect = (key) => {
+		loops.get(key)?.stop();
+		loops.delete(key);
+	};
+	/** (Re)connect `entry` with the token saved now, its directory entry kept or created in place. */
+	const connect = (entry) => {
+		const key = entry.id;
+		disconnect(key);
+		directory.upsert(entry, registry.token(key));
+		loops.set(key, keepHostConnected({
+			connect: (attempt) => {
+				const token = registry.token(key);
+				return token ? dial(entry, token, attempt) : Promise.reject(new MissingHostTokenError());
+			},
+			update: (patch) => directory.update(key, patch),
+			classify,
+			...options.onSignal ? { onSignal: (signal) => options.onSignal(key, signal) } : {},
+			...options.onConnected ? { onConnected: (client) => options.onConnected(key, client) } : {},
+			...options.onDisconnected ? { onDisconnected: () => options.onDisconnected(key) } : {},
+			...options.minDelayMs !== void 0 ? { minDelayMs: options.minDelayMs } : {},
+			...options.maxDelayMs !== void 0 ? { maxDelayMs: options.maxDelayMs } : {}
+		}));
+	};
+	/** Bring the directory in line with the saved hosts. */
+	const sync = () => {
+		const entries = registry.list().filter((entry) => !skip(entry));
+		const saved = new Set(entries.map((entry) => entry.id));
+		const known = new Map(directory.saved().map((host) => [host.key, host.url]));
+		for (const key of known.keys()) if (!saved.has(key)) {
+			disconnect(key);
+			directory.remove(key);
+		}
+		for (const entry of entries) if (known.get(entry.id) !== entry.url) connect(entry);
+		else directory.update(entry.id, {
+			name: entry.name,
+			...entry.serverVersion ? { serverVersion: entry.serverVersion } : {}
+		});
+	};
+	sync();
+	return {
+		list: () => registry.list(),
+		add: async (input) => {
+			const entry = await registry.add(input);
+			if (!skip(entry)) connect(entry);
+			sync();
+			return entry;
+		},
+		remove: (id) => {
+			const removed = registry.remove(id);
+			sync();
+			return removed;
+		},
+		rename: (id, name) => {
+			const entry = registry.rename(id, name);
+			sync();
+			return entry;
+		},
+		test: async (target) => {
+			if (typeof target === "object" && !("id" in target)) {
+				if (!options.probeUnsaved) throw new Error("Testing an unsaved host is not available here.");
+				return options.probeUnsaved(target);
+			}
+			const id = typeof target === "string" ? target : target.id;
+			const result = await registry.test(id);
+			if (result.ok) {
+				directory.update(id, {
+					serverName: result.hostRef.name,
+					...result.serverVersion ? { serverVersion: result.serverVersion } : {}
+				});
+				loops.get(id)?.retry();
+			}
+			return result;
+		},
+		retry: (id) => loops.get(id)?.retry(),
+		stop: () => {
+			for (const key of [...loops.keys()]) {
+				disconnect(key);
+				directory.remove(key);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/ipc/hosts/ws.ts
+/** A refused token stays refused until the user changes something: no retry loop. */
+function classifyWsFailure(err) {
+	return err instanceof HostAuthError ? "auth" : err instanceof HostIdentityError ? "identity" : "retry";
+}
+/** The add form's "test": the registry's own checks and probe over WebSocket, saving nothing. */
+function probeUnsavedWsHost(target) {
+	return probeUnsavedHost(probeWsHost, target);
+}
+function startWsSavedHosts(options) {
+	const { dataDir, appVersion, connect, registry, ...rest } = options;
+	return startSavedHosts({
+		...rest,
+		registry: registry ?? createWsHostRegistry({ dataDir }),
+		classify: classifyWsFailure,
+		probeUnsaved: probeUnsavedWsHost,
+		connect: connect ?? ((entry, token, attempt) => connectWsClient({
+			url: entry.url,
+			token,
+			expectHostId: entry.id,
+			...appVersion ? { appVersion } : {},
+			signal: attempt.signal,
+			onClose: attempt.onClose
+		}))
+	});
+}
+//#endregion
+export { startSavedHosts as a, probeWsHost as c, MissingHostTokenError as i, createSyncEngine as l, probeUnsavedWsHost as n, HOST_PROBE_TIMEOUT_MS as o, startWsSavedHosts as r, createWsHostRegistry as s, classifyWsFailure as t };
+
+//# sourceMappingURL=ws-CIHMvlSh.js.map