@danypops/pi-packed 0.6.3 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-packed
 
-Pi integration for `@danypops/packed`: package tools, `/packages`, `/packed`, setup apply/reload, and named profiles.
+Pi integration for `@danypops/packed`: package tools, `/packed`, setup apply/reload, and named profiles.
 
 ```bash
 pi install npm:@danypops/pi-packed
@@ -10,8 +10,13 @@ The extension connects to Packed's authenticated user daemon and starts the pack
 
 ## Commands
 
-- `/packages` -- an interactive panel listing every installed Pi package, with update availability. Select one to update or remove it; `r` refreshes, `/` filters, `Tab` cycles view modes.
-- `/packed` -- 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,201 @@
+/**
+ * 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, Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
+import { Container, Input, SelectList, type SelectItem, type SelectListTheme, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { shouldSearch } from "./discover-model.js";
+import type { Natives, PackageSummary } from "./packed.js";
+import { InstallServiceError } from "./packed.js";
+import { approvePackageOperation } from "./tools.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";
+	}
+}
+
+function selectListTheme(theme: Theme): SelectListTheme {
+	return {
+		selectedPrefix: (text) => theme.fg("accent", text),
+		selectedText: (text) => theme.fg("accent", text),
+		description: (text) => theme.fg("muted", text),
+		scrollInfo: (text) => theme.fg("muted", text),
+		noMatch: (text) => theme.fg("muted", text),
+	};
+}
+
+async function showInstallMenu(ctx: ExtensionCommandContext, result: PackageSummary): Promise<boolean> {
+	const items: SelectItem[] = [{ value: "install", label: `Install ${result.name}@${result.version}` }, { value: "cancel", label: "Cancel" }];
+	const choice = await ctx.ui.custom<"install" | "cancel" | undefined>(
+		(_tui, theme, _kb, done) => {
+			const list = new SelectList(items, items.length, selectListTheme(theme));
+			list.onSelect = (item) => done(item.value as "install" | "cancel");
+			list.onCancel = () => done(undefined);
+			return list;
+		},
+		{ overlay: true, overlayOptions: { width: 40, anchor: "center" } },
+	);
+	return choice === "install";
+}
+
+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

@@ -2,7 +2,7 @@
  * pi-packed — Pi extension seam.
  *
  * Thin by design: registers agent tools (pkg_search/pkg_info/pkg_install/pkg_update/pkg_remove),
- * the /packages command, and a session_start update notification. ALL logic
+ * the /packed command, and a session_start update notification. ALL logic
  * lives in the Bun service (src/): registry access, caching, watcher,
  * catalog sync, install execution.
  *
@@ -10,10 +10,9 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerTools } from "./tools.js";
-import { showPackages } from "./tui.js";
+import { showPackedPanel } from "./tui.js";
 import { createNatives } from "./packed.js";
 import { formatUpdateNotice } from "./model.js";
-import { showPackedSettings } from "./security-tui.js";
 import { registerProfiles } from "./profile.js";
 import { handleSetupCommand } from "./setup-command.js";
 import { handleResourceConfigCommand } from "./resource-config.js";
@@ -26,18 +25,11 @@ export default async function (pi: ExtensionAPI) {
 	registerTools(pi, natives);
 
 	pi.registerCommand("packed", {
-		description: "Configure pi-packed security settings, run setup plan/apply, or manage resources with config",
+		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;
-			await showPackedSettings(ctx, natives);
-		},
-	});
-
-	pi.registerCommand("packages", {
-		description: "Browse and manage installed Pi packages (pi-packed)",
-		handler: async (_args, ctx) => {
-			await showPackages(ctx, natives);
+			await showPackedPanel(ctx, natives);
 		},
 	});
 
@@ -47,7 +39,7 @@ export default async function (pi: ExtensionAPI) {
 		try {
 			const updates = await natives.updates();
 			if (updates.length) {
-				ctx.ui.notify(`${formatUpdateNotice(updates)} — /packages to review`, "info");
+				ctx.ui.notify(`${formatUpdateNotice(updates)} — /packed to review`, "info");
 			}
 		} catch {
 			// mirror missing or unreadable — stay silent, never block startup.

package/extension/src/model.ts

@@ -1,5 +1,5 @@
 /**
- * model.ts — pure row logic for the /packages panel. No I/O: vitest drives
+ * model.ts — pure row logic for the /packed panel. No I/O: vitest drives
  * this directly (the TUI component is a thin shell over these functions).
  */
 import type { InstalledPkg, UpdateEntry } from "./packed.js";

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/reload.ts

@@ -1,7 +1,7 @@
 /**
  * reload.ts — one shared decision for whether a Pi package mutation needs a
  * reload to take effect, and the exact wording every mutation surface
- * (native tools, the /packages panel, and the resource overlay) uses to
+ * (native tools, the /packed panel, and the resource overlay) uses to
  * warn about it. Keeps three independent implementations from drifting
  * apart on when and how they say a reload is coming.
  */

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,19 +1,29 @@
 /**
- * tui.ts — /packages interactive 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, esc close.
- * 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 type { ExtensionCommandContext, Theme } 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 { Container, Input, SelectList, type SelectItem, type SelectListTheme, Spacer, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 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";
 
 interface PanelAction {
-	type: "menu" | "refresh";
+	type: "update" | "updateAll" | "remove" | "disable" | "config" | "find" | "refresh" | "settings";
 	row?: Row;
 }
 
@@ -74,6 +84,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([
@@ -86,9 +173,40 @@ async function loadRows(natives: Natives): Promise<{ rows: Row[]; error?: string
 	}
 }
 
-export async function showPackages(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
+function selectListTheme(theme: Theme): SelectListTheme {
+	return {
+		selectedPrefix: (text) => theme.fg("accent", text),
+		selectedText: (text) => theme.fg("accent", text),
+		description: (text) => theme.fg("muted", text),
+		scrollInfo: (text) => theme.fg("muted", text),
+		noMatch: (text) => theme.fg("muted", text),
+	};
+}
+
+/** 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> {
+	const items: SelectItem[] = [
+		...(row.hasUpdate ? [{ value: "update", label: `Update to ${row.latest}` }] : []),
+		{ value: "disable", label: "Disable/enable extensions" },
+		{ value: "config", label: "Configure resources" },
+		{ value: "remove", label: "Remove" },
+	];
+	return ctx.ui.custom<"update" | "remove" | "disable" | "config" | undefined>(
+		(_tui, theme, _kb, done) => {
+			const list = new SelectList(items, items.length, selectListTheme(theme));
+			list.onSelect = (item) => done(item.value as "update" | "remove" | "disable" | "config");
+			list.onCancel = () => done(undefined);
+			return list;
+		},
+		{ overlay: true, overlayOptions: { width: 40, anchor: "center" } },
+	);
+}
+
+export async function showPackedPanel(ctx: ExtensionCommandContext, natives: Natives): Promise<void> {
 	if (!ctx.hasUI) {
-		ctx.ui.notify("/packages requires interactive mode", "warning");
+		ctx.ui.notify("/packed requires interactive mode", "warning");
 		return;
 	}
 
@@ -109,19 +227,37 @@ export async function showPackages(ctx: ExtensionCommandContext, natives: Native
 			continue;
 		}
 
+		if (action.type === "settings") {
+			await showPackedSettings(ctx, natives);
+			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
 	}
 }
@@ -149,18 +285,26 @@ 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", " · ") +
 						rawKeyHint("esc", "close");
 				const spacing = Math.max(1, width - visibleWidth(title) - visibleWidth(badge) - visibleWidth(hint));
 				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,
 					"",
 				);
@@ -241,9 +385,45 @@ function renderPanel(ctx: ExtensionCommandContext, rows: Row[]): Promise<PanelAc
 					case "r":
 						done({ type: "refresh" });
 						return;
+					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.6.3",
+  "version": "0.8.0",
   "description": "Pi package tools, commands, profiles, and TUI for the Packed daemon",
   "type": "module",
   "keywords": ["pi-package"],