zidane 7.2.4 → 8.0.4

package/dist/links-j8rED1sR.js

@@ -0,0 +1,603 @@
+import { i as writeJsonFileAtomic, t as OWNER_ONLY } from "./atomic-write-Ijgf2Mhc.js";
+import { n as JsonRpcRemoteError, t as JsonRpcConnectionClosedError } from "./json-rpc--HXQti1E.js";
+import { $t as MachineErrorCode, en as isValidMachineName, tn as machineCredentialKey } from "./tool-formatters-IQFDrdrs.js";
+import { n as displayHostUrl } from "./url-D8HCl65b.js";
+import { t as createHostRegistry } from "./registry-D6ShBWJU.js";
+import { ir as MachineLinkLostError } from "./chat-JPJJ8uu5.js";
+import { m as writeCredentialEntry, r as readCredentialEntry } from "./credentials-JttEuRON.js";
+import { f as HostIdentityError } from "./types-CH5XpIHw.js";
+import { x as ZIDANE_VERSION } 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 { createMachineExecutor, shareableRoot } from "./executor-Cx5-8yqi.js";
+import { n as machineIdentity } from "./identity-CwfO8K-t.js";
+import { closeSync, existsSync, linkSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import process from "node:process";
+//#region src/ipc/machine/agent.ts
+/** A registration the host refused for good (its name taken, another protocol). */
+var MachineRegisterError = class extends Error {
+	forGood;
+	constructor(message, forGood) {
+		super(message);
+		this.forGood = forGood;
+		this.name = "MachineRegisterError";
+	}
+};
+function normalizeRoots(roots, zidaneDataDir) {
+	if (roots.length === 0) throw new Error("Share at least one folder (--root).");
+	return roots.map((root) => {
+		const entry = typeof root === "string" ? { path: root } : root;
+		const real = shareableRoot(entry.path, zidaneDataDir);
+		if (!statSync(real).isDirectory()) throw new Error(`Root ${entry.path} is not a folder.`);
+		return {
+			path: real,
+			...entry.label ? { label: entry.label } : {}
+		};
+	});
+}
+/** The host id this machine pinned for `url` (the first host that answered there). */
+function pinnedHosts(dataDir) {
+	const file = join(dataDir, "machine-hosts.json");
+	const read = () => {
+		try {
+			return JSON.parse(readFileSync(file, "utf8"));
+		} catch {
+			return {};
+		}
+	};
+	return {
+		get: (url) => read()[url],
+		set: (url, hostId) => writeJsonFileAtomic(file, {
+			...read(),
+			[url]: hostId
+		}, {
+			ensureDir: true,
+			mode: 384
+		})
+	};
+}
+function startMachineAgent(options) {
+	if (!isValidMachineName(options.name)) throw new Error(`"${options.name}" is not a valid machine name: 1 to 64 letters, digits, ".", "-" or "_".`);
+	mkdirSync(options.dataDir, {
+		recursive: true,
+		mode: 448
+	});
+	const dataDir = realpathSync.native(options.dataDir);
+	const roots = normalizeRoots(options.roots, options.credentialsDataDir);
+	const machineId = machineIdentity(dataDir);
+	const pins = pinnedHosts(dataDir);
+	const url = options.hostUrl;
+	let client = null;
+	let status = "connecting";
+	const executor = createMachineExecutor({
+		roots,
+		dataDir,
+		...options.terminalGraceMs !== void 0 ? { terminalGraceMs: options.terminalGraceMs } : {},
+		...options.sandbox ? { sandbox: options.sandbox } : {},
+		...options.credentialsDataDir ? { credentialsDataDir: options.credentialsDataDir } : {},
+		notify: (method, params) => {
+			if (!client) return false;
+			try {
+				client.notify(method, params);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	});
+	const register = {
+		machineId,
+		name: options.name,
+		roots,
+		capabilities: {
+			shell: true,
+			terminals: typeof globalThis.Bun !== "undefined",
+			background: true,
+			worktrees: true,
+			stream: true,
+			sandboxed: executor.sandbox.on
+		},
+		version: options.appVersion ?? ZIDANE_VERSION,
+		protocolVersion: 1
+	};
+	const loop = keepHostConnected({
+		minDelayMs: options.minDelayMs ?? 1e3,
+		maxDelayMs: options.maxDelayMs ?? 3e4,
+		async connect({ signal, onClose }) {
+			const expectHostId = pins.get(url);
+			const connected = await connectWsClient({
+				url,
+				token: options.token,
+				signal,
+				onClose,
+				appVersion: register.version,
+				...options.heartbeatMs !== void 0 ? { heartbeatMs: options.heartbeatMs } : {},
+				...expectHostId ? { expectHostId } : {},
+				serve: {
+					request: (method, params) => executor.handle(method, params),
+					notification: (method, params) => void executor.handle(method, params).catch(() => void 0)
+				}
+			});
+			try {
+				await connected.request("machine.register", register);
+			} catch (err) {
+				connected.close();
+				const code = err instanceof JsonRpcRemoteError ? err.code : void 0;
+				throw new MachineRegisterError(`${displayHostUrl(url)} refused this machine: ${err.message}`, code === MachineErrorCode.NameTaken || code === MachineErrorCode.VersionSkew || code === MachineErrorCode.IdBound);
+			}
+			if (!expectHostId && connected.hello.hostId) pins.set(url, connected.hello.hostId);
+			return connected;
+		},
+		classify: (err) => {
+			if (err instanceof HostIdentityError) return "identity";
+			if (err instanceof HostAuthError || err instanceof MachineRegisterError && err.forGood) return "auth";
+			return "retry";
+		},
+		update: (patch) => {
+			if (patch.client !== void 0) client = patch.client;
+			if (patch.status) {
+				status = patch.status;
+				options.onStatus?.(patch.status, patch.error);
+			}
+		},
+		onConnected: () => executor.linkUp(),
+		onDisconnected: () => executor.linkLost()
+	});
+	return {
+		machineId,
+		status: () => status,
+		retry: () => loop.retry(),
+		async stop() {
+			loop.stop();
+			await executor.close();
+		}
+	};
+}
+//#endregion
+//#region src/ipc/machine/reverse.ts
+/** The server refused to lend itself (`allowAsMachine` off, a name taken here): for good. A busy server is retried. */
+var AttachRefusedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AttachRefusedError";
+	}
+};
+function connectionOver(client) {
+	return {
+		async request(method, params) {
+			try {
+				return await client.request("machine.call", {
+					method,
+					params: params ?? {}
+				});
+			} catch (err) {
+				if (err instanceof JsonRpcConnectionClosedError) throw new MachineLinkLostError();
+				throw err instanceof JsonRpcRemoteError ? new Error(err.message) : err;
+			}
+		},
+		notify: (method, params) => client.notify("machine.call", {
+			method,
+			params: params ?? {}
+		}),
+		close: () => client.close()
+	};
+}
+function startServerMachine(options) {
+	let attached;
+	const where = displayHostUrl(options.url);
+	const detach = () => {
+		attached?.closed();
+		attached = void 0;
+	};
+	const loop = keepHostConnected({
+		...options.minDelayMs !== void 0 ? { minDelayMs: options.minDelayMs } : {},
+		...options.maxDelayMs !== void 0 ? { maxDelayMs: options.maxDelayMs } : {},
+		async connect({ signal, onClose }) {
+			const client = await connectWsClient({
+				url: options.url,
+				token: options.token,
+				expectHostId: options.expectHostId,
+				signal,
+				onClose,
+				...options.appVersion ? { appVersion: options.appVersion } : {},
+				...options.heartbeatMs !== void 0 ? { heartbeatMs: options.heartbeatMs } : {}
+			});
+			const early = [];
+			let current;
+			client.onSignal((s) => {
+				if (s.kind !== "machine:notification") return;
+				if (current) current.notification(s.method, s.params);
+				else if (early.length < 1024) early.push({
+					method: s.method,
+					params: s.params
+				});
+			});
+			try {
+				const params = await client.request("machine.attach", { hostId: options.localHostId });
+				detach();
+				current = options.machines.attach(params, connectionOver(client));
+				attached = current;
+				for (const { method, params: p } of early.splice(0)) current.notification(method, p);
+				options.onState("connected", void 0, params.name);
+			} catch (err) {
+				client.close();
+				if (err instanceof JsonRpcConnectionClosedError || err instanceof JsonRpcRemoteError && err.code === MachineErrorCode.Busy) throw new Error(`${where} can't lend itself right now: ${err.message}`);
+				throw new AttachRefusedError(`${where} refused to be a machine: ${err.message}`);
+			}
+			return client;
+		},
+		classify: (err) => err instanceof HostIdentityError ? "identity" : err instanceof HostAuthError || err instanceof AttachRefusedError ? "auth" : "retry",
+		update: (patch) => {
+			if (!patch.status || patch.status === "connected") return;
+			options.onState(patch.status === "auth-refused" && patch.error?.includes("refused to be a machine") ? "refused" : patch.status, patch.error);
+		},
+		onDisconnected: detach
+	});
+	return {
+		retry: () => loop.retry(),
+		stop() {
+			loop.stop();
+			detach();
+		}
+	};
+}
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+function readRecord(file) {
+	try {
+		const mtimeMs = statSync(file).mtimeMs;
+		const raw = JSON.parse(readFileSync(file, "utf8"));
+		return {
+			mtimeMs,
+			...typeof raw.pid === "number" && typeof raw.nonce === "string" ? { record: {
+				pid: raw.pid,
+				nonce: raw.nonce
+			} } : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		try {
+			return { mtimeMs: statSync(file).mtimeMs };
+		} catch {
+			return;
+		}
+	}
+}
+function createShareLock(file, options = {}) {
+	const pid = options.pid ?? process.pid;
+	const alive = options.alive ?? processAlive;
+	const now = options.now ?? Date.now;
+	const staleMs = options.staleMs ?? 3e4;
+	const nonce = randomBytes(12).toString("hex");
+	let holding = false;
+	const create = () => {
+		let fd;
+		try {
+			fd = openSync(file, "wx", 384);
+		} catch {
+			return false;
+		}
+		try {
+			writeSync(fd, JSON.stringify({
+				pid,
+				nonce
+			}));
+		} finally {
+			closeSync(fd);
+		}
+		return true;
+	};
+	const ours = () => readRecord(file)?.record?.nonce === nonce;
+	const stale = (found) => now() - found.mtimeMs > staleMs || found.record !== void 0 && !alive(found.record.pid);
+	/** Move a stale lock aside; `true` when the record moved is the one judged stale. */
+	const evict = (judged) => {
+		const aside = `${file}.${nonce}.stale`;
+		try {
+			renameSync(file, aside);
+		} catch {
+			return false;
+		}
+		const moved = readRecord(aside);
+		const same = moved?.record?.nonce === judged.record?.nonce && moved?.mtimeMs === judged.mtimeMs;
+		if (!same) try {
+			linkSync(aside, file);
+		} catch {}
+		rmSync(aside, { force: true });
+		return same;
+	};
+	return {
+		acquire() {
+			if (holding) {
+				if (ours()) {
+					try {
+						const at = new Date(now());
+						utimesSync(file, at, at);
+					} catch {}
+					return true;
+				}
+				holding = false;
+			}
+			if (create()) {
+				holding = true;
+				return true;
+			}
+			const found = readRecord(file);
+			if (found && !stale(found)) return false;
+			if (found && !evict(found)) return false;
+			holding = create();
+			return holding;
+		},
+		held: () => holding,
+		release() {
+			const mine = holding && ours();
+			if (mine) rmSync(file, { force: true });
+			holding = false;
+			return mine;
+		}
+	};
+}
+//#endregion
+//#region src/ipc/machine/links.ts
+const POLL_MS = 2e3;
+const CONFIG_FILE = "machine-links.json";
+const STATUS_FILE = "machine-links-status.json";
+const LOCK_FILE = "machine-links.lock";
+const MAX_ROOTS = 32;
+function readJson(file, fallback) {
+	try {
+		return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : fallback;
+	} catch {
+		return fallback;
+	}
+}
+function readConfig(file) {
+	const raw = readJson(file, {});
+	return {
+		version: 1,
+		shares: Array.isArray(raw.shares) ? raw.shares.filter((s) => !!s && typeof s.hostId === "string" && typeof s.name === "string" && Array.isArray(s.roots) && s.roots.every((r) => typeof r === "string")) : [],
+		uses: Array.isArray(raw.uses) ? raw.uses.filter((u) => typeof u === "string") : []
+	};
+}
+/**
+* A share's name and roots, as a client sent them: every root absolute,
+* existing, and not (by its real path) zidane's data dir, inside it, or a
+* credentials folder (`./executor`'s `shareableRoot`).
+*/
+function checkShareInput(input, zidaneDataDir) {
+	if (!isValidMachineName(input.name)) throw new Error(`"${input.name}" is not a valid machine name: 1 to 64 letters, digits, ".", "-" or "_".`);
+	if (!Array.isArray(input.roots) || input.roots.length === 0) throw new Error("Share at least one folder.");
+	if (input.roots.length > MAX_ROOTS) throw new Error(`Share at most ${MAX_ROOTS} folders.`);
+	for (const root of input.roots) {
+		if (typeof root !== "string" || !isAbsolute(root)) throw new Error(`${String(root)} is not an absolute folder path.`);
+		shareableRoot(root, zidaneDataDir);
+	}
+}
+function startMachineLinks(options) {
+	const { dataDir, machines } = options;
+	const configFile = join(dataDir, CONFIG_FILE);
+	const statusFile = join(dataDir, STATUS_FILE);
+	const lock = createShareLock(join(dataDir, LOCK_FILE));
+	const hosts = createHostRegistry({
+		dataDir,
+		probe: async () => ({
+			ok: false,
+			error: "unreachable",
+			message: "not probed here"
+		})
+	});
+	const instance = `${(options.hostId ?? "local").slice(0, 40)}-${randomBytes(4).toString("hex")}`;
+	const pacing = {
+		...options.minDelayMs !== void 0 ? { minDelayMs: options.minDelayMs } : {},
+		...options.maxDelayMs !== void 0 ? { maxDelayMs: options.maxDelayMs } : {},
+		...options.heartbeatMs !== void 0 ? { heartbeatMs: options.heartbeatMs } : {}
+	};
+	const shares = /* @__PURE__ */ new Map();
+	const uses = /* @__PURE__ */ new Map();
+	let holder = false;
+	let closed = false;
+	let lastPublished = "";
+	const ownStatus = () => ({
+		shares: [...shares.values()].map((s) => s.status),
+		uses: [...uses.values()].map((u) => u.status)
+	});
+	/** Shares as the holder reports them (another process may run them). */
+	const status = () => {
+		const own = ownStatus();
+		if (holder) return own;
+		const config = readConfig(configFile);
+		const published = readJson(statusFile, {});
+		const known = new Map((published.shares ?? []).map((s) => [s.hostId, s]));
+		return {
+			shares: config.shares.map((s) => known.get(s.hostId) ?? {
+				hostId: s.hostId,
+				name: s.name,
+				roots: s.roots,
+				state: "connecting",
+				detail: "waiting for the zidane process that shares this computer"
+			}),
+			uses: own.uses
+		};
+	};
+	const publish = () => {
+		if (closed) return;
+		const snapshot = status();
+		const text = JSON.stringify(snapshot);
+		if (holder) try {
+			writeJsonFileAtomic(statusFile, { shares: snapshot.shares }, OWNER_ONLY);
+		} catch {}
+		if (text === lastPublished) return;
+		lastPublished = text;
+		options.onChange(snapshot);
+	};
+	const entry = (hostId) => {
+		const found = hosts.get(hostId);
+		if (!found) throw new Error(`No saved server "${hostId}": add it on the Hosts page first.`);
+		return found;
+	};
+	function runShare(config) {
+		const status = {
+			hostId: config.hostId,
+			name: config.name,
+			roots: config.roots,
+			state: "connecting"
+		};
+		const share = {
+			config,
+			status
+		};
+		shares.set(config.hostId, share);
+		const set = (state, detail) => {
+			share.status = {
+				...status,
+				state,
+				...detail && state !== "connected" ? { detail } : {}
+			};
+			publish();
+		};
+		try {
+			const server = entry(config.hostId);
+			const cred = readCredentialEntry(dataDir, machineCredentialKey(config.hostId));
+			const token = cred?.kind === "apikey" ? cred.value : void 0;
+			if (!token) throw new Error(`No machine token saved for ${server.name}.`);
+			share.agent = startMachineAgent({
+				hostUrl: server.url,
+				token,
+				name: config.name,
+				roots: config.roots,
+				dataDir: join(dataDir, "machine"),
+				credentialsDataDir: dataDir,
+				...options.settings ? { sandbox: options.settings() } : {},
+				...pacing,
+				...options.appVersion ? { appVersion: options.appVersion } : {},
+				onStatus: (state, detail) => set(state, detail)
+			});
+		} catch (err) {
+			set("refused", err.message);
+		}
+	}
+	function runUse(hostId) {
+		const use = { status: {
+			hostId,
+			state: "connecting"
+		} };
+		uses.set(hostId, use);
+		const set = (state, detail, machineName) => {
+			use.status = {
+				hostId,
+				state,
+				...detail && state !== "connected" ? { detail } : {},
+				...machineName ?? use.status.machineName ? { machineName: machineName ?? use.status.machineName } : {}
+			};
+			publish();
+		};
+		try {
+			const server = entry(hostId);
+			const token = hosts.token(hostId);
+			if (!token) throw new Error(`No token saved for ${server.name}: add it again.`);
+			use.link = startServerMachine({
+				machines,
+				url: server.url,
+				token,
+				expectHostId: hostId,
+				localHostId: instance,
+				...pacing,
+				...options.appVersion ? { appVersion: options.appVersion } : {},
+				onState: set
+			});
+		} catch (err) {
+			set("refused", err.message);
+		}
+	}
+	const stopShare = async (hostId) => {
+		const share = shares.get(hostId);
+		shares.delete(hostId);
+		await share?.agent?.stop();
+	};
+	/** Bring the running links in line with the saved config. */
+	function reconcile() {
+		if (closed) return;
+		const config = readConfig(configFile);
+		holder = lock.acquire();
+		if (!holder) for (const hostId of [...shares.keys()]) stopShare(hostId);
+		else {
+			const wanted = new Map(config.shares.map((s) => [s.hostId, s]));
+			for (const [hostId, share] of shares) {
+				const want = wanted.get(hostId);
+				if (!want || JSON.stringify(want) !== JSON.stringify(share.config)) stopShare(hostId);
+			}
+			for (const share of config.shares) if (!shares.has(share.hostId)) runShare(share);
+		}
+		const wantedUses = new Set(config.uses);
+		for (const [hostId, use] of uses) if (!wantedUses.has(hostId)) {
+			use.link?.stop();
+			uses.delete(hostId);
+		}
+		for (const hostId of config.uses) if (!uses.has(hostId)) runUse(hostId);
+		publish();
+	}
+	const writeConfig = (mutate) => {
+		const config = readConfig(configFile);
+		mutate(config);
+		writeJsonFileAtomic(configFile, config, OWNER_ONLY);
+		reconcile();
+		return status();
+	};
+	reconcile();
+	const timer = setInterval(reconcile, options.pollMs ?? POLL_MS);
+	timer.unref?.();
+	return {
+		status,
+		startShare(input) {
+			checkShareInput(input, dataDir);
+			const server = entry(input.hostId);
+			const token = input.token?.trim();
+			if (token) writeCredentialEntry(dataDir, machineCredentialKey(input.hostId), {
+				kind: "apikey",
+				value: token
+			});
+			else if (readCredentialEntry(dataDir, machineCredentialKey(input.hostId))?.kind !== "apikey") throw new Error(`No machine token for ${server.name}: create one there (zidane server token create --scope machine) or let this window create it.`);
+			return writeConfig((config) => {
+				config.shares = [...config.shares.filter((s) => s.hostId !== input.hostId), {
+					hostId: input.hostId,
+					name: input.name,
+					roots: [...input.roots]
+				}];
+			});
+		},
+		stopShare(hostId) {
+			return writeConfig((config) => {
+				config.shares = config.shares.filter((s) => s.hostId !== hostId);
+			});
+		},
+		setUse(hostId, enabled) {
+			if (enabled) {
+				const server = entry(hostId);
+				if (!hosts.token(hostId)) throw new Error(`No token saved for ${server.name}: add it again.`);
+			}
+			return writeConfig((config) => {
+				config.uses = enabled ? [.../* @__PURE__ */ new Set([...config.uses, hostId])] : config.uses.filter((u) => u !== hostId);
+			});
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			clearInterval(timer);
+			for (const use of uses.values()) use.link?.stop();
+			uses.clear();
+			await Promise.all([...shares.keys()].map(stopShare));
+			if (lock.release()) rmSync(statusFile, { force: true });
+		}
+	};
+}
+//#endregion
+export { startMachineLinks };
+
+//# sourceMappingURL=links-j8rED1sR.js.map