@iseoane/agent-depot 0.2.0 → 0.2.1

package/dist/src/tui/installations.js

@@ -0,0 +1,149 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { defaultProjectManifestPath, ProjectManifestStore, } from "../project-manifest.js";
+import { formatVersionPolicy } from "../skill-install.js";
+import { inspectSkillRemovals, userGlobalRemovalOptions } from "../skill-removal.js";
+import { scanUserGlobalSkillInventory, } from "../user-global-skill-inventory.js";
+import { prepareInstall } from "./catalog-installs.js";
+/** Hosts in display order; the Claude root serves Claude Code, the shared root serves the others. */
+const HOST_DISPLAY_ORDER = ["claude", "pi", "codex", "opencode"];
+const ROOT_HOSTS = {
+    agents: ["pi", "codex", "opencode"],
+    claude: ["claude"],
+};
+/**
+ * Groups the unmanaged directories, the unmanaged symlinks and the Claude links that
+ * expose an unmanaged canonical directory by Skill name. Hosts come from the root kinds.
+ */
+export function groupUnmanaged(inventory) {
+    const byName = new Map();
+    const add = (name, location) => byName.set(name, [...(byName.get(name) ?? []), location]);
+    for (const entry of inventory.unmanaged)
+        add(entry.name, { path: entry.path, root: entry.root, entry });
+    for (const link of inventory.symlinks)
+        add(link.name, { path: link.path, root: link.root, linkTarget: link.target });
+    const unmanagedPaths = new Set(inventory.unmanaged.map((entry) => path.resolve(entry.path)));
+    for (const exposure of inventory.exposures) {
+        if (unmanagedPaths.has(path.resolve(exposure.target))) {
+            add(exposure.name, { path: exposure.path, root: exposure.root, linkTarget: exposure.target });
+        }
+    }
+    return [...byName]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, locations]) => {
+        const ordered = [...locations].sort((left, right) => Number(left.root === "claude") - Number(right.root === "claude"));
+        const hosts = HOST_DISPLAY_ORDER.filter((host) => ordered.some((location) => ROOT_HOSTS[location.root].includes(host)));
+        return { name, locations: ordered, hosts };
+    });
+}
+export function homeOf(environment) {
+    return path.resolve(environment.homeDirectory ?? homedir());
+}
+function projectRootOf(environment) {
+    return path.resolve(environment.projectRoot ?? process.cwd());
+}
+function sourceLabel(source) {
+    if (source.kind === "builtin")
+        return source.id;
+    return "url" in source ? `${source.url}${source.ref === undefined ? "" : `@${source.ref}`}` : source.path;
+}
+/** Short label of version evidence: the package version or the first commit characters. */
+export function formatVersionEvidence(evidence) {
+    if (!evidence)
+        return "unknown";
+    return evidence.kind === "builtin-package" ? evidence.version : evidence.commit.slice(0, 7);
+}
+function installedVersion(selection) {
+    return formatVersionEvidence(selection.installation?.resolvedVersion);
+}
+async function toRow(scope, selection, inspectionOptions) {
+    const modified = await inspectSkillRemovals([selection], inspectionOptions).then((plan) => plan.inspections[0]?.modified, () => undefined);
+    return {
+        scope,
+        selection,
+        source: sourceLabel(selection.source),
+        policy: formatVersionPolicy(selection.version),
+        installed: installedVersion(selection),
+        adopted: selection.installation?.adopted === true,
+        ...(modified === undefined ? {} : { modified }),
+    };
+}
+/** Loads both scopes and the unmanaged user-global inventory the CLI's `update check` uses. */
+export async function loadInstallations(operations, environment) {
+    const home = homeOf(environment);
+    const globalRecords = operations.listUserGlobalInstallations
+        ? await operations.listUserGlobalInstallations()
+        : undefined;
+    const globalOptions = userGlobalRemovalOptions(home, environment.installationOptions);
+    const global = globalRecords
+        ? await Promise.all(globalRecords.map((record) => toRow("user-global", record, globalOptions)))
+        : undefined;
+    const store = environment.projectManifestStore ??
+        new ProjectManifestStore(defaultProjectManifestPath(projectRootOf(environment)));
+    let projectRecords = [];
+    let projectError;
+    try {
+        projectRecords = (await store.load()).skills;
+    }
+    catch (error) {
+        projectError = error instanceof Error ? error.message : String(error);
+    }
+    const projectOptions = {
+        projectRoot: projectRootOf(environment),
+        sourceAccess: { readSkillTree: async () => [] },
+        ...environment.installationOptions,
+    };
+    const project = await Promise.all(projectRecords.map((record) => toRow("project", record, projectOptions)));
+    const unmanaged = globalRecords
+        ? groupUnmanaged(await scanUserGlobalSkillInventory({ homeDirectory: home, managedInstallations: globalRecords }))
+        : [];
+    const sources = await operations.listSources().catch(() => []);
+    return { global, project, ...(projectError === undefined ? {} : { projectError }), unmanaged, sources };
+}
+/** Source id of an installation's Source, when that Source is still registered. */
+export function sourceIdOf(selection, sources) {
+    const source = selection.source;
+    if (source.kind === "builtin")
+        return source.id;
+    if (!("url" in source))
+        return undefined;
+    return sources.find((candidate) => candidate.kind === "git" && candidate.url === source.url)?.id;
+}
+/** The Skill of an installation, as the shared manage flows expect it. */
+export function skillOf(row, sourceId) {
+    return { sourceId, path: row.selection.path, name: path.posix.basename(row.selection.path), description: "" };
+}
+/** Source Skills whose directory name equals the unmanaged Skill's, across every registered Source. */
+export async function findAdoptionCandidates(operations, entry) {
+    if (!operations.discoverSkills)
+        throw new Error("Discovery is not supported by the configured operations");
+    const ids = (await operations.listSources()).map((source) => source.id);
+    return (await operations.discoverSkills(ids)).filter((skill) => path.posix.basename(skill.path) === entry.name);
+}
+/** Hosts that already read the unmanaged Skill's location, so adopting it exposes nothing new. */
+export function defaultAdoptionHosts(entry) {
+    return entry.host === "claude" ? ["claude"] : ["pi", "codex", "opencode"];
+}
+/**
+ * Adoption keeps the existing location, so it only applies when that exact
+ * location's content is identical to the selected Source Skill (the CLI's rule).
+ */
+export function adoptionVerdict(prepared, entry) {
+    const { inspection } = prepared.plan;
+    const location = path.resolve(entry.path);
+    const identical = inspection.locations.some((candidate) => candidate.status === "identical" && path.resolve(candidate.path) === location);
+    if (identical)
+        return { adoptable: true };
+    const collision = inspection.collision ?? inspection.locations.find((candidate) => candidate.collision)?.collision;
+    return {
+        adoptable: false,
+        reason: collision
+            ? `Cannot adopt ${entry.path}: it does not match the selected Source Skill (${collision.reason} at ${collision.path}); nothing was changed`
+            : `Cannot adopt ${entry.path}: no identical existing copy was found, so an install would create a new copy instead; nothing was changed`,
+    };
+}
+/** Plan step: the shared install plan (refreshing the Source) plus the adoption verdict. Changes nothing. */
+export async function prepareAdoption(operations, environment, entry, skill, choice) {
+    const prepared = await prepareInstall(operations, environment, skill, { ...choice, scope: "user-global" });
+    return { prepared, verdict: adoptionVerdict(prepared, entry) };
+}

package/dist/src/tui/keys.js

@@ -0,0 +1,31 @@
+import { useInput } from "ink";
+/** Plain printable characters only: control characters and escape sequences are never split. */
+const PRINTABLE = /^[^\p{Cc}]+$/u;
+/**
+ * Ink strips the ESC of sequences it does not resolve and hands over the rest
+ * (`[200~` paste markers, `[I` focus events, `[<0;10;5M` mouse reports). Splitting
+ * them would replay digits and letters as key presses, so they are kept whole.
+ * Only the final bytes xterm actually emits count (CSI: arrows, Home/End, focus, mouse,
+ * Shift+Tab, F1-F4, `~`; SS3: arrows, Home/End, F1-F4), so typed text such as `Ok` is not one.
+ */
+const ESCAPE_REMNANT = /^(?:\[[\d;<:?]*[A-DFHIMOPQRSZm~]|O[A-DFHPQRS])$/;
+const PASTE_MARKERS = new Set(["[200~", "[201~"]);
+/**
+ * `useInput` that treats several plain characters delivered in one write (fast
+ * typing, a paste) as the separate key presses they are, in order.
+ */
+export function useKeys(handler) {
+    useInput((input, key) => {
+        if (ESCAPE_REMNANT.test(input)) {
+            if (!PASTE_MARKERS.has(input))
+                handler(input, key);
+            return;
+        }
+        if (input.length > 1 && !key.ctrl && !key.meta && !key.escape && PRINTABLE.test(input)) {
+            for (const character of input)
+                handler(character, key);
+            return;
+        }
+        handler(input, key);
+    });
+}

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

@@ -0,0 +1,172 @@
+import { globalRecord, missingHosts, prepareHostAddition, prepareHostRemoval, prepareUninstall, runHostAddition, runHostRemoval, runUninstall, UNINSTALL_REFUSALS, } from "./catalog-installs.js";
+import { errorText } from "./batch.js";
+import { BULK_KINDS, handleBulkKey } from "./bulk-actions.js";
+import { answerYesNo, applyChecklistOutcome, hostChecklistKey } from "./mode-keys.js";
+import { handleUnmanagedKey, UNMANAGED_KINDS } from "./unmanaged-actions.js";
+const MANAGE_KINDS = new Set([
+    "remove-scope",
+    "hosts-add",
+    "hosts-remove",
+    "confirm-host-add",
+    "confirm-host-exposure",
+    "confirm-host-remove",
+    "confirm-uninstall",
+    ...UNMANAGED_KINDS,
+    ...BULK_KINDS,
+    "busy",
+]);
+function isManageMode(mode) {
+    return MANAGE_KINDS.has(mode.kind);
+}
+export { errorText };
+function cancel(context, text) {
+    context.setMessage({ kind: "ok", text });
+    context.browse();
+}
+/** `u`: one host goes straight to full removal; several ask whether to remove all or choose. */
+export function startUninstall(context, skill) {
+    const record = globalRecord(skill, context.installed);
+    if (record && record.hosts.length > 1)
+        context.setMode({ kind: "remove-scope", skill, hosts: record.hosts });
+    else
+        void startFullUninstall(context, skill);
+}
+async function startFullUninstall(context, skill) {
+    context.setMode({ kind: "busy", label: `Preparing uninstall of ${skill.name}...` });
+    try {
+        const prepared = await prepareUninstall(context.operations, context.env, skill, context.installed);
+        if (!context.isMounted())
+            return;
+        if (prepared.kind === "ready") {
+            context.setMode({ kind: "confirm-uninstall", skill, prepared });
+            return;
+        }
+        context.setMessage({ kind: "error", text: UNINSTALL_REFUSALS[prepared.kind] });
+    }
+    catch (error) {
+        if (!context.isMounted())
+            return;
+        context.setMessage({ kind: "error", text: errorText(error) });
+    }
+    context.browse();
+}
+/** Opens the host checklist for the hosts the installed Skill does not serve yet. */
+export function startHostAddition(context, skill) {
+    const record = globalRecord(skill, context.installed);
+    const missing = record ? missingHosts(record) : [];
+    if (missing.length === 0) {
+        context.setMessage({ kind: "error", text: record ? `${skill.name} already has every host` : "Skill is not installed" });
+        return;
+    }
+    context.setMode({ kind: "hosts-add", skill, choices: missing, cursor: 0, selected: [] });
+}
+async function startHostChange(context, mode) {
+    const { operations, env, installed } = context;
+    context.setMode({ kind: "busy", label: `Preparing host change of ${mode.skill.name}...` });
+    try {
+        if (mode.kind === "hosts-add") {
+            const prepared = await prepareHostAddition(operations, env, mode.skill, installed, mode.selected);
+            if (!context.isMounted())
+                return;
+            context.setMode({ kind: "confirm-host-add", skill: mode.skill, prepared });
+        }
+        else {
+            const prepared = await prepareHostRemoval(operations, env, mode.skill, installed, mode.selected);
+            if (!context.isMounted())
+                return;
+            context.setMode({ kind: "confirm-host-remove", skill: mode.skill, prepared });
+        }
+    }
+    catch (error) {
+        if (!context.isMounted())
+            return;
+        context.setMessage({ kind: "error", text: errorText(error) });
+        context.browse();
+    }
+}
+/** Runs a confirmed step in the busy mode and finishes with its outcome. */
+async function execute(context, label, action) {
+    context.setMode({ kind: "busy", label });
+    let result;
+    try {
+        result = { kind: "ok", text: await action() };
+    }
+    catch (error) {
+        result = { kind: "error", text: errorText(error) };
+    }
+    await context.finish(result);
+}
+function handleHostChecklistKey(context, mode, input, key) {
+    applyChecklistOutcome(hostChecklistKey(mode, mode.choices, input, key), {
+        cancel: () => cancel(context, mode.kind === "hosts-add" ? "Install cancelled" : "Uninstall cancelled"),
+        update: (state) => context.setMode({ ...mode, ...state }),
+        submit: () => void startHostChange(context, mode),
+        setMessage: context.setMessage,
+    });
+}
+function handleRemoveScopeKey(context, mode, input, key) {
+    if (key.escape)
+        cancel(context, "Uninstall cancelled");
+    else if (input === "1")
+        void startFullUninstall(context, mode.skill);
+    else if (input === "2")
+        context.setMode({ kind: "hosts-remove", skill: mode.skill, choices: mode.hosts, cursor: 0, selected: [] });
+}
+/** Keys of the confirmation modes: `y` runs the step (or asks for exposure consent first), `n`/Esc cancels. */
+function handleConfirmKey(context, mode, input, key) {
+    const { operations, env } = context;
+    const cancelWith = (text) => () => cancel(context, text);
+    switch (mode.kind) {
+        case "confirm-host-add":
+            answerYesNo(input, key, () => context.setMode({ ...mode, kind: "confirm-host-exposure" }), cancelWith("Install cancelled"));
+            return;
+        case "confirm-host-exposure":
+            answerYesNo(input, key, () => {
+                void execute(context, `Changing hosts of ${mode.skill.name}...`, () => runHostAddition(mode.prepared, operations, env));
+            }, cancelWith("Install cancelled"));
+            return;
+        case "confirm-host-remove":
+            answerYesNo(input, key, () => {
+                void execute(context, `Changing hosts of ${mode.skill.name}...`, () => runHostRemoval(mode.prepared, operations, env, mode.skill));
+            }, cancelWith("Uninstall cancelled"));
+            return;
+        case "confirm-uninstall":
+            answerYesNo(input, key, () => {
+                void execute(context, `Removing ${mode.skill.name}...`, async () => {
+                    await runUninstall(mode.prepared, operations, env);
+                    return `Removed ${mode.skill.name} (${mode.skill.path})`;
+                });
+            }, cancelWith("Uninstall cancelled"));
+            return;
+    }
+}
+/**
+ * Handles a key in one of the manage modes. Returns false when the mode is not
+ * a manage mode, so the host view can handle its own modes.
+ */
+export function handleManageKey(context, mode, input, key) {
+    if (!isManageMode(mode))
+        return false;
+    if (handleUnmanagedKey(context, mode, input, key))
+        return true;
+    if (handleBulkKey(context, mode, input, key))
+        return true;
+    switch (mode.kind) {
+        case "remove-scope":
+            handleRemoveScopeKey(context, mode, input, key);
+            break;
+        case "hosts-add":
+        case "hosts-remove":
+            handleHostChecklistKey(context, mode, input, key);
+            break;
+        case "confirm-host-add":
+        case "confirm-host-exposure":
+        case "confirm-host-remove":
+        case "confirm-uninstall":
+            handleConfirmKey(context, mode, input, key);
+            break;
+        default:
+            break;
+    }
+    return true;
+}

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

@@ -0,0 +1,59 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { ChecklistLines, HostChecklist, PreviewConfirm, PreviewLines } from "./panel-parts.js";
+import { theme } from "./theme.js";
+const plural = (n) => `${n} ${n === 1 ? "item" : "items"}`;
+function SkippedLines({ skipped }) {
+    return (_jsx(_Fragment, { children: skipped.map(({ id, label, reason }) => _jsxs(Text, { color: theme.warning, children: ["Skipped ", label, ": ", reason] }, id)) }));
+}
+/** One block per planned item, the skipped ones, then the y/n question. */
+function PlanPreview({ entries, skipped, question }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [entries.map((entry) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.group, children: entry.label }), _jsx(PreviewLines, { lines: entry.lines, warnFirst: entry.warnFirst })] }, entry.id))), _jsx(SkippedLines, { skipped: skipped }), _jsx(Text, { children: question })] }));
+}
+function UninstallPreview({ plan }) {
+    const entries = plan.items.map((item) => ({
+        id: item.id,
+        label: item.label,
+        lines: item.kind === "managed" ? item.prepared.plan.preview : item.prepared.preview,
+        warnFirst: item.kind === "unmanaged",
+    }));
+    return _jsx(PlanPreview, { entries: entries, skipped: plan.skipped, question: `Uninstall ${plural(plan.items.length)}? y/n` });
+}
+function HostsPreview({ plan }) {
+    const entries = plan.items.map((item) => ({ id: item.id, label: item.label, lines: item.prepared.preview, warnFirst: false }));
+    return _jsx(PlanPreview, { entries: entries, skipped: plan.skipped, question: `Add hosts to ${plural(plan.items.length)}? y/n` });
+}
+/** Renders the prompt of a manage mode: host lists, previews and confirmations. */
+export function ManagePanel({ mode }) {
+    switch (mode.kind) {
+        case "remove-scope":
+            return _jsxs(Text, { children: ["Uninstall ", mode.skill.name, " (hosts: ", mode.hosts.join(", "), "): 1 all hosts  2 choose hosts  (Esc cancel)"] });
+        case "hosts-add":
+        case "hosts-remove":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [mode.kind === "hosts-add" ? "Add hosts to" : "Remove hosts from", " ", mode.skill.name, ". Host (space/1-", mode.choices.length, " toggle, j/k move, Enter continue, Esc cancel):"] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
+        case "confirm-host-add":
+            return _jsx(PreviewConfirm, { lines: mode.prepared.preview, question: `Add hosts to ${mode.skill.name}? y/n` });
+        case "confirm-host-exposure":
+            return (_jsxs(Text, { color: theme.warning, children: ["Adding hosts exposes the installed ", mode.skill.name, " to more hosts and needs separate confirmation (CLI: --confirm-additional-host). Confirm? y/n"] }));
+        case "confirm-host-remove":
+            return _jsx(PreviewConfirm, { lines: mode.prepared.preview, question: `Remove hosts from ${mode.skill.name}? y/n` });
+        case "confirm-uninstall":
+            return _jsx(PreviewConfirm, { lines: mode.prepared.plan.preview, question: `Uninstall ${mode.skill.name}? y/n` });
+        case "unmanaged-scope":
+            return _jsxs(Text, { children: ["Remove ", mode.group.name, " (", mode.group.locations.length, " locations): 1 all locations  2 choose locations  (Esc cancel)"] });
+        case "unmanaged-pick":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Remove locations of ", mode.group.name, ". Location (space/1-", mode.group.locations.length, " toggle, j/k move, Enter continue, Esc cancel):"] }), _jsx(ChecklistLines, { choices: mode.group.locations, cursor: mode.cursor, isSelected: (location) => mode.selected.includes(location.path), keyOf: (location) => location.path, label: (location) => `${location.path}${location.linkTarget === undefined ? "" : `  symlink → ${location.linkTarget}`}` })] }));
+        case "confirm-unmanaged":
+            return _jsx(PreviewConfirm, { lines: mode.prepared.preview, question: `Remove ${mode.group.name}? y/n`, warnFirst: true });
+        case "bulk-hosts":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Add hosts to ", plural(mode.targets.length), ". Host (space/1-", mode.choices.length, " toggle, j/k move, Enter continue, Esc cancel):"] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected }), _jsx(SkippedLines, { skipped: mode.skipped })] }));
+        case "confirm-bulk-uninstall":
+            return _jsx(UninstallPreview, { plan: mode.plan });
+        case "confirm-bulk-hosts":
+            return _jsx(HostsPreview, { plan: mode.plan });
+        case "confirm-bulk-exposure":
+            return (_jsxs(Text, { color: theme.warning, children: ["Adding hosts exposes the installed ", mode.plan.items.map((item) => item.label).join(", "), " to more hosts and needs separate confirmation (CLI: --confirm-additional-host). Confirm? y/n"] }));
+        case "busy":
+            return _jsx(Text, { children: mode.label });
+    }
+}

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

@@ -0,0 +1,61 @@
+import { isValidFixedVersion } from "../skill-install.js";
+/** The cursor after a down/up key (arrows or j/k), or undefined when the key does not move it. */
+export function moveCursor(cursor, length, input, key) {
+    if (key.downArrow || input === "j")
+        return Math.min(cursor + 1, length - 1);
+    if (key.upArrow || input === "k")
+        return Math.max(cursor - 1, 0);
+    return undefined;
+}
+/** `selected` with `choice` flipped, always in the order of `choices`. */
+export function toggleChoice(choices, selected, choice) {
+    return choices.filter((candidate) => candidate === choice ? !selected.includes(candidate) : selected.includes(candidate));
+}
+/**
+ * Keys of a host checklist: Esc cancels, j/k or arrows move, space toggles the
+ * cursor row, a digit toggles that row, Enter submits a non-empty selection.
+ */
+export function hostChecklistKey(state, choices, input, key) {
+    if (key.escape)
+        return { kind: "cancel" };
+    const cursor = moveCursor(state.cursor, choices.length, input, key);
+    if (cursor !== undefined)
+        return { kind: "update", state: { ...state, cursor } };
+    const flipped = input === " " ? choices[state.cursor] : choices[Number(input) - 1];
+    if (input === " " || flipped !== undefined) {
+        return { kind: "update", state: { ...state, selected: toggleChoice(choices, state.selected, flipped) } };
+    }
+    if (key.return)
+        return state.selected.length > 0 ? { kind: "submit", selected: state.selected } : { kind: "empty" };
+    return { kind: "ignore" };
+}
+/** Runs the handler for what a key did to a host checklist; an empty Enter shows the shared message. */
+export function applyChecklistOutcome(outcome, handlers) {
+    if (outcome.kind === "cancel")
+        handlers.cancel();
+    else if (outcome.kind === "update")
+        handlers.update(outcome.state);
+    else if (outcome.kind === "submit")
+        handlers.submit(outcome.selected);
+    else if (outcome.kind === "empty")
+        handlers.setMessage({ kind: "error", text: "Select at least one host" });
+}
+/** The y/n confirmation keys: `y` confirms, `n` or Esc declines, anything else is ignored. */
+export function answerYesNo(input, key, onYes, onNo) {
+    if (input === "y")
+        onYes();
+    else if (input === "n" || key.escape)
+        onNo();
+}
+/** Esc cancels, Enter submits a valid version, backspace deletes, any other plain key is typed. */
+export function versionInputKey(value, input, key) {
+    if (key.escape)
+        return { kind: "cancel" };
+    if (key.return)
+        return isValidFixedVersion(value) ? { kind: "submit" } : { kind: "ignore" };
+    if (key.backspace || key.delete)
+        return { kind: "edit", value: value.slice(0, -1) };
+    if (input !== "" && !key.ctrl && !key.meta)
+        return { kind: "edit", value: value + input };
+    return { kind: "ignore" };
+}

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

@@ -0,0 +1,23 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "./theme.js";
+/** The `> [x] 1 name` rows of a checklist; the caller renders the header. */
+export function ChecklistLines({ choices, cursor, isSelected, keyOf, label }) {
+    return (_jsx(_Fragment, { children: choices.map((choice, position) => (_jsxs(Text, { children: [position === cursor ? "> " : "  ", "[", isSelected(choice) ? "x" : " ", "] ", position + 1, " ", label(choice)] }, keyOf(choice)))) }));
+}
+/** The host rows of a checklist. */
+export function HostChecklist({ choices, cursor, selected }) {
+    return _jsx(ChecklistLines, { choices: choices, cursor: cursor, isSelected: (host) => selected.includes(host), keyOf: (host) => host, label: (host) => host });
+}
+/** Preview lines; `warnFirst` colors the first one as a warning. */
+export function PreviewLines({ lines, warnFirst = false }) {
+    return (_jsx(_Fragment, { children: lines.map((line, position) => _jsx(Text, { color: warnFirst && position === 0 ? theme.warning : undefined, children: line }, position)) }));
+}
+/** Under a list: the window indicator, how many items are marked, and the last result. */
+export function ListFooter({ indicator, selectedCount, message }) {
+    return (_jsxs(_Fragment, { children: [indicator ? _jsx(Text, { color: theme.muted, children: indicator }) : null, selectedCount > 0 ? _jsxs(Text, { color: theme.muted, children: [selectedCount, " selected"] }) : null, message ? _jsx(Text, { color: message.kind === "error" ? theme.error : theme.success, children: message.text }) : null] }));
+}
+/** A preview followed by a y/n question. */
+export function PreviewConfirm({ lines, question, warnFirst }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PreviewLines, { lines: lines, warnFirst: warnFirst }), _jsx(Text, { children: question })] }));
+}

package/dist/src/tui/render.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./app.js";
+/** Renders the TUI and resolves once the user exits it. */
+export async function renderTui(operations, environment) {
+    const instance = render(_jsx(App, { operations: operations, environment: environment }));
+    await instance.waitUntilExit();
+}

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

@@ -0,0 +1,17 @@
+export const initialMode = { kind: "browse" };
+export function modeReducer(mode, event) {
+    switch (event.type) {
+        case "input":
+            return { kind: "input", value: "" };
+        case "edit":
+            return mode.kind === "input" ? { kind: "input", value: event.value } : mode;
+        case "confirm":
+            return event.action === "refresh"
+                ? { kind: "confirm", action: "refresh", sources: event.sources }
+                : { kind: "confirm", action: "remove", source: event.source };
+        case "busy":
+            return { kind: "busy" };
+        case "done":
+            return initialMode;
+    }
+}