@iseoane/agent-depot 0.4.1 → 0.5.1

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

@@ -0,0 +1,165 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describeCoordinates } from "../package-model.js";
+import { errorText } from "./batch.js";
+import { answerYesNo } from "./mode-keys.js";
+import { installedEvidenceLabel, packagePlanLines } from "./package-rows.js";
+import { PreviewConfirm } from "./panel-parts.js";
+/** The per-row keys of a Package; Enter is approval, handled beside these. */
+export const PACKAGE_ACTION_KEYS = new Map([
+    ["i", "install"],
+    ["U", "update"],
+    ["u", "uninstall"],
+    ["f", "forget"],
+]);
+export const PACKAGE_KINDS = ["package-approve", "package-confirm", "package-forget"];
+/** Narrows the view's mode without asserting a partial mode is a Package mode. */
+export function isPackageMode(mode) {
+    return PACKAGE_KINDS.some(kind => kind === mode.kind);
+}
+/** `install`, `update`, `uninstall` and `forget` plan a step; `approve` writes the install receipt. */
+export async function startPackageAction(context, target, input) {
+    const { manage, packages } = context;
+    manage.setMessage(undefined);
+    try {
+        if (input === "approve") {
+            manage.setMode({ kind: "busy", label: `Preparing the declaration of ${target.name}...` });
+            const plan = await packages.planLifecycle(target.selection, "install");
+            if (manage.isMounted()) {
+                manage.setMode({ kind: "package-approve", target, lines: packagePlanLines(plan, "needs approval") });
+            }
+            return;
+        }
+        const action = PACKAGE_ACTION_KEYS.get(input);
+        if (action === "forget") {
+            manage.setMode({ kind: "busy", label: `Preparing to forget ${target.name}...` });
+            const inspection = await packages.inspect(target.selection);
+            if (manage.isMounted()) {
+                manage.setMode({
+                    kind: "package-forget",
+                    target,
+                    lines: [
+                        `Package: ${target.name} (${target.selection.host})`,
+                        `Coordinates: ${describeCoordinates(target.selection)}`,
+                        `Installed: ${installedEvidenceLabel(inspection.installed)}`,
+                        "Forgetting drops the Agent Depot selection record only; the host install is left as it is and no host command runs.",
+                    ],
+                });
+            }
+            return;
+        }
+        if (action !== undefined) {
+            manage.setMode({ kind: "busy", label: `Preparing the ${action} of ${target.name}...` });
+            const plan = await packages.planLifecycle(target.selection, action);
+            const approval = await packages.approvalStatus(target.selection, action);
+            if (manage.isMounted())
+                manage.setMode({ kind: "package-confirm", plan, approval });
+            return;
+        }
+        await manage.finish({ kind: "error", text: `The action ${JSON.stringify(input)} is not available for Packages` });
+    }
+    catch (error) {
+        await manage.finish({ kind: "error", text: errorText(error) });
+    }
+}
+/** The `y` of a lifecycle confirmation whose receipt is missing approves it first, then asks again. */
+async function approveThenConfirm(context, mode) {
+    const { manage, packages } = context;
+    manage.setMode({ kind: "busy", label: `Approving the ${mode.plan.action} declaration of ${mode.plan.descriptor.name}...` });
+    try {
+        await packages.approve(mode.plan.selection, mode.plan.action);
+        if (manage.isMounted())
+            manage.setMode({ ...mode, approval: "approved" });
+    }
+    catch (error) {
+        if (manage.isMounted())
+            await manage.finish({ kind: "error", text: errorText(error) });
+    }
+}
+function resultLine(plan, result) {
+    const name = plan.descriptor.name;
+    switch (result.status) {
+        case "installed":
+            return { ok: true, text: `${name}: installed (${installedEvidenceLabel(result.verified)})` };
+        case "updated":
+            return { ok: true, text: `${name}: updated (${installedEvidenceLabel(result.previous)} -> ${installedEvidenceLabel(result.verified)})` };
+        case "removed":
+            return { ok: true, text: `${name}: removed` };
+        case "selected":
+            return { ok: true, text: `${name}: selected` };
+        case "forgotten":
+            return { ok: true, text: `${name}: forgotten` };
+        case "not confirmed":
+            return { ok: true, text: `${name}: not changed` };
+        case "stale plan":
+            return { ok: false, text: `${name}: ${plan.action} not run: ${result.reason}` };
+        case "manual required":
+            return { ok: false, text: `${name}: ${plan.action} needs a manual step: ${result.reason}` };
+        case "failed":
+            return { ok: false, text: `${name}: failed: ${result.reason}${result.output === undefined ? "" : ` (${result.output})`}` };
+    }
+}
+async function executePackagePlan(context, plan) {
+    const { manage, packages } = context;
+    manage.setMode({ kind: "busy", label: `Running the ${plan.action} of ${plan.descriptor.name}...` });
+    let result;
+    try {
+        result = await packages.executeLifecycle(plan, true);
+    }
+    catch (error) {
+        await manage.finish({ kind: "error", text: errorText(error) });
+        return;
+    }
+    const line = resultLine(plan, result);
+    await manage.finish({ kind: line.ok ? "ok" : "error", text: line.text });
+}
+async function forgetSelection(context, mode) {
+    const { manage, packages } = context;
+    manage.setMode({ kind: "busy", label: `Forgetting ${mode.target.name}...` });
+    try {
+        await packages.forget(mode.target.selection, true);
+        await manage.finish({ kind: "ok", text: `Forgot ${mode.target.name}; no host command ran` });
+    }
+    catch (error) {
+        await manage.finish({ kind: "error", text: errorText(error) });
+    }
+}
+/** Applies the y/n keys of every Package confirmation; `n` and Esc run nothing. */
+export function handlePackageKey(context, mode, input, key) {
+    const { manage, packages } = context;
+    const cancel = (text) => {
+        manage.setMessage({ kind: "ok", text });
+        manage.browse();
+    };
+    switch (mode.kind) {
+        case "package-approve":
+            answerYesNo(input, key, () => {
+                manage.setMode({ kind: "busy", label: `Approving the install declaration of ${mode.target.name}...` });
+                void packages.approve(mode.target.selection, "install").then(() => manage.finish({ kind: "ok", text: `Approved the install declaration of ${mode.target.name}` }), error => manage.finish({ kind: "error", text: errorText(error) }));
+            }, () => cancel("Package action cancelled"));
+            return;
+        case "package-forget":
+            answerYesNo(input, key, () => void forgetSelection(context, mode), () => cancel("Package action cancelled"));
+            return;
+        case "package-confirm":
+            answerYesNo(input, key, () => {
+                if (mode.approval === "needs approval")
+                    void approveThenConfirm(context, mode);
+                else
+                    void executePackagePlan(context, mode.plan);
+            }, () => cancel("Package action cancelled"));
+            return;
+    }
+}
+/** Renders a Package prompt with the existing preview panel and y/n confirmation. */
+export function PackagePanel({ mode }) {
+    switch (mode.kind) {
+        case "package-approve":
+            return _jsx(PreviewConfirm, { lines: mode.lines, question: `Approve this install declaration for ${mode.target.name}? y/n` });
+        case "package-forget":
+            return _jsx(PreviewConfirm, { lines: mode.lines, question: `Forget the selection record of ${mode.target.name}? y/n` });
+        case "package-confirm":
+            return (_jsx(PreviewConfirm, { lines: packagePlanLines(mode.plan, mode.approval), question: mode.approval === "needs approval"
+                    ? "Approve this declaration and continue? y/n"
+                    : `${mode.plan.action} ${mode.plan.descriptor.name}? y/n` }));
+    }
+}

package/dist/src/tui/package-rows.js

@@ -0,0 +1,91 @@
+import { classifyUpdate } from "../package-host-plans.js";
+import { describeCoordinates, } from "../package-model.js";
+/** Version evidence as a short label; `unknown` when the host or the bundle states none. */
+export function packageVersionLabel(evidence) {
+    if (evidence === undefined)
+        return "unknown";
+    return evidence.kind === "manifest-version" ? evidence.version : evidence.commit.slice(0, 7);
+}
+/** What the host reports about an install, as one phrase. Never a guess. */
+export function installedEvidenceLabel(evidence) {
+    switch (evidence.kind) {
+        case "installed": {
+            if (evidence.reason !== undefined) {
+                const reason = evidence.reason.includes("local modifications") ? "local changes" : evidence.reason;
+                return `installed (version unavailable: ${reason})`;
+            }
+            if (evidence.version !== undefined)
+                return `installed ${evidence.version}`;
+            if (evidence.commit !== undefined)
+                return `installed at ${evidence.commit.slice(0, 7)}`;
+            return "installed with no version evidence";
+        }
+        case "absent": {
+            return "not installed";
+        }
+        case "unknown": {
+            return `unknown (${evidence.reason})`;
+        }
+    }
+}
+/** The shared update vocabulary; the Updates list prints `up to date`, not `current`. */
+export function packageStatusLabel(status) {
+    if (status === "current")
+        return "up to date";
+    if (status === "unknown")
+        return "cannot assess";
+    return status;
+}
+/** What a selection record itself remembers, for lists that do not read host evidence. */
+export function recordedVersionLabel(record) {
+    if (record.verified !== undefined)
+        return packageVersionLabel(record.verified);
+    if (record.lastDelegatedCommit !== undefined)
+        return record.lastDelegatedCommit.slice(0, 7);
+    return "unknown";
+}
+export function packageRow(record, inspection) {
+    return {
+        selection: record.selection,
+        name: inspection.descriptor?.name ?? describeCoordinates(record.selection),
+        installed: installedEvidenceLabel(inspection.installed),
+        available: packageVersionLabel(inspection.available),
+        status: classifyUpdate(inspection.installed, inspection.available, inspection.availableCommit, inspection.installedCommitIsAncestor),
+        ...(inspection.drift === undefined ? {} : { drift: inspection.drift }),
+    };
+}
+/** Host, evidence and status of one row, as the Installations line prints it. */
+export function describePackageRow(row) {
+    const drift = row.drift === undefined ? "" : `  drift: ${row.drift}`;
+    return `${row.selection.host}  ${row.installed}  available ${row.available}  ${packageStatusLabel(row.status)}${drift}`;
+}
+/** One component of the inventory; the executable effect and a host-only owner are called out. */
+export function describePackageComponent(component) {
+    const risk = component.effect === "executable" ? "  runs a host process" : "";
+    const ownership = component.ownership === "host-only" ? "  host-only: Agent Depot never manages it" : "";
+    const paths = component.paths.length === 0 ? "" : `  ${component.paths.join(", ")}`;
+    return `${component.kind}  ${component.ownership}  ${component.effect}${risk}${ownership}${paths}`;
+}
+/** The preview lines of one frozen plan: origin, inventory, argv, blast radius and approval state. */
+export function packagePlanLines(plan, approval) {
+    const { descriptor, selection } = plan;
+    return [
+        `Environment: ${plan.environment}`,
+        `Package: ${descriptor.name} (${selection.host}) ${plan.action}`,
+        `Coordinates: ${describeCoordinates(selection)}`,
+        `Origin: manifest ${plan.origin.manifestDigest.slice(0, 12)}${plan.origin.resolvedCommit === undefined ? "" : `  commit ${plan.origin.resolvedCommit.slice(0, 7)}`}`,
+        `Available: ${packageVersionLabel(descriptor.version)}`,
+        `Components (${descriptor.components.length}):`,
+        ...descriptor.components.map((component) => `  ${describePackageComponent(component)}`),
+        ...(plan.commands.length === 0
+            ? ["This action runs no host command."]
+            : plan.commands.flatMap((command, position) => [
+                `Step ${position + 1} (${command.purpose}): ${JSON.stringify([command.executable, ...command.args])}`,
+                `Executable: ${command.resolvedPath ?? command.executable}`,
+            ])),
+        `Blast radius: ${plan.affects.map(describeCoordinates).join(", ")}`,
+        `Working directory: ${plan.cwd}`,
+        `Approval: ${approval === "approved" ? "approved" : "needs approval"}`,
+        ...plan.warnings.map((warning) => `Warning: ${warning}`),
+    ];
+}

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

@@ -3,9 +3,10 @@ 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 { buildProfileExport, describeProfilePackage, profileExportPreview, writeProfileExport, } from "../profile-export.js";
 import { applyProfileImport, buildProfileImport, } from "../profile-import.js";
 import { PROFILE_FORMAT } from "../profile.js";
+import { packageOperationsOf } from "./environment.js";
 import { useKeys } from "./keys.js";
 import { answerYesNo, moveCursor, toggleChoice } from "./mode-keys.js";
 import { ChecklistLines, PreviewConfirm, PreviewLines } from "./panel-parts.js";
@@ -21,6 +22,9 @@ function rowsFromExport(plan) {
         ...plan.profile.apps.map((value, index) => ({
             block: "apps", index, label: `Apps: ${value.name} (${value.platform ?? "all platforms"})`, selectable: true,
         })),
+        ...plan.profile.packages.map((value, index) => ({
+            block: "packages", index, label: `Packages: ${describeProfilePackage(value)}`, selectable: true,
+        })),
         ...plan.exclusions.map((item, index) => ({
             block: "excluded", index, label: `Excluded ${item.label}: ${item.reason}`, selectable: false,
         })),
@@ -29,21 +33,35 @@ function rowsFromExport(plan) {
         })),
     ];
 }
+/** The four import blocks in one indexed list, so the checklist and the confirmation share positions. */
+function planEntries(plan) {
+    return [...plan.items, ...plan.packages];
+}
 function rowsFromPlan(plan) {
-    return plan.items.map((item, index) => ({
+    return planEntries(plan).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));
+function selectedPlanEntries(plan, selected) {
+    return planEntries(plan).filter((item, index) => item.status !== "add" || selected.some(row => row.index === index));
+}
+/** A plan whose items are the chosen subset, split back into the block the writer consumes. */
+function chosenPlan(plan, selected) {
+    const entries = selectedPlanEntries(plan, selected);
+    return {
+        ...plan,
+        items: entries.filter((item) => item.block !== "packages"),
+        packages: entries.filter((item) => item.block === "packages"),
+    };
 }
 /** 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 packages = useMemo(() => packageOperationsOf(environment), [environment]);
     const [mode, setModeState] = useState("browse");
     const modeRef = useRef("browse");
     const mounted = useRef(true);
@@ -113,6 +131,7 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
             sources: profile.sources.filter((_, index) => isChosen("sources", index)),
             skills: profile.skills.filter((_, index) => isChosen("skills", index)),
             apps: profile.apps.filter((_, index) => isChosen("apps", index)),
+            packages: profile.packages.filter((_, index) => isChosen("packages", index)),
         };
     };
     useKeys((input, key) => {
@@ -123,7 +142,9 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
             if (input === "e") {
                 action.current = "export";
                 void run(async () => {
-                    const exported = await buildProfileExport(operations, apps, { homeDirectory: environment.homeDirectory });
+                    const exported = await buildProfileExport(operations, apps, {
+                        homeDirectory: environment.homeDirectory, packageOperations: packages,
+                    });
                     if (!mounted.current)
                         return;
                     setProfile(exported.profile);
@@ -156,7 +177,7 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
                 else
                     void run(async () => {
                         const raw = JSON.parse(await readFile(typed.current, "utf8"));
-                        const imported = await buildProfileImport(raw, operations, apps);
+                        const imported = await buildProfileImport(raw, operations, apps, {}, packages);
                         profileVersion.current = raw.agentDepotVersion;
                         if (!mounted.current)
                             return;
@@ -183,8 +204,8 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
                         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 });
+                        const confirmed = chosenPlan(plan, selectedRef.current);
+                        const outcomes = await applyProfileImport(confirmed, operations, apps, true, () => undefined, { homeDirectory: environment.homeDirectory, packageOperations: packages, ...environment.installationOptions });
                         result = outcomes.map(outcome => `${outcome.status}: ${outcome.item.label}${outcome.detail ? `; ${outcome.detail}` : ""}`);
                     }
                     if (mounted.current) {
@@ -225,13 +246,14 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
             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 entries = selectedPlanEntries(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);
+                        sources: entries.filter(item => item.block === "sources").map(item => item.value),
+                        skills: entries.filter(item => item.block === "skills").map(item => item.value),
+                        apps: entries.filter(item => item.block === "apps").map(item => item.value),
+                        packages: entries.filter(item => item.block === "packages").map(item => item.value),
+                    }, operations, apps, {}, packages);
                     if (mounted.current)
                         showLines(preview.preview, "confirm");
                 });
@@ -239,7 +261,7 @@ export function ProfileView({ operations, environment = {}, onCapturingChange, l
     });
     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 => {
+    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", "packages", "excluded"].map(block => {
                 const choices = rows.slice(window.start, window.end).filter(row => row.block === block);
                 if (!choices.length)
                     return null;

package/dist/src/tui/render.js

@@ -3,6 +3,6 @@ import { render } from "ink";
 import { App } from "./app.js";
 /** Renders the TUI and resolves once the user exits it. */
 export async function renderTui(operations, environment) {
-    const instance = render(_jsx(App, { operations: operations, environment: environment }));
+    const instance = render(_jsx(App, { operations: operations, environment: environment }), { alternateScreen: true });
     await instance.waitUntilExit();
 }

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

@@ -1,6 +1,8 @@
 export const initialMode = { kind: "browse" };
 export function modeReducer(mode, event) {
     switch (event.type) {
+        case "add-kind":
+            return { kind: "add-kind" };
         case "input":
             return { kind: "input", value: "" };
         case "edit":