mainflow 0.30.0-alpha.1 → 0.31.0-alpha.1

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { B as parseRef, H as refExample, V as parseUntil, Y as stampMs, k as UNTIL_FORMS } from "./dist-IdbnCDqM.js";
-import { B as checkHubName, H as loadHub, J as TASK_FILE, Q as nodeStorage, S as readSession, V as HubError, X as nowMinute, Y as requireSlug, _ as untilState, d as retroReportFromReceiver, f as receiverFromEnv, g as initHub, l as migrateHub, ot as DATA_DIR, p as RETRY_RULES, q as MAINLINE_FILE, rt as findHubRoot, st as WriteError, u as retroReport, v as duplicateClaimLines, x as loadSessions, y as sessionBriefing, z as applyOperation } from "./host-DmVNYRql.js";
+import { B as checkHubName, H as loadHub, J as TASK_FILE, Q as nodeStorage, S as readSession, V as HubError, X as nowMinute, Y as requireSlug, _ as untilState, at as findHubRoot, ct as DATA_DIR, d as retroReportFromReceiver, f as receiverFromEnv, g as initHub, l as migrateHub, lt as WriteError, p as RETRY_RULES, q as MAINLINE_FILE, u as retroReport, v as duplicateClaimLines, x as loadSessions, y as sessionBriefing, z as applyOperation } from "./host-CdB_vDY_.js";
 import { t as listProgress } from "./progress-1BfPg2zN.js";
-import { C as ServerError, S as ServerApi, _ as silentHint, a as remoteMode, c as syncSettings, d as startDaemon, f as DaemonRunning, g as readDaemon, h as probeDaemon, i as queuedCount, l as hookAnswer, m as callDaemon, n as hubWriter, o as ENV, p as DaemonUnavailable, r as writtenLines, s as hubName, t as CONFIRM_MS, u as planFlush, v as SETTINGS_FILE, x as syncPaths } from "./operation-BQiUL0eq.js";
+import { C as syncSettings, D as syncPaths, S as hubName, _ as readRemote, a as remoteMode, b as ENV, c as planFetch, d as DaemonRunning, f as DaemonUnavailable, g as silentHint, h as readDaemon, i as queuedCount, l as planFlush, m as probeDaemon, n as hubWriter, o as fetchDenial, p as callDaemon, r as writtenLines, s as hookAnswer, t as CONFIRM_MS, u as startDaemon, v as ServerApi, w as SETTINGS_FILE, x as earlierToken, y as ServerError } from "./operation-BmysMg4R.js";
 import { COMMAND_SPECS, OPTIONS } from "./facts.js";
 import { hookFallback, parsePayload, runHook } from "./hooks.js";
-import { c as watchHubGone, l as CLI_VERSION, r as launchUi, s as startUiInBackground } from "./launch-DHug6eli.js";
+import { c as watchHubGone, l as CLI_VERSION, r as launchUi, s as startUiInBackground } from "./launch-D1zaGo7W.js";
 import { randomBytes } from "node:crypto";
-import { existsSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
-import { basename, join, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 //#region src/remote/sync.ts
@@ -20,7 +20,8 @@ import { parseArgs } from "node:util";
 async function syncRun(root) {
 	const settings = syncSettings(root);
 	if (!settings) {
-		console.error(`✗ no sync server: set ${ENV.url} and ${ENV.token}, or url and token in .mainflow/${SETTINGS_FILE}`);
+		const earlier = earlierToken(root);
+		console.error(earlier ? `✗ ${earlier}` : `✗ no sync server: set ${ENV.url}, ${ENV.clientId} and ${ENV.clientSecret}, or url, clientId and clientSecret in .mainflow/${SETTINGS_FILE}`);
 		return 1;
 	}
 	const running = await probeDaemon(root);
@@ -28,13 +29,16 @@ async function syncRun(root) {
 		console.error(`✗ mainflow sync already runs for this hub (pid ${running.daemon.pid})${running.state === "silent" ? `; ${silentHint(running.daemon)}` : ""}`);
 		return 1;
 	}
+	const api = new ServerApi(settings);
 	try {
-		await new ServerApi(settings).snapshot();
+		await api.check();
 	} catch (error) {
 		if (error instanceof ServerError) {
 			console.error(`✗ ${error.message} (hub ${settings.hub} at ${settings.url})`);
 			return 1;
 		}
+	} finally {
+		api.close();
 	}
 	let daemon;
 	try {
@@ -104,6 +108,96 @@ async function syncFlush(root, hook) {
 	console.log(`${result.problems.length} problems, ${result.queued} queued, ${result.online ? "online" : "offline"}`);
 	return result.problems.length > 0 ? 1 : 0;
 }
+/** How long a download may take before the command or the hook gives up on the sync client's answer. */
+const FETCH_MS = 3e4;
+/**
+* What `target` names, as the sync client takes it: a mainline (m001) or a task (m001/t002), as its directory with every
+* file under it, or a path, from the current directory or from .mainflow/. Null when it names nothing of the hub.
+*/
+function fetchSpec(root, target) {
+	const ref = /^(m\d{3})(?:\/(t\d{3}))?$/.exec(target);
+	if (ref) {
+		const dirOf = (parent, id) => existsSync(join(root, ".mainflow", parent)) ? readdirSync(join(root, DATA_DIR, parent)).find((name) => name.startsWith(`${id}-`)) : void 0;
+		const mainline = dirOf("mainlines", ref[1]);
+		if (!mainline) return null;
+		if (!ref[2]) return `mainlines/${mainline}/`;
+		const task = dirOf(`mainlines/${mainline}/tasks`, ref[2]);
+		return task ? `mainlines/${mainline}/tasks/${task}/` : null;
+	}
+	const inHub = (file) => {
+		const path = relative(join(root, DATA_DIR), file).split(sep).join("/");
+		return path === "" || path.startsWith("../") || path === ".." || isAbsolute(path) ? null : path;
+	};
+	return inHub(resolve(process.cwd(), target)) ?? (isAbsolute(target) ? null : inHub(join(root, ".mainflow", target)));
+}
+/**
+* Download files only on the sync server, the artifacts of closed mainlines an environment with on-demand downloads
+* left there: one file, a directory, or a mainline's or task's, by its ID. With `hook`, read the PreToolUse payload from
+* stdin instead: a Read, Edit, Write or MultiEdit of an artifact that is not here downloads it first, when the host runs
+* the hook for it (Claude Code answers an Edit of a missing file before its hooks). A Read then goes ahead; a write is
+* stopped with the reason, so the agent reads the file before writing over it. When it cannot be
+* downloaded, or no sync client runs, the tool is stopped with the reason, so the agent does not take the file for one
+* that does not exist. Anything else answers nothing.
+*/
+async function syncFetch(root, target, hook) {
+	if (hook) return syncFetchHook(root, readPayload());
+	if (target === void 0) {
+		console.error("✗ Usage: mainflow sync fetch <path|m|m/t> (or --hook for a PreToolUse hook)");
+		return 1;
+	}
+	const spec = fetchSpec(root, target);
+	if (spec === null) {
+		console.error(`✗ ${target} names no mainline, task or path in .mainflow/`);
+		return 1;
+	}
+	const daemon = readDaemon(root);
+	if (!daemon) {
+		console.error("✗ mainflow sync is not running for this hub; start it with mainflow sync, then fetch again");
+		return 1;
+	}
+	let result;
+	try {
+		result = await callDaemon(daemon, "/fetch", { paths: [spec] }, FETCH_MS);
+	} catch (error) {
+		if (!(error instanceof DaemonUnavailable)) throw error;
+		console.error(error.silent ? `✗ mainflow sync (pid ${daemon.pid}) did not answer within ${FETCH_MS / 1e3} s: it is busy, as with a large snapshot or a slow download; try again shortly` : `✗ ${error.message}; start mainflow sync, then fetch again`);
+		return 1;
+	}
+	if (result.error) {
+		console.error(`✗ could not download ${spec}: ${result.error}`);
+		return 1;
+	}
+	for (const path of result.fetched) console.log(`  ${path}`);
+	for (const path of result.gone) console.log(`! ${path} is no longer on the sync server`);
+	if (result.fetched.length === 0 && result.gone.length === 0) console.log(`✓ nothing to download: no file under ${spec} is only on the sync server`);
+	else console.log(`✓ downloaded ${result.fetched.length} file${result.fetched.length === 1 ? "" : "s"}`);
+	return 0;
+}
+async function syncFetchHook(root, payload) {
+	const plan = planFetch(root, payload);
+	if (!plan) return 0;
+	const deny = (reason) => {
+		console.log(fetchDenial(reason));
+		return 0;
+	};
+	const daemon = readDaemon(root);
+	let result = null;
+	let busy = false;
+	if (daemon) try {
+		result = await callDaemon(daemon, "/fetch", { paths: [plan.path] }, FETCH_MS);
+	} catch (error) {
+		busy = error instanceof DaemonUnavailable && error.silent;
+	}
+	if (!result) {
+		if (!(plan.path in readRemote(root))) return 0;
+		if (busy) return deny(`.mainflow/${plan.path} is only on the sync server and is not downloaded yet: mainflow sync did not answer within ${FETCH_MS / 1e3} s, as it is busy, such as with a large snapshot. Try again shortly, or run mainflow sync fetch ${plan.path}; the file exists, do not take it for missing.`);
+		return deny(`.mainflow/${plan.path} is only on the sync server and is not downloaded here, and mainflow sync is not running, so it cannot be downloaded now. Start mainflow sync and run mainflow sync fetch ${plan.path}; the file exists, do not take it for missing.`);
+	}
+	if (result.error) return deny(`.mainflow/${plan.path} is only on the sync server and could not be downloaded (${result.error}). Try again once mainflow sync status says online; the file exists, do not take it for missing.`);
+	if (!result.fetched.includes(plan.path)) return 0;
+	if (plan.write) return deny(`.mainflow/${plan.path} was only on the sync server and is downloaded now. Read it before writing to it, so the write starts from what it holds.`);
+	return 0;
+}
 async function syncStatus(root) {
 	const probe = await probeDaemon(root);
 	if (probe?.state === "silent") {
@@ -113,11 +207,14 @@ async function syncStatus(root) {
 	if (probe?.state === "running") {
 		const { status, daemon } = probe;
 		if (!status) console.log(`mainflow sync runs for this hub (pid ${daemon.pid}); it did not give its status`);
-		else console.log(`mainflow sync runs (pid ${daemon.pid}): ${status.online ? status.caughtUp ? "online, caught up" : "online, catching up" : "offline"}, ${status.queued} queued, atomic exchange ${status.swapping ? "on" : "off"}, ${status.problems} problems so far`);
+		else console.log(`mainflow sync runs (pid ${daemon.pid}): ${status.online ? status.caughtUp ? "online, caught up" : "online, catching up" : "offline"}, ${status.queued} queued, atomic exchange ${status.swapping ? "on" : "off"}, ${status.problems} problems so far${status.remote ? `, ${status.remote} file${status.remote === 1 ? "" : "s"} only on the server (mainflow sync fetch)` : ""}`);
+		if (status?.waitingForUpload) console.log("! the sync server has no copy of this hub, and this environment downloads on demand, so it does not upload its copy; run mainflow sync with on-demand downloads off in an environment that keeps every file of the hub to upload it");
 		return 0;
 	}
 	const queue = queuedCount(root);
 	console.log(`mainflow sync is not running; ${remoteMode(root) ? `${queue} write(s) wait in the outbox until it runs` : "writes go to the local files"}`);
+	const earlier = remoteMode(root) ? null : earlierToken(root);
+	if (earlier) console.error(`! ${earlier}`);
 	return 0;
 }
 //#endregion
@@ -801,7 +898,12 @@ const WRITES = {
 function runWrite(ctx, spec) {
 	spec.check?.(ctx);
 	const input = spec.input(ctx);
-	if (!remoteMode(ctx.root)) return spec.print(ctx, applyOperation(nodeStorage(ctx.root), spec.op, input, { now: nowMinute() }).value);
+	if (!remoteMode(ctx.root)) {
+		const code = spec.print(ctx, applyOperation(nodeStorage(ctx.root), spec.op, input, { now: nowMinute() }).value);
+		const earlier = earlierToken(ctx.root);
+		if (earlier) console.error(`! ${earlier}`);
+		return code;
+	}
 	return hubWriter(ctx.root, process.env, { confirmMs: CONFIRM_MS })(spec.op, input).then((written) => {
 		const code = spec.print(ctx, written.value);
 		for (const line of writtenLines(written)) (line.startsWith("!") ? console.error : console.log)(line);
@@ -920,6 +1022,7 @@ const RUNS = {
 	},
 	sync: ({ root }) => syncRun(root),
 	"sync flush": ({ root, opts }) => syncFlush(root, opts.hook ?? false),
+	"sync fetch": ({ root, args, opts }) => syncFetch(root, args[0], opts.hook ?? false),
 	"sync status": ({ root }) => syncStatus(root)
 };
 const COMMANDS = Object.fromEntries(Object.keys(COMMAND_SPECS).map((name) => [name, {

package/dist/facts.d.ts

@@ -342,7 +342,7 @@ export declare const COMMAND_SPECS: {
   };
   readonly sync: {
     readonly usage: 'sync';
-    readonly summary: `Keep .mainflow/ in step with the hub on the sync server until stopped: pull its changes, send every local change. The server and token come from MAINFLOW_SYNC_URL and MAINFLOW_SYNC_TOKEN, or url and token in .mainflow/local/sync.json. While it runs, or with a server and token set, every mainflow write is applied here and put in the outbox, which it sends in order; a writing command waits up to 15 s for the server's answer`;
+    readonly summary: `Keep .mainflow/ in step with the hub on the sync server until stopped: pull its changes, send every local change. The server and its Cloudflare Access service token come from MAINFLOW_SYNC_URL, MAINFLOW_SYNC_CLIENT_ID and MAINFLOW_SYNC_CLIENT_SECRET, or url, clientId and clientSecret in .mainflow/local/sync.json. On connecting it downloads only the files that differ from the versions it last synced; with MAINFLOW_SYNC_ON_DEMAND=1, or onDemand: true in sync.json, it leaves the artifacts of done and dropped mainlines on the server until they are used (sync fetch). While it runs, or with a server and token set, every mainflow write is applied here and put in the outbox, which it sends in order; a writing command waits up to 15 s for the server's answer`;
     readonly args: 0;
     readonly needsHub: true;
   };
@@ -352,6 +352,13 @@ export declare const COMMAND_SPECS: {
     readonly args: 0;
     readonly needsHub: true;
   };
+  readonly 'sync fetch': {
+    readonly usage: 'sync fetch [<path|m|m/t>] [--hook]';
+    readonly summary: 'Download files only on the sync server: with MAINFLOW_SYNC_ON_DEMAND, or onDemand in .mainflow/local/sync.json, the artifacts of done and dropped mainlines stay there until used. Give a file or directory (from here or from .mainflow/), or a mainline or task ID for all of its artifacts; mainflow sync must be running. Grep and Glob do not see a file that is not downloaded, so fetch the mainline before searching it. --hook reads a PreToolUse payload from stdin: a Read or Write of such a file downloads it first (Claude Code 2.1.285 answers an Edit of a missing file before any hook runs, so Read it or fetch it before editing); a Write, a failed download, or a mainflow sync that does not run or does not answer within 30 s answers deny with the reason';
+    readonly args: 0;
+    readonly optionalArgs: 1;
+    readonly needsHub: true;
+  };
   readonly 'sync status': {
     readonly usage: 'sync status';
     readonly summary: 'Say whether mainflow sync runs for this hub, whether it is online and caught up with the server, and how many writes wait to be sent';

package/dist/facts.js

@@ -332,7 +332,7 @@ const COMMAND_SPECS = {
 	},
 	sync: {
 		usage: "sync",
-		summary: `Keep .mainflow/ in step with the hub on the sync server until stopped: pull its changes, send every local change. The server and token come from MAINFLOW_SYNC_URL and MAINFLOW_SYNC_TOKEN, or url and token in .mainflow/local/sync.json. While it runs, or with a server and token set, every mainflow write is applied here and put in the outbox, which it sends in order; a writing command waits up to 15 s for the server's answer`,
+		summary: `Keep .mainflow/ in step with the hub on the sync server until stopped: pull its changes, send every local change. The server and its Cloudflare Access service token come from MAINFLOW_SYNC_URL, MAINFLOW_SYNC_CLIENT_ID and MAINFLOW_SYNC_CLIENT_SECRET, or url, clientId and clientSecret in .mainflow/local/sync.json. On connecting it downloads only the files that differ from the versions it last synced; with MAINFLOW_SYNC_ON_DEMAND=1, or onDemand: true in sync.json, it leaves the artifacts of done and dropped mainlines on the server until they are used (sync fetch). While it runs, or with a server and token set, every mainflow write is applied here and put in the outbox, which it sends in order; a writing command waits up to 15 s for the server's answer`,
 		args: 0,
 		needsHub: true
 	},
@@ -342,6 +342,13 @@ const COMMAND_SPECS = {
 		args: 0,
 		needsHub: true
 	},
+	"sync fetch": {
+		usage: "sync fetch [<path|m|m/t>] [--hook]",
+		summary: "Download files only on the sync server: with MAINFLOW_SYNC_ON_DEMAND, or onDemand in .mainflow/local/sync.json, the artifacts of done and dropped mainlines stay there until used. Give a file or directory (from here or from .mainflow/), or a mainline or task ID for all of its artifacts; mainflow sync must be running. Grep and Glob do not see a file that is not downloaded, so fetch the mainline before searching it. --hook reads a PreToolUse payload from stdin: a Read or Write of such a file downloads it first (Claude Code 2.1.285 answers an Edit of a missing file before any hook runs, so Read it or fetch it before editing); a Write, a failed download, or a mainflow sync that does not run or does not answer within 30 s answers deny with the reason",
+		args: 0,
+		optionalArgs: 1,
+		needsHub: true
+	},
 	"sync status": {
 		usage: "sync status",
 		summary: "Say whether mainflow sync runs for this hub, whether it is online and caught up with the server, and how many writes wait to be sent",

package/dist/hooks.js

@@ -1,6 +1,6 @@
 import { $ as describeRequest, j as configSchema } from "./dist-IdbnCDqM.js";
-import { D as endsWithMarker, E as decorateReply, H as loadHub, O as headerLine, S as readSession, T as matchGrants, V as HubError, Z as readYaml, b as turnReminder, i as hostName, it as worktreesOf, k as mayDecorate, nt as currentBranch, ot as DATA_DIR, rt as findHubRoot, w as grantScope, x as loadSessions, y as sessionBriefing } from "./host-DmVNYRql.js";
-import { n as hubWriter, r as writtenLines } from "./operation-BQiUL0eq.js";
+import { D as endsWithMarker, E as decorateReply, H as loadHub, O as headerLine, S as readSession, T as matchGrants, V as HubError, Z as readYaml, at as findHubRoot, b as turnReminder, ct as DATA_DIR, i as hostName, it as currentBranch, k as mayDecorate, ot as worktreesOf, w as grantScope, x as loadSessions, y as sessionBriefing } from "./host-CdB_vDY_.js";
+import { n as hubWriter, r as writtenLines } from "./operation-BmysMg4R.js";
 import { resolveFixed, scanCommand, scopedCwd } from "./grant-commands.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";

package/dist/{host-DmVNYRql.js → host-CdB_vDY_.js}

@@ -328,17 +328,54 @@ function requestTime(instant = /* @__PURE__ */ new Date()) {
 }
 /** The routes, below the server's origin. `{hub}` is the hub's name, like carlos-space. */
 const ROUTES = {
-	/** GET, without a token: the protocol version this server speaks, `{ protocol }` */
+	/** GET: the protocol version this server speaks, `{ protocol }` */
 	version: "/version",
 	/** POST one request (SyncRequest), answered with its response and broadcast to the hub's connections when applied */
 	request: (hub) => `/hub/${hub}/request`,
-	/** GET `?protocol=2`: every file and directory of the hub (Snapshot). PUT: upload a whole hub (UploadRequest) */
+	/** POST: one batch of the hub's snapshot (SnapshotRequest, answered with SnapshotBatch). PUT: upload a whole hub (UploadRequest) */
 	snapshot: (hub) => `/hub/${hub}/snapshot`,
-	/** GET `?protocol=2` with `Upgrade: websocket`: receive every broadcast of the hub (ServerBroadcast) */
+	/** GET `?protocol=3` with `Upgrade: websocket`: receive every broadcast of the hub (ServerBroadcast) */
 	socket: (hub) => `/hub/${hub}/ws`
 };
-/** Every route below /hub/ needs this header as `Bearer <token>`, with the token of that hub. */
-const AUTHORIZATION = "authorization";
+/**
+* The service token of Cloudflare Access, which stands in front of the sync server and lets through only the requests
+* that carry a valid one: every request, the WebSocket's upgrade included, sends both headers. The sync server itself
+* checks no credentials, so one deployed without Access in front serves anyone who knows its address.
+*/
+const ACCESS_HEADERS = {
+	clientId: "CF-Access-Client-Id",
+	clientSecret: "CF-Access-Client-Secret"
+};
+/**
+* The order of paths in a snapshot: by Unicode code point, which is the order of their UTF-8 bytes and so the order
+* SQLite gives TEXT. JavaScript compares strings by UTF-16 code unit, which differs only where a character beyond
+* U+FFFF meets one from U+E000 to U+FFFF.
+*/
+function comparePaths(a, b) {
+	const length = Math.min(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		let x = a.charCodeAt(i);
+		let y = b.charCodeAt(i);
+		if (x === y) continue;
+		if (x >= 55296 && y >= 55296) {
+			x += x < 57344 ? 8192 : -2048;
+			y += y < 57344 ? 8192 : -2048;
+		}
+		return x - y;
+	}
+	return a.length - b.length;
+}
+/**
+* The close the sync server ends a WebSocket with once the connection is older than the server lets one live, instead
+* of sending it a broadcast. Cloudflare Access checks the service token only on the upgrade, so a connection opened
+* before its token was revoked would otherwise go on receiving the hub; the client reconnects at once, through Access
+* again, and the snapshot on the new connection brings what changed meanwhile. 4000 is the first of the codes RFC 6455
+* leaves to applications.
+*/
+const SOCKET_MAX_AGE_CLOSE = {
+	code: 4e3,
+	reason: "the connection reached its maximum age; reconnect"
+};
 //#endregion
 //#region ../core/dist/storage/node.js
 const LOCK_WAIT_MS = 5e3;
@@ -7297,4 +7334,4 @@ function openInApp(hub, target, closeAfterMs = 150) {
 	return true;
 }
 //#endregion
-export { AUTHORIZATION as $, attributeTrace as A, checkHubName as B, transcriptPath as C, endsWithMarker as D, decorateReply as E, renumberFiles as F, linksInto as G, loadHub as H, renumberPath as I, TASK_FILE as J, refIndex as K, renumberText as L, transcriptTitle as M, applyOffline as N, headerLine as O, renumberRequest as P, nodeStorage as Q, scopeOfPath as R, readSession as S, matchGrants as T, dependencyGraph as U, HubError as V, mainlineEdges as W, nowMinute as X, requireSlug as Y, readYaml as Z, untilState as _, openInApp as a, ConflictError as at, turnReminder as b, syncHost as c, contentHash as ct, retroReportFromReceiver as d, ROUTES as et, receiverFromEnv as f, initHub as g, setArchivedMany as h, hostName as i, worktreesOf as it, traceTranscript as j, mayDecorate as k, migrateHub as l, ARCHIVE_KINDS as m, DEFAULT_UI_PORT as n, currentBranch as nt, removeHostLink as o, DATA_DIR as ot, RETRY_RULES as p, MAINLINE_FILE as q, caddySites as r, findHubRoot as rt, siteBlock as s, WriteError as st, APP_BUNDLE_ID as t, requestTime as tt, retroReport as u, duplicateClaimLines as v, grantScope as w, loadSessions as x, sessionBriefing as y, applyOperation as z };
+export { ACCESS_HEADERS as $, attributeTrace as A, checkHubName as B, transcriptPath as C, endsWithMarker as D, decorateReply as E, renumberFiles as F, linksInto as G, loadHub as H, renumberPath as I, TASK_FILE as J, refIndex as K, renumberText as L, transcriptTitle as M, applyOffline as N, headerLine as O, renumberRequest as P, nodeStorage as Q, scopeOfPath as R, readSession as S, matchGrants as T, dependencyGraph as U, HubError as V, mainlineEdges as W, nowMinute as X, requireSlug as Y, readYaml as Z, untilState as _, openInApp as a, findHubRoot as at, turnReminder as b, syncHost as c, DATA_DIR as ct, retroReportFromReceiver as d, splitFrontMatter as dt, ROUTES as et, receiverFromEnv as f, initHub as g, setArchivedMany as h, hostName as i, currentBranch as it, traceTranscript as j, mayDecorate as k, migrateHub as l, WriteError as lt, ARCHIVE_KINDS as m, DEFAULT_UI_PORT as n, comparePaths as nt, removeHostLink as o, worktreesOf as ot, RETRY_RULES as p, MAINLINE_FILE as q, caddySites as r, requestTime as rt, siteBlock as s, ConflictError as st, APP_BUNDLE_ID as t, SOCKET_MAX_AGE_CLOSE as tt, retroReport as u, contentHash as ut, duplicateClaimLines as v, grantScope as w, loadSessions as x, sessionBriefing as y, applyOperation as z };

package/dist/host.js

@@ -1,2 +1,2 @@
-import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-DmVNYRql.js";
+import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-CdB_vDY_.js";
 export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeHostLink, siteBlock, syncHost };

package/dist/{launch-DHug6eli.js → launch-D1zaGo7W.js}

@@ -1,4 +1,4 @@
-import { c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, ot as DATA_DIR, st as WriteError } from "./host-DmVNYRql.js";
+import { c as syncHost, ct as DATA_DIR, i as hostName, lt as WriteError, n as DEFAULT_UI_PORT, o as removeHostLink } from "./host-CdB_vDY_.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
@@ -176,7 +176,7 @@ async function launchUi(root, hub, configured, options) {
 	}
 	let server;
 	if (!reuse) {
-		const { serveUi } = await import("./ui-BqRmaHXn.js");
+		const { serveUi } = await import("./ui-DlOY5qEU.js");
 		server = await serveUi(root, choice.port);
 		writeUiRecord(root, {
 			port: choice.port,

package/dist/launch.js

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