@iseoane/agent-depot 0.2.1 → 0.4.0

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

@@ -0,0 +1,249 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { readFile } from "node:fs/promises";
+import { Box, Text } from "ink";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { createAppOperations } from "../app-flow.js";
+import { buildProfileExport, profileExportPreview, writeProfileExport, } from "../profile-export.js";
+import { applyProfileImport, buildProfileImport, } from "../profile-import.js";
+import { PROFILE_FORMAT } from "../profile.js";
+import { useKeys } from "./keys.js";
+import { answerYesNo, moveCursor, toggleChoice } from "./mode-keys.js";
+import { ChecklistLines, PreviewConfirm, PreviewLines } from "./panel-parts.js";
+import { computeWindow, useListHeight } from "./window.js";
+function rowsFromExport(plan) {
+    return [
+        ...plan.profile.sources.map((value, index) => ({
+            block: "sources", index, label: `Sources: ${value.url}`, selectable: true,
+        })),
+        ...plan.profile.skills.map((value, index) => ({
+            block: "skills", index, label: `Skills: ${value.path}`, selectable: true,
+        })),
+        ...plan.profile.apps.map((value, index) => ({
+            block: "apps", index, label: `Apps: ${value.name} (${value.platform ?? "all platforms"})`, selectable: true,
+        })),
+        ...plan.exclusions.map((item, index) => ({
+            block: "excluded", index, label: `Excluded ${item.label}: ${item.reason}`, selectable: false,
+        })),
+        ...plan.warnings.filter(warning => warning.kind === "load").map((warning, index) => ({
+            block: "excluded", index: plan.exclusions.length + index, label: warning.message, selectable: false,
+        })),
+    ];
+}
+function rowsFromPlan(plan) {
+    return plan.items.map((item, index) => ({
+        block: item.block, index,
+        label: `${item.status}: ${item.label}${item.difference ? `; ${item.difference}` : ""}`,
+        selectable: item.status === "add",
+    }));
+}
+function selectedPlanItems(plan, selected) {
+    return plan.items.filter((item, index) => item.status !== "add" || selected.some(row => row.index === index));
+}
+/** Collect choices, display shared-core previews and confirm portable Profile transfers. */
+export function ProfileView({ operations, environment = {}, onCapturingChange, listHeight }) {
+    const apps = useMemo(() => createAppOperations({
+        homeDirectory: environment.homeDirectory, ...environment.appEnvironment,
+    }), [environment]);
+    const [mode, setModeState] = useState("browse");
+    const modeRef = useRef("browse");
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        return () => { mounted.current = false; };
+    }, []);
+    const setMode = (next) => {
+        modeRef.current = next;
+        onCapturingChange?.(next !== "browse" && next !== "results");
+        setModeState(next);
+    };
+    const [rows, setRows] = useState([]);
+    const [selected, setSelectedState] = useState([]);
+    const selectedRef = useRef([]);
+    const select = (next) => {
+        selectedRef.current = next;
+        setSelectedState(next);
+    };
+    const [cursor, setCursorState] = useState(0);
+    const cursorRef = useRef(0);
+    const cursorTo = (next) => {
+        cursorRef.current = next;
+        setCursorState(next);
+    };
+    const [text, setText] = useState("");
+    const typed = useRef("");
+    const [lines, setLines] = useState([]);
+    const [profile, setProfile] = useState();
+    const [plan, setPlan] = useState();
+    const diagnostics = useRef([]);
+    const action = useRef("export");
+    const profileVersion = useRef("");
+    const height = useListHeight(listHeight, 9);
+    const showLines = (next, nextMode) => {
+        setLines(next);
+        cursorTo(0);
+        setMode(nextMode);
+    };
+    const run = async (work) => {
+        setMode("busy");
+        try {
+            await work();
+        }
+        catch (error) {
+            if (mounted.current) {
+                showLines([`Error: ${error instanceof Error ? error.message : String(error)}`], "results");
+            }
+        }
+    };
+    const prompt = (next) => {
+        typed.current = "";
+        setText("");
+        setMode(next);
+    };
+    const loadRows = (next, nextMode) => {
+        setRows(next);
+        select(next.filter(row => row.selectable));
+        cursorTo(0);
+        setMode(nextMode);
+    };
+    const chosenProfile = () => {
+        const chosen = selectedRef.current;
+        const isChosen = (block, index) => chosen.some(row => row.block === block && row.index === index);
+        return {
+            ...profile,
+            sources: profile.sources.filter((_, index) => isChosen("sources", index)),
+            skills: profile.skills.filter((_, index) => isChosen("skills", index)),
+            apps: profile.apps.filter((_, index) => isChosen("apps", index)),
+        };
+    };
+    useKeys((input, key) => {
+        const current = modeRef.current;
+        if (current === "busy")
+            return;
+        if (current === "browse" || current === "results") {
+            if (input === "e") {
+                action.current = "export";
+                void run(async () => {
+                    const exported = await buildProfileExport(operations, apps, { homeDirectory: environment.homeDirectory });
+                    if (!mounted.current)
+                        return;
+                    setProfile(exported.profile);
+                    diagnostics.current = [...exported.exclusions, ...exported.warnings];
+                    loadRows(rowsFromExport(exported), "export-list");
+                });
+            }
+            else if (input === "i") {
+                action.current = "import";
+                prompt("import-path");
+            }
+            else if (current === "results") {
+                const next = moveCursor(cursorRef.current, lines.length, input, key);
+                if (next !== undefined)
+                    cursorTo(Math.max(0, next));
+            }
+            return;
+        }
+        if (current === "export-path" || current === "import-path") {
+            if (key.escape) {
+                setMode("browse");
+                return;
+            }
+            if (key.return) {
+                if (!typed.current.trim())
+                    return;
+                if (current === "export-path") {
+                    showLines(profileExportPreview(chosenProfile(), diagnostics.current), "confirm");
+                }
+                else
+                    void run(async () => {
+                        const raw = JSON.parse(await readFile(typed.current, "utf8"));
+                        const imported = await buildProfileImport(raw, operations, apps);
+                        profileVersion.current = raw.agentDepotVersion;
+                        if (!mounted.current)
+                            return;
+                        setPlan(imported);
+                        loadRows(rowsFromPlan(imported), "import-list");
+                    });
+            }
+            else if (key.backspace || key.delete) {
+                typed.current = typed.current.slice(0, -1);
+                setText(typed.current);
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                typed.current += input;
+                setText(typed.current);
+            }
+            return;
+        }
+        if (current === "confirm") {
+            answerYesNo(input, key, () => {
+                void run(async () => {
+                    let result;
+                    if (action.current === "export") {
+                        await writeProfileExport(typed.current, chosenProfile());
+                        result = [`Exported profile to ${typed.current}`];
+                    }
+                    else {
+                        const confirmed = { ...plan, items: selectedPlanItems(plan, selectedRef.current) };
+                        const outcomes = await applyProfileImport(confirmed, operations, apps, true, () => undefined, { homeDirectory: environment.homeDirectory, ...environment.installationOptions });
+                        result = outcomes.map(outcome => `${outcome.status}: ${outcome.item.label}${outcome.detail ? `; ${outcome.detail}` : ""}`);
+                    }
+                    if (mounted.current) {
+                        showLines(result.length ? result : ["Nothing selected; nothing written."], "results");
+                    }
+                });
+            }, () => setMode("browse"));
+            if (input === "y" || input === "n" || key.escape)
+                return;
+            const next = moveCursor(cursorRef.current, lines.length, input, key);
+            if (next !== undefined)
+                cursorTo(Math.max(0, next));
+            return;
+        }
+        if (key.escape) {
+            setMode("browse");
+            return;
+        }
+        // Export diagnostics follow the checklist, but never own its cursor.
+        // Import same/conflict rows still draw a cursor so their differences can be reviewed.
+        const checklistLength = rows.filter(row => row.block !== "excluded").length;
+        const next = moveCursor(cursorRef.current, checklistLength, input, key);
+        if (next !== undefined)
+            cursorTo(Math.max(0, next));
+        else if (input === " " && rows[cursorRef.current]?.selectable) {
+            select(toggleChoice(rows, selectedRef.current, rows[cursorRef.current]));
+        }
+        else if (input === "a")
+            select(selectedRef.current.length ? [] : rows.filter(row => row.selectable));
+        else if (key.return) {
+            if (current === "export-list") {
+                if (!selectedRef.current.length) {
+                    showLines(["Nothing selected; nothing written."], "results");
+                }
+                else
+                    prompt("export-path");
+            }
+            else
+                void run(async () => {
+                    // Reuse the CLI's core preview for the exact selected subset, including argv and Source notes.
+                    const items = selectedPlanItems(plan, selectedRef.current);
+                    const preview = await buildProfileImport({
+                        format: PROFILE_FORMAT, agentDepotVersion: profileVersion.current,
+                        sources: items.filter(item => item.block === "sources").map(item => item.value),
+                        skills: items.filter(item => item.block === "skills").map(item => item.value),
+                        apps: items.filter(item => item.block === "apps").map(item => item.value),
+                    }, operations, apps);
+                    if (mounted.current)
+                        showLines(preview.preview, "confirm");
+                });
+        }
+    });
+    const listing = mode === "export-list" || mode === "import-list";
+    const window = computeWindow(listing ? rows.length : lines.length, cursor, height);
+    return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Portable user-global Profile \u00B7 e export \u00B7 i import" }), mode === "busy" ? _jsx(Text, { children: "Loading Profile\u2026" }) : null, mode.endsWith("-path") ? _jsxs(Text, { children: ["Profile path: ", text, "_"] }) : null, listing ? ["sources", "skills", "apps", "excluded"].map(block => {
+                const choices = rows.slice(window.start, window.end).filter(row => row.block === block);
+                if (!choices.length)
+                    return null;
+                return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: block === "excluded" ? "Excluded" : block[0].toUpperCase() + block.slice(1) }), block === "excluded" ? _jsx(PreviewLines, { lines: choices.map(row => `${row.label} (not selectable)`) }) :
+                            _jsx(ChecklistLines, { choices: choices, cursor: choices.indexOf(rows[cursor]), isSelected: row => selected.includes(row), keyOf: row => `${row.block}:${row.index}`, label: row => `${row.label}${row.selectable ? "" : " (not selectable)"}` })] }, block);
+            }) : null, mode === "confirm" ? _jsx(PreviewConfirm, { lines: lines.slice(window.start, window.end), question: "Apply Profile? (y/n) \u00B7 j/k scroll" }) : null, mode === "results" ? _jsxs(_Fragment, { children: [_jsx(PreviewLines, { lines: lines.slice(window.start, window.end) }), _jsx(Text, { children: "j/k scroll" })] }) : null, window.indicator && (listing || mode === "confirm" || mode === "results") ? _jsx(Text, { children: window.indicator }) : null, listing ? _jsx(Text, { children: "j/k move \u00B7 space toggle \u00B7 a all \u00B7 Enter preview \u00B7 Esc cancel" }) : null] });
+}

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

@@ -0,0 +1,216 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createAppOperations } from "../app-flow.js";
+import { BUILT_IN_SOURCE } from "../sources.js";
+import { handleCatalogActionKey } from "./catalog-flow.js";
+import { ActionPanel } from "./catalog-panel.js";
+import { hasUnmanagedCopy, isInstalled, loadInstalledSkills } from "./catalog-installs.js";
+import { appName, appStepLines } from "./app-actions.js";
+import { errorText } from "./batch.js";
+import { useMounted } from "./view-state.js";
+import { PreviewConfirm } from "./panel-parts.js";
+import { answerYesNo } from "./mode-keys.js";
+import { rowStyle, theme } from "./theme.js";
+import { computeWindow, pageStep } from "./window.js";
+/**
+ * Returns section focus, key dispatch (true when consumed), the recipe panel,
+ * and the Git list's share of the common height budget. Sources owns key dispatch.
+ */
+export function useSourcesRecipes({ operations, environment, onCapturingChange, height, gitCount, }) {
+    const homeDirectory = environment?.homeDirectory;
+    const appEnvironment = environment?.appEnvironment;
+    const apps = useMemo(() => createAppOperations({
+        homeDirectory,
+        ...appEnvironment,
+    }), [homeDirectory, appEnvironment]);
+    const mounted = useMounted();
+    const [rows, setRows] = useState([]);
+    const [error, setError] = useState();
+    const [loadError, setLoadError] = useState();
+    const [focused, setFocused] = useState(false);
+    // Ref mirrors keep Tab and subsequent keys in a single burst on the same section.
+    const focusRef = useRef(false);
+    const [index, setIndex] = useState(0);
+    const indexRef = useRef(0);
+    const [mode, setModeState] = useState({ kind: "browse" });
+    const modeRef = useRef(mode);
+    const setMode = (next) => {
+        modeRef.current = next;
+        onCapturingChange?.(next.kind !== "browse");
+        setModeState(next);
+    };
+    const finish = async () => {
+        await reload();
+        if (mounted.current)
+            setMode({ kind: "browse" });
+    };
+    const preview = async (entry, status) => {
+        setError(undefined);
+        setMode({ kind: "busy" });
+        try {
+            const steps = await apps.preview(entry);
+            if (mounted.current) {
+                setMode({
+                    kind: "approve",
+                    entry,
+                    lines: [
+                        `File: ${entry.file}`,
+                        `Platform: ${entry.recipe?.platform ?? "all"}`,
+                        `Status: ${status}`,
+                        ...steps.flatMap(step => [step.step, ...appStepLines(step)]),
+                    ],
+                });
+            }
+        }
+        catch (error) {
+            if (mounted.current) {
+                setError(errorText(error));
+                setMode({ kind: "browse" });
+            }
+        }
+    };
+    const flow = {
+        operations,
+        env: environment ?? {},
+        isMounted: () => mounted.current,
+        setAction: action => setMode(action.kind === "browse"
+            ? { kind: "browse" }
+            : { kind: "install", action }),
+        setMessage: message => {
+            if (mounted.current)
+                setError(message?.text);
+        },
+        keepMarked: () => undefined,
+        finish: async (result) => {
+            if (mounted.current) {
+                setError(result.kind === "error" ? result.text : undefined);
+                setMode({ kind: result.kind === "ok" ? "prompt" : "browse" });
+            }
+        },
+    };
+    const startAI = async () => {
+        setMode({ kind: "busy" });
+        try {
+            if (!operations.discoverSkills)
+                throw new Error("Discovery is not supported by the configured operations");
+            const [skills, installed] = await Promise.all([
+                operations.discoverSkills([BUILT_IN_SOURCE.id]),
+                loadInstalledSkills(operations, environment ?? {}),
+            ]);
+            const skill = skills.find(skill => skill.name === "agent-depot-apprecipe");
+            if (!skill)
+                throw new Error("Built-in agent-depot-apprecipe Skill is unavailable");
+            if (!mounted.current)
+                return;
+            if (isInstalled(skill, installed) || hasUnmanagedCopy(skill, installed)) {
+                setMode({ kind: "prompt" });
+            }
+            else {
+                flow.setAction({ kind: "host", skills: [skill], cursor: 0, selected: [] });
+            }
+        }
+        catch (error) {
+            if (mounted.current) {
+                setError(errorText(error));
+                setMode({ kind: "browse" });
+            }
+        }
+    };
+    /** Handles captured modes and browse keys only in the focused section. */
+    const handleKey = (input, key) => {
+        const current = modeRef.current;
+        if (current.kind === "busy")
+            return true;
+        if (current.kind === "install") {
+            // Host/scope/version are selection prompts; version chooses latest or fixed
+            // by number. Only the separate fixed mode accepts free-text version input.
+            // n declines these selections; fixed input and in-flight installs are untouched.
+            const decline = input === "n" && ["host", "scope", "version"].includes(current.action.kind);
+            handleCatalogActionKey(flow, current.action, input, decline ? { ...key, escape: true } : key);
+            return true;
+        }
+        if (current.kind === "guide" || current.kind === "manual" || current.kind === "prompt") {
+            if (key.escape || input === "n")
+                setMode({ kind: "browse" });
+            else if (current.kind === "guide" && input === "1")
+                void startAI();
+            else if (current.kind === "guide" && input === "2")
+                setMode({ kind: "manual" });
+            return true;
+        }
+        if (current.kind === "approve") {
+            answerYesNo(input, key, () => {
+                setMode({ kind: "busy" });
+                void apps.approve(current.entry).then(finish, error => {
+                    if (mounted.current) {
+                        setError(errorText(error));
+                        setMode({ kind: "browse" });
+                    }
+                });
+            }, () => setMode({ kind: "browse" }));
+            return true;
+        }
+        if (key.tab) {
+            setError(undefined);
+            focusRef.current = !focusRef.current;
+            setFocused(focusRef.current);
+            return true;
+        }
+        if (!focusRef.current)
+            return false;
+        if (key.downArrow || input === "j" || key.upArrow || input === "k" || key.pageDown || key.pageUp) {
+            const step = key.pageDown || key.pageUp ? pageStep(recipeHeight) : 1;
+            const down = key.downArrow || input === "j" || key.pageDown;
+            indexRef.current = Math.min(Math.max(indexRef.current + (down ? step : -step), 0), Math.max(rows.length - 1, 0));
+            setIndex(indexRef.current);
+        }
+        else if (input === "n") {
+            setError(undefined);
+            setMode({ kind: "guide" });
+        }
+        else if (input === "r") {
+            void reload();
+        }
+        else if (key.return) {
+            const row = rows[Math.min(indexRef.current, rows.length - 1)];
+            if (row)
+                void preview(row.entry, row.status);
+        }
+        return true;
+    };
+    /** Reloads parsing and approval receipts, never version/latest commands. */
+    const reload = useCallback(async () => {
+        try {
+            const entries = await apps.load();
+            const rows = await Promise.all(entries.map(async (entry) => {
+                const inspection = await apps.approvalStatus(entry);
+                const status = inspection.status === "invalid"
+                    ? `invalid recipe: ${inspection.reason}`
+                    : inspection.status;
+                return { entry, status };
+            }));
+            if (mounted.current) {
+                setRows(rows);
+                setLoadError(undefined);
+            }
+        }
+        catch (error) {
+            if (mounted.current)
+                setLoadError(errorText(error));
+        }
+    }, [apps, mounted]);
+    useEffect(() => { void reload(); }, [reload]);
+    // Give each nonempty section half the rows, then reclaim unused Git capacity.
+    const budget = Math.max(height, gitCount > 0 && rows.length > 0 ? 2 : 1);
+    const gitShare = Math.min(gitCount, Math.max(1, Math.floor(budget / 2)));
+    const recipeHeight = Math.min(rows.length, budget - gitShare);
+    const gitHeight = Math.max(1, budget - recipeHeight);
+    const at = Math.min(index, rows.length - 1);
+    const window = computeWindow(rows.length, at, recipeHeight);
+    const panel = (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { ...rowStyle(focused && rows.length === 0), children: ["App recipes \u00B7 ", apps.directory, " \u00B7 Tab switches section"] }), focused ? _jsx(Text, { color: theme.muted, children: "j/k move \u00B7 Enter preview \u00B7 n add recipe \u00B7 r reload" }) : null, loadError ? _jsxs(Text, { color: theme.error, children: ["Error loading App recipes: ", loadError] }) : null, error ? _jsx(Text, { color: theme.error, children: error }) : null, rows.slice(window.start, window.end).map(({ entry, status }, offset) => {
+                const selected = focused && window.start + offset === at;
+                return (_jsxs(Text, { ...rowStyle(selected), children: [selected ? "> " : "  ", entry.file.split(/[\\/]/u).pop(), " \u00B7 ", status] }, entry.file));
+            }), window.indicator ? _jsx(Text, { color: theme.muted, children: window.indicator }) : null, mode.kind === "guide" ? (_jsxs(Text, { children: ["1 With the AI skill · install if missing, then copy the prompt\n", "2 Manual · write a recipe using the schema\nn or Esc closes"] })) : null, mode.kind === "manual" ? (_jsxs(Text, { children: ["Write a JSON recipe in ", apps.directory, "\n", "Schema: agent-depot app schema \u00B7 n or Esc closes"] })) : null, mode.kind === "prompt" ? (_jsxs(Text, { children: ["Use the agent-depot-apprecipe skill to create the recipe for <app>", "\n", "Recipes: ", apps.directory, " \u00B7 n or Esc closes"] })) : null, mode.kind === "install" ? _jsx(ActionPanel, { mode: mode.action }) : null, mode.kind === "busy" ? _jsx(Text, { children: "Working..." }) : null, mode.kind === "approve" ? (_jsx(PreviewConfirm, { lines: mode.lines, question: `Approve ${appName(mode.entry)}? y/n` })) : null] }));
+    return { focused, handleKey, gitHeight, panel };
+}

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

@@ -5,6 +5,7 @@ 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";
+import { useSourcesRecipes } from "./sources-recipes.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);
@@ -28,8 +29,8 @@ async function refreshEach(operations, targets) {
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function SourcesView({ operations, onCapturingChange, onOpenCatalog, listHeight }) {
-    const height = useListHeight(listHeight, 7);
+export function SourcesView({ operations, onCapturingChange, onOpenCatalog, listHeight, environment }) {
+    const height = useListHeight(listHeight, 9);
     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.
@@ -95,6 +96,9 @@ export function SourcesView({ operations, onCapturingChange, onOpenCatalog, list
     const sourcesRef = useRef(sources);
     sourcesRef.current = sources;
     const selected = resolveIndex(sources, selection);
+    const recipes = useSourcesRecipes({
+        operations, environment, onCapturingChange, height, gitCount: sources.length,
+    });
     const select = (index) => {
         const listed = sourcesRef.current;
         const bounded = Math.min(Math.max(index, 0), Math.max(listed.length - 1, 0));
@@ -201,6 +205,11 @@ export function SourcesView({ operations, onCapturingChange, onOpenCatalog, list
                 dispatch({ type: "done" });
             return;
         }
+        if (recipes.handleKey(input, key)) {
+            if (key.tab)
+                setMessage(undefined);
+            return;
+        }
         const listed = sourcesRef.current;
         const at = resolveIndex(listed, selectionRef.current);
         const highlighted = listed[at];
@@ -211,10 +220,10 @@ export function SourcesView({ operations, onCapturingChange, onOpenCatalog, list
             select(at - 1);
         }
         else if (key.pageDown) {
-            select(at + pageStep(height));
+            select(at + pageStep(recipes.gitHeight));
         }
         else if (key.pageUp) {
-            select(at - pageStep(height));
+            select(at - pageStep(recipes.gitHeight));
         }
         else if (key.return && highlighted) {
             onOpenCatalog?.(highlighted);
@@ -255,11 +264,11 @@ export function SourcesView({ operations, onCapturingChange, onOpenCatalog, list
         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);
+    const window = computeWindow(sources.length, selected, recipes.gitHeight);
     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] }));
+                return (_jsxs(Text, { ...rowStyle(!recipes.focused && index === selected), children: [!recipes.focused && 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, recipes.panel, _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")

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":