@iseoane/agent-depot 0.2.0 → 0.3.0

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

@@ -0,0 +1,174 @@
+import { APP_KINDS } from "./app-actions.js";
+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",
+    ...APP_KINDS,
+    ...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,65 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { AppPanel } from "./app-actions.js";
+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 "app-approve":
+        case "app-hosts":
+        case "app-confirm":
+        case "app-manual":
+            return _jsx(AppPanel, { mode: mode });
+        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;
+    }
+}

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 };
+}