@iseoane/agent-depot 0.2.1 → 0.3.0

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

@@ -0,0 +1,157 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PROJECT_HOSTS } from "../project-manifest.js";
+import { errorText, runBatch } from "./batch.js";
+import { answerYesNo, hostChecklistKey } from "./mode-keys.js";
+import { HostChecklist, PreviewConfirm } from "./panel-parts.js";
+export const APP_KINDS = ["app-approve", "app-hosts", "app-confirm", "app-manual"];
+/** Narrows the view's mode without asserting a partial mode is an App mode. */
+export function isAppMode(mode) {
+    return APP_KINDS.some(kind => kind === mode.kind);
+}
+/** Recipe name, falling back to the file identity for invalid recipes. */
+export const appName = (entry) => entry.recipe?.name ?? entry.file;
+function stepLines(step) {
+    return [
+        ...(step.argv ? [`argv: ${JSON.stringify(step.argv)}`, `Executable: ${step.executable ?? "unavailable"}`] : []),
+        ...(step.manual ? [`Manual: ${step.manual}`] : []),
+        `Working directory: ${step.cwd}`,
+        ...(step.warning ? [step.warning] : []),
+    ];
+}
+async function prepareNext(context, requests, results = [], failures = 0) {
+    const { manage, apps } = context;
+    manage.setMode({ kind: "busy", label: "Preparing App step..." });
+    // Independent planning failures never stop the remaining marked Apps.
+    const [request, ...remaining] = requests;
+    if (!request) {
+        await manage.finish({ kind: failures > 0 ? "error" : "ok", text: results.join("\n") });
+        return;
+    }
+    try {
+        const plan = await apps.planLifecycle(request.entry, request.action, request.host);
+        if (manage.isMounted()) {
+            manage.setMode({
+                kind: !plan.argv && plan.manual ? "app-manual" : "app-confirm",
+                plan, remaining, results, failures,
+            });
+        }
+    }
+    catch (error) {
+        if (manage.isMounted()) {
+            await prepareNext(context, remaining, [...results, `${appName(request.entry)}: failed: ${errorText(error)}`], failures + 1);
+        }
+    }
+}
+/** Opens approval, the Host checklist, or the first lifecycle preview for selected Apps. */
+export async function startAppAction(context, entries, input) {
+    const { manage, apps } = context;
+    manage.setMessage(undefined);
+    try {
+        if (input === "approve") {
+            const entry = entries[0];
+            if (!entry)
+                throw new Error("No App selected");
+            manage.setMode({ kind: "busy", label: "Preparing recipe approval..." });
+            const steps = await apps.preview(entry);
+            if (manage.isMounted()) {
+                manage.setMode({ kind: "app-approve", entry, lines: steps.flatMap(step => [step.step, ...stepLines(step)]) });
+            }
+        }
+        else if (input === "h") {
+            const choices = PROJECT_HOSTS.filter(host => entries.some(entry => entry.recipe?.setup?.[host] || entry.recipe?.teardown?.[host]));
+            if (!choices.length)
+                throw new Error("No declared Host steps");
+            // This is an action selector, not a claim about persisted Host wiring.
+            manage.setMode({
+                kind: "app-hosts", entries, choices, cursor: 0,
+                selected: choices.filter(host => entries.some(entry => entry.recipe?.teardown?.[host])),
+            });
+        }
+        else {
+            await prepareNext(context, entries.map(entry => ({ entry, action: input === "u" ? "uninstall" : "install" })));
+        }
+    }
+    catch (error) {
+        await manage.finish({ kind: "error", text: errorText(error) });
+    }
+}
+async function execute(context, mode) {
+    const { manage, apps } = context;
+    manage.setMode({ kind: "busy", label: "Running App step..." });
+    let manualRequired = false;
+    const [outcome] = await runBatch([mode.plan], async (plan) => {
+        const result = mode.kind === "app-manual"
+            ? await apps.completeManual(plan, true)
+            : await apps.executeLifecycle(plan, true);
+        if (result.status === "manual required") {
+            manualRequired = true;
+            if (manage.isMounted())
+                manage.setMode({ ...mode, kind: "app-manual" });
+            return "manual required";
+        }
+        if (result.status === "failed")
+            throw new Error(result.reason);
+        manage.unmark([`app:${plan.entry.file}`]);
+        return `${appName(plan.entry)}: ${result.status}${result.installedVersion ? ` ${result.installedVersion}` : ""}`;
+    }, (plan, error) => `${appName(plan.entry)}: failed: ${errorText(error)}`);
+    if (manage.isMounted() && outcome && !manualRequired) {
+        await prepareNext(context, mode.remaining, [...mode.results, outcome.line], mode.failures + (outcome.ok ? 0 : 1));
+    }
+}
+/** Applies checklist and y/n keys, continuing independent batch steps after cancellation or failure. */
+export function handleAppKey(context, mode, input, key) {
+    const { manage, apps } = context;
+    const cancel = () => {
+        manage.browse();
+        manage.setMessage({ kind: "ok", text: "App action cancelled" });
+    };
+    if (mode.kind === "app-hosts") {
+        const outcome = hostChecklistKey(mode, mode.choices, input, key);
+        if (outcome.kind === "cancel")
+            cancel();
+        else if (outcome.kind === "update")
+            manage.setMode({ ...mode, ...outcome.state });
+        else if (key.return) {
+            const requests = mode.entries.flatMap(entry => mode.choices.flatMap(host => {
+                const action = mode.selected.includes(host) ? "setup" : "teardown";
+                return entry.recipe?.[action]?.[host] ? [{ entry, action, host }] : [];
+            }));
+            if (!requests.length)
+                manage.setMessage({ kind: "error", text: "No declared steps for this selection" });
+            else
+                void prepareNext(context, requests);
+        }
+    }
+    else
+        answerYesNo(input, key, () => {
+            if (mode.kind !== "app-approve") {
+                void execute(context, mode);
+                return;
+            }
+            manage.setMode({ kind: "busy", label: "Approving recipe..." });
+            void apps.approve(mode.entry).then(() => manage.finish({ kind: "ok", text: `Approved ${appName(mode.entry)}` }), error => manage.finish({ kind: "error", text: errorText(error) }));
+        }, () => {
+            if (mode.kind === "app-confirm" || mode.kind === "app-manual") {
+                void prepareNext(context, mode.remaining, [...mode.results, `${appName(mode.plan.entry)}: cancelled`], mode.failures);
+            }
+            else
+                cancel();
+        });
+}
+/** Renders App prompts using the existing checklist and preview-confirm panels. */
+export function AppPanel({ mode }) {
+    if (mode.kind === "app-hosts") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["App Host steps: checked = setup, unchecked = teardown. Wiring is not tracked. Space/1-", mode.choices.length, " toggle, j/k move, Enter continue, Esc cancel."] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
+    }
+    if (mode.kind === "app-approve") {
+        return _jsx(PreviewConfirm, { lines: mode.lines, question: `Approve ${appName(mode.entry)}? y/n` });
+    }
+    return (_jsx(PreviewConfirm, { lines: [
+            `Environment: ${mode.plan.environment}`,
+            `App: ${appName(mode.plan.entry)} ${mode.plan.action}${mode.plan.host ? ` (${mode.plan.host})` : ""}`,
+            ...stepLines(mode.plan),
+        ], question: mode.kind === "app-manual"
+            ? "Manual step done, check now? y/n"
+            : `${mode.plan.action} ${appName(mode.plan.entry)}? y/n` }));
+}

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

@@ -20,7 +20,11 @@ export async function loadInstalledSkills(operations, environment) {
         manifestStoreOf(environment).load().then((manifest) => manifest.skills, () => []),
         operations.listSources().catch(() => []),
     ]);
-    const unmanagedNames = await scanUserGlobalSkillInventory({ homeDirectory: homeOf(environment), managedInstallations: global }).then((inventory) => new Set([...inventory.unmanaged, ...inventory.symlinks].map((entry) => entry.name)), () => new Set());
+    const unmanagedNames = await scanUserGlobalSkillInventory({
+        homeDirectory: homeOf(environment),
+        appEnvironment: environment.appEnvironment,
+        managedInstallations: global,
+    }).then((inventory) => new Set([...inventory.unmanaged, ...inventory.symlinks].map((entry) => entry.name)), () => new Set());
     return { global, project, sources, unmanagedNames };
 }
 /** Whether an unmanaged copy with the Skill's directory name exists on disk (the name an install would use). */

package/dist/src/tui/installations-browse.js

@@ -1,3 +1,4 @@
+import { appName } from "./app-actions.js";
 import { startBulkHostAddition, startBulkUninstall } from "./bulk-actions.js";
 import { skillOf, sourceIdOf } from "./installations.js";
 import { leavesOf, targetOf } from "./installations-tree.js";
@@ -86,7 +87,21 @@ function actOnRow(context, snapshot, row, input, key) {
     context.setMessage(undefined);
     if (item.kind === "unmanaged")
         actOnUnmanaged(context, item.group, input, key);
-    else
+    else if (item.kind === "app") {
+        if (input === "A")
+            context.setMessage({ kind: "error", text: "Adoption applies to unmanaged Skills, not Apps" });
+        else if (key.return && item.row.inspection.status !== "needs approval") {
+            const { entry, inspection } = item.row;
+            const approved = inspection.status === "installed" || inspection.status === "not installed";
+            context.setMessage({
+                kind: approved ? "ok" : "error",
+                text: approved ? `${appName(entry)} is already approved` : inspection.reason ?? inspection.status,
+            });
+        }
+        else
+            context.startApps([item.row.entry], key.return ? "approve" : input);
+    }
+    else if (item.kind === "installation")
         actOnInstallation(context, data, item, input, key);
 }
 /** Keys while browsing: navigation, marks, bulk actions and the per-row actions. */
@@ -96,7 +111,14 @@ export function handleBrowseKey(context, input, key) {
         return;
     const row = snapshot.visible[snapshot.at];
     const rowAction = input === "A" || key.return || input === "u" || input === "h" || input === "i";
-    if (input === " ")
+    const appMarks = leavesOf(context.navigation.latestRoots()).filter(node => context.marks.markedRef.current.has(node.id) && node.data.kind === "app");
+    if ((input === "u" || input === "h" || input === "i") && appMarks.length) {
+        if (markedTargets(context).length)
+            context.setMessage({ kind: "error", text: "Select Apps or Skills separately for bulk actions" });
+        else
+            context.startApps(appMarks.flatMap(node => node.data.kind === "app" ? [node.data.row.entry] : []), input);
+    }
+    else if (input === " ")
         markRow(context, row);
     else if (input === "a")
         markAllListed(context, snapshot.visible);

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

@@ -29,9 +29,17 @@ export function buildTree(data) {
     });
     roots.push({
         id: "scope:unmanaged",
-        data: { kind: "group", label: `Unmanaged (user-global) (${data.unmanaged.length})` },
+        data: {
+            kind: "group",
+            label: `Unmanaged (user-global) (${data.unmanaged.length})${data.unmanagedWarnings?.length ? ` — ${data.unmanagedWarnings.join("; ")}` : ""}`,
+        },
         children: data.unmanaged.map((group) => ({ id: `unmanaged:${group.name}`, data: { kind: "unmanaged", group } })),
     });
+    if (data.apps?.length || data.appsError)
+        roots.push({
+            id: "scope:apps", data: { kind: "group", label: `Apps (user-global) (${data.apps?.length ?? 0})${data.appsError ? ` — ${data.appsError}` : ""}` },
+            children: (data.apps ?? []).map(row => ({ id: `app:${row.entry.file}`, data: { kind: "app", row } })),
+        });
     return roots;
 }
 /** Version, policy and hosts of a leaf; `adopted` / `modified` only when true (the legend explains them). */
@@ -59,6 +67,10 @@ export function describeNode(row) {
         return `${row.expandable ? (row.expanded ? "▾" : "▸") : " "} ${data.label}`;
     if (data.kind === "installation")
         return data.row.selection.path;
+    if (data.kind === "app") {
+        const { entry, inspection } = data.row;
+        return `${entry.recipe?.name ?? entry.file}  ${inspection.status === "invalid" ? `invalid recipe: ${inspection.reason}` : inspection.installedVersion ?? inspection.status}`;
+    }
     return `${data.group.name} [${data.group.hosts.join(", ")}]`;
 }
 /** `symlink → <target>` for the locations that are links, one entry per distinct target. */

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

@@ -1,6 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createAppOperations } from "../app-flow.js";
+import { handleAppKey, isAppMode, startAppAction } from "./app-actions.js";
 import { loadInstallations } from "./installations.js";
 import { BROWSE } from "./installations-mode.js";
 import { errorText } from "./batch.js";
@@ -22,6 +24,7 @@ const LEGEND = "adopted: tracked in place · modified: changed on disk";
 export function InstallationsView({ operations, environment, onCapturingChange, listHeight }) {
     const height = useListHeight(listHeight, 7);
     const env = environment ?? NO_ENVIRONMENT;
+    const apps = useMemo(() => createAppOperations({ homeDirectory: env.homeDirectory, ...env.appEnvironment }), [env]);
     const [state, setState] = useState({ status: "loading" });
     const [mode, setModeState] = useState(BROWSE);
     // Mirrors the mode synchronously so later keystrokes and the shell never see stale state.
@@ -34,17 +37,19 @@ export function InstallationsView({ operations, environment, onCapturingChange,
         onCapturingChange?.(next.kind !== "browse");
         setModeState(next);
     };
+    const loadGeneration = useRef(0);
     const reload = useCallback(async () => {
+        const generation = ++loadGeneration.current;
         try {
-            const data = await loadInstallations(operations, env);
-            if (mounted.current)
+            const data = await loadInstallations(operations, env, apps);
+            if (mounted.current && generation === loadGeneration.current)
                 setState({ status: "ready", data });
         }
         catch (error) {
-            if (mounted.current)
+            if (mounted.current && generation === loadGeneration.current)
                 setState({ status: "error", message: errorText(error) });
         }
-    }, [operations, env, mounted]);
+    }, [operations, env, apps, mounted]);
     useEffect(() => {
         void reload();
     }, [reload]);
@@ -52,6 +57,35 @@ export function InstallationsView({ operations, environment, onCapturingChange,
     const roots = useMemo(() => (data ? buildTree(data) : []), [data]);
     const navigation = useTreeNavigation(roots, defaultExpanded);
     const { rows, index } = navigation;
+    const checked = useRef(new Set());
+    const highlighted = rows[index]?.node.data;
+    useEffect(() => {
+        if (highlighted?.kind !== "app")
+            return;
+        const { entry } = highlighted.row;
+        const identity = `${entry.file}:${entry.hash}`;
+        if (checked.current.has(identity))
+            return;
+        checked.current.add(identity);
+        const generation = loadGeneration.current;
+        void apps.inspect(entry).then(inspection => {
+            if (!mounted.current || generation !== loadGeneration.current)
+                return;
+            setState(previous => previous.status !== "ready" ? previous : {
+                ...previous,
+                data: {
+                    ...previous.data,
+                    apps: previous.data.apps?.map(row => row.entry.file === entry.file && row.entry.hash === entry.hash
+                        ? { entry, inspection } : row),
+                },
+            });
+        }).catch(error => {
+            if (!mounted.current || generation !== loadGeneration.current)
+                return;
+            checked.current.delete(identity);
+            setMessage({ kind: "error", text: errorText(error) });
+        });
+    }, [highlighted, apps, mounted]);
     const installed = useMemo(() => ({
         global: (data?.global ?? []).map((row) => row.selection),
         project: (data?.project ?? []).map((row) => row.selection),
@@ -68,6 +102,7 @@ export function InstallationsView({ operations, environment, onCapturingChange,
         isMounted: () => mounted.current,
         unmark: (ids) => marks.setMarked(new Set([...marks.markedRef.current].filter((id) => !ids.includes(id)))),
         finish: async (result) => {
+            checked.current.clear();
             await reload();
             if (!mounted.current)
                 return;
@@ -92,11 +127,14 @@ export function InstallationsView({ operations, environment, onCapturingChange,
         manage,
         startAdoption: (group) => void startAdoption(adoption, group),
         setMessage,
+        startApps: (entries, input) => void startAppAction({ apps, manage }, entries, input),
     };
     useKeys((input, key) => {
         const current = modeRef.current;
         if (current.kind === "browse")
             handleBrowseKey(browse, input, key);
+        else if (isAppMode(current))
+            handleAppKey({ apps, manage }, current, input, key);
         else if (!handleManageKey(manage, current, input, key))
             handleAdoptionKey(adoption, current, input, key);
     });
@@ -107,8 +145,10 @@ export function InstallationsView({ operations, environment, onCapturingChange,
     const ready = state.data;
     const window = computeWindow(rows.length, index, height);
     const listed = rows.slice(window.start, window.end);
-    const selectedCount = leavesOf(roots).filter((node) => marks.marked.has(node.id)).length;
+    const markedLeaves = leavesOf(roots).filter(node => marks.marked.has(node.id));
+    const selectedCount = markedLeaves.length;
+    const markedApps = markedLeaves.filter(node => node.data.kind === "app").length;
     // The legend explains the markers, so it shows only while a rendered row carries one.
     const legendNeeded = listed.some((row) => row.node.data.kind === "installation" && markersOf(row.node.data.row) !== "");
-    return (_jsxs(Box, { flexDirection: "column", children: [ready.global === undefined ? _jsx(Text, { children: "User-global installations are not supported by the configured operations" }) : null, ready.projectError === undefined ? null : _jsxs(Text, { color: theme.error, children: ["Error: ", ready.projectError] }), listed.map((row, offset) => (_jsx(TreeRowLine, { row: row, selected: window.start + offset === index, marked: marks.marked.has(row.node.id) }, row.node.id))), _jsx(ListFooter, { indicator: window.indicator, selectedCount: selectedCount, message: message }), legendNeeded ? _jsx(Text, { color: theme.muted, children: LEGEND }) : null, _jsx(ModePanel, { mode: mode })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [ready.global === undefined ? _jsx(Text, { children: "User-global installations are not supported by the configured operations" }) : null, ready.projectError === undefined ? null : _jsxs(Text, { color: theme.error, children: ["Error: ", ready.projectError] }), listed.map((row, offset) => (_jsx(TreeRowLine, { row: row, selected: window.start + offset === index, marked: marks.marked.has(row.node.id) }, row.node.id))), _jsx(ListFooter, { indicator: window.indicator, selectedCount: selectedCount, message: message }), markedApps > 0 ? _jsxs(Text, { color: theme.muted, children: [markedApps, " Apps marked"] }) : null, legendNeeded ? _jsx(Text, { color: theme.muted, children: LEGEND }) : null, _jsx(ModePanel, { mode: mode })] }));
 }

package/dist/src/tui/installations.js

@@ -1,9 +1,11 @@
 import { homedir } from "node:os";
 import path from "node:path";
+import { createAppOperations } from "../app-flow.js";
 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 { errorText } from "./batch.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"];
@@ -69,8 +71,23 @@ async function toRow(scope, selection, inspectionOptions) {
     };
 }
 /** Loads both scopes and the unmanaged user-global inventory the CLI's `update check` uses. */
-export async function loadInstallations(operations, environment) {
+export async function loadInstallations(operations, environment, appOperations = createAppOperations({ homeDirectory: homeOf(environment), ...environment.appEnvironment })) {
     const home = homeOf(environment);
+    let apps = [];
+    let appsError;
+    try {
+        const tracked = await appOperations.trackedApps();
+        apps = await Promise.all((await appOperations.load()).filter(entry => entry.applicable).map(async (entry) => ({
+            entry,
+            inspection: await appOperations.inspect(entry, {
+                installedVersion: tracked.find(record => record.name === entry.recipe?.name
+                    && record.recipeFile === entry.canonicalFile)?.installedVersion,
+            }),
+        })));
+    }
+    catch (error) {
+        appsError = errorText(error);
+    }
     const globalRecords = operations.listUserGlobalInstallations
         ? await operations.listUserGlobalInstallations()
         : undefined;
@@ -94,11 +111,17 @@ export async function loadInstallations(operations, environment) {
         ...environment.installationOptions,
     };
     const project = await Promise.all(projectRecords.map((record) => toRow("project", record, projectOptions)));
+    const unmanagedWarnings = [];
     const unmanaged = globalRecords
-        ? groupUnmanaged(await scanUserGlobalSkillInventory({ homeDirectory: home, managedInstallations: globalRecords }))
+        ? groupUnmanaged(await scanUserGlobalSkillInventory({
+            homeDirectory: home,
+            managedInstallations: globalRecords,
+            appEnvironment: environment.appEnvironment,
+            reportWarning: warning => unmanagedWarnings.push(warning),
+        }))
         : [];
     const sources = await operations.listSources().catch(() => []);
-    return { global, project, ...(projectError === undefined ? {} : { projectError }), unmanaged, sources };
+    return { unmanagedWarnings, global, project, ...(projectError === undefined ? {} : { projectError }), unmanaged, sources, apps, ...(appsError === undefined ? {} : { appsError }) };
 }
 /** Source id of an installation's Source, when that Source is still registered. */
 export function sourceIdOf(selection, sources) {

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

@@ -1,3 +1,4 @@
+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";
@@ -11,6 +12,7 @@ const MANAGE_KINDS = new Set([
     "confirm-host-exposure",
     "confirm-host-remove",
     "confirm-uninstall",
+    ...APP_KINDS,
     ...UNMANAGED_KINDS,
     ...BULK_KINDS,
     "busy",

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

@@ -1,5 +1,6 @@
 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"}`;
@@ -26,6 +27,11 @@ function HostsPreview({ plan }) {
 /** 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":

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

@@ -36,7 +36,7 @@ export async function prepareUnmanagedRemoval(operations, environment, group, lo
     if (!operations.listUserGlobalInstallations)
         throw new Error("Uninstall is not supported by the configured operations");
     const installations = await operations.listUserGlobalInstallations();
-    const options = { homeDirectory: homeOf(environment), managedInstallations: installations };
+    const options = { homeDirectory: homeOf(environment), appEnvironment: environment.appEnvironment, managedInstallations: installations };
     const items = [];
     const preview = [`WARNING: agent-depot did not create these files (unmanaged skill ${group.name})`];
     // A chosen directory takes the links that point at it along, so none is left dangling.
@@ -70,7 +70,7 @@ export async function prepareUnmanagedRemoval(operations, environment, group, lo
 }
 /** Execute step: each location is rechecked and removed on its own, so one failure does not stop the others. */
 export async function runUnmanagedRemoval(prepared, operations, environment) {
-    const context = { operations, homeDirectory: homeOf(environment) };
+    const context = { operations, homeDirectory: homeOf(environment), appEnvironment: environment.appEnvironment };
     const lines = [];
     let failed = false;
     const notRemoved = new Set();

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

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { errorText } from "./batch.js";
 import { BROWSE } from "./updates-mode.js";
 import { CHECKING, emptyData, PHASE_LABEL, REFRESHING } from "./updates-model.js";
@@ -7,6 +7,10 @@ export function useUpdatesFlow(inputs) {
     const { operations, env, clock, mounted, checkedRef, latest, setChecked, setCursor, setMode, setMessage } = inputs;
     const [state, setState] = useState({ status: "loading", label: REFRESHING });
     const loadToken = useRef(0);
+    const pendingAnswer = useRef(undefined);
+    useEffect(() => () => {
+        pendingAnswer.current?.(false);
+    }, []);
     const load = useCallback(async (refresh) => {
         const token = ++loadToken.current;
         const phase = (next) => {
@@ -45,7 +49,7 @@ export function useUpdatesFlow(inputs) {
         try {
             const prepared = await prepareUpdates(current, selected);
             if (mounted.current)
-                setMode({ kind: "preview", selected: selected.map((row) => row.item), prepared });
+                setMode({ kind: "preview", prepared });
         }
         catch (error) {
             if (!mounted.current)
@@ -58,7 +62,18 @@ export function useUpdatesFlow(inputs) {
         setMode({ kind: "busy", label: "Applying updates..." });
         let result;
         try {
-            const outcome = await runUpdates(prepared, confirmedPaths);
+            const outcome = await runUpdates(prepared, confirmedPaths, (plan, reason) => new Promise(resolve => {
+                if (!mounted.current) {
+                    resolve(false);
+                    return;
+                }
+                const answer = (done) => {
+                    pendingAnswer.current = undefined;
+                    resolve(done);
+                };
+                pendingAnswer.current = answer;
+                setMode({ kind: "manual", plan, reason, answer });
+            }));
             result = { kind: outcome.failed === 0 ? "ok" : "error", lines: outcome.lines };
         }
         catch (error) {

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

@@ -80,6 +80,15 @@ function handlePreviewKey(context, mode, input, key) {
 /** Handles a key in the current Updates mode; `busy` ignores keys. */
 export function handleUpdatesKey(context, mode, input, key) {
     switch (mode.kind) {
+        case "manual":
+            answerYesNo(input, key, () => {
+                context.setMode({ kind: "busy", label: "Checking App version..." });
+                mode.answer(true);
+            }, () => {
+                context.setMode({ kind: "busy", label: "Continuing updates..." });
+                mode.answer(false);
+            });
+            return;
         case "browse":
             handleBrowseKey(context, input, key);
             return;

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

@@ -15,9 +15,9 @@ const matchesScope = (row, filter) => filter === "all" || row.scope === filter;
 /** The rows the list shows for a scope filter and fold state, and the cursor positions they make up. */
 export function viewOf(data, scope, showUnknown) {
     const shown = (data?.rows ?? []).filter((row) => matchesScope(row, scope));
-    const updatable = shown.filter((row) => row.item.status === "updateable");
-    const unknown = shown.filter((row) => row.item.status === "unknown");
-    const upToDate = shown.filter((row) => row.item.status === "current").length;
+    const updatable = shown.filter((row) => row.status === "update available");
+    const unknown = shown.filter((row) => row.status === "cannot assess");
+    const upToDate = shown.filter((row) => row.status === "up to date").length;
     const entries = [
         ...updatable.map((row) => ({ kind: "update", row })),
         ...(unknown.length > 0 ? [{ kind: "summary" }] : []),

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

@@ -7,7 +7,7 @@ import { PreviewLines } from "./panel-parts.js";
 /** What the last check found out: its age, how the sources were refreshed, and what failed. */
 export function CheckStatus({ data, now }) {
     const errors = data.results.filter((result) => result.error !== undefined);
-    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.muted, children: ["checked ", formatAgo(now - data.checkedAt), " \u00B7 ", describeRefresh(data)] }), data.refresh.failed.map((failure) => (_jsxs(Text, { color: theme.warning, children: ["refresh failed for ", failure.source, ": ", failure.reason] }, failure.source))), errors.map((result) => _jsxs(Text, { color: theme.error, children: ["Error (", result.scope, "): ", result.error] }, result.scope))] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.muted, children: ["checked ", formatAgo(now - data.checkedAt), " \u00B7 ", describeRefresh(data)] }), data.refresh.failed.map((failure) => (_jsxs(Text, { color: theme.warning, children: ["refresh failed for ", failure.source, ": ", failure.reason] }, failure.source))), data.appError ? _jsxs(Text, { color: theme.error, children: ["Error (Apps): ", data.appError] }) : null, errors.map((result) => _jsxs(Text, { color: theme.error, children: ["Error (", result.scope, "): ", result.error] }, result.scope))] }));
 }
 /** One line of the list: an update, the fold of unassessable items, or one of those when unfolded. */
 export function EntryLine({ entry, selected, checked, view, showUnknown }) {
@@ -28,12 +28,14 @@ export function UpdatesFooter({ indicator, upToDate, updatableCount, checkedCoun
 /** The prompt of the preview and confirmation modes; browsing and the check itself show nothing. */
 export function ModePanel({ mode }) {
     switch (mode.kind) {
+        case "manual":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["App: ", mode.plan.entry.recipe.name] }), _jsxs(Text, { children: ["Environment: ", mode.plan.environment] }), _jsxs(Text, { children: ["Working directory: ", mode.plan.cwd] }), _jsxs(Text, { children: ["Manual: ", mode.plan.manual] }), mode.reason ? _jsx(Text, { color: theme.warning, children: mode.reason }) : null, _jsx(Text, { children: "Manual step done, check now? y/n" })] }));
         case "browse":
             return null;
         case "busy":
             return mode.label === REFRESHING || mode.label === CHECKING ? null : _jsx(Text, { children: mode.label });
         case "preview":
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PreviewLines, { lines: mode.prepared.lines }), mode.prepared.failures.map(({ item, message }) => (_jsxs(Text, { color: theme.error, children: ["Preview failed for ", JSON.stringify(item.id), ": ", message] }, item.id))), mode.prepared.applicable.length === 0
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PreviewLines, { lines: mode.prepared.lines }), _jsx(PreviewLines, { lines: mode.prepared.appFailures }), mode.prepared.failures.map(({ item, message }) => (_jsxs(Text, { color: theme.error, children: ["Preview failed for ", JSON.stringify(item.id), ": ", message] }, item.id))), mode.prepared.applicable.length === 0
                         ? _jsx(Text, { children: "Nothing can be applied. Enter/Esc to go back" })
                         : _jsxs(Text, { children: ["Apply ", mode.prepared.applicable.length, " ", mode.prepared.applicable.length === 1 ? "update" : "updates", "? y/n"] })] }));
         case "confirm-paths":

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

@@ -96,6 +96,6 @@ export function UpdatesView({ operations, environment, onCapturingChange, listHe
     useKeys((input, key) => handleUpdatesKey(keyContext, modeRef.current, input, key));
     const window = computeWindow(entries.length, index, height);
     const view = { shown, updatable, unknown, upToDate, entries };
-    const hasErrors = (data?.results ?? []).some((result) => result.error !== undefined);
+    const hasErrors = data?.appError !== undefined || (data?.results ?? []).some((result) => result.error !== undefined);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.accent, bold: true, children: ["Updates (scope: ", scope, ")  t all \u00B7 p project \u00B7 g user-global"] }), state.status === "loading" ? _jsx(Text, { children: state.label }) : null, data ? _jsx(CheckStatus, { data: data, now: clock() }) : null, data && !hasErrors && shown.length === 0 ? _jsx(Text, { children: "No installations" }) : null, entries.slice(window.start, window.end).map((entry, offset) => (_jsx(EntryLine, { entry: entry, selected: window.start + offset === index, checked: entry.kind === "update" && checked.includes(entry.row.key), view: view, showUnknown: showUnknown }, entry.kind === "summary" ? "summary" : entry.row.key))), _jsx(UpdatesFooter, { indicator: window.indicator, upToDate: upToDate, updatableCount: updatable.length, checkedCount: checked.length, message: message }), _jsx(ModePanel, { mode: mode })] }));
 }