@iseoane/agent-depot 0.2.0 → 0.3.0

package/dist/src/tui/app-actions.js

@@ -0,0 +1,157 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PROJECT_HOSTS } from "../project-manifest.js";
+import { errorText, runBatch } from "./batch.js";
+import { answerYesNo, hostChecklistKey } from "./mode-keys.js";
+import { HostChecklist, PreviewConfirm } from "./panel-parts.js";
+export const APP_KINDS = ["app-approve", "app-hosts", "app-confirm", "app-manual"];
+/** Narrows the view's mode without asserting a partial mode is an App mode. */
+export function isAppMode(mode) {
+    return APP_KINDS.some(kind => kind === mode.kind);
+}
+/** Recipe name, falling back to the file identity for invalid recipes. */
+export const appName = (entry) => entry.recipe?.name ?? entry.file;
+function stepLines(step) {
+    return [
+        ...(step.argv ? [`argv: ${JSON.stringify(step.argv)}`, `Executable: ${step.executable ?? "unavailable"}`] : []),
+        ...(step.manual ? [`Manual: ${step.manual}`] : []),
+        `Working directory: ${step.cwd}`,
+        ...(step.warning ? [step.warning] : []),
+    ];
+}
+async function prepareNext(context, requests, results = [], failures = 0) {
+    const { manage, apps } = context;
+    manage.setMode({ kind: "busy", label: "Preparing App step..." });
+    // Independent planning failures never stop the remaining marked Apps.
+    const [request, ...remaining] = requests;
+    if (!request) {
+        await manage.finish({ kind: failures > 0 ? "error" : "ok", text: results.join("\n") });
+        return;
+    }
+    try {
+        const plan = await apps.planLifecycle(request.entry, request.action, request.host);
+        if (manage.isMounted()) {
+            manage.setMode({
+                kind: !plan.argv && plan.manual ? "app-manual" : "app-confirm",
+                plan, remaining, results, failures,
+            });
+        }
+    }
+    catch (error) {
+        if (manage.isMounted()) {
+            await prepareNext(context, remaining, [...results, `${appName(request.entry)}: failed: ${errorText(error)}`], failures + 1);
+        }
+    }
+}
+/** Opens approval, the Host checklist, or the first lifecycle preview for selected Apps. */
+export async function startAppAction(context, entries, input) {
+    const { manage, apps } = context;
+    manage.setMessage(undefined);
+    try {
+        if (input === "approve") {
+            const entry = entries[0];
+            if (!entry)
+                throw new Error("No App selected");
+            manage.setMode({ kind: "busy", label: "Preparing recipe approval..." });
+            const steps = await apps.preview(entry);
+            if (manage.isMounted()) {
+                manage.setMode({ kind: "app-approve", entry, lines: steps.flatMap(step => [step.step, ...stepLines(step)]) });
+            }
+        }
+        else if (input === "h") {
+            const choices = PROJECT_HOSTS.filter(host => entries.some(entry => entry.recipe?.setup?.[host] || entry.recipe?.teardown?.[host]));
+            if (!choices.length)
+                throw new Error("No declared Host steps");
+            // This is an action selector, not a claim about persisted Host wiring.
+            manage.setMode({
+                kind: "app-hosts", entries, choices, cursor: 0,
+                selected: choices.filter(host => entries.some(entry => entry.recipe?.teardown?.[host])),
+            });
+        }
+        else {
+            await prepareNext(context, entries.map(entry => ({ entry, action: input === "u" ? "uninstall" : "install" })));
+        }
+    }
+    catch (error) {
+        await manage.finish({ kind: "error", text: errorText(error) });
+    }
+}
+async function execute(context, mode) {
+    const { manage, apps } = context;
+    manage.setMode({ kind: "busy", label: "Running App step..." });
+    let manualRequired = false;
+    const [outcome] = await runBatch([mode.plan], async (plan) => {
+        const result = mode.kind === "app-manual"
+            ? await apps.completeManual(plan, true)
+            : await apps.executeLifecycle(plan, true);
+        if (result.status === "manual required") {
+            manualRequired = true;
+            if (manage.isMounted())
+                manage.setMode({ ...mode, kind: "app-manual" });
+            return "manual required";
+        }
+        if (result.status === "failed")
+            throw new Error(result.reason);
+        manage.unmark([`app:${plan.entry.file}`]);
+        return `${appName(plan.entry)}: ${result.status}${result.installedVersion ? ` ${result.installedVersion}` : ""}`;
+    }, (plan, error) => `${appName(plan.entry)}: failed: ${errorText(error)}`);
+    if (manage.isMounted() && outcome && !manualRequired) {
+        await prepareNext(context, mode.remaining, [...mode.results, outcome.line], mode.failures + (outcome.ok ? 0 : 1));
+    }
+}
+/** Applies checklist and y/n keys, continuing independent batch steps after cancellation or failure. */
+export function handleAppKey(context, mode, input, key) {
+    const { manage, apps } = context;
+    const cancel = () => {
+        manage.browse();
+        manage.setMessage({ kind: "ok", text: "App action cancelled" });
+    };
+    if (mode.kind === "app-hosts") {
+        const outcome = hostChecklistKey(mode, mode.choices, input, key);
+        if (outcome.kind === "cancel")
+            cancel();
+        else if (outcome.kind === "update")
+            manage.setMode({ ...mode, ...outcome.state });
+        else if (key.return) {
+            const requests = mode.entries.flatMap(entry => mode.choices.flatMap(host => {
+                const action = mode.selected.includes(host) ? "setup" : "teardown";
+                return entry.recipe?.[action]?.[host] ? [{ entry, action, host }] : [];
+            }));
+            if (!requests.length)
+                manage.setMessage({ kind: "error", text: "No declared steps for this selection" });
+            else
+                void prepareNext(context, requests);
+        }
+    }
+    else
+        answerYesNo(input, key, () => {
+            if (mode.kind !== "app-approve") {
+                void execute(context, mode);
+                return;
+            }
+            manage.setMode({ kind: "busy", label: "Approving recipe..." });
+            void apps.approve(mode.entry).then(() => manage.finish({ kind: "ok", text: `Approved ${appName(mode.entry)}` }), error => manage.finish({ kind: "error", text: errorText(error) }));
+        }, () => {
+            if (mode.kind === "app-confirm" || mode.kind === "app-manual") {
+                void prepareNext(context, mode.remaining, [...mode.results, `${appName(mode.plan.entry)}: cancelled`], mode.failures);
+            }
+            else
+                cancel();
+        });
+}
+/** Renders App prompts using the existing checklist and preview-confirm panels. */
+export function AppPanel({ mode }) {
+    if (mode.kind === "app-hosts") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["App Host steps: checked = setup, unchecked = teardown. Wiring is not tracked. Space/1-", mode.choices.length, " toggle, j/k move, Enter continue, Esc cancel."] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
+    }
+    if (mode.kind === "app-approve") {
+        return _jsx(PreviewConfirm, { lines: mode.lines, question: `Approve ${appName(mode.entry)}? y/n` });
+    }
+    return (_jsx(PreviewConfirm, { lines: [
+            `Environment: ${mode.plan.environment}`,
+            `App: ${appName(mode.plan.entry)} ${mode.plan.action}${mode.plan.host ? ` (${mode.plan.host})` : ""}`,
+            ...stepLines(mode.plan),
+        ], question: mode.kind === "app-manual"
+            ? "Manual step done, check now? y/n"
+            : `${mode.plan.action} ${appName(mode.plan.entry)}? y/n` }));
+}

package/dist/src/tui/app.js

@@ -0,0 +1,63 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useApp, useStdout } from "ink";
+import { useCallback, useRef, useState } from "react";
+import { AGENT_DEPOT_PACKAGE_VERSION } from "../project-manifest.js";
+import { CatalogView } from "./catalog-view.js";
+import { InstallationsView } from "./installations-view.js";
+import { SourcesView } from "./sources-view.js";
+import { separatorLine, theme } from "./theme.js";
+import { UpdatesView } from "./updates-view.js";
+import { useKeys } from "./keys.js";
+const TABS = [
+    ["sources", "1 Sources"],
+    ["catalog", "2 Catalog"],
+    ["installations", "3 Installations"],
+    ["updates", "4 Updates"],
+];
+/** Compact keys of the current view; the tab bar already shows how to switch views. */
+function hintsOf(view, catalogFocusedOnSource) {
+    switch (view) {
+        case "sources":
+            return "j/k move · space mark · a all · Enter catalog · n add · r refresh · d remove · q quit";
+        case "catalog":
+            return `j/k move · Enter expand · space mark · a all · i install · / filter${catalogFocusedOnSource ? " · s all sources" : ""} · q quit`;
+        case "installations":
+            return "j/k move · Enter expand · space mark · a all · u uninstall · h add hosts · A adopt · q quit";
+        case "updates":
+            return "j/k move · space mark · a all · Enter preview · r check again · q quit";
+    }
+}
+export function App({ operations, environment, onExit }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [capturing, setCapturing] = useState(false);
+    // Updated synchronously by the views so keys in the same burst never see a stale capturing state.
+    const capturingRef = useRef(false);
+    const onCapturingChange = useCallback((value) => {
+        capturingRef.current = value;
+        setCapturing(value);
+    }, []);
+    const [view, setView] = useState("sources");
+    const [catalogSourceId, setCatalogSourceId] = useState();
+    const showView = (next) => setView(next);
+    useKeys((input) => {
+        if (capturingRef.current)
+            return;
+        if (input === "q") {
+            onExit?.();
+            exit();
+        }
+        else if (input === "1")
+            showView("sources");
+        else if (input === "2")
+            showView("catalog");
+        else if (input === "3")
+            showView("installations");
+        else if (input === "4")
+            showView("updates");
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: theme.accent, children: ["Agent Depot", AGENT_DEPOT_PACKAGE_VERSION === undefined ? "" : ` v${AGENT_DEPOT_PACKAGE_VERSION}`] }), _jsx(Text, { children: TABS.map(([name, label], position) => (_jsxs(Text, { color: view === name ? theme.accent : theme.inactive, bold: view === name, children: [position > 0 ? " " : "", view === name ? `[${label}]` : ` ${label} `] }, name))) }), _jsx(Text, { color: theme.muted, children: separatorLine(stdout.columns) }), view === "sources" ? (_jsx(SourcesView, { operations: operations, onCapturingChange: onCapturingChange, onOpenCatalog: (source) => {
+                    setCatalogSourceId(source.id);
+                    setView("catalog");
+                } })) : view === "installations" ? (_jsx(InstallationsView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : view === "updates" ? (_jsx(UpdatesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : (_jsx(CatalogView, { operations: operations, sourceId: catalogSourceId, environment: environment, onCapturingChange: onCapturingChange })), _jsx(Text, { color: theme.muted, children: capturing ? "Enter submit · Esc cancel · y/n confirm · space toggle" : hintsOf(view, catalogSourceId !== undefined) })] }));
+}

package/dist/src/tui/batch.js

@@ -0,0 +1,17 @@
+export const errorText = (error) => (error instanceof Error ? error.message : String(error));
+/**
+ * Applies the items one after another. A failure is reported for that item and
+ * the rest still run, so the outcomes always cover every item in order.
+ */
+export async function runBatch(items, run, describeFailure) {
+    const outcomes = [];
+    for (const item of items) {
+        try {
+            outcomes.push({ item, ok: true, line: await run(item) });
+        }
+        catch (error) {
+            outcomes.push({ item, ok: false, line: describeFailure(item, error) });
+        }
+    }
+    return outcomes;
+}

package/dist/src/tui/bulk-actions.js

@@ -0,0 +1,243 @@
+import { PROJECT_HOSTS } from "../project-manifest.js";
+import { assertManagedInstallationRecordsUnchanged } from "../skill-removal.js";
+import { errorText, runBatch } from "./batch.js";
+import { missingHosts, prepareHostAddition, prepareUninstall, runHostAddition, runUninstall, UNINSTALL_REFUSALS, } from "./catalog-installs.js";
+import { answerYesNo, applyChecklistOutcome, hostChecklistKey } from "./mode-keys.js";
+import { skillOf, sourceIdOf } from "./installations.js";
+import { prepareUnmanagedRemoval, runUnmanagedRemoval } from "./unmanaged-actions.js";
+export const BULK_KINDS = ["bulk-hosts", "confirm-bulk-uninstall", "confirm-bulk-hosts", "confirm-bulk-exposure"];
+const count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+function skip(target, label, reason) {
+    return { id: target.id, label, reason };
+}
+function labelOf(target) {
+    const { leaf } = target;
+    if (leaf.kind === "unmanaged")
+        return leaf.group.name;
+    return leaf.row.scope === "project" ? `${leaf.row.selection.path} (project)` : leaf.row.selection.path;
+}
+/** Reads the records once, so every item of the batch is checked against the same state. */
+async function listRecords(operations) {
+    return operations.listUserGlobalInstallations ? operations.listUserGlobalInstallations() : [];
+}
+/**
+ * Drift check before an item: the records must be exactly what the previous items were expected to leave.
+ * The baseline only ever advances by the change an item made, so an outside change is never absorbed.
+ */
+async function assertNoDrift(operations, expected) {
+    const actual = await listRecords(operations);
+    try {
+        assertManagedInstallationRecordsUnchanged(expected, actual);
+    }
+    catch {
+        throw new Error("The installation records changed outside this batch since the previous item; this item was left untouched");
+    }
+}
+const sameRecord = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+/** Plan step of a bulk uninstall: prepares each marked leaf with its shared plan, or records why it is skipped. */
+export async function prepareBulkUninstall(context, targets) {
+    const { operations, env, installed } = context;
+    const installations = await listRecords(operations);
+    const items = [];
+    const skipped = [];
+    for (const target of targets) {
+        const label = labelOf(target);
+        const { leaf } = target;
+        try {
+            if (leaf.kind === "unmanaged") {
+                items.push({ kind: "unmanaged", id: target.id, label, prepared: await prepareUnmanagedRemoval(operations, env, leaf.group, leaf.group.locations) });
+                continue;
+            }
+            if (leaf.row.scope === "project") {
+                skipped.push(skip(target, label, UNINSTALL_REFUSALS["project-only"]));
+                continue;
+            }
+            const sourceId = sourceIdOf(leaf.row.selection, installed.sources);
+            if (sourceId === undefined) {
+                skipped.push(skip(target, label, "The Source of this installation is no longer registered"));
+                continue;
+            }
+            const skill = skillOf(leaf.row, sourceId);
+            const prepared = await prepareUninstall(operations, env, skill, installed);
+            if (prepared.kind === "ready")
+                items.push({ kind: "managed", id: target.id, label, skill, prepared });
+            else
+                skipped.push(skip(target, label, UNINSTALL_REFUSALS[prepared.kind]));
+        }
+        catch (error) {
+            skipped.push(skip(target, label, errorText(error)));
+        }
+    }
+    return { items, skipped, installations };
+}
+function resultOf(outcomes, skipped) {
+    const lines = [...outcomes.map((outcome) => outcome.line), ...skipped.map(({ label, reason }) => `Skipped ${label}: ${reason}`)];
+    return {
+        message: { kind: outcomes.some((outcome) => !outcome.ok) ? "error" : "ok", text: lines.join("\n") },
+        applied: outcomes.filter((outcome) => outcome.ok).map((outcome) => outcome.item.id),
+    };
+}
+/** Execute step: each item is rechecked and applied on its own against the records the previous items were expected to leave. */
+export async function runBulkUninstall(plan, operations, env) {
+    let expected = plan.installations;
+    const outcomes = await runBatch(plan.items, async (item) => {
+        await assertNoDrift(operations, expected);
+        if (item.kind === "unmanaged") {
+            const result = await runUnmanagedRemoval({ ...item.prepared, installations: expected }, operations, env);
+            if (result.kind === "error")
+                throw new Error(result.text);
+            return result.text;
+        }
+        await runUninstall({ ...item.prepared, installations: expected }, operations, env);
+        // Only the record this item removed moves the baseline the next item is checked against.
+        expected = expected.filter((record) => !item.prepared.plan.selections.some((removed) => sameRecord(removed, record)));
+        return `Removed ${item.label}`;
+    }, (item, error) => (item.kind === "unmanaged" ? errorText(error) : `Failed ${item.label}: ${errorText(error)}`));
+    return resultOf(outcomes, plan.skipped);
+}
+/** Managed user-global leaves that can gain hosts, and the leaves that cannot with their reasons. */
+export function classifyHostTargets(context, targets) {
+    const ready = [];
+    const skipped = [];
+    for (const target of targets) {
+        const label = labelOf(target);
+        const { leaf } = target;
+        if (leaf.kind === "unmanaged") {
+            skipped.push(skip(target, label, "Host changes are not available for unmanaged skills"));
+        }
+        else if (leaf.row.scope === "project") {
+            skipped.push(skip(target, label, "Project installations are managed with the CLI"));
+        }
+        else if (missingHosts(leaf.row.selection).length === 0) {
+            skipped.push(skip(target, label, "already has every host"));
+        }
+        else {
+            const sourceId = sourceIdOf(leaf.row.selection, context.installed.sources);
+            if (sourceId === undefined)
+                skipped.push(skip(target, label, "The Source of this installation is no longer registered"));
+            else
+                ready.push({ id: target.id, label, skill: skillOf(leaf.row, sourceId), hosts: leaf.row.selection.hosts });
+        }
+    }
+    return { ready, skipped };
+}
+/** Plan step after the checklist: each item adds only the chosen hosts it lacks. */
+export async function prepareBulkHostAddition(context, targets, alreadySkipped, chosen) {
+    const { operations, env, installed } = context;
+    const installations = await listRecords(operations);
+    const items = [];
+    const skipped = [...alreadySkipped];
+    for (const target of targets) {
+        const lacking = chosen.filter((host) => !target.hosts.includes(host));
+        if (lacking.length === 0) {
+            skipped.push({ id: target.id, label: target.label, reason: `already has ${chosen.join(", ")}` });
+            continue;
+        }
+        try {
+            items.push({ id: target.id, label: target.label, prepared: await prepareHostAddition(operations, env, target.skill, installed, lacking) });
+        }
+        catch (error) {
+            skipped.push({ id: target.id, label: target.label, reason: errorText(error) });
+        }
+    }
+    return { items, skipped, installations };
+}
+/** Execute step: the single exposure confirmation covers every item; each one is rechecked on its own. */
+export async function runBulkHostAddition(plan, operations, env) {
+    let expected = plan.installations;
+    const outcomes = await runBatch(plan.items, async (item) => {
+        await assertNoDrift(operations, expected);
+        const line = await runHostAddition({ ...item.prepared, installations: expected }, operations, env);
+        // Only the record this item updated moves the baseline the next item is checked against.
+        const { selection, updated } = item.prepared.plan;
+        expected = expected.map((record) => (sameRecord(record, selection) ? updated : record));
+        return line;
+    }, (item, error) => `Failed ${item.label}: ${errorText(error)}`);
+    return resultOf(outcomes, plan.skipped);
+}
+function cancel(context, text) {
+    context.setMessage({ kind: "ok", text });
+    context.browse();
+}
+/** Runs a prepare step in the busy mode; a plan with items goes to its confirmation, otherwise the reasons are reported. */
+async function preparePlan(context, label, prepare, confirmation) {
+    context.setMode({ kind: "busy", label });
+    try {
+        const plan = await prepare();
+        if (!context.isMounted())
+            return;
+        if (plan.items.length === 0) {
+            context.setMessage({ kind: "error", text: plan.skipped.map(({ label: name, reason }) => `Skipped ${name}: ${reason}`).join("\n") });
+            context.browse();
+            return;
+        }
+        context.setMode(confirmation(plan));
+    }
+    catch (error) {
+        if (!context.isMounted())
+            return;
+        context.setMessage({ kind: "error", text: errorText(error) });
+        context.browse();
+    }
+}
+/** `u` with marks: prepares every marked leaf, then asks once. */
+export function startBulkUninstall(context, targets) {
+    return preparePlan(context, `Preparing uninstall of ${count(targets.length, "item")}...`, () => prepareBulkUninstall(context, targets), (plan) => ({ kind: "confirm-bulk-uninstall", plan }));
+}
+/** `h` with marks: asks the hosts once, for the union of what the eligible items lack. */
+export function startBulkHostAddition(context, targets) {
+    const { ready, skipped } = classifyHostTargets(context, targets);
+    const choices = PROJECT_HOSTS.filter((host) => ready.some((target) => !target.hosts.includes(host)));
+    if (ready.length === 0) {
+        context.setMessage({ kind: "error", text: skipped.map(({ label, reason }) => `Skipped ${label}: ${reason}`).join("\n") });
+        return;
+    }
+    context.setMessage(undefined);
+    context.setMode({ kind: "bulk-hosts", targets: ready, skipped, choices, cursor: 0, selected: [] });
+}
+function prepareHosts(context, mode) {
+    return preparePlan(context, `Preparing host change of ${count(mode.targets.length, "item")}...`, () => prepareBulkHostAddition(context, mode.targets, mode.skipped, mode.selected), (plan) => ({ kind: "confirm-bulk-hosts", plan }));
+}
+async function apply(context, label, action) {
+    context.setMode({ kind: "busy", label });
+    let result;
+    try {
+        result = await action();
+    }
+    catch (error) {
+        result = { message: { kind: "error", text: errorText(error) }, applied: [] };
+    }
+    context.unmark(result.applied);
+    await context.finish(result.message);
+}
+/** Handles a key in a bulk mode; returns false for any other mode. */
+export function handleBulkKey(context, mode, input, key) {
+    const current = mode;
+    const { operations, env } = context;
+    switch (current.kind) {
+        case "bulk-hosts": {
+            applyChecklistOutcome(hostChecklistKey(current, current.choices, input, key), {
+                cancel: () => cancel(context, "Add hosts cancelled"),
+                update: (state) => context.setMode({ ...current, ...state }),
+                submit: () => void prepareHosts(context, current),
+                setMessage: context.setMessage,
+            });
+            return true;
+        }
+        case "confirm-bulk-uninstall":
+            answerYesNo(input, key, () => {
+                void apply(context, `Removing ${count(current.plan.items.length, "item")}...`, () => runBulkUninstall(current.plan, operations, env));
+            }, () => cancel(context, "Uninstall cancelled"));
+            return true;
+        case "confirm-bulk-hosts":
+            answerYesNo(input, key, () => context.setMode({ kind: "confirm-bulk-exposure", plan: current.plan }), () => cancel(context, "Add hosts cancelled"));
+            return true;
+        case "confirm-bulk-exposure":
+            answerYesNo(input, key, () => {
+                void apply(context, `Changing hosts of ${count(current.plan.items.length, "item")}...`, () => runBulkHostAddition(current.plan, operations, env));
+            }, () => cancel(context, "Add hosts cancelled"));
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/tui/catalog-actions.js

@@ -0,0 +1,9 @@
+import { PROJECT_HOSTS } from "../project-manifest.js";
+/** Host choices in checklist order; labels use the project's host identifiers. */
+export const HOST_CHOICES = PROJECT_HOSTS;
+export const SCOPE_CHOICES = ["project", "user-global"];
+/** `beta` for one Skill, `3 skills` for a batch. */
+export function describeSkills(skills) {
+    return skills.length === 1 ? skills[0].name : `${skills.length} skills`;
+}
+export const BROWSE = { kind: "browse" };

package/dist/src/tui/catalog-browse.js

@@ -0,0 +1,59 @@
+import { leavesOf, skillKey } from "./catalog-tree.js";
+import { navigateTree } from "./tree-navigation.js";
+import { toggleNode } from "./tree.js";
+import { toggledMark } from "./view-state.js";
+/** Space: marks the highlighted Skill for a batch install. */
+function markRow(context, row) {
+    if (row.node.data.kind !== "skill") {
+        context.setMessage({ kind: "error", text: "Mark skills, not source rows" });
+        return;
+    }
+    context.setMessage(undefined);
+    context.marks.setMarked(toggledMark(context.marks.markedRef.current, row.node.id));
+}
+/** `a`: marks every listed Skill, or clears the marks when they are all marked already. */
+function markAllListed(context) {
+    const { markedRef, setMarked } = context.marks;
+    const leaves = leavesOf(context.navigation.latestRoots());
+    if (leaves.length === 0) {
+        context.setMessage({ kind: "error", text: "There are no skills to select" });
+        return;
+    }
+    context.setMessage(undefined);
+    setMarked(leaves.every((skill) => markedRef.current.has(skillKey(skill))) ? new Set() : new Set(leaves.map(skillKey)));
+}
+/** `i`: installs the marked Skills that are listed, or the highlighted one. */
+function chooseHosts(context, row) {
+    // Only what is listed installs: marks on Skills hidden by the filter are ignored.
+    const marked = leavesOf(context.navigation.latestRoots())
+        .filter((skill) => context.marks.markedRef.current.has(skillKey(skill)));
+    const highlighted = row.node.data.kind === "skill" ? [row.node.data.skill] : [];
+    const chosen = marked.length > 0 ? marked : highlighted;
+    if (chosen.length === 0) {
+        context.setMessage({ kind: "error", text: "Install is not available for source rows; highlight a skill or mark some with space" });
+        return;
+    }
+    context.setMessage(undefined);
+    context.setAction({ kind: "host", skills: chosen, cursor: 0, selected: [] });
+}
+/** Keys while browsing the Catalog: navigation, filter, marks and starting an install. */
+export function handleCatalogBrowseKey(context, input, key) {
+    const snapshot = context.navigation.latest();
+    if (navigateTree(context.navigation, snapshot, context.height, input, key))
+        return;
+    const row = snapshot.visible[snapshot.at];
+    if (key.return && row)
+        context.navigation.setExpanded(toggleNode(snapshot.open, row));
+    else if (input === "/")
+        context.filter.open();
+    else if (key.escape && context.filter.filterRef.current.query !== "")
+        context.filter.clear(context.navigation.restart);
+    else if (input === "s" && context.canWiden)
+        context.toggleAll();
+    else if (input === " " && row)
+        markRow(context, row);
+    else if (input === "a")
+        markAllListed(context);
+    else if (input === "i" && context.ready && row)
+        chooseHosts(context, row);
+}

package/dist/src/tui/catalog-filter.js

@@ -0,0 +1,20 @@
+export const initialFilter = { editing: false, query: "" };
+export function filterReducer(state, event) {
+    switch (event.type) {
+        case "open":
+            return { ...state, editing: true };
+        case "edit":
+            return state.editing ? { editing: true, query: event.query } : state;
+        case "keep":
+            return { ...state, editing: false };
+        case "clear":
+            return initialFilter;
+    }
+}
+/** Case-insensitive match on name and description. */
+export function filterSkills(skills, query) {
+    const needle = query.trim().toLowerCase();
+    if (needle === "")
+        return skills;
+    return skills.filter((skill) => skill.name.toLowerCase().includes(needle) || skill.description.toLowerCase().includes(needle));
+}