@iseoane/agent-depot 0.2.0 → 0.2.1

package/dist/src/tui/sources-view.js

@@ -0,0 +1,276 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+import { initialMode, modeReducer } from "./sources-mode.js";
+import { rowStyle, theme } from "./theme.js";
+import { computeWindow, pageStep, useListHeight } from "./window.js";
+import { useKeys } from "./keys.js";
+/** The highlighted index: by stable id while that source exists, otherwise the bounded fallback index. */
+function resolveIndex(sources, selection) {
+    const found = sources.findIndex((source) => source.id === selection.id);
+    return found >= 0 ? found : Math.min(selection.index, Math.max(sources.length - 1, 0));
+}
+/** Refreshes each source in order; one failure is reported and does not stop the others. */
+async function refreshEach(operations, targets) {
+    const lines = [];
+    let failed = false;
+    for (const source of targets) {
+        try {
+            lines.push(`Refreshed Git Source: ${(await operations.refreshSource(source.id)).id}`);
+        }
+        catch (error) {
+            failed = true;
+            lines.push(`Failed ${source.id}: ${errorText(error)}`);
+        }
+    }
+    return { kind: failed ? "error" : "ok", text: lines.join("\n") };
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function SourcesView({ operations, onCapturingChange, onOpenCatalog, listHeight }) {
+    const height = useListHeight(listHeight, 7);
+    const [state, setState] = useState({ status: "loading" });
+    // The highlight follows the source id; the index is only the fallback once that source is gone.
+    // Selection and marks are mirrored in refs updated first, so keys delivered in one burst act on the latest state.
+    const [selection, setSelectionState] = useState({ index: 0 });
+    const selectionRef = useRef({ index: 0 });
+    const setSelection = (next) => {
+        selectionRef.current = next;
+        setSelectionState(next);
+    };
+    const [mode, dispatchMode] = useReducer(modeReducer, initialMode);
+    // Mirrors the mode synchronously so the shell and later keystrokes never see a stale capturing state.
+    const modeRef = useRef(initialMode);
+    const mounted = useRef(true);
+    const [message, setMessage] = useState();
+    // Git sources marked for a combined refresh; the built-in source can never be marked.
+    const [marked, setMarkedState] = useState(new Set());
+    const markedRef = useRef(new Set());
+    const setMarked = (next) => {
+        markedRef.current = next;
+        setMarkedState(next);
+    };
+    // Mirrors the typed URL synchronously so keystrokes delivered in one burst are not lost to stale closures.
+    const typed = useRef("");
+    const reload = useCallback(async () => {
+        try {
+            const sources = await operations.listSources();
+            if (mounted.current)
+                setState({ status: "ready", sources });
+        }
+        catch (error) {
+            if (mounted.current)
+                setState({ status: "error", message: errorText(error) });
+        }
+    }, [operations]);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const dispatch = (event) => {
+        modeRef.current = modeReducer(modeRef.current, event);
+        onCapturingChange?.(modeRef.current.kind !== "browse");
+        dispatchMode(event);
+    };
+    useEffect(() => {
+        let cancelled = false;
+        operations.listSources().then((sources) => {
+            if (!cancelled)
+                setState({ status: "ready", sources });
+        }, (error) => {
+            if (!cancelled)
+                setState({ status: "error", message: errorText(error) });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [operations]);
+    const allSources = state.status === "ready" ? state.sources : [];
+    const builtin = allSources.find((source) => source.kind === "builtin");
+    // The built-in source is a fixed row; only Git sources are selectable and navigable.
+    const sources = allSources.filter((source) => source.kind === "git");
+    const sourcesRef = useRef(sources);
+    sourcesRef.current = sources;
+    const selected = resolveIndex(sources, selection);
+    const select = (index) => {
+        const listed = sourcesRef.current;
+        const bounded = Math.min(Math.max(index, 0), Math.max(listed.length - 1, 0));
+        setSelection({ id: listed[bounded]?.id, index: bounded });
+    };
+    /** Runs a mutating action in the busy mode, reports its outcome and reloads the list. */
+    const run = async (action) => {
+        dispatch({ type: "busy" });
+        setMessage(undefined);
+        let outcome;
+        try {
+            const result = await action();
+            outcome = typeof result === "string" ? { kind: "ok", text: result } : result;
+        }
+        catch (error) {
+            outcome = { kind: "error", text: `Error: ${errorText(error)}` };
+        }
+        if (!mounted.current)
+            return;
+        setMessage(outcome);
+        await reload();
+        if (mounted.current)
+            dispatch({ type: "done" });
+    };
+    /** Marks the given ids, or unmarks them all when every one is already marked. */
+    const toggle = (ids) => {
+        const next = new Set(markedRef.current);
+        if (ids.every((id) => next.has(id)))
+            ids.forEach((id) => next.delete(id));
+        else
+            ids.forEach((id) => next.add(id));
+        setMarked(next);
+    };
+    const stop = (text) => setMessage({ kind: "error", text });
+    const startRemoval = async (source) => {
+        if (!operations.listUserGlobalInstallations || !operations.removeGitSource) {
+            stop("Removing sources is not supported by the configured operations");
+            return;
+        }
+        dispatch({ type: "busy" });
+        setMessage(undefined);
+        try {
+            const installations = await operations.listUserGlobalInstallations();
+            if (!mounted.current)
+                return;
+            const dependent = installations.some((selection) => selection.source.kind === "external" && "url" in selection.source && selection.source.url === source.url);
+            if (dependent) {
+                stop(`Dependent user-global Skills exist; run \`agent-depot source remove ${source.id}\` in the CLI`);
+                dispatch({ type: "done" });
+            }
+            else {
+                dispatch({ type: "confirm", action: "remove", source });
+            }
+        }
+        catch (error) {
+            if (!mounted.current)
+                return;
+            stop(`Error: ${errorText(error)}`);
+            dispatch({ type: "done" });
+        }
+    };
+    useKeys((input, key) => {
+        const mode = modeRef.current;
+        if (mode.kind === "busy")
+            return;
+        if (mode.kind === "input") {
+            if (key.escape)
+                dispatch({ type: "done" });
+            else if (key.return) {
+                const url = typed.current.trim();
+                if (url === "")
+                    return;
+                void run(async () => `Added Git Source: ${(await operations.addGitSource(url)).id}`);
+            }
+            else if (key.backspace || key.delete) {
+                typed.current = typed.current.slice(0, -1);
+                dispatch({ type: "edit", value: typed.current });
+            }
+            else if (input !== "" && !key.ctrl && !key.meta) {
+                typed.current += input;
+                dispatch({ type: "edit", value: typed.current });
+            }
+            return;
+        }
+        if (mode.kind === "confirm") {
+            if (input === "y") {
+                if (mode.action === "refresh") {
+                    const { sources: targets } = mode;
+                    void run(async () => {
+                        const result = await refreshEach(operations, targets);
+                        setMarked(new Set());
+                        return result;
+                    });
+                }
+                else {
+                    const { source } = mode;
+                    void run(async () => {
+                        await operations.removeGitSource?.(source.id);
+                        return `Removed Git Source: ${source.id}`;
+                    });
+                }
+            }
+            else if (input === "n" || key.escape)
+                dispatch({ type: "done" });
+            return;
+        }
+        const listed = sourcesRef.current;
+        const at = resolveIndex(listed, selectionRef.current);
+        const highlighted = listed[at];
+        if (key.downArrow || input === "j") {
+            select(at + 1);
+        }
+        else if (key.upArrow || input === "k") {
+            select(at - 1);
+        }
+        else if (key.pageDown) {
+            select(at + pageStep(height));
+        }
+        else if (key.pageUp) {
+            select(at - pageStep(height));
+        }
+        else if (key.return && highlighted) {
+            onOpenCatalog?.(highlighted);
+        }
+        else if (input === "n") {
+            setMessage(undefined);
+            typed.current = "";
+            dispatch({ type: "input" });
+        }
+        else if (input === " " && highlighted) {
+            setMessage(undefined);
+            toggle([highlighted.id]);
+        }
+        else if (input === "a") {
+            if (listed.length === 0)
+                stop("There are no Git sources to select");
+            else {
+                setMessage(undefined);
+                toggle(listed.map((source) => source.id));
+            }
+        }
+        else if (input === "r") {
+            const targets = markedRef.current.size > 0
+                ? listed.filter((source) => markedRef.current.has(source.id))
+                : highlighted ? [highlighted] : [];
+            if (targets.length > 0) {
+                setMessage(undefined);
+                dispatch({ type: "confirm", action: "refresh", sources: targets });
+            }
+        }
+        else if (input === "d" && highlighted) {
+            void startRemoval(highlighted);
+        }
+    });
+    // Sources removed since they were marked no longer count.
+    const selectedCount = sources.filter((source) => marked.has(source.id)).length;
+    if (state.status === "loading")
+        return _jsx(Text, { children: "Loading sources..." });
+    if (state.status === "error")
+        return _jsxs(Text, { color: theme.error, children: ["Error: ", state.message] });
+    const window = computeWindow(sources.length, selected, height);
+    return (_jsxs(Box, { flexDirection: "column", children: [builtin ? _jsxs(Text, { color: theme.muted, children: ["    ", builtin.id, " \u00B7 included"] }) : null, sources.length === 0 ? _jsx(Text, { children: "No Git sources \u00B7 n to add" }) : null, sources.length > 0 ? _jsxs(Text, { color: theme.muted, children: ["      ", "ID  KIND  URL"] }) : null, sources.slice(window.start, window.end).map((source, offset) => {
+                const index = window.start + offset;
+                return (_jsxs(Text, { ...rowStyle(index === selected), children: [index === selected ? "> " : "  ", marked.has(source.id) ? "[x] " : "[ ] ", source.id, "  ", source.kind, "  ", source.url] }, source.id));
+            }), window.indicator ? _jsx(Text, { color: theme.muted, children: window.indicator }) : null, selectedCount > 0 ? _jsxs(Text, { children: [selectedCount, " selected"] }) : null, _jsx(Prompt, { mode: mode }), message ? _jsx(Text, { color: message.kind === "error" ? theme.error : theme.success, children: message.text }) : null] }));
+}
+function Prompt({ mode }) {
+    if (mode.kind === "input")
+        return _jsxs(Text, { children: ["URL: ", mode.value] });
+    if (mode.kind === "busy")
+        return _jsx(Text, { children: "Working..." });
+    if (mode.kind === "confirm") {
+        const lines = mode.action === "refresh"
+            ? mode.sources.map((source) => `refresh Git Source ${source.id} from ${source.url}`)
+            : [`remove Git Source ${mode.source.id} from ${mode.source.url}`];
+        return _jsxs(Text, { children: [lines.join("\n"), "\n", "[y/n]"] });
+    }
+    return null;
+}

package/dist/src/tui/theme.js

@@ -0,0 +1,29 @@
+/** Central xeo palette for the TUI; views take every colour from here. */
+export const theme = {
+    /** Title and active tab. */
+    accent: "#ff2e9a",
+    /** Group nodes and selection text. */
+    group: "#7aa2f7",
+    /** Markers such as hosts and versions. */
+    marker: "#449dab",
+    success: "#9ece6a",
+    warning: "#e0af68",
+    error: "#f7768e",
+    /** Hints and footer. */
+    muted: "#414868",
+    /** Inactive tabs. */
+    inactive: "#565f89",
+    /** Background of the selected row. */
+    selection: "#292e42",
+};
+/** Columns assumed when the terminal width is unknown. */
+export const FALLBACK_TERMINAL_COLUMNS = 80;
+/** Double-line rule as wide as the terminal. */
+export function separatorLine(columns) {
+    const width = columns !== undefined && columns > 0 ? Math.floor(columns) : FALLBACK_TERMINAL_COLUMNS;
+    return "═".repeat(width);
+}
+/** Text props for a list row: bold on the selection background when selected. */
+export function rowStyle(selected) {
+    return selected ? { bold: true, backgroundColor: theme.selection } : { bold: false };
+}

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), 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) };
+    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,74 @@
+import { useCallback, 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 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", selected: selected.map((row) => row.item), 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);
+            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 };
+}