@iseoane/agent-depot 0.6.13 → 0.6.15

package/dist/src/skill-update.js

@@ -128,6 +128,7 @@ export async function applyUpdateBatch(selected, options) {
     const items = "updateable" in selected ? selected.updateable : selected;
     const results = [];
     for (const item of items) {
+        options.onItem?.(item, results.length + 1, items.length);
         try {
             const result = await applySkillUpdate(item, options);
             results.push(Object.freeze({ id: item.id, selection: item.selection, status: "updated", result }));

package/dist/src/source-refresh-session.js

@@ -0,0 +1,139 @@
+import { projectSourceOf, resolveProjectSource } from "./sources.js";
+/** ADR 0004 (amended): how long a refresh made by this process stands in for the one a preview needs. */
+const FRESHNESS_WINDOW_MS = 60 * 60 * 1000;
+const BACKGROUND_CONCURRENCY = 2;
+export function createSourceRefreshSession(operations, options = {}) {
+    const now = options.now ?? Date.now;
+    let states = new Map();
+    const inFlight = new Map();
+    const listeners = new Set();
+    const queue = [];
+    let backgroundRunning = 0;
+    const setState = (sourceId, state) => {
+        states = new Map(states).set(sourceId, state);
+        for (const listener of listeners)
+            listener();
+    };
+    // The project refresh carries the Source's own URL, so it also covers Sources missing from the registry.
+    const refreshReally = (source, background) => operations.refreshProjectSource
+        ? operations.refreshProjectSource(projectSourceOf(source), { background })
+        : operations.refreshSource(source.id, { background });
+    const start = (source, background) => {
+        const startedAt = now();
+        setState(source.id, { status: "refreshing", startedAt });
+        const running = refreshReally(source, background).then(() => {
+            inFlight.delete(source.id);
+            setState(source.id, { status: "refreshed", startedAt, finishedAt: now() });
+        }, (error) => {
+            inFlight.delete(source.id);
+            setState(source.id, { status: "failed", startedAt, finishedAt: now(), error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        });
+        inFlight.set(source.id, running);
+        return running;
+    };
+    const isFresh = (sourceId) => {
+        const state = states.get(sourceId);
+        return state?.status === "refreshed" && state.finishedAt !== undefined && now() - state.finishedAt < FRESHNESS_WINDOW_MS;
+    };
+    // Background refreshes cannot prompt and are time-limited (D2), so a user call never joins one:
+    // it waits for it to settle, then reuses its success (unless forced) or refreshes in the foreground.
+    const backgroundRuns = new Set();
+    const userRuns = new Map();
+    const refreshInBackground = (source) => {
+        const running = inFlight.get(source.id);
+        if (running)
+            return running;
+        if (isFresh(source.id))
+            return Promise.resolve();
+        const started = start(source, true);
+        backgroundRuns.add(started);
+        const forget = () => backgroundRuns.delete(started);
+        started.then(forget, forget);
+        return started;
+    };
+    const refreshForUser = (source, force) => {
+        const pending = userRuns.get(source.id);
+        // An unforced call may share any pending run; a forced one only another forced run.
+        if (pending && (pending.force || !force))
+            return pending.run;
+        const run = (async () => {
+            if (pending)
+                await pending.run.catch(() => undefined);
+            // A background refresh may start while this one waits, so wait until none is running.
+            for (let running = inFlight.get(source.id); running; running = inFlight.get(source.id)) {
+                await running.catch(() => undefined);
+            }
+            if (!force && isFresh(source.id))
+                return;
+            await start(source, false);
+        })();
+        const entry = { run, force };
+        userRuns.set(source.id, entry);
+        const forget = () => {
+            if (userRuns.get(source.id) === entry)
+                userRuns.delete(source.id);
+        };
+        run.then(forget, forget);
+        return run;
+    };
+    const drain = () => {
+        while (backgroundRunning < BACKGROUND_CONCURRENCY && queue.length > 0) {
+            const source = queue.shift();
+            backgroundRunning += 1;
+            void refreshInBackground(source)
+                .catch(() => undefined)
+                .finally(() => {
+                backgroundRunning -= 1;
+                drain();
+            });
+        }
+    };
+    return {
+        refresh: (source, refreshOptions = {}) => refreshForUser(source, refreshOptions.force === true),
+        refreshInBackground(sources) {
+            queue.push(...sources);
+            drain();
+        },
+        snapshot: () => states,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        now,
+        stop() {
+            queue.length = 0;
+        },
+        async settled() {
+            while (inFlight.size > 0 || userRuns.size > 0) {
+                await Promise.allSettled([...inFlight.values(), ...[...userRuns.values()].map((entry) => entry.run)]);
+            }
+        },
+    };
+}
+/**
+ * Routes `refreshSource` and `refreshProjectSource` through the session, so previews, Updates and
+ * Packages share and reuse refreshes. Built-in and unregistered ids keep the plain behavior and errors.
+ */
+export function withRefreshSession(operations, session) {
+    const refreshProjectSource = operations.refreshProjectSource;
+    return {
+        ...operations,
+        async refreshSource(sourceId, options) {
+            const source = (await operations.listSources()).find((candidate) => candidate.kind === "git" && candidate.id === sourceId);
+            if (!source)
+                return operations.refreshSource(sourceId, options);
+            await session.refresh(source, options);
+            return source;
+        },
+        ...(refreshProjectSource === undefined ? {} : {
+            async refreshProjectSource(projectSource, options) {
+                const source = resolveProjectSource(projectSource);
+                if (source.kind !== "git")
+                    return refreshProjectSource(projectSource, options);
+                await session.refresh(source, options);
+                return source;
+            },
+        }),
+    };
+}

package/dist/src/sources.js

@@ -72,7 +72,7 @@ export function createSourceOperations(options = {}) {
             const state = await stateStore.load();
             return Object.freeze([BUILT_IN_SOURCE, ...state.gitSources]);
         },
-        async refreshSource(sourceId) {
+        async refreshSource(sourceId, options) {
             if (sourceId === BUILT_IN_SOURCE.id) {
                 throw new BuiltInSourceError();
             }
@@ -81,7 +81,7 @@ export function createSourceOperations(options = {}) {
             if (!source) {
                 throw new SourceNotFoundError(sourceId);
             }
-            await gitAccess.refresh(source);
+            await gitAccess.refresh(source, options);
             return source;
         },
         async removeGitSource(sourceId, installations = []) {
@@ -185,12 +185,12 @@ export function createSourceOperations(options = {}) {
         async resolveProjectSource(projectSource) {
             return resolveProjectSource(projectSource);
         },
-        async refreshProjectSource(projectSource) {
+        async refreshProjectSource(projectSource, options) {
             const source = resolveProjectSource(projectSource);
             if (source.kind === "builtin") {
                 throw new BuiltInSourceError();
             }
-            await gitAccess.refresh(source);
+            await gitAccess.refresh(source, options);
             return source;
         },
         async readInstallationMethod(source, skillPath, previewTree) {

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

@@ -2,7 +2,7 @@ import { HOST_CHOICES } from "./catalog-actions.js";
 import { runInstall } from "./catalog-installs.js";
 import { errorText } from "./batch.js";
 import { defaultAdoptionHosts, findAdoptionCandidates, prepareAdoption } from "./installations.js";
-import { answerYesNo, applyChecklistOutcome, hostChecklistKey, moveCursor, versionInputKey } from "./mode-keys.js";
+import { answerYesNo, applyChecklistOutcome, hostChecklistKey, moveCursor, movePreviewCursor, versionInputKey } from "./mode-keys.js";
 import { busy } from "./working-model.js";
 function cancel(context) {
     context.setMessage({ kind: "ok", text: "Adoption cancelled" });
@@ -49,7 +49,7 @@ async function prepare(context, mode, version) {
         const adoption = await prepareAdoption(context.operations, context.env, mode.entry, mode.skill, { hosts: mode.hosts, version });
         if (!context.isMounted())
             return;
-        context.setMode({ kind: "confirm", entry: mode.entry, skill: mode.skill, adoption });
+        context.setMode({ kind: "confirm", entry: mode.entry, skill: mode.skill, adoption, cursor: 0 });
     }
     catch (error) {
         fail(context, error);
@@ -105,13 +105,32 @@ function handleFixedKey(context, mode, input, key) {
     else if (outcome.kind === "edit")
         context.setMode({ ...mode, value: outcome.value });
 }
+/** What an adoptable preview shows, so the key handler and the panel page the same rows. */
+export function adoptionPreview(mode) {
+    const { prepared } = mode.adoption;
+    const name = mode.entry.name;
+    return {
+        lines: [...prepared.preview, ...(prepared.runsExternalCommand ? ["This install runs an external command (see above)."] : [])],
+        chrome: { title: `Adopt ${name}`, action: `Adopt ${name}`, consequence: `Adopt ${name}? y/n` },
+    };
+}
+/** Pages the preview like the other footer confirmations: `y` answers only once it has all been displayed. */
 function handleConfirmKey(context, mode, input, key) {
     if (!mode.adoption.verdict.adoptable) {
         if (key.escape || key.return || input === "n")
             cancel(context);
         return;
     }
+    const { lines, chrome } = adoptionPreview(mode);
+    const viewport = context.previewGeometry(lines, mode.cursor, chrome);
+    const cursor = movePreviewCursor(mode.cursor, viewport.total, input, key, viewport.height);
+    if (cursor !== undefined) {
+        context.setMode({ ...mode, cursor });
+        return;
+    }
     answerYesNo(input, key, () => {
+        if (!viewport.reachedEnd)
+            return;
         if (mode.adoption.prepared.additionalHostExposure)
             context.setMode({ ...mode, kind: "confirm-exposure" });
         else

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

@@ -1,10 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text, useWindowSize } from "ink";
+import { Text } from "./safe-text.js";
+import { formatStepLabel } from "../flow-progress.js";
+import { commandLine } from "../preview-model.js";
 import { PROJECT_HOSTS } from "../project-manifest.js";
 import { errorText, runBatch } from "./batch.js";
+import { isYes } from "./keys.js";
 import { hostChecklistKey, movePreviewCursor } from "./mode-keys.js";
-import { BorderPanel, HostChecklist, PreviewConfirm, Working } from "./panel-parts.js";
-import { previewViewport } from "./preview-window.js";
+import { BorderPanel, HostChecklist, PagedPreview, Working } from "./panel-parts.js";
+import { usePreviewGeometry } from "./preview-window.js";
+import { fieldLine, lineText, span, stepBlockLines, textLine } from "./preview-render.js";
 import { theme } from "./theme.js";
 import { operationStart } from "./working-model.js";
 /** Finished items shown under a running batch; older ones are counted. */
@@ -17,59 +21,65 @@ export function isAppMode(mode) {
 /** Recipe name, falling back to the file identity for invalid recipes. */
 export const appName = (entry) => entry.recipe?.name ?? entry.file;
 function appPreviewChrome(mode) {
-    const title = mode.kind === "app-approve" ? "Recipe approval · does not install"
-        : mode.kind === "app-manual" ? "App manual step" : `App ${mode.plan.action} confirmation`;
-    const question = mode.kind === "app-approve" ? `Approve ${appName(mode.entry)}? y/n · recipe approval does not install the App.`
-        : mode.kind === "app-manual" ? "Manual step done, check now? y/n"
-            : `${mode.plan.action} ${appName(mode.plan.entry)}? y/n`;
-    return { title, questions: [question, "Scroll to end before y; n cancels."], footerRows: 2 };
+    if (mode.kind === "app-approve")
+        return recipeApprovalChrome(mode.entry);
+    if (mode.kind === "app-manual")
+        return { title: "App manual step", action: "Check now", consequence: "Manual step done, check now? y/n" };
+    const { action, entry } = mode.plan;
+    return {
+        title: `App ${action} confirmation`,
+        action: `${action[0].toUpperCase()}${action.slice(1)} ${appName(entry)}`,
+        consequence: `${action} ${appName(entry)}? y/n`,
+    };
+}
+/** Approving a recipe records consent to its commands; it installs nothing. */
+export function recipeApprovalChrome(entry) {
+    return {
+        title: "Recipe approval · does not install",
+        action: `Approve ${appName(entry)}`,
+        consequence: `Approve ${appName(entry)}? y/n · recipe approval does not install the App.`,
+    };
 }
-export function appStepLines(step) {
-    const argv = step.argv;
+/** What confirming an App step does: its name, Host and versions, then the step as one block. */
+export function appPlanLines(plan) {
+    const { previousVersion, latestVersion } = plan;
+    const both = previousVersion !== undefined && latestVersion !== undefined;
     return [
-        ...(argv ? [
-            "argv: [",
-            ...argv.map((argument, index) => `  ${JSON.stringify(argument)}${index < argv.length - 1 ? "," : ""}`),
-            "]",
-            `Executable: ${step.executable ?? `${JSON.stringify(argv[0])} not found in PATH`}`,
-        ] : []),
-        ...(step.manual ? [`Manual: ${step.manual}`] : []),
-        ...(step.declaration ? [step.declaration] : []),
-        ...(step.pattern ? [`Version pattern: ${step.pattern}`] : []),
-        ...(step.environment ? [`Environment: ${step.environment}`] : []),
-        `Working directory: ${step.cwd}`,
-        ...(step.warning ? [step.warning] : []),
+        [
+            span(` App ${appName(plan.entry)} ${plan.action}${plan.host ? ` (${plan.host})` : ""}`, theme.value, true),
+            ...(both ? [span(`  ${previousVersion} → ${latestVersion}`, theme.version)] : []),
+        ],
+        ...(!both && previousVersion !== undefined ? [fieldLine(" Previous version:", previousVersion)] : []),
+        ...(!both && latestVersion !== undefined ? [fieldLine(" Latest version:", latestVersion)] : []),
+        textLine(" "),
+        ...stepBlockLines([{ ...plan, step: plan.host ? `${plan.action}.${plan.host}` : plan.action }]),
     ];
 }
+/** The recipe's identity and approval status, then one block per step. */
 export function appRecipePreviewLines(entry, status, steps) {
     const recipe = entry.recipe;
     return [
-        `File: ${entry.file}`,
-        `Name: ${recipe?.name ?? entry.file}`,
-        `Platform: ${recipe?.platform ?? "all"}`,
-        `Status: ${status}`,
-        ...(recipe?.homepage ? [`Homepage: ${recipe.homepage}`] : []),
-        ...(recipe?.skills ? [`Owned Skills: ${JSON.stringify(recipe.skills)}`] : []),
-        ...steps.flatMap(step => [step.step, ...appStepLines(step)]),
+        [
+            span(` ${appName(entry)}`, theme.value, true),
+            span(`  ${recipe?.platform ?? "all"}`, theme.field),
+            span(`  ● ${status}`, status === "approved" ? theme.success : theme.warning),
+        ],
+        [span(` ${[entry.file, ...(recipe?.homepage ? [recipe.homepage] : [])].join(" · ")}`, theme.legend)],
+        ...(recipe?.skills ? [fieldLine(" Owned Skills:", commandLine(recipe.skills, { terminal: true }))] : []),
+        textLine(" "),
+        ...stepBlockLines(steps),
     ];
 }
 function appPreviewLines(mode) {
-    if (mode.kind === "app-approve")
-        return mode.lines;
-    return [
-        `App: ${appName(mode.plan.entry)} ${mode.plan.action}${mode.plan.host ? ` (${mode.plan.host})` : ""}`,
-        ...(mode.plan.previousVersion ? [`Previous version: ${mode.plan.previousVersion}`] : []),
-        ...(mode.plan.latestVersion ? [`Latest version: ${mode.plan.latestVersion}`] : []),
-        ...appStepLines(mode.plan),
-    ];
+    return mode.kind === "app-approve" ? mode.lines : appPlanLines(mode.plan);
 }
 /** The busy mode of an App step; `previous` is the busy mode this step continues, so the clock keeps running. */
 function appBusy(label, previous, done) {
     return { kind: "app-busy", label, startedAt: operationStart(previous), ...(done?.length ? { done } : {}) };
 }
-/** `Running App step: name (2/5)…`; the position is left out for a batch of one. */
+/** `Running App step: name (2/5)…`; `finished` counts the steps already done. */
 function stepLabel(verb, entry, finished, total) {
-    return `${verb} App step: ${appName(entry)}${total > 1 ? ` (${finished + 1}/${total})` : ""}…`;
+    return formatStepLabel(`${verb} App step: ${appName(entry)}`, finished + 1, total);
 }
 async function prepareNext(context, requests, results = [], failures = 0, previous) {
     const { manage, apps } = context;
@@ -182,8 +192,8 @@ export function handleAppKey(context, mode, input, key) {
         }
     }
     else {
-        const lines = appPreviewLines(mode);
-        const viewport = previewViewport(lines, mode.cursor, context.terminalRows, context.terminalColumns, appPreviewChrome(mode));
+        const lines = appPreviewLines(mode).map(lineText);
+        const viewport = context.previewGeometry(lines, mode.cursor, appPreviewChrome(mode));
         const cursor = movePreviewCursor(mode.cursor, viewport.total, input, key, viewport.height);
         if (cursor !== undefined) {
             manage.setMode({ ...mode, cursor });
@@ -197,7 +207,7 @@ export function handleAppKey(context, mode, input, key) {
                 cancel();
             return;
         }
-        if (input !== "y" || !viewport.reachedEnd)
+        if (!isYes(input, key) || !viewport.reachedEnd)
             return;
         if (mode.kind !== "app-approve") {
             void execute(context, mode);
@@ -209,7 +219,7 @@ export function handleAppKey(context, mode, input, key) {
 }
 /** Renders App prompts using the existing checklist and preview-confirm panels. */
 export function AppPanel({ mode }) {
-    const { rows, columns } = useWindowSize();
+    const geometry = usePreviewGeometry();
     if (mode.kind === "app-busy") {
         const done = mode.done ?? [];
         return (_jsxs(BorderPanel, { title: "App lifecycle", children: [_jsx(Working, { label: mode.label, since: mode.startedAt }), done.length > MAX_DONE_LINES ? _jsxs(Text, { color: theme.muted, children: [done.length - MAX_DONE_LINES, " earlier finished"] }) : null, done.slice(-MAX_DONE_LINES).map((line, index) => _jsx(Text, { color: theme.muted, children: line }, index))] }));
@@ -217,8 +227,8 @@ export function AppPanel({ mode }) {
     if (mode.kind === "app-hosts") {
         return (_jsxs(BorderPanel, { title: "App Host steps", children: [_jsx(Text, { children: "Checked = setup. Unchecked = teardown. Wiring is not tracked." }), _jsxs(Text, { children: ["Space/1-", mode.choices.length, " toggle \u00B7 j/k move \u00B7 Enter continue \u00B7 Esc cancel"] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
     }
-    const lines = appPreviewLines(mode);
+    const styled = appPreviewLines(mode);
+    const lines = styled.map(lineText);
     const chrome = appPreviewChrome(mode);
-    const viewport = previewViewport(lines, mode.cursor, rows || 24, columns || 80, chrome);
-    return (_jsx(PreviewConfirm, { title: chrome.title, lines: lines, cursor: mode.cursor, question: viewport.reachedEnd ? chrome.questions[0] : chrome.questions[1], chrome: chrome }));
+    return _jsx(PagedPreview, { lines: lines, styled: styled, viewport: geometry(lines, mode.cursor, chrome) });
 }

package/dist/src/tui/app.js

@@ -1,7 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text, useApp, useWindowSize } from "ink";
-import { useCallback, useRef, useState } from "react";
+import { Box, useApp, useWindowSize } from "ink";
+import { Text } from "./safe-text.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { AGENT_DEPOT_PACKAGE_VERSION } from "../project-manifest.js";
+import { withRefreshSession } from "../source-refresh-session.js";
 import { CatalogView } from "./catalog-view.js";
 import { InstallationsView } from "./installations-view.js";
 import { headerTabRows, TABS } from "./header-layout.js";
@@ -28,7 +30,23 @@ export function Header({ view, columns }) {
     const innerWidth = Math.max(columns - 4, 1);
     return (_jsxs(Box, { borderStyle: "round", borderColor: theme.accent, paddingX: 1, flexDirection: "column", width: columns, children: [_jsxs(Box, { width: innerWidth, justifyContent: "space-between", children: [_jsx(Text, { color: theme.accent, bold: true, children: "AGENT DEPOT" }), AGENT_DEPOT_PACKAGE_VERSION === undefined ? null : _jsxs(Text, { color: theme.value, children: ["v", AGENT_DEPOT_PACKAGE_VERSION] })] }), _jsx(Box, { flexDirection: "column", children: headerTabRows(innerWidth).map((row, rowIndex) => (_jsx(Text, { wrap: "truncate-end", children: row.map(([name, label], tabIndex) => (_jsxs(Text, { color: view === name ? theme.accent : theme.inactive, children: [tabIndex === 0 ? "" : "  ", view === name ? "▶ " : "", label] }, name))) }, rowIndex))) })] }));
 }
-export function App({ operations, environment, onExit }) {
+export function App({ operations: plainOperations, environment: plainEnvironment, onExit, refreshSession, refreshOnStart }) {
+    // Memoized: views reload whenever the operations they receive change identity.
+    const operations = useMemo(() => refreshSession === undefined ? plainOperations : withRefreshSession(plainOperations, refreshSession), [plainOperations, refreshSession]);
+    // Package previews refresh through the same session, so they reuse and show the same refreshes.
+    const environment = useMemo(() => refreshSession === undefined ? plainEnvironment : {
+        ...plainEnvironment,
+        refreshSession,
+        ...(plainEnvironment?.packages !== undefined ? {} : {
+            packagesEnvironment: { ...plainEnvironment?.packagesEnvironment, sourceOperations: operations },
+        }),
+    }, [plainEnvironment, refreshSession, operations]);
+    useEffect(() => {
+        if (!refreshOnStart || refreshSession === undefined)
+            return;
+        // D3 (I0031): only registered Git Sources; the built-in Source is never refreshed.
+        plainOperations.listSources().then((sources) => refreshSession.refreshInBackground(sources.filter((source) => source.kind === "git")), () => undefined);
+    }, [plainOperations, refreshSession, refreshOnStart]);
     const { exit } = useApp();
     const { columns, rows } = useWindowSize();
     const [capturing, setCapturing] = useState(false);
@@ -79,7 +97,7 @@ export function App({ operations, environment, onExit }) {
         else if (input === "5")
             showView("profile");
     });
-    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Header, { view: view, columns: columns }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: view === "sources" ? (_jsx(SourcesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange, onHintsChange: setSourcesHints, onOpenCatalog: (source) => {
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Header, { view: view, columns: columns }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: view === "sources" ? (_jsx(SourcesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange, onHintsChange: setSourcesHints, refreshSession: refreshSession, onOpenCatalog: (source) => {
                         setCatalogSourceId(source.id);
                         showView("catalog");
                     } })) : view === "installations" ? (_jsx(InstallationsView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange, retention: retention })) : view === "profile" ? (_jsx(ProfileView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : view === "updates" ? (_jsx(UpdatesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : (_jsx(CatalogView, { operations: operations, sourceId: catalogSourceId, environment: environment, onCapturingChange: onCapturingChange, retention: retention })) }), _jsx(Text, { color: theme.muted, children: capturing

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

@@ -1,8 +1,11 @@
 import { PROJECT_HOSTS } from "../project-manifest.js";
 import { assertManagedInstallationRecordsUnchanged } from "../skill-removal.js";
+import { formatStepLabel } from "../flow-progress.js";
 import { errorText, runBatch } from "./batch.js";
 import { missingHosts, prepareHostAddition, prepareUninstall, runHostAddition, runUninstall, UNINSTALL_REFUSALS, } from "./catalog-installs.js";
-import { answerYesNo, applyChecklistOutcome, hostChecklistKey } from "./mode-keys.js";
+import { answerPaged, answerYesNo, applyChecklistOutcome, hostChecklistKey } from "./mode-keys.js";
+import { span } from "./preview-render.js";
+import { theme } from "./theme.js";
 import { skillOf, sourceIdOf } from "./installations.js";
 import { prepareUnmanagedRemoval, runUnmanagedRemoval } from "./unmanaged-actions.js";
 import { busy } from "./working-model.js";
@@ -78,12 +81,12 @@ function resultOf(outcomes, skipped) {
         applied: outcomes.filter((outcome) => outcome.ok).map((outcome) => outcome.item.id),
     };
 }
-/** `Removing name (2/5)…` for each item as it starts. */
+/** `Removing name (2/5)…` (no position for one item) for each item as it starts. */
 function startOf(verb, progress) {
     if (!progress)
         return undefined;
     return (item, position, total, finished) => {
-        progress(`${verb} ${item.label} (${position}/${total})…`, finished.map(outcome => outcome.line));
+        progress(formatStepLabel(`${verb} ${item.label}`, position, total), finished.map(outcome => outcome.line));
     };
 }
 /** Execute step: each item is rechecked and applied on its own against the records the previous items were expected to leave. */
@@ -193,7 +196,7 @@ async function preparePlan(context, label, prepare, confirmation) {
 }
 /** `u` with marks: prepares every marked leaf, then asks once. */
 export function startBulkUninstall(context, targets) {
-    return preparePlan(context, `Preparing uninstall of ${count(targets.length, "item")}…`, () => prepareBulkUninstall(context, targets), (plan) => ({ kind: "confirm-bulk-uninstall", plan }));
+    return preparePlan(context, `Preparing uninstall of ${count(targets.length, "item")}…`, () => prepareBulkUninstall(context, targets), (plan) => ({ kind: "confirm-bulk-uninstall", plan, cursor: 0 }));
 }
 /** `h` with marks: asks the hosts once, for the union of what the eligible items lack. */
 export function startBulkHostAddition(context, targets) {
@@ -207,7 +210,7 @@ export function startBulkHostAddition(context, targets) {
     context.setMode({ kind: "bulk-hosts", targets: ready, skipped, choices, cursor: 0, selected: [] });
 }
 function prepareHosts(context, mode) {
-    return preparePlan(context, `Preparing host change of ${count(mode.targets.length, "item")}…`, () => prepareBulkHostAddition(context, mode.targets, mode.skipped, mode.selected), (plan) => ({ kind: "confirm-bulk-hosts", plan }));
+    return preparePlan(context, `Preparing host change of ${count(mode.targets.length, "item")}…`, () => prepareBulkHostAddition(context, mode.targets, mode.skipped, mode.selected), (plan) => ({ kind: "confirm-bulk-hosts", plan, cursor: 0 }));
 }
 async function apply(context, label, action) {
     const started = busy(label);
@@ -226,6 +229,30 @@ async function apply(context, label, action) {
     context.unmark(result.applied);
     await context.finish(result.message);
 }
+function previewOf(item) {
+    if (!("kind" in item))
+        return item.prepared.preview;
+    return item.kind === "managed" ? item.prepared.plan.preview : item.prepared.preview;
+}
+/**
+ * One block per planned item (its label, then its preview), then the skipped ones, with the footer's action and question.
+ * Only the labels are styled; `styled` is sparse so the other lines keep the colours inferred from their text.
+ */
+export function bulkConfirmPreview(mode) {
+    const { plan } = mode;
+    const items = count(plan.items.length, "item");
+    const blocks = plan.items.flatMap((item) => [
+        { text: item.label, label: true },
+        ...previewOf(item).map((text) => ({ text, label: false })),
+    ]);
+    const skipped = plan.skipped.map(({ label, reason }) => ({ text: `Skipped ${label}: ${reason}`, label: false }));
+    const entries = [...blocks, ...skipped];
+    const lines = entries.map(({ text }) => text);
+    const styled = entries.map(({ text, label }) => label ? [span(text, theme.group)] : undefined);
+    return mode.kind === "confirm-bulk-uninstall"
+        ? { lines, styled, chrome: { title: "Uninstall", action: `Uninstall ${items}`, consequence: `Uninstall ${items}? y/n` } }
+        : { lines, styled, chrome: { title: "Add hosts", action: `Add hosts to ${items}`, consequence: `Add hosts to ${items}? y/n` } };
+}
 /** Handles a key in a bulk mode; returns false for any other mode. */
 export function handleBulkKey(context, mode, input, key) {
     const current = mode;
@@ -241,13 +268,20 @@ export function handleBulkKey(context, mode, input, key) {
             return true;
         }
         case "confirm-bulk-uninstall":
-            answerYesNo(input, key, () => {
-                void apply(context, `Removing ${count(current.plan.items.length, "item")}…`, (progress) => runBulkUninstall(current.plan, operations, env, progress));
-            }, () => cancel(context, "Uninstall cancelled"));
-            return true;
-        case "confirm-bulk-hosts":
-            answerYesNo(input, key, () => context.setMode({ kind: "confirm-bulk-exposure", plan: current.plan }), () => cancel(context, "Add hosts cancelled"));
+        case "confirm-bulk-hosts": {
+            const { lines, chrome } = bulkConfirmPreview(current);
+            answerPaged(context.previewGeometry(lines, current.cursor, chrome), current.cursor, input, key, {
+                moveTo: (cursor) => context.setMode({ ...current, cursor }),
+                yes: () => {
+                    if (current.kind === "confirm-bulk-hosts")
+                        context.setMode({ kind: "confirm-bulk-exposure", plan: current.plan });
+                    else
+                        void apply(context, `Removing ${count(current.plan.items.length, "item")}…`, (progress) => runBulkUninstall(current.plan, operations, env, progress));
+                },
+                no: () => cancel(context, current.kind === "confirm-bulk-hosts" ? "Add hosts cancelled" : "Uninstall cancelled"),
+            });
             return true;
+        }
         case "confirm-bulk-exposure":
             answerYesNo(input, key, () => {
                 void apply(context, `Changing hosts of ${count(current.plan.items.length, "item")}…`, (progress) => runBulkHostAddition(current.plan, operations, env, progress));

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

@@ -7,3 +7,15 @@ export function describeSkills(skills) {
     return skills.length === 1 ? skills[0].name : `${skills.length} skills`;
 }
 export const BROWSE = { kind: "browse" };
+/** What the install confirmation shows, so the key handler and the panel page the same rows. */
+export function installPreview(items) {
+    const ready = items.filter((item) => item.prepared !== undefined);
+    const single = items.length === 1;
+    const name = describeSkills(ready.map((item) => item.skill));
+    const lines = [
+        ...(ready[0]?.prepared?.projectTarget ?? []),
+        ...items.flatMap(({ skill, prepared, error }) => prepared === undefined ? [`Cannot install ${skill.name}: ${error}`] : [...(single ? [] : [skill.name]), ...prepared.preview]),
+        ...(ready.some((item) => item.prepared?.runsExternalCommand) ? ["This install runs an external command (see above)."] : []),
+    ];
+    return { lines, chrome: { title: `Skill install preview · ${ready.length} ready`, action: `Install ${name}`, consequence: `Install ${name}? y/n` } };
+}

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

@@ -1,8 +1,9 @@
-import { BROWSE, describeSkills, HOST_CHOICES, SCOPE_CHOICES } from "./catalog-actions.js";
+import { formatProgressLabel } from "../flow-progress.js";
+import { BROWSE, describeSkills, installPreview, HOST_CHOICES, SCOPE_CHOICES } from "./catalog-actions.js";
 import { prepareInstall, runInstall } from "./catalog-installs.js";
 import { skillKey } from "./catalog-tree.js";
 import { errorText, runBatch } from "./batch.js";
-import { answerYesNo, applyChecklistOutcome, hostChecklistKey, versionInputKey } from "./mode-keys.js";
+import { answerYesNo, applyChecklistOutcome, hostChecklistKey, movePreviewCursor, versionInputKey } from "./mode-keys.js";
 import { busy } from "./working-model.js";
 function cancel(context) {
     context.setMessage({ kind: "ok", text: "Install cancelled" });
@@ -27,22 +28,46 @@ async function startInstall(context, skills, choice) {
         context.setAction(BROWSE);
         return;
     }
-    context.setAction({ kind: "confirm-install", items });
+    context.setAction({ kind: "confirm-install", items, cursor: 0 });
 }
 /** Applies the prepared items one by one; a failure is reported for that item and the rest still run. */
 async function confirmInstall(context, items, exposure) {
-    context.setAction(busy(`Installing ${describeSkills(items.map((item) => item.skill))}…`));
+    const running = busy(`Installing ${describeSkills(items.map((item) => item.skill))}…`);
+    context.setAction(running);
     const outcomes = await runBatch(items, async ({ prepared, error }) => {
         if (prepared === undefined)
             throw new Error(error);
         return (await runInstall(prepared, context.operations, exposure && prepared.additionalHostExposure)).join(" ");
-    }, ({ skill }, caught) => `Failed ${skill.name}: ${errorText(caught)}`);
+    }, ({ skill }, caught) => `Failed ${skill.name}: ${errorText(caught)}`, ({ skill }, position, total, finished) => {
+        if (!context.isMounted())
+            return;
+        const label = formatProgressLabel({ kind: "skill", name: skill.name, position, total, verb: "Installing" });
+        context.setAction({ ...running, label, done: finished.map((outcome) => outcome.line) });
+    });
     const lines = outcomes.map((outcome) => outcome.line);
     const failed = new Set(outcomes.filter((outcome) => !outcome.ok).map((outcome) => skillKey(outcome.item.skill)));
     // Installed Skills leave the list; only the failed ones stay marked for another try.
     context.keepMarked(failed);
     await context.finish({ kind: failed.size > 0 ? "error" : "ok", text: lines.join("\n") });
 }
+/** Pages the preview like the other footer confirmations: `y` answers only once it has all been displayed. */
+function handleInstallKey(context, mode, input, key) {
+    const { lines, chrome } = installPreview(mode.items);
+    const viewport = context.previewGeometry(lines, mode.cursor, chrome);
+    const cursor = movePreviewCursor(mode.cursor, viewport.total, input, key, viewport.height);
+    if (cursor !== undefined) {
+        context.setAction({ ...mode, cursor });
+        return;
+    }
+    answerYesNo(input, key, () => {
+        if (!viewport.reachedEnd)
+            return;
+        if (mode.items.some((item) => item.prepared?.additionalHostExposure))
+            context.setAction({ kind: "confirm-exposure", items: mode.items });
+        else
+            void confirmInstall(context, mode.items, false);
+    }, () => cancel(context));
+}
 function handleHostKey(context, mode, input, key) {
     applyChecklistOutcome(hostChecklistKey(mode, HOST_CHOICES, input, key), {
         cancel: () => cancel(context),
@@ -92,12 +117,7 @@ export function handleCatalogActionKey(context, mode, input, key) {
             handleFixedKey(context, mode, input, key);
             return;
         case "confirm-install":
-            answerYesNo(input, key, () => {
-                if (mode.items.some((item) => item.prepared?.additionalHostExposure))
-                    context.setAction({ ...mode, kind: "confirm-exposure" });
-                else
-                    void confirmInstall(context, mode.items, false);
-            }, () => cancel(context));
+            handleInstallKey(context, mode, input, key);
             return;
         case "confirm-exposure":
             answerYesNo(input, key, () => void confirmInstall(context, mode.items, true), () => cancel(context));