fleetfizz 0.10.0 → 0.11.0

package/dist/fleetfizz.mjs

@@ -7433,6 +7433,8 @@ const onExitFilter = /*#__PURE__*/ dual(3, (self, filter, f) => onExit$1(self, (
 }));
 /** @internal */
 const onError$1 = /*#__PURE__*/ dual(2, (self, f) => onExitFilter(self, exitFilterCause, f));
+/** @internal */
+const acquireUseRelease$1 = (acquire, use, release) => uninterruptibleMask$1((restore) => flatMap$2(acquire, (a) => onExitPrimitive$1(suspend$3(() => restore(use(a))), (exit) => release(a, exit), true)));
 const infiniteTTL = /*#__PURE__*/ constant(Infinity);
 const makeCachedUnsafe = (self, ttlMillis) => {
 	let expiresAt = 0;
@@ -12690,6 +12692,82 @@ const scopedWith = scopedWith$1;
 */
 const acquireRelease = acquireRelease$1;
 /**
+* Runs resource acquisition, usage, and release as one bracketed effect.
+*
+* **When to use**
+*
+* Use to bracket acquire, use, and release logic in one effect.
+*
+* **Details**
+*
+* `acquireUseRelease` does the following:
+*
+*   1. Ensures that the `Effect` value that acquires the resource will not be
+*      interrupted. Note that acquisition may still fail due to internal
+*      reasons (such as an uncaught exception).
+*   2. Ensures that the `release` `Effect` value will not be interrupted,
+*      and will be executed as long as the acquisition `Effect` value
+*      successfully acquires the resource.
+*
+* During the time period between the acquisition and release of the resource,
+* the `use` `Effect` value will be executed.
+*
+* If the `release` `Effect` value fails, then the entire `Effect` value will
+* fail, even if the `use` `Effect` value succeeds. If this fail-fast behavior
+* is not desired, errors produced by the `release` `Effect` value can be caught
+* and ignored.
+*
+* **Example** (Acquiring resources with cleanup)
+*
+* ```ts import.meta.vitest
+* import { Effect, Exit } from "effect"
+* const output: Array<unknown> = []
+*
+* interface Database {
+*   readonly connection: string
+*   readonly query: (sql: string) => Effect.Effect<string>
+* }
+*
+* const program = Effect.acquireUseRelease(
+*   // Acquire - connect to database
+*   Effect.gen(function*() {
+*     yield* Effect.sync(() => { output.push("Connecting to database...") })
+*     return {
+*       connection: "db://localhost:5432",
+*       query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+*     }
+*   }),
+*   // Use - perform database operations
+*   (db) =>
+*     Effect.gen(function*() {
+*       yield* Effect.sync(() => { output.push(`Connected to ${db.connection}`) })
+*       const result = yield* db.query("SELECT * FROM users")
+*       yield* Effect.sync(() => { output.push(`Query result: ${result}`) })
+*       return result
+*     }),
+*   // Release - close database connection
+*   (db, exit) =>
+*     Effect.gen(function*() {
+*       if (Exit.isSuccess(exit)) {
+*         yield* Effect.sync(() => { output.push(`Closing connection to ${db.connection} (success)`) })
+*       } else {
+*         yield* Effect.sync(() => { output.push(`Closing connection to ${db.connection} (failure)`) })
+*       }
+*     })
+* )
+*
+* await Effect.runPromise(program)
+* output // => ["Connecting to database...", "Connected to db://localhost:5432", "Query result: Result for: SELECT * FROM users", "Closing connection to db://localhost:5432 (success)"]
+* ```
+*
+* @see {@link acquireRelease} for scoped resources whose use happens later
+*
+* @stability stable
+* @category resource management
+* @since 2.0.0
+*/
+const acquireUseRelease = acquireUseRelease$1;
+/**
 * Adds a finalizer to the current scope.
 *
 * **When to use**
@@ -33264,7 +33342,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.10.0";
+var version = "0.11.0";
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Logger.js
 const TypeId = "~effect/Logger";
@@ -61120,7 +61198,7 @@ if (process$1.env["DEV"] === "true") {
 	} catch {}
 	if (isDevtoolsInstalled) await init_devtools().then(() => devtools_exports);
 }
-const diff = (before, after) => {
+const diff$1 = (before, after) => {
 	if (before === after) return;
 	if (!before) return after;
 	const changed = {};
@@ -61295,8 +61373,8 @@ const hostConfig = {
 			const rootNode = findRootNode(node);
 			if (rootNode) rootNode.isStaticDirty = true;
 		}
-		const props = diff(oldProps, newProps);
-		const style = diff(oldProps["style"], newProps["style"]);
+		const props = diff$1(oldProps, newProps);
+		const style = diff$1(oldProps["style"], newProps["style"]);
 		if (!props && !style) return;
 		if (props) for (const [key, value] of Object.entries(props)) {
 			if (key === "style") {
@@ -65011,6 +65089,14 @@ const useInput = (inputHandler, options = {}) => {
 	}, [options.isActive, internal_eventEmitter]);
 };
 //#endregion
+//#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/hooks/use-app.js
+/**
+A React hook that returns app lifecycle methods like `exit()` and `waitUntilRenderFlush()`.
+*/
+function useApp() {
+	return (0, import_react.use)(AppContext);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/ink@8.0.0_@types+react@19.3.0_react@19.3.0/node_modules/ink/build/hooks/use-stdout.js
 /**
 A React hook that returns the stdout stream where Ink renders your app.
@@ -67680,10 +67766,10 @@ const Cell = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box, {
 const value = (i) => i.to === void 0 ? i.from ?? "" : i.from === void 0 ? `+ ${i.to}` : i.from === i.to ? i.to : `${i.from} → ${i.to}`;
 const SPINNER = cli_spinners_default.dots;
 const runGlyph = (live, now) => (live ? SPINNER.frames[Math.floor(now / SPINNER.interval) % SPINNER.frames.length] : void 0) ?? "▸";
-const unchanged = (i) => ({
+const UNCHANGED = {
 	text: "",
-	detail: i.kind === "record" || i.kind === "config" ? "up to date" : void 0
-});
+	quiet: true
+};
 const statusOf = (i, dryRun, glyph) => {
 	switch (i.status) {
 		case "running": return {
@@ -67701,7 +67787,7 @@ const statusOf = (i, dryRun, glyph) => {
 			detail: i.detail
 		};
 		case "ok":
-			if (!i.changes) return unchanged(i);
+			if (!i.changes) return UNCHANGED;
 			if (i.kind === "config") return {
 				text: "✓ copied",
 				tone: "ok"
@@ -67723,9 +67809,10 @@ const statusOf = (i, dryRun, glyph) => {
 			if (i.changes) return {
 				text: dryRun ? "· planned" : "· queued",
 				tone: "dim",
-				detail: i.reason
+				detail: i.reason,
+				quiet: true
 			};
-			return unchanged(i);
+			return UNCHANGED;
 	}
 };
 const countsOf = (m) => {
@@ -67875,7 +67962,7 @@ const MachineLine = (props) => {
 const ItemLine = (props) => {
 	const { i, w } = props;
 	const status = statusOf(i, props.dryRun, props.glyph);
-	const quiet = i.status === "idle" ? "dim" : void 0;
+	const quiet = status.quiet === true ? "dim" : void 0;
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box, {
 		columnGap: GAP,
 		children: [
@@ -68446,6 +68533,7 @@ const copiesOf = (checked, from) => {
 	return copies;
 };
 const PULL = "pull:";
+const DIFF = "diff:";
 const askWhy = (current, record, source, from) => {
 	if (record === void 0) return "differs, and no Ship wrote it";
 	const recorded = recordEntries(record);
@@ -68471,7 +68559,11 @@ const fileQuestion = (subject, found, problem, pull, from) => ({
 			title: "skip on these Machines (leave as is, shown as skipped)"
 		}
 	],
-	default: "skip"
+	default: "skip",
+	...pull === void 0 || !pull.openssl ? {} : { diffs: [{
+		value: `${DIFF}${pull.machine}`,
+		title: `view the diff from ${pull.machine}'s copy to this Machine's`
+	}] }
 });
 const missingQuestion = (subject, found, copies, from) => ({
 	kind: "file",
@@ -68670,16 +68762,12 @@ const copyStep = (change) => {
 		input
 	};
 };
-const pull = (name, machine, resolved) => gen(function* () {
-	const source = resolved.sources.get(name);
-	const copy = resolved.copies.get(name)?.find((c) => c.machine === machine);
-	if (source === void 0 || copy === void 0 || source.kind === "unreadable") return { error: `cannot pull ${machine}'s copy here` };
+const fetchFiles = (copy, rels) => gen(function* () {
 	const key = [...globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32))].map((b) => b.toString(16).padStart(2, "0")).join("");
-	const rels = [...copy.entries].flatMap(([rel, entry]) => entry.startsWith("f ") ? [rel] : []);
 	const contents = /* @__PURE__ */ new Map();
 	let finished = false;
 	const code = yield* runScript({
-		name: machine,
+		name: copy.machine,
 		local: false
 	}, [
 		prelude,
@@ -68693,24 +68781,114 @@ const pull = (name, machine, resolved) => gen(function* () {
 		if (match !== null) contents.set(Number(match[1]), new Hidden(match[2] ?? ""));
 		else if (line === "ff-pulled") finished = true;
 	}));
-	if (!finished || contents.size !== rels.length) return { error: code === 255 ? `could not reach ${machine}` : `could not read its copy on ${machine}` };
+	return !finished || contents.size !== rels.length ? { error: code === 255 ? `could not reach ${copy.machine}` : `could not read its copy on ${copy.machine}` } : {
+		key: new Hidden(key),
+		contents: new Map(rels.map((rel, n) => [rel, contents.get(n) ?? new Hidden("")]))
+	};
+});
+const runHere = (from, step) => gen(function* () {
+	let ok = false;
+	yield* runScript({
+		name: from,
+		local: true
+	}, stepScript(step), stepStdin(step), (line) => sync(() => {
+		const parsed = parseLine(line);
+		if (parsed.kind === "done" && parsed.done.id === step.id) ok = parsed.done.ok;
+	}));
+	return ok;
+});
+const pull = (name, machine, resolved) => gen(function* () {
+	const source = resolved.sources.get(name);
+	const copy = resolved.copies.get(name)?.find((c) => c.machine === machine);
+	if (source === void 0 || copy === void 0 || source.kind === "unreadable") return { error: `cannot pull ${machine}'s copy here` };
+	const fetched = yield* fetchFiles(copy, [...copy.entries].flatMap(([rel, entry]) => entry.startsWith("f ") ? [rel] : []));
+	if ("error" in fetched) return fetched;
 	const step = copyStep({
 		item: source.item,
 		entries: copy.entries,
 		...source.kind === "present" ? { current: source.entries } : {},
-		contents: new Map(rels.map((rel, n) => [rel, contents.get(n) ?? new Hidden("")])),
+		contents: fetched.contents,
 		at: copy.record?.at ?? resolved.at,
-		key: new Hidden(key)
+		key: fetched.key
 	});
-	let written = false;
-	yield* runScript({
-		name: resolved.from,
-		local: true
-	}, stepScript(step), stepStdin(step), (line) => sync(() => {
-		const parsed = parseLine(line);
-		if (parsed.kind === "done" && parsed.done.id === step.id) written = parsed.done.ok;
-	}));
-	return written ? { done: `pulled ${short$1(copy.entries)} from ${machine}` } : { error: `could not write ${machine}'s copy on ${resolved.from}` };
+	return (yield* runHere(resolved.from, step)) ? { done: `pulled ${short$1(copy.entries)} from ${machine}` } : { error: `could not write ${machine}'s copy on ${resolved.from}` };
+}).pipe(catch_((e) => succeed$3({ error: e.message })));
+const differing = (a, b) => [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])].filter((rel) => a.get(rel) !== b.get(rel)).toSorted();
+const notShownByGit = (name, old, now) => differing(old.entries, now.entries).flatMap((rel) => {
+	const a = old.entries.get(rel);
+	const b = now.entries.get(rel);
+	const path = rel === "." ? name : `${name}/${rel}`;
+	const mode = (entry) => entry.split(" ")[1] ?? "";
+	const executable = (entry) => (Number.parseInt(mode(entry), 8) & 64) !== 0;
+	if (a?.startsWith("d ") === true && b?.startsWith("d ") === true) return [`${path}/ mode ${mode(a)} → ${mode(b)}`];
+	if (a?.startsWith("d ") === true) return [`${path}/ only on ${old.machine}`];
+	if (b?.startsWith("d ") === true) return [`${path}/ only on ${now.machine}`];
+	if (a?.startsWith("f ") === true && b?.startsWith("f ") === true && mode(a) !== mode(b) && executable(a) === executable(b)) return [`${path} mode ${mode(a)} → ${mode(b)}`];
+	return [];
+});
+const diffStep = (input) => {
+	const rels = differing(input.old.entries, input.new.entries);
+	const inputs = [];
+	const side = (s) => {
+		const decode = s.key === void 0 ? "base64 -d" : `FF_KEY="$ff_input_${inputs.push(s.key) - 1}" openssl enc -d ${CIPHER} -pass env:FF_KEY`;
+		return [
+			`ff_p=${quote(`${input.dir}/${s.machine}/${input.name}`)}`,
+			kindOf(s.entries) === "a directory" ? `mkdir -p "$ff_p"` : `mkdir -p "$(dirname "$ff_p")"`,
+			...rels.flatMap((rel) => {
+				const entry = s.entries.get(rel);
+				if (entry?.startsWith("l ")) return [`mkdir -p "$(dirname ${at(rel)})"`, `ln -s -- ${quote(entry.slice(2))} ${at(rel)}`];
+				if (!entry?.startsWith("f ")) return [];
+				const n = inputs.push(s.contents.get(rel) ?? new Hidden("")) - 1;
+				return [
+					`mkdir -p "$(dirname ${at(rel)})"`,
+					`printf '%s' "$ff_input_${n}" | ${decode} > ${at(rel)}`,
+					`chmod ${entry.split(" ")[1] ?? ""} ${at(rel)}`
+				];
+			})
+		];
+	};
+	const run = [...side(input.old), ...side(input.new)];
+	return {
+		id: `files:${input.name}:diff`,
+		items: [input.name],
+		doing: "diffing",
+		run: [
+			"(",
+			"  set -e",
+			...run.map((l) => `  ${l}`),
+			")"
+		],
+		input: inputs
+	};
+};
+const diff = (name, machine, resolved, dir) => gen(function* () {
+	const source = resolved.sources.get(name);
+	const copy = resolved.copies.get(name)?.find((c) => c.machine === machine);
+	if (source?.kind !== "present" || copy === void 0) return { error: `cannot diff ${machine}'s copy here` };
+	const fetched = yield* fetchFiles(copy, differing(copy.entries, source.entries).filter((rel) => copy.entries.get(rel)?.startsWith("f ") === true));
+	if ("error" in fetched) return fetched;
+	const sides = {
+		old: {
+			machine,
+			entries: copy.entries,
+			contents: fetched.contents,
+			key: fetched.key
+		},
+		new: {
+			machine: resolved.from,
+			entries: source.entries,
+			contents: source.contents
+		}
+	};
+	return (yield* runHere(resolved.from, diffStep({
+		name,
+		dir,
+		...sides
+	}))) ? {
+		old: machine,
+		new: resolved.from,
+		notShown: notShownByGit(name, sides.old, sides.new)
+	} : { error: `could not write the diff on ${resolved.from}` };
 }).pipe(catch_((e) => succeed$3({ error: e.message })));
 const recordStep = (change) => ({
 	id: `files:${change.item.name}:record`,
@@ -68762,7 +68940,8 @@ const files = {
 	}),
 	decide: ({ items, observed, resolved, ctx }) => items.map((item) => decideFile(item, observed, resolved, ctx)),
 	act: (decisions) => decisions.flatMap((d) => d.kind === "change" ? [copyStep(d.change)] : d.kind === "leave" && d.upkeep !== void 0 ? [recordStep(d.upkeep)] : []),
-	adopt: (item, answer, resolved) => answer.startsWith(PULL) ? pull(item, answer.slice(5), resolved) : void 0
+	adopt: (item, answer, resolved) => answer.startsWith(PULL) ? pull(item, answer.slice(5), resolved) : void 0,
+	diff: (item, choice, resolved, dir) => choice.startsWith(DIFF) ? diff(item, choice.slice(5), resolved, dir) : void 0
 };
 const decodeFact$1 = decodeUnknownOption(Union([
 	Struct({
@@ -69367,6 +69546,25 @@ const PROVIDERS = [
 	repos
 ];
 //#endregion
+//#region src/diff.ts
+const showDiff = fn("showDiff")(function* (dir, sides) {
+	const spawner = yield* ChildProcessSpawner;
+	return yield* scoped(gen(function* () {
+		return yield* (yield* spawner.spawn(make$13("git", [
+			"diff",
+			"--no-index",
+			"--",
+			sides.old,
+			sides.new
+		], {
+			cwd: dir,
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit"
+		}))).exitCode;
+	}));
+});
+//#endregion
 //#region src/live.tsx
 const cell = (initial) => {
 	let value = initial;
@@ -69384,6 +69582,10 @@ const cell = (initial) => {
 	};
 };
 const LiveLedger = (props) => {
+	const { suspendTerminal } = useApp();
+	(0, import_react.useEffect)(() => {
+		props.suspend.current = suspendTerminal;
+	}, [props.suspend, suspendTerminal]);
 	const { state, now } = (0, import_react.useSyncExternalStore)(props.store.subscribe, props.store.get);
 	const asking = (0, import_react.useSyncExternalStore)(props.asking.subscribe, props.asking.get);
 	const [full, setFull] = (0, import_react.useState)(false);
@@ -69423,9 +69625,11 @@ const LiveLedger = (props) => {
 };
 const startLive = fn("startLive")(function* (store, color) {
 	const asking = cell(void 0);
+	const suspend = {};
 	const instance = render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LiveLedger, {
 		store,
 		asking,
+		suspend,
 		color
 	}), { exitOnCtrlC: false });
 	yield* addFinalizer(() => promise(async () => {
@@ -69434,20 +69638,29 @@ const startLive = fn("startLive")(function* (store, color) {
 		await instance.waitUntilExit();
 	}));
 	yield* forkScoped(repeat$1(store.tick, spaced(`${SPINNER.interval} millis`)));
-	return { ask: process.stdin.isTTY ? (choices) => callback$1((resume) => {
-		asking.set({
-			titles: choices.map((c) => c.title),
-			answer: (index) => {
-				const choice = choices[index];
-				if (choice === void 0) return;
-				asking.set(void 0);
-				resume(succeed$3(choice.value));
-			}
-		});
-		return sync(() => asking.set(void 0));
-	}) : void 0 };
+	return {
+		ask: process.stdin.isTTY ? (choices) => callback$1((resume) => {
+			asking.set({
+				titles: choices.map((c) => c.title),
+				answer: (index) => {
+					const choice = choices[index];
+					if (choice === void 0) return;
+					asking.set(void 0);
+					resume(succeed$3(choice.value));
+				}
+			});
+			return sync(() => asking.set(void 0));
+		}) : void 0,
+		aside: (effect) => {
+			const suspendTerminal = suspend.current;
+			return suspendTerminal === void 0 ? effect : acquireUseRelease(promise(() => suspendTerminal()), () => effect, (suspension) => promise(() => suspension.resume()));
+		}
+	};
 });
-const noLive = { ask: void 0 };
+const noLive = {
+	ask: void 0,
+	aside: (effect) => effect
+};
 const canRedraw = () => Boolean(process.stdout.isTTY) && process.env.TERM !== "dumb";
 //#endregion
 //#region src/machine.ts
@@ -69606,7 +69819,14 @@ const askQuestions = fn("askQuestions")(function* (input) {
 			value: c.value,
 			title: c.value === "bump" && bumps.length > 0 ? `bump the config to ${bumps.map((b) => bumpedRange(b.range, b.newest)).join(" and ")}` : c.title
 		}));
-		const answer = input.answer(question.kind, question.subject) ?? (input.ask === void 0 ? question.default : yield* input.ask(choices));
+		const diffs = [...new Map(group.flatMap((a) => a.question.diffs ?? []).map((c) => [c.value, c])).values()];
+		const isDiff = (value) => diffs.some((d) => d.value === value);
+		let answer = input.answer(question.kind, question.subject);
+		while (answer === void 0) {
+			const picked = input.ask === void 0 ? question.default : yield* input.ask([...choices, ...diffs]);
+			if (isDiff(picked)) yield* input.diff(question, picked);
+			else answer = picked;
+		}
 		yield* input.ledger.note("answer", choices.find((c) => c.value === answer)?.title ?? answer);
 		answered.push({
 			question,
@@ -69885,6 +70105,18 @@ const shipPass = fn("shipPass")(function* (flags, tailnet, hidden, id) {
 	let cfg = config;
 	const decided = /* @__PURE__ */ new Map();
 	const answer = (kind, subject) => decided.get(`${kind}:${subject}`) ?? given(kind, subject);
+	const diff = (question, choice) => scoped(gen(function* () {
+		const at = parseAddress(question.subject);
+		const provider = providers.find((p) => p.name === at?.provider);
+		if (at === void 0 || provider === void 0) return;
+		const dir = yield* fs.makeTempDirectoryScoped({ prefix: "fleetfizz-diff-" });
+		const sides = yield* provider.diff?.(at.item, choice, resolved[provider.name], dir) ?? succeed$3(void 0);
+		if (sides === void 0) return;
+		if ("error" in sides) return yield* ledger.note("info", `${question.subject}: ${sides.error}`);
+		const code = yield* live.aside(showDiff(dir, sides));
+		if (code > 1) yield* ledger.note("info", `${question.subject}: git diff exited with ${code}`);
+		if (sides.notShown.length > 0) yield* ledger.note("info", `${question.subject}: also differs, not shown by git: ${sides.notShown.join(", ")}`);
+	})).pipe(catch_((e) => ledger.note("info", `${question.subject}: could not show the diff: ${e.message}`)));
 	let planned = planAll(cfg, answer);
 	for (;;) {
 		const asked = planned.flatMap((g) => g.plan.providers.flatMap((pp) => pp.decisions.flatMap((d) => d.kind === "ask" ? [{
@@ -69896,6 +70128,7 @@ const shipPass = fn("shipPass")(function* (flags, tailnet, hidden, id) {
 			answer,
 			ledger,
 			ask: live.ask,
+			diff,
 			dryRun: flags.dryRun
 		});
 		let progressed = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetfizz",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Keep every Machine on your tailnet in line with one config.",
   "license": "MIT",
   "repository": {