mainflow 0.42.0 → 0.43.0-alpha.1

package/dist/{ui-D1dg19Jw.js → ui-xxzmhAqF.js}

@@ -1,11 +1,12 @@
-import { P as configSchema } from "./dist-zSabglPq.js";
-import { $ as linksInto, At as WriteError, C as HANDLED_FILE, D as loadSessions, E as readNotices$1, I as attributeTrace, J as loadConfig, L as traceTranscript, O as readSession, Ot as ConflictError, Q as mainlineEdges, R as transcriptTitle, T as parseWarn, X as sectionText, Y as loadHub, Z as dependencyGraph, _ as setArchivedMany, a as openInApp, g as ARCHIVE_KINDS, k as transcriptPath, kt as DATA_DIR, nt as remoteMembers, q as HubError, st as readYaml, tt as refIndex, u as groupPlan, w as markNoticesHandled } from "./host-BAMZmRy8.js";
+import { I as configSchema, tt as repoPaths } from "./dist-D5rZ0MQH.js";
+import { $ as loadConfig, $t as WriteError, A as transcriptPath, D as readNotices$1, E as parseWarn, Jt as hubPath, L as attributeTrace, Nt as hubAtRoot, O as loadSessions, Q as HubError, Qt as DATA_DIR, R as traceTranscript, T as markNoticesHandled, Zt as ConflictError, _ as ARCHIVE_KINDS, a as openInApp, et as loadHub, ft as readYaml, it as linksInto, k as readSession, nt as dependencyGraph, ot as refIndex, qt as dataFile, rt as mainlineEdges, st as remoteMembers, tt as sectionText, u as groupPlan, v as setArchivedMany, w as HANDLED_FILE, z as transcriptTitle } from "./host-BJvqZy-i.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { A as isSynced, _ as readDaemon, a as remoteMode, b as readRemote, h as callDaemon, j as syncPaths, k as SYNC_DIR, m as DaemonUnavailable, n as hubWriter, r as writtenLines, y as watchTree } from "./operation-2wx2ex6x.js";
-import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-DosYhbwc.js";
+import { C as readRemote, F as syncPaths, N as SYNC_DIR, P as isSynced, S as watchTree, _ as DaemonUnavailable, b as readDaemon, n as hubWriter, r as writtenLines, s as remoteMode, v as callDaemon } from "./operation-BhBbGauo.js";
+import { t as CLI_VERSION } from "./version-Dvv4jwF1.js";
+import { readUiRecord, realRoot } from "./launch.js";
 import { createRequire } from "node:module";
 import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, realpathSync, statSync } from "node:fs";
-import { basename, dirname, extname, join, normalize, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 import { parse as parse$1 } from "yaml";
@@ -140,9 +141,11 @@ const groupView = (hub, g) => ({
 	summary: groupSummary(g.body),
 	order: groupPlan(hub, [], g.id).members.map((m) => m.ref)
 });
-/** The 503 body for a config.yaml that cannot be used, with the hub's root left out of paths. */
-function configErrorView(root, error) {
-	const scrub = (text) => text.replaceAll(`${root}${sep}`, "");
+/** A message with the hub's directories left out of its paths: a file of the hub reads `.mainflow/{path}`. */
+const scrubbed = (dirs, text) => text.replaceAll(`${dirs.data}${sep}`, `${DATA_DIR}/`).replaceAll(`${dirs.root}${sep}`, "");
+/** The 503 body for a config.yaml that cannot be used, with the hub's directories left out of paths. */
+function configErrorView(dirs, error) {
+	const scrub = (text) => scrubbed(dirs, text);
 	const message = scrub(error.message);
 	const problems = error instanceof HubError ? error.problems : [];
 	const detail = problems.map((p) => `${p.field ? `${p.field}: ` : ""}${scrub(p.message)}`).join("; ");
@@ -158,10 +161,10 @@ function configErrorView(root, error) {
 * through the hub's writer (src/remote/operation.ts), so in remote mode they are operations the sync server applies;
 * `env` gives the sync server and service token as the environment variables do, `{}` for a hub other than the process's own.
 */
-function createApp(root, options = {}) {
+function createApp(dirs, options = {}) {
 	const app = new Hono();
-	const mainlinesRoot = join(root, DATA_DIR, "mainlines");
-	const writer = hubWriter(root, options.env);
+	const mainlinesRoot = join(dirs.data, "mainlines");
+	const writer = hubWriter(dirs, options.env);
 	const notes = /* @__PURE__ */ new WeakMap();
 	const write = async (c, op, input) => {
 		const written = await writer(op, input);
@@ -185,10 +188,10 @@ function createApp(root, options = {}) {
 	let knownName;
 	const configFailure = () => {
 		try {
-			knownName = loadConfig(root).hub;
+			knownName = loadConfig(dirs).hub;
 			return null;
 		} catch (error) {
-			return configErrorView(root, error);
+			return configErrorView(dirs, error);
 		}
 	};
 	/**
@@ -198,10 +201,10 @@ function createApp(root, options = {}) {
 	const fallbackName = () => {
 		if (knownName) return knownName;
 		try {
-			const raw = configSchema.safeParse(parse$1(readFileSync(join(root, DATA_DIR, "config.yaml"), "utf8")));
+			const raw = configSchema.safeParse(parse$1(readFileSync(join(dirs.data, "config.yaml"), "utf8")));
 			if (raw.success) return raw.data.hub;
 		} catch {}
-		return basename(realRoot(root));
+		return basename(realRoot(dirs.root));
 	};
 	configFailure();
 	app.use("/api/*", async (c, next) => {
@@ -210,8 +213,8 @@ function createApp(root, options = {}) {
 		return failure ? c.json(failure, 503) : next();
 	});
 	app.onError((error, c) => {
-		const message = error.message.replaceAll(`${root}${sep}`, "");
-		if (error instanceof HubError) return c.json(configErrorView(root, error), 503);
+		const message = scrubbed(dirs, error.message);
+		if (error instanceof HubError) return c.json(configErrorView(dirs, error), 503);
 		if (error instanceof ConflictError) return c.json({ error: message }, 409);
 		if (error instanceof WriteError) return c.json({ error: message }, 400);
 		throw error;
@@ -220,7 +223,7 @@ function createApp(root, options = {}) {
 		const failure = configFailure();
 		const who = {
 			hub: failure ? fallbackName() : knownName,
-			root: realRoot(root),
+			root: realRoot(dirs.root),
 			version: CLI_VERSION,
 			pid: process.pid
 		};
@@ -232,15 +235,15 @@ function createApp(root, options = {}) {
 		return c.json(who);
 	});
 	app.get("/api/host", (c) => {
-		const hostError = readUiRecord(root)?.hostError;
+		const hostError = readUiRecord(dirs)?.hostError;
 		return c.json(hostError ? { hostError } : {});
 	});
 	app.get("/api/hub", (c) => {
-		const hub = loadHub(root);
+		const hub = loadHub(dirs);
 		const body = {
 			hub: hub.config.hub,
 			version: CLI_VERSION,
-			repos: hub.config.repos,
+			repos: repoPaths(hub.config.repos),
 			mainlines: hub.mainlines.map(summarize),
 			groups: hub.groups.map((g) => groupView(hub, g)),
 			openIssues: hub.issues.filter((i) => i.status !== "closed").length,
@@ -249,21 +252,21 @@ function createApp(root, options = {}) {
 		};
 		return c.json(body);
 	});
-	app.get("/api/relations", (c) => c.json(relationsView(loadHub(root))));
-	const local = () => loadHub(root, { remotes: false });
+	app.get("/api/relations", (c) => c.json(relationsView(loadHub(dirs))));
+	const local = () => loadHub(dirs, { remotes: false });
 	app.get("/api/issues", (c) => c.json(local().issues));
 	app.get("/api/findings", (c) => c.json(local().findings));
 	app.get("/api/ops", (c) => c.json(local().ops));
 	app.post("/api/reveal", async (c) => {
 		const { path } = await c.req.json();
-		const known = loadSessions(root).sessions.some((s) => s.transcript === path);
-		const file = transcriptPath(root, path);
+		const known = loadSessions(dirs).sessions.some((s) => s.transcript === path);
+		const file = transcriptPath(dirs, path);
 		if (!known || !existsSync(file)) return c.json({ error: "only a transcript recorded on a session can be revealed" }, 400);
 		const opened = spawnSync("open", ["-R", file]);
 		return opened.status === 0 ? c.json({ revealed: file }) : c.json({ error: `open -R failed: ${opened.stderr}` }, 500);
 	});
 	const viewOf = (m) => {
-		const remoteFiles = remoteFilesOf(root, m);
+		const remoteFiles = remoteFilesOf(dirs, m);
 		return remoteFiles.length > 0 ? {
 			...m,
 			remoteFiles
@@ -283,13 +286,13 @@ function createApp(root, options = {}) {
 		if (!mainline) return c.json({ error: `mainline ${c.req.param("m")} not found` }, 404);
 		const { path } = await c.req.json().catch(() => ({ path: void 0 }));
 		if (typeof path !== "string") return c.json({ error: "path is required" }, 400);
-		if (resolve(root, path).startsWith(join(root, mainline.dir) + sep) && !remoteFilesOf(root, mainline).includes(path) && existsSync(resolve(root, path))) return c.json({ fetched: true });
-		if (!remoteFilesOf(root, mainline).includes(path)) return c.json({ error: `${path} is not a file of ${mainline.id} that is only on the sync server` }, 404);
-		return c.json(await fetchFromServer(root, path));
+		if (dataFile(dirs, normalize(path)).startsWith(dataFile(dirs, mainline.dir) + sep) && !remoteFilesOf(dirs, mainline).includes(path) && existsSync(dataFile(dirs, normalize(path)))) return c.json({ fetched: true });
+		if (!remoteFilesOf(dirs, mainline).includes(path)) return c.json({ error: `${path} is not a file of ${mainline.id} that is only on the sync server` }, 404);
+		return c.json(await fetchFromServer(dirs, path));
 	});
 	const titles = /* @__PURE__ */ new Map();
 	const titleOf = (recorded) => {
-		const transcript = recorded && transcriptPath(root, recorded);
+		const transcript = recorded && transcriptPath(dirs, recorded);
 		if (!transcript || !existsSync(transcript)) return void 0;
 		const { size, mtimeMs } = statSync(transcript);
 		const stamp = `${size}:${mtimeMs}`;
@@ -303,13 +306,13 @@ function createApp(root, options = {}) {
 		return title;
 	};
 	app.get("/api/sessions", (c) => {
-		const { sessions, problems } = loadSessions(root);
+		const { sessions, problems } = loadSessions(dirs);
 		const views = sessions.map((s) => {
 			const title = titleOf(s.transcript);
 			return {
 				...s,
 				...title ? { title } : {},
-				...runsElsewhere(root, s) ? { elsewhere: true } : {}
+				...runsElsewhere(dirs, s) ? { elsewhere: true } : {}
 			};
 		});
 		return c.json({
@@ -346,9 +349,9 @@ function createApp(root, options = {}) {
 		})).value);
 	});
 	app.get("/api/sessions/:id/trace", (c) => {
-		const session = readSession(root, c.req.param("id"));
+		const session = readSession(dirs, c.req.param("id"));
 		if (!session) return c.json({ error: `session ${c.req.param("id")} not found` }, 404);
-		const transcript = session.transcript && transcriptPath(root, session.transcript);
+		const transcript = session.transcript && transcriptPath(dirs, session.transcript);
 		if (!transcript || !existsSync(transcript)) return c.json({
 			available: false,
 			byAction: {},
@@ -363,8 +366,8 @@ function createApp(root, options = {}) {
 	});
 	app.get("/api/files/*", (c) => {
 		const path = normalize(decodeURIComponent(c.req.path.slice(11)));
-		const file = join(root, path);
-		if (!file.startsWith(mainlinesRoot + sep) || !existsSync(file) || !statSync(file).isFile()) return c.json({ error: `file ${path} not found under ${relative(root, mainlinesRoot)}` }, 404);
+		const file = dataFile(dirs, path);
+		if (!file.startsWith(mainlinesRoot + sep) || !existsSync(file) || !statSync(file).isFile()) return c.json({ error: `file ${path} not found under ${hubPath(dirs, mainlinesRoot)}` }, 404);
 		return c.body(readFileSync(file), 200, { "content-type": CONTENT_TYPES[extname(file)] ?? "application/octet-stream" });
 	});
 	app.post("/api/mainlines/:m/archive", async (c) => {
@@ -410,33 +413,33 @@ function createApp(root, options = {}) {
 		return c.json((ref.includes("/") ? await write(c, "item.check", input) : await write(c, "criterion.check", input)).value);
 	});
 	app.get("/api/sync", (c) => c.json({
-		remote: remoteMode(root, options.env),
-		running: readDaemon(root) !== null,
-		notices: readNotices(root)
+		remote: remoteMode(dirs, options.env),
+		running: readDaemon(dirs) !== null,
+		notices: readNotices(dirs)
 	}));
 	app.post("/api/sync/handled", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		if (body.key !== void 0 && typeof body.key !== "string") return c.json({ error: "key must be a string" }, 400);
-		return c.json({ marked: markNoticesHandled(root, body.key === void 0 ? void 0 : [body.key]) });
+		return c.json({ marked: markNoticesHandled(dirs, body.key === void 0 ? void 0 : [body.key]) });
 	});
 	app.get("/api/sync/conflicts/:name", async (c) => {
 		const name = c.req.param("name");
 		const saved = `${SYNC_DIR}/conflicts/${name}`;
-		const file = join(syncPaths(root).conflicts, name);
-		const notice = readNotices(root).find((n) => n.saved === saved);
+		const file = join(syncPaths(dirs).conflicts, name);
+		const notice = readNotices(dirs).find((n) => n.saved === saved);
 		if (name.includes("/") || name.startsWith(".") || !existsSync(file) || !notice) return c.json({ error: `no saved text ${saved} named by a notice` }, 404);
-		if (lstatSync(file).isSymbolicLink() || !insideHub(root, file)) return c.json({ error: `${saved} is not a file the sync client saved in the hub` }, 400);
-		const target = isSynced(notice.path) ? join(root, DATA_DIR, notice.path) : null;
-		if (!target || !insideHub(root, target)) return c.json({ error: `the notice for ${saved} names ${JSON.stringify(notice.path)}, not a synced file of the hub` }, 400);
+		if (lstatSync(file).isSymbolicLink() || !insideHub(dirs, file)) return c.json({ error: `${saved} is not a file the sync client saved in the hub` }, 400);
+		const target = isSynced(notice.path) ? join(dirs.data, notice.path) : null;
+		if (!target || !insideHub(dirs, target)) return c.json({ error: `the notice for ${saved} names ${JSON.stringify(notice.path)}, not a synced file of the hub` }, 400);
 		return c.json({
 			saved,
 			path: notice.path,
 			mine: readFileSync(file, "utf8"),
-			theirs: await serverVersion(root, notice.path, target)
+			theirs: await serverVersion(dirs, notice.path, target)
 		});
 	});
 	app.get("/api/events", (c) => streamSSE(c, async (stream) => {
-		const stop = watchHub(root, (event) => void stream.writeSSE({
+		const stop = watchHub(dirs, (event) => void stream.writeSSE({
 			event: event.kind,
 			data: event.name
 		}));
@@ -449,20 +452,20 @@ function createApp(root, options = {}) {
 * Whether a session runs in another environment: its working directory is not on this machine, and neither is a
 * transcript it recorded. A session of this machine whose worktree was removed still has its transcript here.
 */
-function runsElsewhere(root, session) {
+function runsElsewhere(dirs, session) {
 	if (existsSync(session.cwd)) return false;
-	return !(session.transcript && existsSync(transcriptPath(root, session.transcript)));
+	return !(session.transcript && existsSync(transcriptPath(dirs, session.transcript)));
 }
 /** The notices of the sync client as the interface lists them (core reads the files and tells which are handled). */
-const readNotices = (root) => readNotices$1(root);
+const readNotices = (dirs) => readNotices$1(dirs);
 /**
-* Whether `file` really is inside the hub's .mainflow/ once every symbolic link on the way is followed. A file that
+* Whether `file` really is inside the hub's data directory once every symbolic link on the way is followed. A file that
 * does not exist yet is judged by the deepest directory above it that does.
 */
-function insideHub(root, file) {
+function insideHub(dirs, file) {
 	let data;
 	try {
-		data = realpathSync(join(root, DATA_DIR));
+		data = realpathSync(dirs.data);
 	} catch {
 		return false;
 	}
@@ -482,8 +485,8 @@ function insideHub(root, file) {
 * The file at `path` as the hub has it: from the running sync client's copy of the server's version, else this
 * machine's file at `file`, already checked to be inside the hub.
 */
-async function serverVersion(root, path, file) {
-	const daemon = readDaemon(root);
+async function serverVersion(dirs, path, file) {
+	const daemon = readDaemon(dirs);
 	if (daemon) try {
 		const { text } = await callDaemon(daemon, "/file", { path }, 5e3);
 		if (text !== void 0) return {
@@ -498,13 +501,13 @@ async function serverVersion(root, path, file) {
 		source: "local"
 	};
 }
-/** The files of `mainline` that remote.json lists and that are not on disk here, as paths relative to the hub root. */
-function remoteFilesOf(root, mainline) {
-	return Object.keys(readRemote(root)).map((path) => `${DATA_DIR}/${path}`).filter((path) => path.startsWith(`${mainline.dir}/`) && !existsSync(join(root, path))).sort();
+/** The files of `mainline` that remote.json lists and that are not on disk here, named as `mainline.dir` is. */
+function remoteFilesOf(dirs, mainline) {
+	return Object.keys(readRemote(dirs)).map((path) => `${DATA_DIR}/${path}`).filter((path) => path.startsWith(`${mainline.dir}/`) && !existsSync(dataFile(dirs, path))).sort();
 }
-/** Download `path`, relative to the hub root, through the running sync client. */
-async function fetchFromServer(root, path) {
-	const daemon = readDaemon(root);
+/** Download `path`, a file of the hub named `.mainflow/{path}`, through the running sync client. */
+async function fetchFromServer(dirs, path) {
+	const daemon = readDaemon(dirs);
 	if (!daemon) return {
 		fetched: false,
 		error: "mainflow sync is not running for this hub, so the file cannot be downloaded; start it with mainflow sync"
@@ -523,7 +526,7 @@ async function fetchFromServer(root, path) {
 			error: error.message
 		};
 	}
-	if (existsSync(join(root, path))) return { fetched: true };
+	if (existsSync(dataFile(dirs, path))) return { fetched: true };
 	if (result.error) return {
 		fetched: false,
 		error: result.error
@@ -576,18 +579,18 @@ function watchDataDir(dataDir, onName, platform = process.platform) {
 }
 /** One file watcher per hub, shared by every listener of that hub. */
 var HubWatch = class {
-	root;
+	dirs;
 	listeners = /* @__PURE__ */ new Set();
 	watcher;
 	/** How far notices.jsonl has been read */
 	offset;
 	/** handled.json as last told of, so the several events of one write tell the interface once */
 	handledSeen;
-	constructor(root) {
-		this.root = root;
-		this.offset = sizeOf(syncPaths(root).notices);
+	constructor(dirs) {
+		this.dirs = dirs;
+		this.offset = sizeOf(syncPaths(dirs).notices);
 		this.handledSeen = this.handledSignature();
-		this.watcher = watchDataDir(join(root, DATA_DIR), (name) => {
+		this.watcher = watchDataDir(dirs.data, (name) => {
 			const kind = eventOf(name);
 			if (kind === null || kind === "notices" && !this.newWarnings() || kind === "handled" && !this.handledChanged()) return;
 			const event = {
@@ -602,7 +605,7 @@ var HubWatch = class {
 	}
 	/** Whether the lines added to notices.jsonl since the last read hold a warn-level notice. */
 	newWarnings() {
-		const file = syncPaths(this.root).notices;
+		const file = syncPaths(this.dirs).notices;
 		const size = sizeOf(file);
 		if (size < this.offset) this.offset = 0;
 		if (size === this.offset) return false;
@@ -627,7 +630,7 @@ var HubWatch = class {
 	/** handled.json's time and size, empty while there is none. */
 	handledSignature() {
 		try {
-			const info = statSync(join(this.root, DATA_DIR, HANDLED_FILE));
+			const info = statSync(join(this.dirs.data, HANDLED_FILE));
 			return `${info.mtimeMs}:${info.size}`;
 		} catch {
 			return "";
@@ -654,9 +657,9 @@ function sizeOf(file) {
 * Call `listener` for every change the interface reloads on, and once for each batch of new warn-level notices.
 * Every listener of a hub shares one file watcher, which closes with the last of them. Returns the unsubscribe.
 */
-function watchHub(root, listener) {
-	const key = resolve(root);
-	const hub = watches.get(key) ?? new HubWatch(key);
+function watchHub(dirs, listener) {
+	const key = resolve(dirs.data);
+	const hub = watches.get(key) ?? new HubWatch(dirs);
 	watches.set(key, hub);
 	hub.listeners.add(listener);
 	return () => {
@@ -666,20 +669,23 @@ function watchHub(root, listener) {
 		watches.delete(key);
 	};
 }
-/** The hubs this interface serves: its own, then every hub registered in its config.yaml, with each one's root when it is here. */
-function servedHubs(root) {
-	const config = readYaml(join(root, DATA_DIR, "config.yaml"), configSchema).data;
+/**
+* The hubs this interface serves: its own, then every hub registered in its config.yaml, with each one's directories
+* when this machine registered it from the path config.yaml gives.
+*/
+function servedHubs(dirs) {
+	const config = readYaml(join(dirs.data, "config.yaml"), configSchema).data;
 	const others = Object.entries(config.hubs ?? {}).map(([name, path]) => {
 		const base = `/h/${name}/`;
-		const other = resolve(root, path);
-		const file = join(other, DATA_DIR, "config.yaml");
 		if (name === config.hub) return {
 			name,
 			base,
 			available: false,
 			reason: "this hub"
 		};
-		if (!existsSync(file)) return {
+		const other = hubAtRoot(resolve(dirs.root, path));
+		const file = other ? join(other.data, "config.yaml") : null;
+		if (!other || !file || !existsSync(file)) return {
 			name,
 			base,
 			available: false,
@@ -711,14 +717,17 @@ function servedHubs(root) {
 			name,
 			base,
 			available: true,
-			root: other
+			dirs: {
+				root: other.root,
+				data: other.data
+			}
 		};
 	});
 	return [{
 		name: config.hub,
 		base: "/",
 		available: true,
-		root
+		dirs
 	}, ...others];
 }
 let lastTurn = Promise.resolve();
@@ -731,12 +740,12 @@ const pace = async (c, next) => {
 	}
 	await next();
 };
-function hubListGuard(root) {
+function hubListGuard(dirs) {
 	return async (c, next) => {
 		try {
-			loadConfig(root);
+			loadConfig(dirs);
 		} catch (error) {
-			return c.json(configErrorView(root, error), 503);
+			return c.json(configErrorView(dirs, error), 503);
 		}
 		return next();
 	};
@@ -747,33 +756,33 @@ function hubListGuard(root) {
 * hub's changes and notices tagged with its name, so the switcher shows where something happened. Another hub is
 * written through its own sync settings only, never through this process's environment variables.
 */
-function createUiApp(root) {
+function createUiApp(dirs) {
 	const app = new Hono();
 	app.use("/api/*", pace);
 	app.use("/h/:name/api/*", pace);
-	app.use("/api/hubs", hubListGuard(root));
-	app.use("/api/hubs/events", hubListGuard(root));
-	const own = createApp(root);
+	app.use("/api/hubs", hubListGuard(dirs));
+	app.use("/api/hubs/events", hubListGuard(dirs));
+	const own = createApp(dirs);
 	const others = /* @__PURE__ */ new Map();
 	const appOf = (name) => {
-		const hub = servedHubs(root).find((h) => h.name === name && h.base !== "/");
-		if (!hub?.available || !hub.root) return null;
-		let sub = others.get(hub.root);
+		const hub = servedHubs(dirs).find((h) => h.name === name && h.base !== "/");
+		if (!hub?.available || !hub.dirs) return null;
+		let sub = others.get(hub.dirs.data);
 		if (!sub) {
-			sub = createApp(hub.root, { env: {} });
-			others.set(hub.root, sub);
+			sub = createApp(hub.dirs, { env: {} });
+			others.set(hub.dirs.data, sub);
 		}
 		return sub;
 	};
 	app.get("/api/hubs", (c) => {
-		const hubs = servedHubs(root);
+		const hubs = servedHubs(dirs);
 		return c.json({
 			primary: hubs[0].name,
-			hubs: hubs.map(({ root: _root, ...link }) => link)
+			hubs: hubs.map(({ dirs: _dirs, ...link }) => link)
 		});
 	});
 	app.get("/api/hubs/events", (c) => streamSSE(c, async (stream) => {
-		const stops = servedHubs(root).flatMap((hub) => hub.available && hub.root ? [watchHub(hub.root, (event) => void stream.writeSSE({
+		const stops = servedHubs(dirs).flatMap((hub) => hub.available && hub.dirs ? [watchHub(hub.dirs, (event) => void stream.writeSSE({
 			event: event.kind,
 			data: JSON.stringify({
 				hub: hub.name,
@@ -810,10 +819,10 @@ function webDir() {
 * Resolves once the port is listening. A port taken between the free-port probe and here rejects with a
 * WriteError instead of Node's unhandled 'error' event and stack trace.
 */
-function serveUi(root, port, open = openInApp) {
-	const app = createUiApp(root);
+function serveUi(dirs, port, open = openInApp) {
+	const app = createUiApp(dirs);
 	const dist = webDir();
-	const hub = loadHub(root, { remotes: false }).config.hub;
+	const hub = loadHub(dirs, { remotes: false }).config.hub;
 	app.get("/open/*", (c) => {
 		const url = new URL(c.req.url);
 		const target = `${url.pathname.slice(5) || "/"}${url.search}`;

package/dist/version-Dvv4jwF1.js

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+//#region src/version.ts
+/** This CLI's own version, from the package manifest one level above both src/ and dist/. */
+const CLI_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+//#endregion
+export { CLI_VERSION as t };