@iseoane/agent-depot 0.2.0 → 0.3.0

package/dist/src/tui/tree-navigation.js

@@ -0,0 +1,68 @@
+import { useCallback, useRef, useState } from "react";
+import { collapseOrParent, expandNode, flattenVisible, resolveSelection, } from "./tree.js";
+import { pageStep } from "./window.js";
+/**
+ * Expansion and selection of a tree, mirrored in refs so keys delivered in one
+ * burst act on the latest state. `openByDefault` decides which groups are open
+ * until the user changes them.
+ */
+export function useTreeNavigation(roots, openByDefault) {
+    const [expandedState, setExpandedState] = useState();
+    const expandedRef = useRef(undefined);
+    const [selection, setSelectionState] = useState({ index: 0 });
+    const selectionRef = useRef({ index: 0 });
+    const rootsRef = useRef(roots);
+    rootsRef.current = roots;
+    const openByDefaultRef = useRef(openByDefault);
+    openByDefaultRef.current = openByDefault;
+    const setExpanded = useCallback((next) => {
+        expandedRef.current = next;
+        setExpandedState(next);
+    }, []);
+    const setSelection = useCallback((next) => {
+        selectionRef.current = next;
+        setSelectionState(next);
+    }, []);
+    const restart = useCallback(() => {
+        setSelection({ index: 0 });
+        setExpanded(undefined);
+    }, [setSelection, setExpanded]);
+    const rows = flattenVisible(roots, expandedState ?? openByDefault(roots));
+    const latest = () => {
+        const open = expandedRef.current ?? openByDefaultRef.current(rootsRef.current);
+        const visible = flattenVisible(rootsRef.current, open);
+        return { open, visible, at: resolveSelection(visible, selectionRef.current) };
+    };
+    const latestRoots = () => rootsRef.current;
+    return { rows, index: resolveSelection(rows, selection), latest, latestRoots, setExpanded, setSelection, restart };
+}
+/**
+ * Up/down, paging and expand/collapse keys shared by the tree views. Returns
+ * whether the key was one of them; Enter, space and letters belong to the view.
+ */
+export function navigateTree(navigation, snapshot, height, input, key) {
+    const { open, visible, at } = snapshot;
+    const row = visible[at];
+    const moveTo = (target) => {
+        const bounded = Math.min(Math.max(target, 0), Math.max(visible.length - 1, 0));
+        navigation.setSelection({ id: visible[bounded]?.node.id, index: bounded });
+    };
+    if (key.downArrow || input === "j")
+        moveTo(at + 1);
+    else if (key.upArrow || input === "k")
+        moveTo(at - 1);
+    else if (key.pageDown)
+        moveTo(at + pageStep(height));
+    else if (key.pageUp)
+        moveTo(at - pageStep(height));
+    else if (key.rightArrow && row)
+        navigation.setExpanded(expandNode(open, row));
+    else if (key.leftArrow && row) {
+        const next = collapseOrParent(open, visible, at);
+        navigation.setExpanded(next.expanded);
+        navigation.setSelection({ id: next.selectedId, index: at });
+    }
+    else
+        return false;
+    return true;
+}

package/dist/src/tui/tree.js

@@ -0,0 +1,53 @@
+/** Initially only the first group with children is open; every other group starts collapsed. */
+export function defaultExpanded(roots) {
+    const first = roots.find((root) => (root.children?.length ?? 0) > 0);
+    return new Set(first ? [first.id] : []);
+}
+/** The visible nodes in display order: children appear only under expanded parents. */
+export function flattenVisible(roots, expanded) {
+    const rows = [];
+    const visit = (nodes, depth, parentId) => {
+        for (const node of nodes) {
+            const expandable = (node.children?.length ?? 0) > 0;
+            const open = expandable && expanded.has(node.id);
+            rows.push({ node, depth, parentId, expandable, expanded: open });
+            if (open)
+                visit(node.children, depth + 1, node.id);
+        }
+    };
+    visit(roots, 0, undefined);
+    return rows;
+}
+/** Expands the node; returns the same set when the node is a leaf or already open. */
+export function expandNode(expanded, row) {
+    if (!row.expandable || row.expanded)
+        return expanded;
+    return new Set(expanded).add(row.node.id);
+}
+/** Expands a collapsed node and collapses an expanded one; leaves are unchanged. */
+export function toggleNode(expanded, row) {
+    if (!row.expandable)
+        return expanded;
+    const next = new Set(expanded);
+    if (row.expanded)
+        next.delete(row.node.id);
+    else
+        next.add(row.node.id);
+    return next;
+}
+/** Left arrow: collapse an open node, otherwise select its parent (a top-level node stays selected). */
+export function collapseOrParent(expanded, rows, index) {
+    const row = rows[index];
+    if (!row)
+        return { expanded, selectedId: undefined };
+    if (row.expanded)
+        return { expanded: toggleNode(expanded, row), selectedId: row.node.id };
+    return { expanded, selectedId: row.parentId ?? row.node.id };
+}
+/** Index of the selected row: by stable id when still visible, otherwise the bounded fallback index. */
+export function resolveSelection(rows, selection) {
+    const found = rows.findIndex((row) => row.node.id === selection.id);
+    if (found >= 0)
+        return found;
+    return Math.min(Math.max(selection.index, 0), Math.max(rows.length - 1, 0));
+}

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

@@ -0,0 +1,178 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { describeUnmanagedRemoval, describeUnmanagedSymlinkRemoval, removeInspectedUnmanagedSkill, removeInspectedUnmanagedSymlink, } from "../unmanaged-removal.js";
+import { inspectUserGlobalSkillRemoval, inspectUserGlobalSymlinkRemoval, } from "../user-global-skill-inventory.js";
+import { answerYesNo, moveCursor } from "./mode-keys.js";
+import { homeOf } from "./installations.js";
+export const UNMANAGED_KINDS = ["unmanaged-scope", "unmanaged-pick", "confirm-unmanaged"];
+const errorText = (error) => (error instanceof Error ? error.message : String(error));
+/** Links first, so a Claude link never outlives the canonical directory it points to. */
+function linksFirst(locations) {
+    return [...locations].sort((left, right) => Number(left.linkTarget === undefined) - Number(right.linkTarget === undefined));
+}
+/** The canonical form of a path, or its normalized form when it cannot be resolved (a dangling target). */
+async function canonical(candidate) {
+    try {
+        return await realpath(candidate);
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
+/** The links of the group that point at `directory`, whether or not they were chosen. */
+async function linksTargeting(group, directory) {
+    const wanted = await canonical(directory);
+    const found = [];
+    for (const candidate of group.locations) {
+        if (candidate.linkTarget === undefined)
+            continue;
+        if (await canonical(path.resolve(path.dirname(candidate.path), candidate.linkTarget)) === wanted)
+            found.push(candidate);
+    }
+    return found;
+}
+/** Plan step: inspects every chosen location exactly as the CLI does; changes nothing. */
+export async function prepareUnmanagedRemoval(operations, environment, group, locations) {
+    if (!operations.listUserGlobalInstallations)
+        throw new Error("Uninstall is not supported by the configured operations");
+    const installations = await operations.listUserGlobalInstallations();
+    const options = { homeDirectory: homeOf(environment), appEnvironment: environment.appEnvironment, managedInstallations: installations };
+    const items = [];
+    const preview = [`WARNING: agent-depot did not create these files (unmanaged skill ${group.name})`];
+    // A chosen directory takes the links that point at it along, so none is left dangling.
+    const planned = new Map(locations.map((chosen) => [chosen.path, chosen]));
+    const dependents = new Map();
+    for (const chosen of locations) {
+        if (chosen.linkTarget !== undefined)
+            continue;
+        const links = await linksTargeting(group, chosen.path);
+        dependents.set(chosen.path, links);
+        for (const link of links) {
+            if (planned.has(link.path))
+                continue;
+            planned.set(link.path, link);
+            preview.push(`also removes link ${JSON.stringify(link.path)} → ${JSON.stringify(chosen.path)} (it would dangle)`);
+        }
+    }
+    for (const location of linksFirst([...planned.values()])) {
+        if (location.linkTarget !== undefined) {
+            const inspection = await inspectUserGlobalSymlinkRemoval(location.path, options);
+            items.push({ kind: "link", inspection });
+            preview.push(...describeUnmanagedSymlinkRemoval(inspection));
+        }
+        else {
+            const inspection = await inspectUserGlobalSkillRemoval(location.path, options);
+            items.push({ kind: "directory", inspection, links: (dependents.get(location.path) ?? []).map((link) => link.path) });
+            preview.push(...describeUnmanagedRemoval(inspection));
+        }
+    }
+    return { items, installations, preview };
+}
+/** Execute step: each location is rechecked and removed on its own, so one failure does not stop the others. */
+export async function runUnmanagedRemoval(prepared, operations, environment) {
+    const context = { operations, homeDirectory: homeOf(environment), appEnvironment: environment.appEnvironment };
+    const lines = [];
+    let failed = false;
+    const notRemoved = new Set();
+    for (const item of prepared.items) {
+        const { path: location } = item.inspection;
+        const blocking = item.kind === "directory" ? item.links.find((link) => notRemoved.has(link)) : undefined;
+        if (blocking !== undefined) {
+            failed = true;
+            notRemoved.add(location);
+            lines.push(`Skipped ${location}: link ${blocking} could not be removed`);
+            continue;
+        }
+        try {
+            if (item.kind === "link")
+                await removeInspectedUnmanagedSymlink(context, item.inspection, prepared.installations);
+            else
+                await removeInspectedUnmanagedSkill(context, item.inspection, prepared.installations);
+            lines.push(`Removed ${location}`);
+        }
+        catch (error) {
+            failed = true;
+            notRemoved.add(location);
+            lines.push(`Failed ${location}: ${errorText(error)}`);
+        }
+    }
+    return { kind: failed ? "error" : "ok", text: lines.join("\n") };
+}
+async function startPreview(context, group, locations) {
+    context.setMode({ kind: "busy", label: `Preparing removal of ${group.name}...` });
+    try {
+        const prepared = await prepareUnmanagedRemoval(context.operations, context.env, group, locations);
+        if (!context.isMounted())
+            return;
+        context.setMode({ kind: "confirm-unmanaged", group, prepared });
+    }
+    catch (error) {
+        if (!context.isMounted())
+            return;
+        context.setMessage({ kind: "error", text: errorText(error) });
+        context.browse();
+    }
+}
+/** `u` on an unmanaged skill: one location goes straight to the preview; several ask all or choose. */
+export function startUnmanagedRemoval(context, group) {
+    if (group.locations.length > 1)
+        context.setMode({ kind: "unmanaged-scope", group });
+    else
+        void startPreview(context, group, group.locations);
+}
+function cancel(context) {
+    context.setMessage({ kind: "ok", text: "Uninstall cancelled" });
+    context.browse();
+}
+async function execute(context, group, prepared) {
+    context.setMode({ kind: "busy", label: `Removing ${group.name}...` });
+    await context.finish(await runUnmanagedRemoval(prepared, context.operations, context.env));
+}
+/** Handles a key in an unmanaged removal mode; returns false for any other mode. */
+export function handleUnmanagedKey(context, mode, input, key) {
+    const current = mode;
+    switch (current.kind) {
+        case "unmanaged-scope":
+            if (key.escape)
+                cancel(context);
+            else if (input === "1")
+                void startPreview(context, current.group, current.group.locations);
+            else if (input === "2")
+                context.setMode({ kind: "unmanaged-pick", group: current.group, cursor: 0, selected: [] });
+            return true;
+        case "unmanaged-pick": {
+            const { locations } = current.group;
+            const toggle = (index) => {
+                const location = locations[index];
+                if (!location)
+                    return;
+                const selected = current.selected.includes(location.path)
+                    ? current.selected.filter((candidate) => candidate !== location.path)
+                    : [...current.selected, location.path];
+                context.setMode({ ...current, selected });
+            };
+            const cursor = moveCursor(current.cursor, locations.length, input, key);
+            if (key.escape)
+                cancel(context);
+            else if (cursor !== undefined)
+                context.setMode({ ...current, cursor });
+            else if (input === " ")
+                toggle(current.cursor);
+            else if (Number(input) >= 1 && Number(input) <= locations.length)
+                toggle(Number(input) - 1);
+            else if (key.return) {
+                const chosen = locations.filter((location) => current.selected.includes(location.path));
+                if (chosen.length > 0)
+                    void startPreview(context, current.group, chosen);
+                else
+                    context.setMessage({ kind: "error", text: "Select at least one location" });
+            }
+            return true;
+        }
+        case "confirm-unmanaged":
+            answerYesNo(input, key, () => void execute(context, current.group, current.prepared), () => cancel(context));
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/tui/updates-flow.js

@@ -0,0 +1,89 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { errorText } from "./batch.js";
+import { BROWSE } from "./updates-mode.js";
+import { CHECKING, emptyData, PHASE_LABEL, REFRESHING } from "./updates-model.js";
+import { loadUpdateRows, prepareUpdates, runUpdates } from "./updates.js";
+export function useUpdatesFlow(inputs) {
+    const { operations, env, clock, mounted, checkedRef, latest, setChecked, setCursor, setMode, setMessage } = inputs;
+    const [state, setState] = useState({ status: "loading", label: REFRESHING });
+    const loadToken = useRef(0);
+    const pendingAnswer = useRef(undefined);
+    useEffect(() => () => {
+        pendingAnswer.current?.(false);
+    }, []);
+    const load = useCallback(async (refresh) => {
+        const token = ++loadToken.current;
+        const phase = (next) => {
+            if (!mounted.current || token !== loadToken.current)
+                return;
+            setState({ status: "loading", label: PHASE_LABEL[next] });
+        };
+        setChecked([]);
+        setCursor(0);
+        setMode({ kind: "busy", label: refresh ? REFRESHING : CHECKING });
+        let next;
+        try {
+            next = { status: "ready", data: await loadUpdateRows(operations, env, { refresh, onPhase: phase, now: clock }) };
+        }
+        catch (error) {
+            // The scopes are read separately, so this is unexpected; show it as the check's result.
+            next = { status: "ready", data: emptyData(errorText(error), clock()) };
+        }
+        // A newer check (`r`) supersedes this one.
+        if (!mounted.current || token !== loadToken.current)
+            return;
+        setState(next);
+        setMode(BROWSE);
+    }, [operations, env, mounted, setMode, setChecked, setCursor, clock]);
+    const startPreview = async () => {
+        const { data: current, updatable: listed } = latest();
+        if (!current)
+            return;
+        const selected = listed.filter((row) => checkedRef.current.includes(row.key));
+        if (selected.length === 0) {
+            setMessage({ kind: "error", lines: ["Select at least one update with space or a"] });
+            return;
+        }
+        setMessage(undefined);
+        setMode({ kind: "busy", label: "Preparing preview..." });
+        try {
+            const prepared = await prepareUpdates(current, selected);
+            if (mounted.current)
+                setMode({ kind: "preview", prepared });
+        }
+        catch (error) {
+            if (!mounted.current)
+                return;
+            setMessage({ kind: "error", lines: [errorText(error)] });
+            setMode(BROWSE);
+        }
+    };
+    const apply = async (prepared, confirmedPaths) => {
+        setMode({ kind: "busy", label: "Applying updates..." });
+        let result;
+        try {
+            const outcome = await runUpdates(prepared, confirmedPaths, (plan, reason) => new Promise(resolve => {
+                if (!mounted.current) {
+                    resolve(false);
+                    return;
+                }
+                const answer = (done) => {
+                    pendingAnswer.current = undefined;
+                    resolve(done);
+                };
+                pendingAnswer.current = answer;
+                setMode({ kind: "manual", plan, reason, answer });
+            }));
+            result = { kind: outcome.failed === 0 ? "ok" : "error", lines: outcome.lines };
+        }
+        catch (error) {
+            result = { kind: "error", lines: [errorText(error)] };
+        }
+        if (!mounted.current)
+            return;
+        setMessage(result);
+        // The sources were fetched for the check that was just applied; only the installations changed.
+        await load(false);
+    };
+    return { state, load, startPreview, apply };
+}

package/dist/src/tui/updates-keys.js

@@ -0,0 +1,104 @@
+import { answerYesNo } from "./mode-keys.js";
+import { pageStep } from "./window.js";
+const SCOPE_KEYS = new Map([["t", "all"], ["p", "project"], ["g", "user-global"]]);
+/** Moves the cursor with the arrows, j/k and paging; returns whether the key was one of them. */
+function moveCursorKey(context, snapshot, input, key) {
+    const last = Math.max(snapshot.entries.length - 1, 0);
+    const { at } = snapshot;
+    if (key.downArrow || input === "j")
+        context.setCursor(Math.min(at + 1, last));
+    else if (key.upArrow || input === "k")
+        context.setCursor(Math.max(at - 1, 0));
+    else if (key.pageDown)
+        context.setCursor(Math.min(at + pageStep(context.height), last));
+    else if (key.pageUp)
+        context.setCursor(Math.max(at - pageStep(context.height), 0));
+    else
+        return false;
+    return true;
+}
+/** Space toggles the highlighted update, `a` selects them all. */
+function selectKey(context, snapshot, input) {
+    if (input === " ") {
+        const entry = snapshot.entries[snapshot.at];
+        if (entry?.kind !== "update")
+            return true;
+        const checked = context.checked();
+        context.setChecked(checked.includes(entry.row.key) ? checked.filter((id) => id !== entry.row.key) : [...checked, entry.row.key]);
+    }
+    else if (input === "a")
+        context.setChecked(snapshot.updatable.map((row) => row.key));
+    else
+        return false;
+    return true;
+}
+/** Right/left unfold and fold the "cannot be checked" rows; Enter toggles the fold or previews the selection. */
+function foldKey(context, snapshot, key) {
+    const entry = snapshot.entries[snapshot.at];
+    if (key.rightArrow) {
+        if (entry?.kind === "summary")
+            context.setShowUnknown(true);
+    }
+    else if (key.leftArrow) {
+        if (entry?.kind === "unknown")
+            context.setCursor(snapshot.updatable.length);
+        if (entry?.kind === "summary" || entry?.kind === "unknown")
+            context.setShowUnknown(false);
+    }
+    else if (key.return) {
+        if (entry?.kind === "summary")
+            context.setShowUnknown(!context.unknownShown());
+        else if (entry?.kind !== "unknown" && snapshot.data)
+            context.startPreview();
+    }
+}
+function handleBrowseKey(context, input, key) {
+    const snapshot = context.latest();
+    if (moveCursorKey(context, snapshot, input, key) || selectKey(context, snapshot, input))
+        return;
+    const scope = SCOPE_KEYS.get(input);
+    if (scope !== undefined)
+        context.changeScope(scope);
+    else if (input === "r")
+        context.recheck();
+    else
+        foldKey(context, snapshot, key);
+}
+function handlePreviewKey(context, mode, input, key) {
+    if (mode.prepared.applicable.length === 0) {
+        if (key.escape || key.return || input === "n")
+            context.cancel();
+        return;
+    }
+    answerYesNo(input, key, () => {
+        if (mode.prepared.nonCanonicalPaths.length > 0)
+            context.setMode({ ...mode, kind: "confirm-paths" });
+        else
+            context.apply(mode.prepared, []);
+    }, context.cancel);
+}
+/** Handles a key in the current Updates mode; `busy` ignores keys. */
+export function handleUpdatesKey(context, mode, input, key) {
+    switch (mode.kind) {
+        case "manual":
+            answerYesNo(input, key, () => {
+                context.setMode({ kind: "busy", label: "Checking App version..." });
+                mode.answer(true);
+            }, () => {
+                context.setMode({ kind: "busy", label: "Continuing updates..." });
+                mode.answer(false);
+            });
+            return;
+        case "browse":
+            handleBrowseKey(context, input, key);
+            return;
+        case "preview":
+            handlePreviewKey(context, mode, input, key);
+            return;
+        case "confirm-paths":
+            answerYesNo(input, key, () => context.apply(mode.prepared, mode.prepared.nonCanonicalPaths), context.cancel);
+            return;
+        default:
+            return;
+    }
+}

package/dist/src/tui/updates-mode.js

@@ -0,0 +1 @@
+export const BROWSE = { kind: "browse" };

package/dist/src/tui/updates-model.js

@@ -0,0 +1,48 @@
+export const REFRESHING = "Refreshing sources...";
+export const CHECKING = "Checking for updates...";
+export const PHASE_LABEL = { refreshing: REFRESHING, checking: CHECKING };
+/** Names the reasons worth knowing before expanding the collapsed "cannot be checked" row. */
+export function describeUnknownReasons(rows) {
+    const newer = rows.filter((row) => /^installed by a newer agent depot/i.test(row.reason)).length;
+    const pinned = rows.filter((row) => /^pinned to agent depot/i.test(row.reason)).length;
+    const parts = [
+        ...(newer > 0 ? [`${newer} installed by a newer Agent Depot`] : []),
+        ...(pinned > 0 ? [`${pinned} pinned to another Agent Depot`] : []),
+    ];
+    return parts.length === 0 ? "" : ` (${parts.join(", ")})`;
+}
+const matchesScope = (row, filter) => filter === "all" || row.scope === filter;
+/** The rows the list shows for a scope filter and fold state, and the cursor positions they make up. */
+export function viewOf(data, scope, showUnknown) {
+    const shown = (data?.rows ?? []).filter((row) => matchesScope(row, scope));
+    const updatable = shown.filter((row) => row.status === "update available");
+    const unknown = shown.filter((row) => row.status === "cannot assess");
+    const upToDate = shown.filter((row) => row.status === "up to date").length;
+    const entries = [
+        ...updatable.map((row) => ({ kind: "update", row })),
+        ...(unknown.length > 0 ? [{ kind: "summary" }] : []),
+        ...(unknown.length > 0 && showUnknown ? unknown.map((row) => ({ kind: "unknown", row })) : []),
+    ];
+    return { shown, updatable, unknown, upToDate, entries };
+}
+export function describeRefresh(data) {
+    const { attempted, refreshed, failed, unreadable } = data.refresh;
+    if (!attempted)
+        return "sources not fetched again";
+    if (unreadable.length > 0) {
+        return `could not refresh: ${unreadable.map(({ scope, reason }) => `${reason} (${scope})`).join("; ")}; cached data was used`;
+    }
+    if (failed.length > 0) {
+        return `${failed.length} of ${failed.length + refreshed.length} sources could not be refreshed; their current data was used`;
+    }
+    return refreshed.length > 0 ? "sources refreshed" : "no Git sources to refresh";
+}
+/** Data for a check that failed as a whole, so the view can show the reason. */
+export function emptyData(reason, checkedAt) {
+    return {
+        results: [{ scope: "project", error: reason }],
+        rows: [],
+        refresh: { attempted: false, refreshed: [], failed: [], unreadable: [] },
+        checkedAt,
+    };
+}

package/dist/src/tui/updates-panel.js

@@ -0,0 +1,44 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { rowStyle, theme } from "./theme.js";
+import { CHECKING, describeRefresh, describeUnknownReasons, REFRESHING } from "./updates-model.js";
+import { formatAgo } from "./updates.js";
+import { PreviewLines } from "./panel-parts.js";
+/** What the last check found out: its age, how the sources were refreshed, and what failed. */
+export function CheckStatus({ data, now }) {
+    const errors = data.results.filter((result) => result.error !== undefined);
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.muted, children: ["checked ", formatAgo(now - data.checkedAt), " \u00B7 ", describeRefresh(data)] }), data.refresh.failed.map((failure) => (_jsxs(Text, { color: theme.warning, children: ["refresh failed for ", failure.source, ": ", failure.reason] }, failure.source))), data.appError ? _jsxs(Text, { color: theme.error, children: ["Error (Apps): ", data.appError] }) : null, errors.map((result) => _jsxs(Text, { color: theme.error, children: ["Error (", result.scope, "): ", result.error] }, result.scope))] }));
+}
+/** One line of the list: an update, the fold of unassessable items, or one of those when unfolded. */
+export function EntryLine({ entry, selected, checked, view, showUnknown }) {
+    const cursor = selected ? "> " : "  ";
+    if (entry.kind === "summary") {
+        return (_jsxs(Text, { ...rowStyle(selected), color: theme.inactive, children: [cursor, view.unknown.length, " cannot be checked ", showUnknown ? "▾" : "▸", describeUnknownReasons(view.unknown)] }));
+    }
+    const { row } = entry;
+    if (entry.kind === "unknown") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { ...rowStyle(selected), children: [cursor, "    ", row.path, "  ", row.scope] }), _jsxs(Text, { color: theme.muted, children: ["        ", row.reason] })] }));
+    }
+    return (_jsxs(Text, { ...rowStyle(selected), children: [cursor, checked ? "[x]" : "[ ]", " ", row.path, "  ", row.scope, "  ", row.policy, "  ", row.installed, " ", "->", " ", row.available] }));
+}
+/** Under the list: the window indicator, what is up to date or selected, and the last result. */
+export function UpdatesFooter({ indicator, upToDate, updatableCount, checkedCount, message }) {
+    return (_jsxs(_Fragment, { children: [indicator ? _jsx(Text, { color: theme.muted, children: indicator }) : null, upToDate > 0 ? _jsxs(Text, { color: theme.muted, children: [upToDate, " up to date"] }) : null, updatableCount > 0 ? _jsxs(Text, { color: theme.muted, children: [checkedCount, " selected"] }) : null, message ? (_jsx(Box, { flexDirection: "column", children: message.lines.map((line, position) => _jsx(Text, { color: message.kind === "error" ? theme.error : theme.success, children: line }, position)) })) : null] }));
+}
+/** The prompt of the preview and confirmation modes; browsing and the check itself show nothing. */
+export function ModePanel({ mode }) {
+    switch (mode.kind) {
+        case "manual":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["App: ", mode.plan.entry.recipe.name] }), _jsxs(Text, { children: ["Environment: ", mode.plan.environment] }), _jsxs(Text, { children: ["Working directory: ", mode.plan.cwd] }), _jsxs(Text, { children: ["Manual: ", mode.plan.manual] }), mode.reason ? _jsx(Text, { color: theme.warning, children: mode.reason }) : null, _jsx(Text, { children: "Manual step done, check now? y/n" })] }));
+        case "browse":
+            return null;
+        case "busy":
+            return mode.label === REFRESHING || mode.label === CHECKING ? null : _jsx(Text, { children: mode.label });
+        case "preview":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PreviewLines, { lines: mode.prepared.lines }), _jsx(PreviewLines, { lines: mode.prepared.appFailures }), mode.prepared.failures.map(({ item, message }) => (_jsxs(Text, { color: theme.error, children: ["Preview failed for ", JSON.stringify(item.id), ": ", message] }, item.id))), mode.prepared.applicable.length === 0
+                        ? _jsx(Text, { children: "Nothing can be applied. Enter/Esc to go back" })
+                        : _jsxs(Text, { children: ["Apply ", mode.prepared.applicable.length, " ", mode.prepared.applicable.length === 1 ? "update" : "updates", "? y/n"] })] }));
+        case "confirm-paths":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "Confirm replacing non-canonical locations (outside .agents/skills and .claude/skills):" }), mode.prepared.nonCanonicalPaths.map((location, position) => _jsxs(Text, { color: theme.warning, children: ["  [", location.scope, "] ", JSON.stringify(location.path)] }, position)), _jsx(Text, { children: "Replace exactly these paths? y/n" })] }));
+    }
+}