mainflow 0.34.0 → 0.35.0

package/dist/{ui-BcXPk-0P.js → ui-C4h4iLDu.js}

@@ -1,13 +1,14 @@
-import { j as configSchema } from "./dist-IdbnCDqM.js";
-import { A as attributeTrace, C as transcriptPath, G as linksInto, H as loadHub, J as readYaml, K as refIndex, M as transcriptTitle, S as readSession, U as dependencyGraph, W as mainlineEdges, a as openInApp, h as setArchivedMany, ht as WriteError, j as traceTranscript, m as ARCHIVE_KINDS, mt as DATA_DIR, pt as ConflictError, x as loadSessions } from "./host-79T-_NMu.js";
+import { F as configSchema, f as GROUP_SECTIONS } from "./dist-BdvWGTsb.js";
+import { C as readSession, G as sectionText, H as HubError, J as linksInto, K as dependencyGraph, M as traceTranscript, N as transcriptTitle, S as loadSessions, U as loadConfig, W as loadHub, Y as refIndex, Z as readYaml, _t as DATA_DIR, a as openInApp, g as setArchivedMany, gt as ConflictError, h as ARCHIVE_KINDS, j as attributeTrace, q as mainlineEdges, vt as WriteError, w as transcriptPath } from "./host-bnHYIwuY.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { A as syncPaths, O as SYNC_DIR, _ as readDaemon, a as remoteMode, h as callDaemon, k as isSynced, m as DaemonUnavailable, n as hubWriter, r as writtenLines, y as readRemote } from "./operation--fJnUqvA.js";
-import { l as CLI_VERSION } from "./launch-DQVyIbpf.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-DVcJgKM9.js";
+import { c as realRoot, f as CLI_VERSION, s as readUiRecord } from "./launch-D80CYPcm.js";
 import { createRequire } from "node:module";
-import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, realpathSync, statSync, watch } from "node:fs";
+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 { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
+import { parse as parse$1 } from "yaml";
 import { homedir } from "node:os";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
@@ -32,7 +33,11 @@ function prefixedRefs(hub) {
 			refs.push(...t.checklist.map((c) => c.supersededBy));
 		}
 	}
-	for (const d of [...hub.issues, ...hub.findings]) doc(d);
+	for (const d of [
+		...hub.issues,
+		...hub.findings,
+		...hub.groups
+	]) doc(d);
 	return [...new Set(refs.filter((r) => !!r && /^[a-z0-9-]+:/.test(r)))];
 }
 function relationsView(hub) {
@@ -104,6 +109,8 @@ function summarize(m) {
 		priority: m.priority ?? null,
 		labels: m.labels ?? [],
 		due: m.due ?? null,
+		group: m.group ?? null,
+		role: m.role ?? "impl",
 		updated: [
 			m,
 			...m.tasks,
@@ -118,6 +125,27 @@ function summarize(m) {
 		decisions: m.decisions.length
 	};
 }
+/** The first paragraph of a group's 說明 on one line, for the heading of its group in a list. */
+function groupSummary(body) {
+	return ((sectionText(body, GROUP_SECTIONS[0]) ?? "").split(/\n\s*\n/)[0] ?? "").replace(/\s+/g, " ").trim();
+}
+const groupView = (g) => ({
+	...g,
+	summary: groupSummary(g.body)
+});
+/** 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}`, "");
+	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("; ");
+	return {
+		error: `config.yaml cannot be used: ${message}${detail ? ` (${detail})` : ""}`,
+		kind: "hub-config",
+		message,
+		problems
+	};
+}
 /**
 * HTTP API over one hub. The CLI `ui` command and the web dev server both mount it, through createUiApp. Writes go
 * through the hub's writer (src/remote/operation.ts), so in remote mode they are operations the sync server applies;
@@ -147,12 +175,59 @@ function createApp(root, options = {}) {
 		}
 		return written;
 	};
+	let knownName;
+	const configFailure = () => {
+		try {
+			knownName = loadConfig(root).hub;
+			return null;
+		} catch (error) {
+			return configErrorView(root, error);
+		}
+	};
+	/**
+	* The name /api/ping gives while config.yaml cannot be used: the last good read, else what a complete file of
+	* another format version says, else the directory's. A half-written file holds only part of its name, so it is not read.
+	*/
+	const fallbackName = () => {
+		if (knownName) return knownName;
+		try {
+			const raw = configSchema.safeParse(parse$1(readFileSync(join(root, DATA_DIR, "config.yaml"), "utf8")));
+			if (raw.success) return raw.data.hub;
+		} catch {}
+		return basename(realRoot(root));
+	};
+	configFailure();
+	app.use("/api/*", async (c, next) => {
+		if (/\/api\/(ping|events)$/.test(c.req.path)) return next();
+		const failure = configFailure();
+		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);
 		if (error instanceof ConflictError) return c.json({ error: message }, 409);
 		if (error instanceof WriteError) return c.json({ error: message }, 400);
 		throw error;
 	});
+	app.get("/api/ping", (c) => {
+		const failure = configFailure();
+		const who = {
+			hub: failure ? fallbackName() : knownName,
+			root: realRoot(root),
+			version: CLI_VERSION,
+			pid: process.pid
+		};
+		if (failure) return c.json({
+			...failure,
+			...who,
+			status: "config-error"
+		}, 503);
+		return c.json(who);
+	});
+	app.get("/api/host", (c) => {
+		const hostError = readUiRecord(root)?.hostError;
+		return c.json(hostError ? { hostError } : {});
+	});
 	app.get("/api/hub", (c) => {
 		const hub = loadHub(root);
 		const body = {
@@ -160,6 +235,7 @@ function createApp(root, options = {}) {
 			version: CLI_VERSION,
 			repos: hub.config.repos,
 			mainlines: hub.mainlines.map(summarize),
+			groups: hub.groups.map(groupView),
 			openIssues: hub.issues.filter((i) => i.status !== "closed").length,
 			validFindings: hub.findings.filter((f) => f.status === "valid").length,
 			problems: hub.problems
@@ -484,7 +560,8 @@ async function fetchFromServer(root, path) {
 * client's notices (`notices`), or nothing. The sync client's own state under local/sync/ (known.json, queue.json,
 * the conflicts it saves, its tmp/) is not the hub's content, so writing it reloads nothing; notices.jsonl only
 * matters when a warn-level line arrives. remote.json lists the files only on the server, which the data view shows,
-* so a change to it reloads. Lock and temporary files are left out as well.
+* so a change to it reloads. Lock and temporary files are left out as well. A session file changes with every hook of a
+* running session, so it is its own kind (`session`) and the interface reloads the sessions only, not the whole hub.
 */
 function eventOf(name) {
 	const path = name.split(sep).join("/");
@@ -492,8 +569,28 @@ function eventOf(name) {
 	if (path === `local/sync/remote.json`) return "change";
 	if (path === "local/sync" || path.startsWith(`local/sync/`)) return null;
 	if (path.endsWith("write.lock") || path.endsWith(".tmp")) return null;
+	if (path === SESSIONS_DIR || path.startsWith(`${SESSIONS_DIR}/`)) return "session";
 	return "change";
 }
+const SESSIONS_DIR = "local/sessions";
+/**
+* Watch the hub's .mainflow/ for `onName`, a path relative to it. macOS and Windows watch the tree natively. Linux has no
+* native tree watch, and Node's emulation of it rereads a directory on every event in it, so hundreds of session files
+* written at once keep the process busy for seconds and every request waits; there the watcher keeps one watch per directory.
+*/
+function watchDataDir(dataDir, onName, platform = process.platform) {
+	const mode = platform === "linux" ? "directories" : "recursive";
+	const watcher = watchTree(dataDir, {
+		mode,
+		include: () => true,
+		onChange: onName,
+		onError: () => void 0
+	});
+	return {
+		mode,
+		close: () => watcher.close()
+	};
+}
 /** One file watcher per hub, shared by every listener of that hub. */
 var HubWatch = class {
 	root;
@@ -504,16 +601,15 @@ var HubWatch = class {
 	constructor(root) {
 		this.root = root;
 		this.offset = sizeOf(syncPaths(root).notices);
-		this.watcher = watch(join(root, DATA_DIR), { recursive: true }, (_event, name) => {
-			const kind = name ? eventOf(String(name)) : null;
+		this.watcher = watchDataDir(join(root, DATA_DIR), (name) => {
+			const kind = eventOf(name);
 			if (kind === null || kind === "notices" && !this.newWarnings()) return;
 			const event = {
-				kind: kind === "change" ? "change" : "notice",
-				name: String(name)
+				kind: kind === "notices" ? "notice" : kind,
+				name
 			};
 			for (const notify of this.listeners) notify(event);
 		});
-		this.watcher.on("error", () => void 0);
 	}
 	close() {
 		this.watcher.close();
@@ -623,6 +719,26 @@ function servedHubs(root) {
 		root
 	}, ...others];
 }
+let lastTurn = Promise.resolve();
+/** Hono middleware: a request waits for its turn, one per event loop iteration, so I/O such as a ping is served between. */
+const pace = async (c, next) => {
+	if (!/\/api\/(ping|events|hubs\/events)$/.test(c.req.path)) {
+		const turn = lastTurn.then(() => new Promise((done) => setImmediate(done)));
+		lastTurn = turn;
+		await turn;
+	}
+	await next();
+};
+function hubListGuard(root) {
+	return async (c, next) => {
+		try {
+			loadConfig(root);
+		} catch (error) {
+			return c.json(configErrorView(root, error), 503);
+		}
+		return next();
+	};
+}
 /**
 * The interface's API: this hub at /api, and every registered hub that is on this machine at /h/{name}/api, so one
 * interface follows several hubs and switches between them. /api/hubs lists them, and /api/hubs/events sends every
@@ -631,6 +747,10 @@ function servedHubs(root) {
 */
 function createUiApp(root) {
 	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);
 	const others = /* @__PURE__ */ new Map();
 	const appOf = (name) => {