@danypops/pi-packed 0.7.0 → 0.9.0

package/README.md

@@ -10,8 +10,13 @@ The extension connects to Packed's authenticated user daemon and starts the pack
 
 ## Commands
 
-- `/packed` -- opens on the packages panel: every installed Pi package, with update availability. Select one to update or remove it; `r` refreshes, `/` filters, `Tab` cycles view modes, `s` opens settings.
-- `/packed` settings (`s` from the panel) -- package mutation-approval settings: require confirmation before install/update/remove/security changes (the default), or turn it off.
+- `/packed` -- opens on the packages 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.
+  - `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).
+  - `f` -- find: search the npm registry for new Pi packages and install one.
+  - `s` -- settings. `Enter` opens a floating action menu with all of the above. `r` refreshes, `/` filters, `Tab` cycles view modes.
 - `/packed config` -- enable or disable individual extensions, skills, prompt templates, and themes declared by installed packages, per package, at global or project scope.
 - `/packed setup plan [path] [--prune]` / `/packed setup apply [path] [--prune]` -- preview or apply a reproducible-environment manifest (`pi-setup.json`) against installed packages and profiles.
 - `/profile [name]` -- switch to a named Pi profile (provider, model, tools, instructions, theme), reading `~/.pi/agent/profiles.json` and a trusted project's own `.pi/profiles.json`. `pi --profile <name>` activates one at startup; `Ctrl+Shift+U` cycles through them.

package/extension/src/discover-model.ts

@@ -0,0 +1,15 @@
+/**
+ * discover-model.ts — pure decision logic for /packed find, kept separate
+ * from ctx.ui.custom rendering so it's directly testable without faking a
+ * terminal (same split as model.ts for the packages panel).
+ */
+
+/** Enter's dual purpose: run a new search when the query has changed
+ * since the last one (or nothing has been searched yet), otherwise treat
+ * it as "activate the highlighted result" -- one key, no separate search
+ * button, matching how a filter box and an action list coexist elsewhere
+ * in this panel. */
+export function shouldSearch(query: string, lastSearchedQuery: string | undefined, hasResults: boolean): boolean {
+	if (!hasResults) return query.trim().length > 0;
+	return query !== lastSearchedQuery;
+}

package/extension/src/discover.ts

@@ -0,0 +1,192 @@
+/**
+ * discover.ts — /packed find: query the npm registry for installable Pi
+ * packages and install one. A sub-flow like settings/config, reachable
+ * from the packages panel via f and returning to it on close. Search
+ * itself never mutates; only Install/Cancel (behind the standard
+ * approval) does.
+ */
+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 { Menu, type MenuItem } from "malevich-tui-components";
+import { shouldSearch } from "./discover-model.js";
+import type { Natives, PackageSummary } from "./packed.js";
+import { InstallServiceError } from "./packed.js";
+import { approvePackageOperation } from "./tools.js";
+import { menuTheme } from "./menu-theme.js";
+
+const SEARCH_LIMIT = 20;
+
+interface FindPanelAction {
+	type: "install" | "close";
+	result?: PackageSummary;
+}
+
+export type InstallOutcome = "installed" | "cancelled" | "failed";
+
+/** Approve-then-install-then-reload, mirroring applyPackageChoice's own
+ * shape for the packages panel's mutations. Best-effort service
+ * registration piggybacks on the same approval, same as the agent tool
+ * path (installPackageWithPolicy) -- most packages aren't daemons at all. */
+export async function applyInstall(result: PackageSummary, natives: Natives, ctx: ExtensionCommandContext): Promise<InstallOutcome> {
+	const source = `npm:${result.name}`;
+	const approval = await approvePackageOperation("install", `pi install ${source}`, natives, ctx);
+	if (!approval.allowed) {
+		ctx.ui.notify(approval.message ?? "install denied", "warning");
+		return "cancelled";
+	}
+	try {
+		const output = (await natives.install(source, approval.approved)) || `Installed ${source}`;
+		try {
+			await natives.installService(source, approval.approved);
+		} catch (e) {
+			if (!(e instanceof InstallServiceError) || !e.notADaemon) {
+				ctx.ui.notify(`note: could not register a persistent service for ${result.name}: ${e instanceof Error ? e.message : e}`, "warning");
+			}
+		}
+		ctx.ui.notify(`${output}; reloading Pi resources.`, "info");
+		await ctx.reload();
+		return "installed";
+	} catch (e) {
+		ctx.ui.notify(`install failed: ${e instanceof Error ? e.message : e}`, "error");
+		return "failed";
+	}
+}
+
+async function showInstallMenu(ctx: ExtensionCommandContext, result: PackageSummary): Promise<boolean> {
+	return ctx.ui.custom<boolean>(
+		(_tui, theme, _kb, done) => {
+			const items: MenuItem[] = [
+				{ label: `Install ${result.name}@${result.version}`, action: () => done(true) },
+				{ label: "Cancel", action: () => done(false) },
+			];
+			return new Menu({ items, theme: menuTheme(theme), onClose: () => done(false) });
+		},
+		{ overlay: true, overlayOptions: { width: 40, anchor: "center" } },
+	);
+}
+
+export async function showDiscoverPanel(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("/packed find requires interactive mode", "warning");
+		return;
+	}
+
+	for (;;) {
+		const action = await renderDiscoverPanel(ctx, natives);
+		if (action.type === "close") return;
+		if (!action.result) continue;
+		const install = await showInstallMenu(ctx, action.result);
+		if (!install) continue;
+		const outcome = await applyInstall(action.result, natives, ctx);
+		if (outcome === "installed") return; // ctx.reload() already replaced the session
+	}
+}
+
+function renderDiscoverPanel(ctx: ExtensionCommandContext, natives: Natives): Promise<FindPanelAction> {
+	return ctx.ui.custom<FindPanelAction>((tui, theme, _kb, done) => {
+		const queryInput = new Input();
+		let results: PackageSummary[] = [];
+		let lastSearchedQuery: string | undefined;
+		let selectedIndex = 0;
+		let searching = false;
+		let error: string | undefined;
+		const maxVisible = 15;
+
+		async function runSearch(): Promise<void> {
+			const query = queryInput.getValue().trim();
+			if (!query) return;
+			searching = true;
+			error = undefined;
+			tui.requestRender();
+			try {
+				const response = await natives.search(query, SEARCH_LIMIT);
+				results = response.results;
+				lastSearchedQuery = queryInput.getValue();
+				selectedIndex = 0;
+			} catch (e) {
+				error = e instanceof Error ? e.message : String(e);
+				results = [];
+			} finally {
+				searching = false;
+				tui.requestRender();
+			}
+		}
+
+		const header = {
+			invalidate() {},
+			render(width: number): string[] {
+				const title = theme.bold("Find packages");
+				const hint = rawKeyHint("enter", "search/install") + theme.fg("muted", " · ") + rawKeyHint("esc", "back");
+				const spacing = Math.max(1, width - visibleWidth(title) - visibleWidth(hint));
+				const line1 = truncateToWidth(`${title}${" ".repeat(spacing)}`, width, "") + hint;
+				const status = searching ? "searching…" : error ? theme.fg("error", error) : `${results.length} result(s)`;
+				const line2 = truncateToWidth(theme.fg("muted", status), width, "");
+				return [line1, line2];
+			},
+		};
+
+		const list = {
+			invalidate() {},
+			render(width: number): string[] {
+				const lines = [...queryInput.render(width), ""];
+				if (results.length === 0) {
+					lines.push(theme.fg("muted", searching ? "  …" : "  Type a query and press enter to search npm"));
+					return lines;
+				}
+				const start = Math.max(0, Math.min(selectedIndex - Math.floor(maxVisible / 2), results.length - maxVisible));
+				const end = Math.min(start + maxVisible, results.length);
+				for (let i = start; i < end; i++) {
+					const result = results[i]!;
+					const selected = i === selectedIndex;
+					const cursor = selected ? theme.fg("accent", "❯") : " ";
+					const name = selected ? theme.bold(result.name) : result.name;
+					const ver = theme.fg("dim", `@${result.version}`);
+					const description = result.description ? theme.fg("muted", ` — ${result.description}`) : "";
+					lines.push(truncateToWidth(`${cursor} ${name}${ver}${description}`, width, ""));
+				}
+				return lines;
+			},
+		};
+
+		const container = new Container();
+		container.addChild(new Spacer(1));
+		container.addChild(new DynamicBorder());
+		container.addChild(new Spacer(1));
+		container.addChild(header);
+		container.addChild(new Spacer(1));
+		container.addChild(list);
+		container.addChild(new Spacer(1));
+		container.addChild(new DynamicBorder());
+
+		return {
+			render: (width: number) => container.render(width),
+			invalidate: () => container.invalidate(),
+			handleInput(data: string) {
+				switch (data) {
+					case "\x1b[A": // up
+						if (results.length > 0) selectedIndex = (selectedIndex - 1 + results.length) % results.length;
+						break;
+					case "\x1b[B": // down
+						if (results.length > 0) selectedIndex = (selectedIndex + 1) % results.length;
+						break;
+					case "\r":
+						if (shouldSearch(queryInput.getValue(), lastSearchedQuery, results.length > 0)) {
+							void runSearch();
+						} else {
+							const result = results[selectedIndex];
+							if (result) done({ type: "install", result });
+						}
+						return;
+					case "\x1b":
+						done({ type: "close" });
+						return;
+					default:
+						queryInput.handleInput(data);
+						break;
+				}
+				tui.requestRender();
+			},
+		};
+	});
+}

package/extension/src/index.ts

@@ -25,7 +25,7 @@ export default async function (pi: ExtensionAPI) {
 	registerTools(pi, natives);
 
 	pi.registerCommand("packed", {
-		description: "Browse and manage installed Pi packages; press s for settings, or run setup plan/apply or config directly",
+		description: "Browse and manage installed Pi packages -- u/U update, x remove, d disable, c config, f find, s settings -- or run setup plan/apply or config directly",
 		handler: async (args, ctx) => {
 			if (await handleSetupCommand(args, ctx, natives)) return;
 			if (await handleResourceConfigCommand(args, ctx, natives)) return;

package/extension/src/menu-theme.ts

@@ -0,0 +1,14 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { 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. */
+export function menuTheme(theme: Theme): MenuTheme {
+	return {
+		border: (s) => theme.fg("border", s),
+		selected: (s) => theme.fg("accent", s),
+		normal: (s) => s,
+		dim: (s) => theme.fg("muted", s),
+		title: (s) => theme.fg("accent", s),
+	};
+}

package/extension/src/packed.ts

@@ -15,7 +15,7 @@ import { PI_COMMAND_NAME, type InstalledPackage, type PackageInfo, type PackageR
 
 export { InstallServiceError, PI_COMMAND_NAME };
 
-export type { PackageInfo, PackageResources, PiStatus, ResourceField, UpdateEntry, UpdateOutcome };
+export type { PackageInfo, PackageResources, PackageSummary, PiStatus, ResourceField, UpdateEntry, UpdateOutcome };
 export type InstalledPkg = InstalledPackage;
 export type PackageDaemonPort = PackedExtensionClient;
 type MutationApproval = SecuritySettings["mutationApproval"];

package/extension/src/resource-config.ts

@@ -95,7 +95,7 @@ export async function handleResourceConfigCommand(args: string, ctx: ExtensionCo
 	return true;
 }
 
-export async function showResourceConfig(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
+export async function showResourceConfig(ctx: ExtensionCommandContext, natives: Natives, initialFilter?: string): Promise<void> {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("/packed config requires interactive mode", "warning");
 		return;
@@ -109,9 +109,11 @@ export async function showResourceConfig(ctx: ExtensionCommandContext, natives:
 
 	let scope: Scope = "global";
 	let pendingReload = false;
+	let filter = initialFilter ?? "";
 
 	for (;;) {
-		const action = await renderConfig(ctx, data, scope);
+		const action = await renderConfig(ctx, data, scope, filter);
+		filter = ""; // only seeds the very first open -- a later refresh/switch starts unfiltered
 		if (action.type === "close") break;
 		if (action.type === "switch") { scope = scope === "global" ? "project" : "global"; continue; }
 		if (action.type === "refresh") {
@@ -135,12 +137,13 @@ export async function showResourceConfig(ctx: ExtensionCommandContext, natives:
 	else ctx.ui.notify("Extension changes pending -- run /reload when ready.", "warning");
 }
 
-function renderConfig(ctx: ExtensionCommandContext, data: { global: PackageResources[]; project: PackageResources[] }, scope: Scope): Promise<PanelAction> {
+function renderConfig(ctx: ExtensionCommandContext, data: { global: PackageResources[]; project: PackageResources[] }, scope: Scope, initialFilter = ""): Promise<PanelAction> {
 	return ctx.ui.custom<PanelAction>((tui, theme, _kb, done) => {
 		const searchInput = new Input();
+		if (initialFilter) searchInput.setValue(initialFilter);
 		let searchActive = false;
 		const items = flatten(scope === "global" ? data.global : data.project, scope);
-		let filtered = items;
+		let filtered = initialFilter ? filterItems(items, initialFilter) : items;
 		let selectedIndex = 0;
 		const maxVisible = 20;
 

package/extension/src/tui.ts

@@ -1,23 +1,31 @@
 /**
- * tui.ts — /packed's default panel. Follows the pi-extension-manager idiom:
- * ctx.ui.custom with Container/DynamicBorder layout, header hints,
- * type-to-filter (/), Tab view modes, Enter → actions, r refresh, s
- * settings, esc close. Packages is the landing page; s opens settings
- * (mutation approval) as a sub-flow and returns to the same panel
- * afterward, rather than a second rendered page. All data flows through
- * the packed CLI (thin seam).
+ * tui.ts — /packed's default panel. Mnemonics follow lazy.nvim's own
+ * convention (folke/lazy.nvim lua/lazy/view/config.lua): uppercase acts on
+ * every row, lowercase acts on the row under the cursor -- U/u update,
+ * X/x was lazy's delete key (clean); here that pairing is single-target
+ * only (x remove -- there is no safe "remove every installed package"
+ * bulk analog, so no X is bound). Adds d disable/enable this package's
+ * extensions, c jump to full resource config, f find/install new
+ * packages, s settings. Enter opens a floating (`ctx.ui.custom` with
+ * overlay:true) action menu instead of a full-screen prompt, so the list
+ * underneath never disappears. 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 { Menu, type MenuItem } from "malevich-tui-components";
 import { filterRows, mergeRows, nextMode, visibleRows } from "./model.js";
 import type { Row, ViewMode } from "./model.js";
-import type { Natives } from "./packed.js";
+import type { Natives, PackageResources } from "./packed.js";
 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";
 
 interface PanelAction {
-	type: "menu" | "refresh" | "settings";
+	type: "update" | "updateAll" | "remove" | "disable" | "config" | "find" | "refresh" | "settings";
 	row?: Row;
 }
 
@@ -78,6 +86,83 @@ export async function applyPackageChoice(
 	return "cancelled";
 }
 
+/** U -- update every outdated row with one combined approval and one
+ * reload, instead of applyPackageChoice's own per-call reload (which
+ * would end the session after the first successful update). */
+export async function applyUpdateAll(rows: Row[], natives: Natives, ctx: ExtensionCommandContext): Promise<PackageChoiceOutcome> {
+	const outdated = rows.filter((row) => row.hasUpdate);
+	if (outdated.length === 0) {
+		ctx.ui.notify("Nothing to update.", "info");
+		return "unchanged";
+	}
+	const approval = await approvePackageOperation(
+		"update",
+		`pi update --extension ${outdated.map((row) => `npm:${row.name}`).join(" ")}`,
+		natives,
+		ctx,
+	);
+	if (!approval.allowed) {
+		ctx.ui.notify(approval.message ?? "update denied", "warning");
+		return "cancelled";
+	}
+	ctx.ui.notify(`Updating ${outdated.length} package(s)…`, "info");
+	let changed = 0;
+	let failed = 0;
+	for (const row of outdated) {
+		try {
+			const outcome = await natives.update(`npm:${row.name}`, approval.approved);
+			if (outcome.reloadRequired) changed += 1;
+		} catch (e) {
+			failed += 1;
+			ctx.ui.notify(`${row.name} update failed: ${e instanceof Error ? e.message : e}`, "error");
+		}
+	}
+	if (changed === 0) {
+		ctx.ui.notify(failed > 0 ? `No packages updated; ${failed} failed.` : "All packages already up to date.", failed > 0 ? "warning" : "info");
+		return failed > 0 ? "cancelled" : "unchanged";
+	}
+	ctx.ui.notify(`Updated ${changed} package(s)${failed > 0 ? `, ${failed} failed` : ""}; reloading Pi resources.`, "info");
+	await ctx.reload();
+	return "changed";
+}
+
+/** d -- toggles every declared extension of this package on or off in one
+ * step (disables if any are enabled, otherwise re-enables all). Reuses
+ * applyResourceToggle per item for its own tested approval/mutation path
+ * rather than a bespoke bulk mutation -- the common case is one extension
+ * per package, so this rarely shows more than a single confirm. */
+export async function applyDisableExtensions(row: Row, natives: Natives, ctx: ExtensionCommandContext): Promise<PackageChoiceOutcome> {
+	let data: { global: PackageResources[]; project: PackageResources[] };
+	try {
+		data = await natives.listResources();
+	} catch (e) {
+		ctx.ui.notify(`packed unavailable: ${e instanceof Error ? e.message : e}`, "error");
+		return "cancelled";
+	}
+	const group = data.global.find((candidate) => candidate.name === row.name);
+	const extensions = group?.extensions ?? [];
+	if (!group || extensions.length === 0) {
+		ctx.ui.notify(`${row.name} declares no extensions to disable.`, "info");
+		return "unchanged";
+	}
+	const disabling = extensions.some((item) => item.enabled);
+	const targets = extensions.filter((item) => item.enabled === disabling);
+	let toggled = 0;
+	for (const item of targets) {
+		const outcome = await applyResourceToggle(
+			{ scope: "global", source: group.source, packageName: group.name, field: "extensions", path: item.path, enabled: item.enabled },
+			natives,
+			ctx,
+		);
+		if (outcome === "toggled") toggled += 1;
+		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");
+	await ctx.reload();
+	return "changed";
+}
+
 async function loadRows(natives: Natives): Promise<{ rows: Row[]; error?: string }> {
 	try {
 		const [installed, updates] = await Promise.all([
@@ -90,6 +175,25 @@ async function loadRows(natives: Natives): Promise<{ rows: Row[]; error?: string
 	}
 }
 
+/** Enter's action menu, floated on top of the still-open packages panel
+ * via ctx.ui.custom's own overlay:true -- no full-screen teardown, unlike
+ * the ctx.ui.select this replaced. */
+async function showActionMenu(ctx: ExtensionCommandContext, row: Row): Promise<"update" | "remove" | "disable" | "config" | undefined> {
+	type Choice = "update" | "remove" | "disable" | "config";
+	return ctx.ui.custom<Choice | undefined>(
+		(_tui, theme, _kb, done) => {
+			const items: MenuItem[] = [
+				...(row.hasUpdate ? [{ label: `Update to ${row.latest}`, action: () => done("update" as Choice) }] : []),
+				{ label: "Disable/enable extensions", action: () => done("disable") },
+				{ label: "Configure resources", action: () => done("config") },
+				{ label: "Remove", action: () => done("remove") },
+			];
+			return new Menu({ items, theme: menuTheme(theme), onClose: () => done(undefined) });
+		},
+		{ overlay: true, overlayOptions: { width: 40, anchor: "center" } },
+	);
+}
+
 export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("/packed requires interactive mode", "warning");
@@ -118,19 +222,32 @@ export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Nat
 			continue; // settings never changes package rows -- reopen as-is
 		}
 
+		if (action.type === "find") {
+			await showDiscoverPanel(ctx, natives);
+			continue; // a successful install already reloaded; a no-op returns here
+		}
+
+		if (action.type === "updateAll") {
+			const outcome = await applyUpdateAll(rows, natives, ctx);
+			if (outcome === "changed") return; // ctx.reload() already replaced the session
+			continue;
+		}
+
+		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;
 
-		const choice = await ctx.ui.select(
-			`${row.name}@${row.version}${row.hasUpdate ? `  →  ${row.latest}` : ""}`,
-			[
-				...(row.hasUpdate ? [`Update to ${row.latest}`] : []),
-				"Remove",
-				"Cancel",
-			],
-		);
+		if (action.type === "disable") {
+			const outcome = await applyDisableExtensions(row, natives, ctx);
+			if (outcome === "changed") return;
+			continue;
+		}
 
-		const outcome = await applyPackageChoice(choice, row, natives, ctx);
+		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
 	}
 }
@@ -158,11 +275,17 @@ function renderPanel(ctx: ExtensionCommandContext, rows: Row[]): Promise<PanelAc
 				const badge = outdated > 0 ? theme.fg("warning", ` ${outdated} update(s)`) : "";
 				const hint = searchActive
 					? rawKeyHint("esc", "clear")
-					: rawKeyHint("enter", "actions") +
+					: rawKeyHint("enter", "menu") +
 						theme.fg("muted", " · ") +
-						rawKeyHint("/", "filter") +
+						rawKeyHint("u/U", "update/all") +
 						theme.fg("muted", " · ") +
-						rawKeyHint("tab", "view") +
+						rawKeyHint("x", "remove") +
+						theme.fg("muted", " · ") +
+						rawKeyHint("d", "disable") +
+						theme.fg("muted", " · ") +
+						rawKeyHint("c", "config") +
+						theme.fg("muted", " · ") +
+						rawKeyHint("f", "find") +
 						theme.fg("muted", " · ") +
 						rawKeyHint("s", "settings") +
 						theme.fg("muted", " · ") +
@@ -171,7 +294,7 @@ function renderPanel(ctx: ExtensionCommandContext, rows: Row[]): Promise<PanelAc
 				const line1 = truncateToWidth(`${title}${badge}${" ".repeat(spacing)}${hint}`, width, "");
 				const dot = "·";
 				const line2 = truncateToWidth(
-					theme.fg("muted", `view: ${mode} ${dot} r refresh ${dot} ${rows.length} installed`),
+					theme.fg("muted", `view: ${mode} ${dot} / filter ${dot} tab view ${dot} r refresh ${dot} ${rows.length} installed`),
 					width,
 					"",
 				);
@@ -255,9 +378,42 @@ function renderPanel(ctx: ExtensionCommandContext, rows: Row[]): Promise<PanelAc
 					case "s":
 						done({ type: "settings" });
 						return;
+					case "f":
+						done({ type: "find" });
+						return;
+					case "U":
+						done({ type: "updateAll" });
+						return;
+					case "u": {
+						const row = filtered[selectedIndex];
+						if (row?.hasUpdate) done({ type: "update", row });
+						return;
+					}
+					case "x": {
+						const row = filtered[selectedIndex];
+						if (row) done({ type: "remove", row });
+						return;
+					}
+					case "d": {
+						const row = filtered[selectedIndex];
+						if (row) done({ type: "disable", row });
+						return;
+					}
+					case "c": {
+						const row = filtered[selectedIndex];
+						if (row) done({ type: "config", row });
+						return;
+					}
 					case "\r": {
 						const row = filtered[selectedIndex];
-						if (row) done({ type: "menu", row });
+						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 });
+							else if (choice === "config") done({ type: "config", row });
+						})();
 						return;
 					}
 					case "\x1b":

package/package.json

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