@danypops/pi-packed 0.13.2 → 0.15.0

package/README.md

@@ -11,7 +11,7 @@ The extension connects to Packed's authenticated user daemon and starts the pack
 ## Commands
 
 - `/packed` -- a floating overlay panel: every installed Pi package, with update availability. Mnemonics follow lazy.nvim's own convention (uppercase acts on every row, lowercase on the one under the cursor):
-  - `u` / `U` -- update the selected package / update every outdated package, one combined confirmation and one reload. `U`'s progress bar appears inline next to the package currently updating -- the list stays visible throughout, nothing swaps to a separate screen.
+  - `u` / `U` -- update the selected package / update every outdated package, one combined confirmation and one reload. `U` shows a spinner inline next to the package currently updating, settling into a real ✓ or ✗ plus a short tail of that update's own captured output once it finishes -- the list stays visible throughout, nothing swaps to a separate screen. A reload is confirmed separately from the update itself -- decline it to defer: the update already happened, only picking it up in this Pi session is deferred until `/reload`.
   - `x` -- remove the selected package.
   - `d` -- disable (or re-enable) the selected package's own extensions.
   - `c` -- jump to resource config for the selected package (skills, prompts, themes).

package/extension/src/reload.ts

@@ -14,3 +14,28 @@ export function reloadWarning(operation: PackageOperation): string {
 		? "This will require a Pi reload (/reload) to deactivate it."
 		: "This will likely require a Pi reload (/reload) to activate its resources.";
 }
+
+export interface ReloadConfirmContext {
+	hasUI: boolean;
+	ui: { confirm(title: string, message: string): Promise<boolean> };
+}
+
+/**
+ * The second, separate decision point: reloadWarning above is a still-just-
+ * likely warning shown before a mutation runs; this is asked only once the
+ * mutation has actually succeeded and a reload is now definitely needed,
+ * not merely predicted. Declining defers it -- the mutation itself already
+ * happened (the package really did install/update/toggle); only Pi's own
+ * currently-loaded resources are stale until /reload runs later. No-UI
+ * contexts reload immediately: there's no one to ask, and staying silently
+ * stale forever is worse than reloading.
+ *
+ * Extracted from resource-config.ts's own pre-existing pendingReload gate
+ * (the first surface to implement this pattern) so every mutation surface
+ * shares identical wording and behavior instead of drifting apart --
+ * reload.ts's whole reason for existing.
+ */
+export async function confirmReload(ctx: ReloadConfirmContext): Promise<boolean> {
+	if (!ctx.hasUI) return true;
+	return ctx.ui.confirm("Reload Pi now?", "This change only takes effect after a reload.");
+}

package/extension/src/resource-config.ts

@@ -14,6 +14,7 @@ import { Container, Input, Spacer, truncateToWidth, visibleWidth } from "@earend
 import type { PackageResources, ResourceField } from "./packed.js";
 import type { Natives } from "./packed.js";
 import { packagePermissionDecision } from "./permission.js";
+import { confirmReload } from "./reload.js";
 
 type Scope = "global" | "project";
 const RESOURCE_FIELDS = ["extensions", "skills", "prompts", "themes"] as const satisfies readonly ResourceField[];
@@ -132,8 +133,7 @@ export async function showResourceConfig(ctx: ExtensionCommandContext, natives:
 	}
 
 	if (!pendingReload) return;
-	const confirmed = await ctx.ui.confirm("Reload Pi now?", "Extension changes only take effect after a reload.");
-	if (confirmed) await ctx.reload();
+	if (await confirmReload(ctx)) await ctx.reload();
 	else ctx.ui.notify("Extension changes pending -- run /reload when ready.", "warning");
 }
 

package/extension/src/spinner.ts

@@ -0,0 +1,44 @@
+/**
+ * spinner.ts — a tiny, testable indeterminate-progress ticker for a
+ * surface with no discrete step count (a single in-flight subprocess
+ * call, unlike ProgressBar's own known N-of-M batch position). tick() is
+ * the pure, synchronously-testable core; start()/stop() wire it to a real
+ * interval for genuine on-screen animation. pi-tui's own Loader component
+ * does the identical thing internally but keeps its current frame private
+ * (it owns a whole Text line), so it can't be embedded inline in a
+ * caller's own row the way this one is -- hence this small local one.
+ */
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const INTERVAL_MS = 80;
+
+export class Spinner {
+	private index = 0;
+	private timer: ReturnType<typeof setInterval> | undefined;
+
+	/** Current animation frame -- a single braille glyph. */
+	glyph(): string {
+		return FRAMES[this.index]!;
+	}
+
+	/** Advances one frame. Pure and synchronous -- the deterministic unit under test; start() is just this wired to a real timer. */
+	tick(): void {
+		this.index = (this.index + 1) % FRAMES.length;
+	}
+
+	/** Wires tick() to a real interval, calling onTick after each advance so a host can requestRender(). Idempotent -- calling start() again restarts cleanly rather than stacking a second interval. */
+	start(onTick: () => void): void {
+		this.stop();
+		this.timer = setInterval(() => {
+			this.tick();
+			onTick();
+		}, INTERVAL_MS);
+	}
+
+	/** Safe to call even if never started, or more than once. */
+	stop(): void {
+		if (this.timer !== undefined) {
+			clearInterval(this.timer);
+			this.timer = undefined;
+		}
+	}
+}

package/extension/src/tui.ts

@@ -12,20 +12,28 @@
  * own row percentage, not a fixed row count -- scales with the real
  * terminal, unlike the anchor:"top-center"+offsetY this replaced, which
  * was pinned 1 row below the absolute top on any terminal size). Enter
- * opens a second, smaller overlay action menu on top of it. U's batch update stays on
- * this same package list -- progress renders inline next to the row
- * currently being updated, not as a separate screen. Rows render through
+ * opens a second, smaller overlay action menu on top of it. U's batch
+ * update stays on this same package list -- an indeterminate spinner
+ * (Spinner, this package's own -- neither Malevich nor pi-tui exposes an
+ * embeddable one) renders inline next to the row currently updating,
+ * settling into a real ✓/✗ plus a bounded tail of that row's own actual
+ * captured stdout/stderr once it finishes, never a determinate bar (a
+ * single subprocess call has no knowable percentage). Rows render through
  * Malevich's Table (real column-aligned Package/Version/status cells,
  * per-row selection styling baked into each cell since Table's own
  * cellStyle is column-wide, not row-wide) inside this panel's own
  * scroll-window slice -- Table deliberately owns no pagination of its
- * own, so the visible-window-around-selectedIndex math stays here. All
+ * own, so the visible-window-around-selectedIndex math stays here. Every
+ * mutation that actually changes something asks confirmReload separately
+ * from the earlier mutation-approval confirm -- declining defers the
+ * reload (the mutation itself already happened) and keeps the panel open
+ * with refreshed rows instead of ending the session. All
  * data flows through the packed CLI (thin seam).
  */
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
 import { Container, Input, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { Envelope, Menu, ProgressBar, Table, type MenuItem, type TableColumn, type TextMeasure } from "malevich-tui-components";
+import { Envelope, Menu, Table, type MenuItem, type TableColumn, type TextMeasure } from "malevich-tui-components";
 import { filterRows, mergeRows, nextMode, visibleRows } from "./model.js";
 import type { Row, ViewMode } from "./model.js";
 import type { Natives, PackageResources } from "./packed.js";
@@ -34,6 +42,8 @@ import { showPackedSettings } from "./security-tui.js";
 import { showResourceConfig, applyResourceToggle } from "./resource-config.js";
 import { showDiscoverPanel } from "./discover.js";
 import { menuTheme } from "./menu-theme.js";
+import { confirmReload } from "./reload.js";
+import { Spinner } from "./spinner.js";
 
 interface PanelAction {
 	type: "update" | "remove" | "disable" | "config" | "find" | "refresh" | "settings";
@@ -43,8 +53,11 @@ interface PanelAction {
 /** Outcome of a confirmed row action, resolved after any real mutation and
  * reload decision -- "changed" means the daemon state changed and Pi has
  * already been reloaded (the caller should stop showing the stale panel);
+ * "deferred" means the mutation itself genuinely happened but the user
+ * declined confirmReload's separate reload gate -- Pi's session is still
+ * alive and the panel should refresh its rows and keep running, not close;
  * "unchanged"/"cancelled" mean the panel keeps running as-is. */
-export type PackageChoiceOutcome = "changed" | "unchanged" | "cancelled";
+export type PackageChoiceOutcome = "changed" | "unchanged" | "cancelled" | "deferred";
 
 export async function applyPackageChoice(
 	choice: string | undefined,
@@ -70,6 +83,10 @@ export async function applyPackageChoice(
 				return "unchanged";
 			}
 			const transition = outcome.previousVersion && outcome.currentVersion ? ` (${outcome.previousVersion} → ${outcome.currentVersion})` : "";
+			if (!(await confirmReload(ctx))) {
+				ctx.ui.notify(`Updated ${row.name}${transition}; reload pending -- run /reload when ready.`, "warning");
+				return "deferred";
+			}
 			ctx.ui.notify(`Updated ${row.name}${transition}; reloading Pi resources.`, "info");
 			await ctx.reload();
 			return "changed";
@@ -86,6 +103,10 @@ export async function applyPackageChoice(
 				return "cancelled";
 			}
 			await natives.remove(row.name, approval.approved);
+			if (!(await confirmReload(ctx))) {
+				ctx.ui.notify(`Removed ${row.name}; reload pending -- run /reload when ready.`, "warning");
+				return "deferred";
+			}
 			ctx.ui.notify(`Removed ${row.name}; reloading Pi resources.`, "info");
 			await ctx.reload();
 			return "changed";
@@ -99,7 +120,13 @@ export async function applyPackageChoice(
 
 interface UpdateAllResult { changed: number; failedNames: string[]; }
 
-interface UpdateProgressEvent { row: Row; index: number; total: number; phase: "start" | "done"; }
+/** Present only on phase "done" -- the real captured stdout+stderr from
+ * ExecInstaller (ok: true) or the thrown error's message (ok: false). This
+ * is the actual execution output, not a synthetic status string, so a host
+ * can show a genuine success/failure sign instead of guessing from
+ * reloadRequired alone. */
+interface UpdateProgressResult { ok: boolean; output: string; }
+interface UpdateProgressEvent { row: Row; index: number; total: number; phase: "start" | "done"; result?: UpdateProgressResult; }
 
 /** The core sequential-update loop, with no UI of its own -- reports each
  * step via onProgress so any host surface (a floating overlay, or the
@@ -118,14 +145,28 @@ async function performUpdateAll(
 		try {
 			const outcome = await natives.update(`npm:${row.name}`, approved);
 			if (outcome.reloadRequired) changed += 1;
+			onProgress?.({ row, index: i, total: outdated.length, phase: "done", result: { ok: true, output: outcome.output } });
 		} catch (e) {
-			failedNames.push(`${row.name}: ${e instanceof Error ? e.message : e}`);
+			const message = e instanceof Error ? e.message : String(e);
+			failedNames.push(`${row.name}: ${message}`);
+			onProgress?.({ row, index: i, total: outdated.length, phase: "done", result: { ok: false, output: message } });
 		}
-		onProgress?.({ row, index: i, total: outdated.length, phase: "done" });
 	}
 	return { changed, failedNames };
 }
 
+const MAX_LOG_TAIL_CHARS = 60;
+
+/** The last non-empty line of real captured output, bounded -- never the
+ * full stdout/stderr dump inline (a noisy npm install can produce hundreds
+ * of lines). undefined when there's nothing worth showing (the common
+ * case: `pi update` often produces no output on success at all). */
+function logTail(output: string): string | undefined {
+	const line = output.trim().split("\n").filter(Boolean).at(-1);
+	if (!line) return undefined;
+	return line.length > MAX_LOG_TAIL_CHARS ? `${line.slice(0, MAX_LOG_TAIL_CHARS - 1)}…` : line;
+}
+
 /** Approves once for the whole batch, runs it via whatever runBatch does
  * (a floating overlay for applyUpdateAll's own public API, or renderPanel's
  * embedded progress bar), then reports the combined result -- shared so
@@ -156,16 +197,27 @@ async function approveAndRunUpdateAll(
 		ctx.ui.notify(failedNames.length > 0 ? `No packages updated; ${failedNames.length} failed.` : "All packages already up to date.", failedNames.length > 0 ? "warning" : "info");
 		return failedNames.length > 0 ? "cancelled" : "unchanged";
 	}
-	ctx.ui.notify(`Updated ${changed} package(s)${failedNames.length > 0 ? `, ${failedNames.length} failed` : ""}; reloading Pi resources.`, "info");
+	const failedSuffix = failedNames.length > 0 ? `, ${failedNames.length} failed` : "";
+	if (!(await confirmReload(ctx))) {
+		ctx.ui.notify(`Updated ${changed} package(s)${failedSuffix}; reload pending -- run /reload when ready.`, "warning");
+		return "deferred";
+	}
+	ctx.ui.notify(`Updated ${changed} package(s)${failedSuffix}; reloading Pi resources.`, "info");
 	await ctx.reload();
 	return "changed";
 }
 
-/** Floats its own progress-bar overlay over the still-open panel -- kept
+const MAX_SETTLED_LOG_LINES = 5;
+
+/** Floats its own spinner+log overlay over the still-open panel -- kept
  * for applyUpdateAll's own public API (and anything calling it directly,
  * outside the packages panel). renderPanel's own U key does not use this;
- * it renders the same progress bar inline on its own already-open overlay
- * instead of stacking a second one. */
+ * it renders the same spinner+log inline on its own already-open overlay
+ * instead of stacking a second one. An indeterminate spinner (not a
+ * determinate bar) because a single subprocess call has no knowable
+ * percentage -- only "still running" or "settled". Each settled row
+ * appends one bounded log line (real captured output, not a synthetic
+ * status) with a genuine success/failure glyph, up to a small scrollback. */
 async function runUpdatesWithProgress(
 	outdated: Row[],
 	natives: Natives,
@@ -174,22 +226,35 @@ async function runUpdatesWithProgress(
 ): Promise<UpdateAllResult> {
 	return ctx.ui.custom<UpdateAllResult>(
 		(tui, theme, _kb, done) => {
-			const bar = new ProgressBar({ value: 0, max: outdated.length, label: `${outdated[0]?.name ?? ""} (1/${outdated.length})`, style: (s) => theme.fg("accent", s) });
+			const spinner = new Spinner();
+			const settledLines: string[] = [];
+			let currentLabel = `${outdated[0]?.name ?? ""} (1/${outdated.length})`;
 			const border = () => new DynamicBorder((s) => theme.fg("border", s));
 			const container = new Container();
 			container.addChild(new Spacer(1));
 			container.addChild(border());
 			container.addChild({ invalidate() {}, render: (_width: number) => [theme.bold("Updating packages")] });
 			container.addChild(new Spacer(1));
-			container.addChild(bar);
+			container.addChild({ invalidate() {}, render: (width: number) => [truncateToWidth(`${theme.fg("accent", spinner.glyph())} ${currentLabel}`, width, "")] });
+			container.addChild(new Spacer(1));
+			container.addChild({
+				invalidate() {},
+				render: (width: number) => settledLines.slice(-MAX_SETTLED_LOG_LINES).map((line) => truncateToWidth(line, width, "")),
+			});
 			container.addChild(new Spacer(1));
 			container.addChild(border());
 
+			spinner.start(() => tui.requestRender());
 			performUpdateAll(outdated, natives, approved, (event) => {
-				bar.setLabel(`${event.row.name} (${event.index + 1}/${event.total})`);
-				if (event.phase === "done") bar.setValue(event.index + 1);
+				if (event.phase === "start") {
+					currentLabel = `${event.row.name} (${event.index + 1}/${event.total})`;
+				} else {
+					const glyph = event.result?.ok ? theme.fg("success", "✓") : theme.fg("error", "✗");
+					const tail = event.result ? logTail(event.result.output) : undefined;
+					settledLines.push(`${glyph} ${event.row.name}${tail ? theme.fg("dim", ` -- ${tail}`) : ""}`);
+				}
 				tui.requestRender();
-			}).then(done);
+			}).finally(() => spinner.stop()).then(done);
 
 			return { render: (width: number) => container.render(width), invalidate: () => container.invalidate(), handleInput() {} };
 		},
@@ -239,7 +304,12 @@ export async function applyDisableExtensions(row: Row, natives: Natives, ctx: Ex
 		else if (outcome === "cancelled") return toggled > 0 ? "changed" : "cancelled";
 	}
 	if (toggled === 0) return "unchanged";
-	ctx.ui.notify(`${disabling ? "Disabled" : "Enabled"} ${toggled} extension(s) for ${row.name}; reloading Pi resources.`, "info");
+	const verb = disabling ? "Disabled" : "Enabled";
+	if (!(await confirmReload(ctx))) {
+		ctx.ui.notify(`${verb} ${toggled} extension(s) for ${row.name}; reload pending -- run /reload when ready.`, "warning");
+		return "deferred";
+	}
+	ctx.ui.notify(`${verb} ${toggled} extension(s) for ${row.name}; reloading Pi resources.`, "info");
 	await ctx.reload();
 	return "changed";
 }
@@ -287,6 +357,14 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 		return;
 	}
 
+	// A deferred reload means the mutation itself genuinely happened but
+	// ctx.reload() was declined -- the session is still alive, so refresh
+	// rows (real on-disk versions) and keep the panel open, same as "refresh".
+	async function refreshRows(): Promise<void> {
+		({ rows, error } = await loadRows(natives));
+		if (error) ctx.ui.notify(`refresh failed: ${error}`, "error");
+	}
+
 	// Panel loop: actions resolve the component, run outside it, then reopen.
 	// U/updateAll is handled entirely inside renderPanel itself (progress
 	// rendered on the same already-open overlay) and never reaches here.
@@ -295,8 +373,7 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 		if (!action) return; // closed
 
 		if (action.type === "refresh") {
-			({ rows, error } = await loadRows(natives));
-			if (error) ctx.ui.notify(`refresh failed: ${error}`, "error");
+			await refreshRows();
 			continue;
 		}
 
@@ -321,11 +398,13 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 		if (action.type === "disable") {
 			const outcome = await applyDisableExtensions(row, natives, ctx);
 			if (outcome === "changed") return;
+			if (outcome === "deferred") await refreshRows();
 			continue;
 		}
 
 		const outcome = await applyPackageChoice(action.type === "update" ? `Update to ${row.latest}` : "Remove", row, natives, ctx);
 		if (outcome === "changed") return; // ctx.reload() already replaced the session
+		if (outcome === "deferred") await refreshRows();
 	}
 }
 
@@ -337,11 +416,16 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 		let searchActive = false;
 		let filtered = visibleRows(rows, mode);
 		let selectedIndex = 0;
-		// Set only while U's batch update is running. The list stays fully
-		// visible throughout -- this just names which row the shared bar
-		// (below) is currently sitting next to.
+		// Set only while U's batch update is running -- blocks input for the
+		// whole batch (the installer owns input until it finishes), same as
+		// before. The list stays fully visible throughout. Which specific row
+		// currently shows a spinner vs. a settled ✓/✗ is settled's own job
+		// (below), not this -- a just-finished row must show its glyph
+		// immediately, even for the instant before the next row's "start"
+		// event reassigns this to the next name.
 		let updatingRowName: string | undefined;
-		const updatingBar = new ProgressBar({ value: 0, max: 1, width: 10, style: (s) => theme.fg("accent", s) });
+		const spinner = new Spinner();
+		const settled = new Map<string, { ok: boolean; tail: string | undefined }>();
 
 		const maxVisible = 20;
 
@@ -351,21 +435,23 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 		}
 
 		/** U -- runs the whole approve+update+notify+reload flow without ever
-		 * closing this panel or replacing the list: each step's progress
-		 * appears inline next to the row currently being updated, via
-		 * updatingRowName/updatingBar, which list's own render checks. Rows
-		 * refresh in place afterward unless a reload already ended the
-		 * session. */
+		 * closing this panel or replacing the list: each row's own settled
+		 * outcome (spinner while in flight, then a real ✓/✗ plus a bounded tail
+		 * of its actual captured output) appears inline next to that row, via
+		 * updatingRowName/spinner/settled, which list's own render checks. Rows
+		 * refresh in place afterward unless a reload already ended the session. */
 		async function runUpdateAllInline(): Promise<void> {
 			const outdated = rows.filter((row) => row.hasUpdate);
+			settled.clear();
 			const outcome = await approveAndRunUpdateAll(outdated, natives, ctx, (batch, approved) => {
-				updatingBar.setValue(0);
-				updatingBar.setMax(batch.length);
+				spinner.start(() => tui.requestRender());
 				return performUpdateAll(batch, natives, approved, (event) => {
 					updatingRowName = event.row.name;
-					if (event.phase === "done") updatingBar.setValue(event.index + 1);
+					if (event.phase === "done" && event.result) {
+						settled.set(event.row.name, { ok: event.result.ok, tail: logTail(event.result.output) });
+					}
 					tui.requestRender();
-				});
+				}).finally(() => spinner.stop());
 			});
 			updatingRowName = undefined;
 			if (outcome === "changed") {
@@ -375,6 +461,7 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 			const reloaded = await loadRows(natives);
 			if (reloaded.error) ctx.ui.notify(`refresh failed: ${reloaded.error}`, "error");
 			else rows = reloaded.rows;
+			settled.clear(); // fresh state for a subsequent batch
 			applyFilter();
 			tui.requestRender();
 		}
@@ -450,10 +537,16 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 						const selected = i === selectedIndex;
 						const cursor = selected ? theme.fg("accent", "❯ ") : "  ";
 						const name = selected ? theme.bold(row.name) : row.name;
-						const isUpdating = updatingRowName === row.name;
+						// A settled row shows its real outcome even for the instant
+						// before the next row's "start" event moves updatingRowName
+						// off it -- settled always wins over "still spinning".
+						const rowSettled = settled.get(row.name);
+						const isUpdating = !rowSettled && updatingRowName === row.name;
 						const status = isUpdating
-							? theme.fg("accent", `${updatingBar.format(10)} updating…`)
-							: row.hasUpdate ? theme.fg("warning", `↑${row.latest}`) : "";
+							? theme.fg("accent", `${spinner.glyph()} updating…`)
+							: rowSettled
+								? theme.fg(rowSettled.ok ? "success" : "error", `${rowSettled.ok ? "✓" : "✗"}${rowSettled.tail ? ` ${rowSettled.tail}` : ""}`)
+								: row.hasUpdate ? theme.fg("warning", `↑${row.latest}`) : "";
 						return { name: `${cursor}${name}`, version: theme.fg("dim", row.version), status };
 					}),
 				);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "Pi package tools, commands, profiles, and TUI for the Packed daemon",
   "type": "module",
   "keywords": ["pi-package"],