mainflow 0.41.0 → 0.43.0-alpha.1

package/dist/web/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>mainflow</title>
-    <script type="module" crossorigin src="/assets/index-DvYj_6IC.js"></script>
+    <script type="module" crossorigin src="/assets/index-B4w2iRCQ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D3P-pLas.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mainflow",
-  "version": "0.41.0",
+  "version": "0.43.0-alpha.1",
   "description": "本機多 AI 協作的主脈絡任務管理：CLI 與介面",
   "license": "MIT",
   "type": "module",
@@ -32,8 +32,8 @@
   "dependencies": {
     "@hono/node-server": "^2.1.1",
     "hono": "^4.13.8",
-    "ignore": "^7.0.12",
     "node-diff3": "3.2.1",
+    "semver": "^7.8.5",
     "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },

package/dist/launch-CMeKJsNd.js

@@ -1,327 +0,0 @@
-import { At as WriteError, i as hostName, kt as DATA_DIR, l as syncHost, n as DEFAULT_UI_PORT, s as removeHostLink } from "./host-BAMZmRy8.js";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { join, resolve } 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 },
-			...typeof record.hostError === "string" && { hostError: record.hostError }
-		};
-	} 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));
-/** How long a server gets to answer /api/ping; the endpoint loads nothing, so a server that is slower is not a live one. */
-const PROBE_MS = 1e3;
-/**
-* Ask `path` of the server on `port`: its JSON body (also from a 503 of kind hub-config), 404 for a server without
-* that endpoint, null for anything else.
-* A server that predates the endpoint answers with its page (200 text/html) rather than 404, so a 200 that is not a
-* JSON object naming a hub counts as no endpoint too.
-*/
-async function getJson(port, path) {
-	try {
-		const res = await fetch(`http://localhost:${port}${path}`, { signal: AbortSignal.timeout(PROBE_MS) });
-		if (res.status === 404) return 404;
-		if (!res.ok && res.status !== 503) return null;
-		const body = await res.json().catch(() => null);
-		if (res.status === 503 && body?.kind !== "hub-config") return null;
-		return body !== null && typeof body === "object" && typeof body.hub === "string" ? body : 404;
-	} catch {
-		return null;
-	}
-}
-const networkProbe = {
-	async serverAt(port) {
-		let body = await getJson(port, "/api/ping");
-		if (body === 404) body = await getJson(port, "/api/hub");
-		if (body === null || body === 404 || typeof body.hub !== "string") return null;
-		return {
-			hub: body.hub,
-			...typeof body.version === "string" && { version: body.version },
-			...typeof body.root === "string" && { root: body.root },
-			...Number.isInteger(body.pid) && { pid: body.pid },
-			...body.status === "config-error" && { status: "config-error" }
-		};
-	},
-	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;
-	}
-};
-/** The absolute path of `root` with symbolic links followed, so two paths to one directory compare equal. */
-function realRoot(root) {
-	try {
-		return realpathSync(root);
-	} catch {
-		return resolve(root);
-	}
-}
-/** Whether `info` is a server of the hub `hub` at `root`. A server that reports no root cannot be told apart by it, so the name decides. */
-const serves = (info, hub, root) => info !== null && info.hub === hub && (info.root === void 0 || root === void 0 || info.root === root);
-/**
-* 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. Among several servers of the hub, the one of `version` is kept, else the first in the order, and
-* the rest are returned as `extras`. A hub of the same name at another root, such as a worktree's, is not this
-* hub's server. Otherwise the first free candidate; ports held by another hub or program are skipped.
-*/
-async function choosePort(hub, candidates, probe = networkProbe, options = {}) {
-	const servers = await Promise.all(candidates.map((port) => probe.serverAt(port)));
-	const ours = candidates.flatMap((port, i) => serves(servers[i], hub, options.root) ? [{
-		port,
-		...servers[i]
-	}] : []);
-	const kept = ours.find((s) => s.version === options.version) ?? ours[0];
-	if (kept) return {
-		port: kept.port,
-		running: kept.version ?? "",
-		...kept.pid !== void 0 && { pid: kept.pid },
-		extras: ours.filter((s) => s !== kept)
-	};
-	for (const [i, port] of candidates.entries()) if (servers[i] === null && await probe.isFree(port)) return {
-		port,
-		running: void 0,
-		extras: []
-	};
-	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>`);
-}
-/** The lock that makes starting an interface one hook at a time: machine-specific, so under the unversioned local/ folder. */
-const uiLockFile = (root) => join(root, DATA_DIR, "local", "ui.lock");
-const processAlive = (pid) => {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
-	}
-};
-/**
-* Run `action` while holding local/ui.lock, so several hooks starting at the same moment, such as the sessions of a
-* workspace opened together, take turns: the later ones then find the first one's server and reuse it. A lock whose
-* process is gone, or that is older than `staleMs`, is taken over; after `waitMs` the action runs without the lock
-* rather than leave a session without its interface.
-*/
-async function withUiLock(root, action, options = {}) {
-	const { waitMs = 2e4, staleMs = 6e4 } = options;
-	const file = uiLockFile(root);
-	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
-	const deadline = Date.now() + waitMs;
-	let held = false;
-	for (;;) {
-		try {
-			writeFileSync(file, `${process.pid}\n`, { flag: "wx" });
-			held = true;
-			break;
-		} catch (error) {
-			if (error.code !== "EEXIST") break;
-		}
-		const holder = Number.parseInt(readLock(file), 10);
-		const age = Date.now() - (statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now());
-		if (Number.isInteger(holder) && holder > 0 && !processAlive(holder) || age > staleMs) {
-			rmSync(file, { force: true });
-			continue;
-		}
-		if (Date.now() >= deadline) break;
-		await sleep(50);
-	}
-	try {
-		return await action();
-	} finally {
-		if (held && Number.parseInt(readLock(file), 10) === process.pid) rmSync(file, { force: true });
-	}
-}
-function readLock(file) {
-	try {
-		return readFileSync(file, "utf8");
-	} catch {
-		return "";
-	}
-}
-/**
-* 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 || process.env.MAINFLOW_NO_BACKGROUND_UI === "1") return;
-	spawn(process.execPath, [
-		cli,
-		"ui",
-		"--no-open"
-	], {
-		cwd: root,
-		detached: true,
-		stdio: "ignore"
-	}).on("error", () => {}).unref();
-}
-/**
-* Call `onGone` once the hub's config.yaml disappears, checking every `everyMs`. A server started for a hub in a
-* directory that is later deleted, such as a test's, then stops instead of holding its port forever. The timer
-* does not keep the process alive by itself.
-*/
-function watchHubGone(root, onGone, everyMs = 3e4) {
-	const timer = setInterval(() => {
-		if (existsSync(join(root, ".mainflow", "config.yaml"))) return;
-		clearInterval(timer);
-		onGone();
-	}, everyMs);
-	timer.unref();
-	return timer;
-}
-/** 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 hubRoot = realRoot(root);
-	const { choice, reuse, server } = await withUiLock(root, async () => {
-		const record = readUiRecord(root);
-		const choice = await choosePort(hub, portCandidates({
-			explicit,
-			configured,
-			last: record?.port
-		}), probe, {
-			root: hubRoot,
-			version: CLI_VERSION
-		});
-		for (const extra of choice.extras) {
-			if (extra.root === void 0) continue;
-			const pid = extra.pid ?? probe.listenerOf(extra.port);
-			if (pid !== null && pid !== process.pid && await probe.stop(pid, extra.port)) log(`! stopped a second interface of ${hub} on localhost:${extra.port}`);
-		}
-		let reuse = choice.running !== void 0;
-		if (reuse && choice.running !== CLI_VERSION) {
-			const from = choice.running || "unknown";
-			const pid = choice.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-9uuI4Jif.js");
-			server = await serveUi(root, choice.port);
-			writeUiRecord(root, {
-				port: choice.port,
-				pid: process.pid,
-				version: CLI_VERSION
-			});
-			const started = server;
-			watchHubGone(root, () => {
-				const failure = removeHostLink(root, hub);
-				if (failure) log(`! caddy reload failed after removing ${hostName(hub)}: ${failure}`);
-				started.close();
-				process.exit(0);
-			});
-		}
-		return {
-			choice,
-			reuse,
-			server
-		};
-	});
-	const host = await syncHost(root, hub, choice.port, options.host);
-	if (host.url === null) log(`! host name not available: ${host.reason}`);
-	const hostError = host.url === null && host.reloadFailed ? host.reason : void 0;
-	const recorded = readUiRecord(root);
-	if (recorded && recorded.hostError !== hostError) {
-		const { hostError: _previous, ...rest } = recorded;
-		writeUiRecord(root, hostError ? {
-			...rest,
-			hostError
-		} : rest);
-	}
-	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,
-		...hostError && { hostError }
-	};
-}
-/**
-* The exit code `mainflow ui` sets once launching is done. A stale host name makes it 1 only when this process
-* has no server of its own and so ends here; a process that serves keeps 0, or a normal stop much later would
-* report 1.
-*/
-const exitCodeFor = (result) => result.hostError && !result.server ? 1 : 0;
-//#endregion
-export { networkProbe as a, realRoot as c, withUiLock as d, CLI_VERSION as f, launchUi as i, startUiInBackground as l, choosePort as n, portCandidates as o, exitCodeFor as r, readUiRecord as s, PORT_SPAN as t, watchHubGone as u };