@danypops/pi-packed 0.15.0 → 0.16.1

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` 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`.
+  - `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`. Every confirm in this flow -- approval and reload alike -- renders inline on this same panel (`y`/`n` keys), never a separate popup.
   - `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/menu-theme.ts

@@ -1,5 +1,5 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { MenuTheme } from "malevich-tui-components";
+import type { DialogTheme, MenuTheme } from "malevich-tui-components";
 
 /** Maps Pi's own Theme onto Malevich's Menu -- the one place this mapping
  * exists, shared by every ctx.ui.custom overlay menu in this extension. */
@@ -12,3 +12,16 @@ export function menuTheme(theme: Theme): MenuTheme {
 		title: (s) => theme.fg("accent", s),
 	};
 }
+
+/** Maps Pi's own Theme onto Malevich's Dialog -- used for an inline y/n
+ * decision (e.g. confirmReload) rendered as part of an already-open
+ * ctx.ui.custom overlay's own content, instead of ctx.ui.confirm's separate,
+ * arrow-select-only native dialog. */
+export function dialogTheme(theme: Theme): DialogTheme {
+	return {
+		border: (s) => theme.fg("border", s),
+		title: (s) => theme.bold(theme.fg("accent", s)),
+		body: (s) => s,
+		dim: (s) => theme.fg("muted", s),
+	};
+}

package/extension/src/tui.ts

@@ -14,26 +14,36 @@
  * 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 -- 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. 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).
+ * (Malevich's Spinner, extracted upstream from this panel's original need
+ * once no embeddable one existed anywhere) 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. u/x/d and the Enter action menu all run their whole
+ * approve+mutate+confirmReload flow inline, without ever closing this
+ * overlay first -- every confirm() along the way (mutation approval,
+ * confirmReload's separate reload gate) renders as a real Malevich Dialog
+ * on this SAME overlay, dispatched by literal y/n keys, instead of
+ * ctx.ui.confirm's own separate native dialog (arrow-select only, and a
+ * genuinely different overlay stacked on top -- confirmed live as a real
+ * user complaint). Declining a reload defers it: the mutation itself
+ * already happened, and the panel stays open with refreshed rows instead
+ * of ending the session. Every non-"changed" settle point (already up to
+ * date, pinned, deferred, a genuine failure) shows its own real reason on
+ * that row too via the same settled map U's batch path uses, not only as
+ * a scrollback toast -- confirmed live as a real bug: a single-row update
+ * that turned out to be a no-op gave zero acknowledgment on the panel
+ * itself. 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, Table, type MenuItem, type TableColumn, type TextMeasure } from "malevich-tui-components";
+import { Dialog, Envelope, Menu, Spinner, 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";
@@ -41,12 +51,11 @@ import { approvePackageOperation } from "./tools.js";
 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 { dialogTheme, 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";
+	type: "config" | "find" | "refresh" | "settings";
 	row?: Row;
 }
 
@@ -59,11 +68,19 @@ interface PanelAction {
  * "unchanged"/"cancelled" mean the panel keeps running as-is. */
 export type PackageChoiceOutcome = "changed" | "unchanged" | "cancelled" | "deferred";
 
+/** A non-"changed" settle point's own detail -- the exact reason nothing
+ * (or only a partial thing) happened, so a caller with somewhere to show
+ * it inline (a row's own status cell) isn't limited to the scrollback
+ * toast every outcome already gets via ctx.ui.notify. "changed" never
+ * calls this: ctx.reload() already replaces the session by then. */
+export interface PackageChoiceSettled { ok: boolean; message: string; }
+
 export async function applyPackageChoice(
 	choice: string | undefined,
 	row: Row,
 	natives: Natives,
 	ctx: ExtensionCommandContext,
+	onSettled?: (settled: PackageChoiceSettled) => void,
 ): Promise<PackageChoiceOutcome> {
 	if (choice?.startsWith("Update")) {
 		try {
@@ -80,18 +97,22 @@ export async function applyPackageChoice(
 					? `pinned to ${version ?? "an exact version"} -- pi update intentionally leaves pinned packages unchanged`
 					: `already up to date${version ? ` at ${version}` : ""}`;
 				ctx.ui.notify(`${row.name} is ${reason}.`, "info");
+				onSettled?.({ ok: true, message: reason });
 				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");
+				onSettled?.({ ok: true, message: `updated${transition}; reload pending` });
 				return "deferred";
 			}
 			ctx.ui.notify(`Updated ${row.name}${transition}; reloading Pi resources.`, "info");
 			await ctx.reload();
 			return "changed";
 		} catch (e) {
-			ctx.ui.notify(`update failed: ${e instanceof Error ? e.message : e}`, "error");
+			const message = e instanceof Error ? e.message : String(e);
+			ctx.ui.notify(`update failed: ${message}`, "error");
+			onSettled?.({ ok: false, message });
 			return "cancelled";
 		}
 	}
@@ -105,13 +126,16 @@ export async function applyPackageChoice(
 			await natives.remove(row.name, approval.approved);
 			if (!(await confirmReload(ctx))) {
 				ctx.ui.notify(`Removed ${row.name}; reload pending -- run /reload when ready.`, "warning");
+				onSettled?.({ ok: true, message: "removed; reload pending" });
 				return "deferred";
 			}
 			ctx.ui.notify(`Removed ${row.name}; reloading Pi resources.`, "info");
 			await ctx.reload();
 			return "changed";
 		} catch (e) {
-			ctx.ui.notify(`remove failed: ${e instanceof Error ? e.message : e}`, "error");
+			const message = e instanceof Error ? e.message : String(e);
+			ctx.ui.notify(`remove failed: ${message}`, "error");
+			onSettled?.({ ok: false, message });
 			return "cancelled";
 		}
 	}
@@ -366,8 +390,10 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 	}
 
 	// 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.
+	// Every mutation (u/x/d, U, and whatever the Enter action menu picks) is
+	// handled entirely inside renderPanel itself -- approval and reload
+	// confirms render inline on the same already-open overlay -- and never
+	// reaches here; only non-mutation navigation resolves this loop.
 	for (;;) {
 		const action = await renderPanel(ctx, natives, rows);
 		if (!action) return; // closed
@@ -387,24 +413,8 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 			continue; // a successful install already reloaded; a no-op returns here
 		}
 
-		if (action.type === "config") {
-			await showResourceConfig(ctx, natives, action.row?.name);
-			continue; // showResourceConfig already handles its own reload prompt
-		}
-
-		const row = action.row;
-		if (!row) continue;
-
-		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();
+		await showResourceConfig(ctx, natives, action.row?.name);
+		// showResourceConfig already handles its own reload prompt
 	}
 }
 
@@ -434,6 +444,66 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 			selectedIndex = 0;
 		}
 
+		// A y/n decision rendered as this SAME overlay's own content (via a real
+		// Malevich Dialog, dispatched by literal key press) instead of
+		// ctx.ui.confirm's separate native dialog -- confirmed live as a real
+		// user complaint: ctx.ui.confirm opens as its own distinct overlay on
+		// top of this one ("a new window"), arrow-select only, no y/n keys.
+		let pendingDialog: Dialog | undefined;
+
+		function confirmInline(title: string, message: string): Promise<boolean> {
+			return new Promise((resolve) => {
+				const settle = (value: boolean) => {
+					pendingDialog = undefined;
+					tui.requestRender();
+					resolve(value);
+				};
+				pendingDialog = new Dialog({
+					title,
+					body: message,
+					actions: [
+						{ label: "Yes", key: "y", action: () => settle(true) },
+						{ label: "No", key: "n", action: () => settle(false) },
+					],
+					theme: dialogTheme(theme),
+				});
+				tui.requestRender();
+			});
+		}
+
+		// Every confirm() call inside a mutation flow driven from this open
+		// overlay (approvePackageOperation's own approval, confirmReload's
+		// separate reload gate) routes through confirmInline instead of the
+		// real ctx.ui.confirm -- notify/reload/etc. stay the genuine ctx.
+		const inlineCtx: ExtensionCommandContext = { ...ctx, hasUI: true, ui: { ...ctx.ui, confirm: confirmInline } };
+
+		/** u/x/d and the Enter action menu all funnel through here: approval and
+		 * reload confirms render inline (via inlineCtx/confirmInline) on this
+		 * same overlay, never closing it first the way done()-dispatch used to. */
+		async function runRowActionInline(action: { type: "update" | "remove" | "disable"; row: Row }): Promise<void> {
+			updatingRowName = action.row.name;
+			tui.requestRender();
+			// A non-"changed" settle point (already up to date, pinned, deferred,
+			// a genuine failure) shows its own real reason on this row, the same
+			// settled map U's batch path already renders -- not just a scrollback
+			// toast, which was the whole bug: nothing on the panel itself ever
+			// acknowledged that a single-row action had even run.
+			const onSettled = (result: PackageChoiceSettled) => settled.set(action.row.name, { ok: result.ok, tail: result.message });
+			const outcome = action.type === "disable"
+				? await applyDisableExtensions(action.row, natives, inlineCtx)
+				: await applyPackageChoice(action.type === "update" ? `Update to ${action.row.latest}` : "Remove", action.row, natives, inlineCtx, onSettled);
+			updatingRowName = undefined;
+			if (outcome === "changed") {
+				done(undefined); // ctx.reload() already replaced the session
+				return;
+			}
+			const reloaded = await loadRows(natives);
+			if (reloaded.error) ctx.ui.notify(`refresh failed: ${reloaded.error}`, "error");
+			else rows = reloaded.rows;
+			applyFilter();
+			tui.requestRender();
+		}
+
 		/** U -- runs the whole approve+update+notify+reload flow without ever
 		 * closing this panel or replacing the list: each row's own settled
 		 * outcome (spinner while in flight, then a real ✓/✗ plus a bounded tail
@@ -443,7 +513,7 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 		async function runUpdateAllInline(): Promise<void> {
 			const outdated = rows.filter((row) => row.hasUpdate);
 			settled.clear();
-			const outcome = await approveAndRunUpdateAll(outdated, natives, ctx, (batch, approved) => {
+			const outcome = await approveAndRunUpdateAll(outdated, natives, inlineCtx, (batch, approved) => {
 				spinner.start(() => tui.requestRender());
 				return performUpdateAll(batch, natives, approved, (event) => {
 					updatingRowName = event.row.name;
@@ -583,11 +653,17 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 		return {
 			render(width: number): string[] {
 				envelope.setTitle(panelTitle());
+				envelope.setContent(pendingDialog ?? body);
 				return envelope.render(width);
 			},
 			invalidate: () => envelope.invalidate(),
 			handleInput(data: string) {
-				if (updatingRowName) return; // the installer owns input until it finishes
+				if (pendingDialog) {
+					pendingDialog.handleInput(data);
+					tui.requestRender();
+					return;
+				}
+				if (updatingRowName) return; // the mutation/installer owns input until it finishes
 
 				if (searchActive) {
 					if (data === "\x1b") {
@@ -632,17 +708,17 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 						return;
 					case "u": {
 						const row = filtered[selectedIndex];
-						if (row?.hasUpdate) done({ type: "update", row });
+						if (row?.hasUpdate) void runRowActionInline({ type: "update", row });
 						return;
 					}
 					case "x": {
 						const row = filtered[selectedIndex];
-						if (row) done({ type: "remove", row });
+						if (row) void runRowActionInline({ type: "remove", row });
 						return;
 					}
 					case "d": {
 						const row = filtered[selectedIndex];
-						if (row) done({ type: "disable", row });
+						if (row) void runRowActionInline({ type: "disable", row });
 						return;
 					}
 					case "c": {
@@ -655,9 +731,7 @@ function renderPanel(ctx: ExtensionCommandContext, natives: Natives, initialRows
 						if (!row) return;
 						void (async () => {
 							const choice = await showActionMenu(ctx, row);
-							if (choice === "update") done({ type: "update", row });
-							else if (choice === "remove") done({ type: "remove", row });
-							else if (choice === "disable") done({ type: "disable", row });
+							if (choice === "update" || choice === "remove" || choice === "disable") void runRowActionInline({ type: choice, row });
 							else if (choice === "config") done({ type: "config", row });
 						})();
 						return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-packed",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Pi package tools, commands, profiles, and TUI for the Packed daemon",
   "type": "module",
   "keywords": ["pi-package"],
@@ -15,7 +15,7 @@
     "@danypops/packed": "^0.2.0",
     "@danypops/vehicle-client": "^0.1.1",
     "@danypops/vehicle-client-pi": "^0.1.5",
-    "malevich-tui-components": "^0.8.0"
+    "malevich-tui-components": "^0.11.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/extension/src/spinner.ts

@@ -1,44 +0,0 @@
-/**
- * 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;
-		}
-	}
-}