mainflow 0.8.0 → 0.10.0

package/dist/launch-D5uHpqkh.js

@@ -0,0 +1,184 @@
+import { n as DEFAULT_UI_PORT, nt as WriteError, rt as DATA_DIR, s as syncHost } from "./host-BFGfpTDq.js";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:net";
+//#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
+//#region src/launch.ts
+/** How many ports above DEFAULT_UI_PORT are tried before giving up. */
+const PORT_SPAN = 100;
+/** Where the last server started is remembered: machine-specific, so under the unversioned local/ folder. */
+const uiRecordFile = (root) => join(root, DATA_DIR, "local", "ui.json");
+function readUiRecord(root) {
+	try {
+		const record = JSON.parse(readFileSync(uiRecordFile(root), "utf8"));
+		if (!Number.isInteger(record.port)) return void 0;
+		return {
+			port: record.port,
+			...Number.isInteger(record.pid) && { pid: record.pid },
+			...typeof record.version === "string" && { version: record.version }
+		};
+	} catch {
+		return;
+	}
+}
+function writeUiRecord(root, record) {
+	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
+	writeFileSync(uiRecordFile(root), `${JSON.stringify(record)}\n`);
+}
+/**
+* Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
+* the hub's configured port, then the last one used, then the default range.
+*/
+function portCandidates(options) {
+	if (options.explicit !== void 0) return [options.explicit];
+	const range = Array.from({ length: 100 }, (_, i) => DEFAULT_UI_PORT + i);
+	return [...new Set([
+		options.configured,
+		options.last,
+		...range
+	].filter((p) => p !== void 0))];
+}
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+const networkProbe = {
+	async serverAt(port) {
+		try {
+			const res = await fetch(`http://localhost:${port}/api/hub`, { signal: AbortSignal.timeout(500) });
+			if (!res.ok) return null;
+			const body = await res.json();
+			if (typeof body.hub !== "string") return null;
+			return {
+				hub: body.hub,
+				...typeof body.version === "string" && { version: body.version }
+			};
+		} catch {
+			return null;
+		}
+	},
+	isFree: (port) => new Promise((done) => {
+		const probe = createServer().once("error", () => done(false));
+		probe.listen(port, () => probe.close(() => done(true)));
+	}),
+	listenerOf(port) {
+		const out = spawnSync("lsof", [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-t"
+		], { encoding: "utf8" });
+		const pid = Number(out.stdout?.split("\n")[0]);
+		return out.status === 0 && Number.isInteger(pid) && pid > 0 ? pid : null;
+	},
+	async stop(pid, port) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			return false;
+		}
+		for (let i = 0; i < 25; i++) {
+			await sleep(200);
+			if (await networkProbe.isFree(port)) return true;
+		}
+		return false;
+	}
+};
+/**
+* A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
+* changed ui.port never starts a second copy; all candidates are asked at once, bounding the wait by one
+* probe timeout. Otherwise the first free candidate; ports held by another hub or program are skipped.
+*/
+async function choosePort(hub, candidates, probe = networkProbe) {
+	const servers = await Promise.all(candidates.map((port) => probe.serverAt(port)));
+	const at = candidates.findIndex((_, i) => servers[i]?.hub === hub);
+	if (at >= 0) return {
+		port: candidates[at],
+		running: servers[at].version ?? ""
+	};
+	for (const [i, port] of candidates.entries()) if (servers[i] === null && await probe.isFree(port)) return {
+		port,
+		running: void 0
+	};
+	const tried = candidates.length === 1 ? `port ${candidates[0]} is` : `ports ${candidates[0]} to ${candidates.at(-1)} are`;
+	throw new WriteError(`${tried} taken by other programs; free one, or pass --port <port>`);
+}
+/**
+* Run `mainflow ui --no-open` detached, for a hook that must not wait: it reuses a server already serving this
+* hub, replaces one of another version, or starts one. The CLI running now is the one started, so the hub's
+* pinned version serves its interface.
+*/
+function startUiInBackground(root) {
+	const cli = process.argv[1];
+	if (!cli) return;
+	spawn(process.execPath, [
+		cli,
+		"ui",
+		"--no-open"
+	], {
+		cwd: root,
+		detached: true,
+		stdio: "ignore"
+	}).on("error", () => {}).unref();
+}
+/** Open a URL in the default browser without waiting for it. */
+function openUrl(url) {
+	const [command, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? [
+		"cmd",
+		"/c",
+		"start",
+		"",
+		url
+	] : ["xdg-open", url];
+	spawn(command, args, {
+		detached: true,
+		stdio: "ignore"
+	}).on("error", () => console.log(`open ${url} in a browser`)).unref();
+}
+/** Start or reuse this hub's interface: the URL it is reached at, and the server when this call started one. */
+async function launchUi(root, hub, configured, options) {
+	const log = options.log ?? console.log;
+	let explicit;
+	if (options.port !== void 0) {
+		explicit = Number(options.port);
+		if (!Number.isInteger(explicit) || explicit < 1024 || explicit > 65535) throw new WriteError("--port must be an integer from 1024 to 65535, e.g. --port 4320");
+	}
+	const probe = options.probe ?? networkProbe;
+	const record = readUiRecord(root);
+	const choice = await choosePort(hub, portCandidates({
+		explicit,
+		configured,
+		last: record?.port
+	}), probe);
+	let reuse = choice.running !== void 0;
+	if (reuse && choice.running !== CLI_VERSION) {
+		const from = choice.running || "unknown";
+		const pid = record?.port === choice.port && record.pid !== void 0 ? record.pid : probe.listenerOf(choice.port);
+		if (pid !== null && await probe.stop(pid, choice.port)) {
+			log(`! restarted: mainflow ${from} → ${CLI_VERSION}`);
+			reuse = false;
+		} else log(`! localhost:${choice.port} still runs mainflow ${from}, not ${CLI_VERSION}; stop it with \`kill $(lsof -ti tcp:${choice.port})\` and run mainflow ui again`);
+	}
+	let server;
+	if (!reuse) {
+		const { serveUi } = await import("./ui-DbEmJiwO.js");
+		server = await serveUi(root, choice.port);
+		writeUiRecord(root, {
+			port: choice.port,
+			pid: process.pid,
+			version: CLI_VERSION
+		});
+	}
+	const host = await syncHost(root, hub, choice.port, options.host);
+	if (host.url === null) log(`! host name not available: ${host.reason}`);
+	const url = host.url ?? `http://localhost:${choice.port}`;
+	log(`${reuse ? "already running" : "mainflow ui"}: ${url} (localhost:${choice.port})`);
+	if (options.open) openUrl(url);
+	return {
+		url,
+		server
+	};
+}
+//#endregion
+export { portCandidates as a, CLI_VERSION as c, networkProbe as i, choosePort as n, readUiRecord as o, launchUi as r, startUiInBackground as s, PORT_SPAN as t };

package/dist/launch.d.ts

@@ -3,7 +3,13 @@ import { ServerType } from "@hono/node-server";
 //#region src/launch.d.ts
 /** How many ports above DEFAULT_UI_PORT are tried before giving up. */
 export declare const PORT_SPAN = 100;
-export declare function readLastPort(root: string): number | undefined;
+/** The server this hub last started: its port, and the process and version when it recorded them. */
+export interface UiRecord {
+  port: number;
+  pid?: number;
+  version?: string;
+}
+export declare function readUiRecord(root: string): UiRecord | undefined;
 /**
  * Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
  * the hub's configured port, then the last one used, then the default range.
@@ -13,15 +19,25 @@ export declare function portCandidates(options: {
   configured?: number;
   last?: number;
 }): number[];
+/** What a mainflow interface on a port reports; servers older than 0.8.1 report no version. */
+export interface ServerInfo {
+  hub: string;
+  version?: string;
+}
 export interface PortProbe {
-  /** The hub name a mainflow interface on this port reports, or null when nothing mainflow answers. */
-  hubAt: (port: number) => Promise<string | null>;
+  /** The mainflow interface on this port, or null when nothing mainflow answers. */
+  serverAt: (port: number) => Promise<ServerInfo | null>;
   isFree: (port: number) => Promise<boolean>;
+  /** The process listening on this port, or null when it cannot be found. */
+  listenerOf: (port: number) => number | null;
+  /** Stop a process and wait until the port is free; false when it did not free up. */
+  stop: (pid: number, port: number) => Promise<boolean>;
 }
 export declare const networkProbe: PortProbe;
+/** A port to serve on; `running` is the version already serving this hub there, '' when it reports none. */
 export type PortChoice = {
   port: number;
-  running: boolean;
+  running?: string;
 };
 /**
  * A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
@@ -29,6 +45,12 @@ export type PortChoice = {
  * probe timeout. Otherwise the first free candidate; ports held by another hub or program are skipped.
  */
 export declare function choosePort(hub: string, candidates: number[], probe?: PortProbe): Promise<PortChoice>;
+/**
+ * Run `mainflow ui --no-open` detached, for a hook that must not wait: it reuses a server already serving this
+ * hub, replaces one of another version, or starts one. The CLI running now is the one started, so the hub's
+ * pinned version serves its interface.
+ */
+export declare function startUiInBackground(root: string): void;
 export interface LaunchOptions {
   port?: string;
   open: boolean;

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as portCandidates, i as networkProbe, n as choosePort, o as readLastPort, r as launchUi, t as PORT_SPAN } from "./launch-V6oqJDGG.js";
-export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readLastPort };
+import { a as portCandidates, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-D5uHpqkh.js";
+export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readUiRecord, startUiInBackground };

package/dist/progress-1BfPg2zN.js

@@ -0,0 +1,10 @@
+//#region ../core/dist/progress.js
+function listProgress(items) {
+	const counted = items.filter((item) => !item.dropped);
+	return {
+		done: counted.filter((item) => item.done).length,
+		total: counted.length
+	};
+}
+//#endregion
+export { listProgress as t };

package/dist/{launch-V6oqJDGG.js → ui-DbEmJiwO.js}

@@ -1,11 +1,11 @@
-import { B as linksInto, F as setFindingArchived, G as WriteError, K as DATA_DIR, L as setIssueArchived, T as transcriptPath, V as refIndex, W as ConflictError, b as setSessionArchived, d as setChecklistItem, f as setCriterion, h as updateTask, p as setMainlineStatus, u as setArchived, v as loadSessions, y as readSession, z as loadHub } from "./dist-DCafRe8c.js";
-import { DEFAULT_UI_PORT, syncHost } from "./host.js";
+import { C as updateTask, D as readSession, E as loadSessions, J as setIssueArchived, K as setFindingArchived, N as transcriptPath, O as setSessionArchived, Q as refIndex, X as loadHub, Z as linksInto, _ as setArchived, a as openInApp, b as setMainlineStatus, nt as WriteError, rt as DATA_DIR, tt as ConflictError, v as setChecklistItem, x as setMainlineTitle, y as setCriterion } from "./host-BFGfpTDq.js";
+import { t as listProgress } from "./progress-1BfPg2zN.js";
+import { c as CLI_VERSION } from "./launch-D5uHpqkh.js";
 import { createRequire } from "node:module";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, watch, writeFileSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, watch } from "node:fs";
 import { basename, dirname, extname, join, normalize, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawn, spawnSync } from "node:child_process";
-import { createServer } from "node:net";
+import { spawnSync } from "node:child_process";
 import { serve } from "@hono/node-server";
 import { homedir } from "node:os";
 import { Hono } from "hono";
@@ -205,15 +205,6 @@ function attributeTrace(trace, actions, now = Date.now()) {
 	};
 }
 //#endregion
-//#region ../core/dist/progress.js
-function listProgress(items) {
-	const counted = items.filter((item) => !item.dropped);
-	return {
-		done: counted.filter((item) => item.done).length,
-		total: counted.length
-	};
-}
-//#endregion
 //#region src/server.ts
 /** Every reference with a hub prefix in the documents of `hub`: links, origins and replaced items. */
 function prefixedRefs(hub) {
@@ -323,6 +314,7 @@ function createApp(root) {
 		const hub = loadHub(root);
 		const body = {
 			hub: hub.config.hub,
+			version: CLI_VERSION,
 			repos: hub.config.repos,
 			mainlines: hub.mainlines.map(summarize),
 			openIssues: hub.issues.filter((i) => i.status !== "closed").length,
@@ -415,6 +407,10 @@ function createApp(root) {
 		const { archived, version } = await c.req.json();
 		return c.json(setArchived(root, c.req.param("m"), archived, version));
 	});
+	app.post("/api/mainlines/:m/title", async (c) => {
+		const { title, version } = await c.req.json();
+		return c.json(setMainlineTitle(root, c.req.param("m"), title, version));
+	});
 	app.post("/api/mainlines/:m/status", async (c) => {
 		const { status, version } = await c.req.json();
 		return c.json(setMainlineStatus(root, c.req.param("m"), status, version));
@@ -456,9 +452,16 @@ 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) {
+function serveUi(root, port, open = openInApp) {
 	const app = createApp(root);
 	const dist = webDir();
+	const hub = loadHub(root, { remotes: false }).config.hub;
+	app.get("/open/*", (c) => {
+		const url = new URL(c.req.url);
+		const target = `${url.pathname.slice(5) || "/"}${url.search}`;
+		const opened = open(hub, target);
+		return c.html(openPage(target, opened));
+	});
 	app.get("*", (c) => {
 		let file = join(dist, normalize(decodeURIComponent(c.req.path)));
 		if (!file.startsWith(dist + sep) || !existsSync(file) || !statSync(file).isFile()) file = join(dist, "index.html");
@@ -472,113 +475,10 @@ function serveUi(root, port) {
 		server.once("error", (error) => fail(error.code === "EADDRINUSE" ? new WriteError(`port ${port} is already in use; run mainflow ui again to pick another`) : error));
 	});
 }
-//#endregion
-//#region src/launch.ts
-/** How many ports above DEFAULT_UI_PORT are tried before giving up. */
-const PORT_SPAN = 100;
-/** Where the last port used is remembered: machine-specific, so under the unversioned local/ folder. */
-const lastPortFile = (root) => join(root, DATA_DIR, "local", "ui.json");
-function readLastPort(root) {
-	try {
-		const port = JSON.parse(readFileSync(lastPortFile(root), "utf8")).port;
-		return Number.isInteger(port) ? port : void 0;
-	} catch {
-		return;
-	}
-}
-function writeLastPort(root, port) {
-	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
-	writeFileSync(lastPortFile(root), `${JSON.stringify({ port })}\n`);
-}
-/**
-* Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
-* the hub's configured port, then the last one used, then the default range.
-*/
-function portCandidates(options) {
-	if (options.explicit !== void 0) return [options.explicit];
-	const range = Array.from({ length: 100 }, (_, i) => DEFAULT_UI_PORT + i);
-	return [...new Set([
-		options.configured,
-		options.last,
-		...range
-	].filter((p) => p !== void 0))];
-}
-const networkProbe = {
-	async hubAt(port) {
-		try {
-			const res = await fetch(`http://localhost:${port}/api/hub`, { signal: AbortSignal.timeout(500) });
-			if (!res.ok) return null;
-			const body = await res.json();
-			return typeof body.hub === "string" ? body.hub : null;
-		} catch {
-			return null;
-		}
-	},
-	isFree: (port) => new Promise((done) => {
-		const probe = createServer().once("error", () => done(false));
-		probe.listen(port, () => probe.close(() => done(true)));
-	})
-};
-/**
-* A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
-* changed ui.port never starts a second copy; all candidates are asked at once, bounding the wait by one
-* probe timeout. Otherwise the first free candidate; ports held by another hub or program are skipped.
-*/
-async function choosePort(hub, candidates, probe = networkProbe) {
-	const owners = await Promise.all(candidates.map((port) => probe.hubAt(port)));
-	const running = candidates.find((_, i) => owners[i] === hub);
-	if (running !== void 0) return {
-		port: running,
-		running: true
-	};
-	for (const [i, port] of candidates.entries()) if (owners[i] === null && await probe.isFree(port)) return {
-		port,
-		running: false
-	};
-	const tried = candidates.length === 1 ? `port ${candidates[0]} is` : `ports ${candidates[0]} to ${candidates.at(-1)} are`;
-	throw new WriteError(`${tried} taken by other programs; free one, or pass --port <port>`);
-}
-/** Open a URL in the default browser without waiting for it. */
-function openUrl(url) {
-	const [command, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? [
-		"cmd",
-		"/c",
-		"start",
-		"",
-		url
-	] : ["xdg-open", url];
-	spawn(command, args, {
-		detached: true,
-		stdio: "ignore"
-	}).on("error", () => console.log(`open ${url} in a browser`)).unref();
-}
-/** Start or reuse this hub's interface: the URL it is reached at, and the server when this call started one. */
-async function launchUi(root, hub, configured, options) {
-	const log = options.log ?? console.log;
-	let explicit;
-	if (options.port !== void 0) {
-		explicit = Number(options.port);
-		if (!Number.isInteger(explicit) || explicit < 1024 || explicit > 65535) throw new WriteError("--port must be an integer from 1024 to 65535, e.g. --port 4320");
-	}
-	const choice = await choosePort(hub, portCandidates({
-		explicit,
-		configured,
-		last: readLastPort(root)
-	}), options.probe);
-	let server;
-	if (!choice.running) {
-		server = await serveUi(root, choice.port);
-		writeLastPort(root, choice.port);
-	}
-	const host = await syncHost(root, hub, choice.port, options.host);
-	if (host.url === null) log(`! host name not available: ${host.reason}`);
-	const url = host.url ?? `http://localhost:${choice.port}`;
-	log(`${choice.running ? "already running" : "mainflow ui"}: ${url} (localhost:${choice.port})`);
-	if (options.open) openUrl(url);
-	return {
-		url,
-		server
-	};
+/** The page an /open link leaves in the browser: blank in the interface's colours, or a jump to the address. */
+function openPage(target, opened) {
+	const escaped = target.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+	return `<!doctype html><meta charset="utf-8"><meta name="color-scheme" content="light dark">${opened ? "" : `<meta http-equiv="refresh" content="0;url=${escaped}">`}<title>mainflow</title><style>html{background:#fff}@media (prefers-color-scheme: dark){html{background:#111113}}</style>`;
 }
 //#endregion
-export { portCandidates as a, networkProbe as i, choosePort as n, readLastPort as o, launchUi as r, listProgress as s, PORT_SPAN as t };
+export { serveUi };