aui-agent-builder 0.3.67 → 0.3.69

package/dist/commands/agents.js

@@ -3,7 +3,7 @@ import { render, Box, Text } from "ink";
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { getAuthenticatedSession, listAgents as listAgentsSvc, listVersions as listVersionsSvc, switchToAgent, } from "../services/agents.service.js";
-import { AgentsMenuView, AgentsListView, AgentSwitchView, VersionsListView, } from "../ui/views/AgentsView.js";
+import { AgentsMenuView, AgentsListView, AgentSwitchView, VersionsListView, AgentDeletePreviewView, AgentDeleteResultView, } from "../ui/views/AgentsView.js";
 import { Spinner, ErrorDisplay, StatusLine } from "../ui/components/index.js";
 import { AUIClient } from "../api-client/index.js";
 import { isJsonMode, outputJson, stderrLog } from "../utils/json-output.js";
@@ -12,6 +12,73 @@ function renderView(element) {
     const instance = render(element);
     instance.unmount();
 }
+/**
+ * Best-effort follow-up DELETE on the legacy network record after the
+ * agent-settings DELETE succeeds.
+ *
+ * Agent creation is a 3-step process (network → settings → agent-management).
+ * The agent-settings DELETE is the primary record removal; this safety-net
+ * also removes the network shell so the agent disappears from the legacy
+ * `networks.list` immediately. If it fails (e.g. already cascaded) we
+ * surface a warning but never let it fail the overall operation.
+ */
+async function deleteNetworkBestEffort(client, networkId) {
+    try {
+        const resp = await client.networks.delete(networkId);
+        if (resp && resp.status === false) {
+            return {
+                deleted: false,
+                errorMessage: resp.message || "backend returned status=false",
+            };
+        }
+        return { deleted: true };
+    }
+    catch (err) {
+        return { deleted: false, errorMessage: formatApiErrorBody(err) };
+    }
+}
+/**
+ * Build a human-readable summary from an API error.
+ *
+ * Surfaces FastAPI-style validation errors so the user sees
+ * "Field required: query.deleted_by" instead of the generic
+ * "API request failed (422 Unprocessable Entity)".
+ */
+function formatApiErrorBody(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const e = error;
+    const status = e.status;
+    const body = e.body;
+    if (body && typeof body === "object") {
+        const detail = body.detail;
+        if (Array.isArray(detail) && detail.length > 0) {
+            const items = detail.slice(0, 3).map((d) => {
+                if (!d || typeof d !== "object")
+                    return String(d);
+                const dd = d;
+                const where = Array.isArray(dd.loc) ? dd.loc.filter(Boolean).join(".") : "";
+                const msg = dd.msg ?? dd.type ?? "invalid";
+                return where ? `${msg} (${where})` : String(msg);
+            });
+            const more = detail.length > items.length ? ` (+${detail.length - items.length} more)` : "";
+            return `${status ?? "?"} — ${items.join("; ")}${more}`;
+        }
+        if (typeof detail === "string")
+            return `${status ?? "?"} — ${detail}`;
+        const msg = body.msg ??
+            body.message ??
+            body.error;
+        if (typeof msg === "string")
+            return `${status ?? "?"} — ${msg}`;
+    }
+    if (typeof body === "string" && body.length > 0) {
+        return `${status ?? "?"} — ${body.slice(0, 300)}`;
+    }
+    if (e.message)
+        return e.message;
+    return String(error);
+}
 export async function agents(options = {}) {
     const session = await getAuthenticatedSession();
     if (options.list) {
@@ -35,6 +102,10 @@ export async function agents(options = {}) {
         await handleCreateAgent(options);
         return;
     }
+    if (options.delete) {
+        await handleDeleteAgent(options);
+        return;
+    }
     if (options.import) {
         const { importAgent } = await import("./import-agent.js");
         await importAgent();
@@ -61,6 +132,11 @@ export async function agents(options = {}) {
                     { name: "Import from another account", value: "import-other-account" },
                     { name: "Import from another organization", value: "import-other-org" },
                     new inquirer.Separator(),
+                    {
+                        name: chalk.red("Delete agent or version") + chalk.gray("  (irreversible)"),
+                        value: "delete",
+                    },
+                    new inquirer.Separator(),
                     { name: "Back", value: "back" },
                 ],
             },
@@ -79,6 +155,9 @@ export async function agents(options = {}) {
         else if (action === "create") {
             await handleCreateAgent({});
         }
+        else if (action === "delete") {
+            await handleDeleteAgent({});
+        }
         else if (action === "import") {
             const { importAgent } = await import("./import-agent.js");
             await importAgent();
@@ -289,6 +368,710 @@ export async function agents(options = {}) {
             renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to switch agent." }));
         }
     }
+    async function handleDeleteAgent(opts = {}) {
+        const config = getConfig();
+        const client = new AUIClient({
+            baseUrl: config.apiUrl,
+            authToken: config.authToken,
+            accountId: config.accountId,
+            organizationId: config.organizationId,
+            environment: config.environment,
+        });
+        const apiKey = loadAgentSettingsApiKey();
+        if (apiKey)
+            client.setAgentSettingsApiKey(apiKey);
+        // ─── Non-interactive: --network-id given → delete entire agent ───
+        // (also covers --network-id + --all-versions explicitly)
+        if (opts.networkId && !opts.version) {
+            await runDeleteEntireAgent(client, {
+                networkId: opts.networkId,
+                skipConfirm: !!opts.yes,
+            });
+            return;
+        }
+        // ─── Non-interactive: --version given → delete specific version ───
+        if (opts.version) {
+            const agentMgmtId = opts.agentId || opts.use;
+            await runDeleteVersion(client, {
+                agentManagementId: agentMgmtId,
+                networkId: opts.networkId,
+                versionId: opts.version,
+                skipConfirm: !!opts.yes,
+            });
+            return;
+        }
+        // ─── Non-interactive: --agent-id + --all-versions → loop per-version DELETEs ───
+        // (kept distinct from --network-id which does a single full-agent DELETE)
+        if (opts.agentId && opts.allVersions) {
+            const agent = await client.agentManagement.getAgent(opts.agentId).catch(() => null);
+            if (!agent) {
+                renderView(_jsx(ErrorDisplay, { message: `Agent not found: ${opts.agentId}`, suggestion: "Run `aui agent --list` to see available agents." }));
+                return;
+            }
+            await runDeleteAllVersions(client, {
+                agentManagementId: agent.id,
+                networkId: agent.scope.network_id || undefined,
+                agentName: agent.name,
+                activeVersionId: agent.active_version_id,
+                skipConfirm: !!opts.yes,
+            });
+            return;
+        }
+        // ─── Interactive flow: org → account → agent → scope ───
+        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", bold: true, children: "⚠ " }), _jsx(Text, { bold: true, children: "Delete an agent or a specific version" })] }), _jsx(Box, { children: _jsx(Text, { color: "gray", children: "  This is permanent and cannot be undone." }) })] }));
+        // Step 1: Select organization
+        logView(_jsx(Text, { color: "gray", children: "  \u250C Step 1 \u2192 Select Organization" }));
+        const org = await pickOrganization(client);
+        if (!org)
+            return;
+        client.setScope({ organizationId: org.id });
+        logView(_jsx(StatusLine, { kind: "success", label: `Organization: ${org.name}` }));
+        // Step 2: Select account
+        logView(_jsx(Text, { color: "gray", children: "  \u251C Step 2 \u2192 Select Account" }));
+        const account = await pickAccount(client);
+        if (!account)
+            return;
+        client.setScope({ accountId: account.id });
+        logView(_jsx(StatusLine, { kind: "success", label: `Account: ${account.name}` }));
+        // Step 3: Select agent
+        logView(_jsx(Text, { color: "gray", children: "  \u251C Step 3 \u2192 Select Agent" }));
+        const picked = await pickAgentInAccount(client);
+        if (!picked)
+            return;
+        const { network } = picked;
+        const networkId = network._id || network.id;
+        const agentName = network.name;
+        logView(_jsx(StatusLine, { kind: "success", label: `Agent: ${agentName}` }));
+        // Step 4: Choose what to delete
+        logView(_jsx(Text, { color: "gray", children: "  \u2514 Step 4 \u2192 Choose what to delete" }));
+        const { scope } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "scope",
+                message: "What do you want to delete?",
+                choices: [
+                    {
+                        name: `${chalk.red("Delete entire agent")} ${chalk.gray("(single API call — removes ALL versions)")}`,
+                        value: "agent",
+                    },
+                    {
+                        name: `${chalk.yellow("Delete a specific version")} ${chalk.gray("(keeps the agent)")}`,
+                        value: "version",
+                    },
+                    {
+                        name: `${chalk.magenta("Delete all versions")} ${chalk.gray("(loops per-version DELETE — keeps the agent shell)")}`,
+                        value: "all-versions",
+                    },
+                    new inquirer.Separator(),
+                    { name: "Cancel", value: "cancel" },
+                ],
+            },
+        ]);
+        if (scope === "cancel") {
+            logView(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+            return;
+        }
+        if (scope === "agent") {
+            // Entire-agent delete only needs the network_id; the cascade + the
+            // safety-net network DELETE handle everything else. Skip the lookup.
+            await runDeleteEntireAgent(client, {
+                networkId,
+                agentName,
+                skipConfirm: false,
+            });
+            return;
+        }
+        // For version-related scopes we need the agent-management ID (and the
+        // active_version_id). Resolve it once via a targeted lookup by network_id.
+        const lookupSpinner = render(_jsx(Spinner, { label: "Resolving agent record..." }));
+        let agentManagementId;
+        let activeVersionId = null;
+        try {
+            const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: networkId });
+            const match = resp.items.find((a) => a.scope.network_id === networkId || a.id === networkId);
+            if (match) {
+                agentManagementId = match.id;
+                activeVersionId = match.active_version_id;
+            }
+        }
+        catch {
+            // best-effort; handled below
+        }
+        finally {
+            lookupSpinner.unmount();
+        }
+        if (!agentManagementId) {
+            renderView(_jsx(ErrorDisplay, { message: "This agent has no agent-management record, so per-version operations aren't available.", suggestion: "Use 'Delete entire agent' instead, or pass --agent-id explicitly." }));
+            return;
+        }
+        if (scope === "all-versions") {
+            await runDeleteAllVersions(client, {
+                agentManagementId,
+                networkId,
+                agentName,
+                activeVersionId,
+                skipConfirm: false,
+            });
+            return;
+        }
+        // scope === "version"
+        const versionsSpinner = render(_jsx(Spinner, { label: `Fetching versions for "${agentName}"...` }));
+        try {
+            const versions = await fetchAllVersionsForAgent(client, agentManagementId);
+            versionsSpinner.unmount();
+            if (versions.length === 0) {
+                renderView(_jsx(ErrorDisplay, { message: "No versions found for this agent.", suggestion: "Nothing to delete. Use the entire-agent option instead." }));
+                return;
+            }
+            const { selectedVersion } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedVersion",
+                    message: "Select version to delete:",
+                    choices: versions.map((v) => {
+                        const isActive = v.id === activeVersionId;
+                        const vLabel = `v${v.version_number}.${v.version_revision_number}`;
+                        const statusBadge = v.status === "published"
+                            ? chalk.green(v.status)
+                            : v.status === "archived"
+                                ? chalk.gray(v.status)
+                                : chalk.yellow(v.status);
+                        const activeBadge = isActive ? chalk.green(" ← live") : "";
+                        return {
+                            name: `${vLabel} [${statusBadge}]${activeBadge}`,
+                            value: v,
+                        };
+                    }),
+                    pageSize: 15,
+                },
+            ]);
+            await runDeleteVersion(client, {
+                agentManagementId,
+                networkId,
+                versionId: selectedVersion.id,
+                agentName,
+                versionLabel: `v${selectedVersion.version_number}.${selectedVersion.version_revision_number}`,
+                versionStatus: selectedVersion.status,
+                isActiveVersion: selectedVersion.id === activeVersionId,
+                skipConfirm: false,
+            });
+        }
+        catch (error) {
+            versionsSpinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch versions." }));
+        }
+    }
+    async function pickOrganization(client) {
+        const spinner = render(_jsx(Spinner, { label: "Fetching organizations..." }));
+        try {
+            // Fetch page 1 to learn totalPages, then fetch the rest in parallel.
+            const first = await client.organizations.listMy(1, 50);
+            const allOrgs = [...first.data.docs];
+            const totalPages = first.data.totalPages ?? 1;
+            if (totalPages > 1) {
+                const restPages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+                const rest = await Promise.all(restPages.map((p) => client.organizations.listMy(p, 50)));
+                for (const r of rest)
+                    allOrgs.push(...r.data.docs);
+            }
+            spinner.unmount();
+            if (allOrgs.length === 0) {
+                const fallbackId = session.organization_id || client.getOrganizationId();
+                if (!fallbackId) {
+                    renderView(_jsx(ErrorDisplay, { message: "No organizations available.", suggestion: "Run `aui login` to refresh your session." }));
+                    return null;
+                }
+                return { id: fallbackId, name: session.organization_name || fallbackId };
+            }
+            if (allOrgs.length === 1) {
+                const o = allOrgs[0];
+                return { id: o._id || o.id, name: o.name };
+            }
+            const currentOrgId = session.organization_id;
+            const { chosen } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "chosen",
+                    message: "Select organization:",
+                    choices: allOrgs.map((o) => {
+                        const isCurrent = o._id === currentOrgId || o.id === currentOrgId;
+                        const meta = chalk.gray(`(${o.niceName || o._id})`);
+                        const label = isCurrent
+                            ? `${o.name} ${meta} ${chalk.green("← current")}`
+                            : `${o.name} ${meta}`;
+                        return { name: label, value: o };
+                    }),
+                    pageSize: 15,
+                },
+            ]);
+            const o = chosen;
+            return { id: o._id || o.id, name: o.name };
+        }
+        catch (error) {
+            spinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch organizations." }));
+            return null;
+        }
+    }
+    async function pickAccount(client) {
+        const spinner = render(_jsx(Spinner, { label: "Fetching accounts..." }));
+        try {
+            // Fetch page 1 to learn totalPages, then fetch the rest in parallel.
+            const first = await client.accounts.list(1, 50);
+            const allAccounts = [...first.data.docs];
+            const totalPages = first.data.totalPages ?? 1;
+            if (totalPages > 1) {
+                const restPages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+                const rest = await Promise.all(restPages.map((p) => client.accounts.list(p, 50)));
+                for (const r of rest)
+                    allAccounts.push(...r.data.docs);
+            }
+            spinner.unmount();
+            if (allAccounts.length === 0) {
+                renderView(_jsx(ErrorDisplay, { message: "No accounts found in this organization.", suggestion: "Nothing to delete here." }));
+                return null;
+            }
+            if (allAccounts.length === 1) {
+                const a = allAccounts[0];
+                return { id: a._id || a.id, name: a.name };
+            }
+            const currentAccountId = session.account_id;
+            const { chosen } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "chosen",
+                    message: "Select account:",
+                    choices: allAccounts.map((a) => {
+                        const isCurrent = a._id === currentAccountId || a.id === currentAccountId;
+                        const meta = chalk.gray(`(${a.niceName})`);
+                        const label = isCurrent
+                            ? `${a.name} ${meta} ${chalk.green("← current")}`
+                            : `${a.name} ${meta}`;
+                        return { name: label, value: a };
+                    }),
+                    pageSize: 15,
+                },
+            ]);
+            const a = chosen;
+            return { id: a._id || a.id, name: a.name };
+        }
+        catch (error) {
+            spinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch accounts." }));
+            return null;
+        }
+    }
+    async function pickAgentInAccount(client) {
+        const spinner = render(_jsx(Spinner, { label: "Fetching agents..." }));
+        try {
+            // Use the legacy networks endpoint — it's already filtered server-side
+            // by org+account, which is what we want for an account-scoped picker.
+            // The agent-management lookup is deferred to AFTER selection (single
+            // targeted call by network_id) and only when the chosen scope needs it.
+            const netResp = await client.networks.list();
+            const networks = netResp.data;
+            spinner.unmount();
+            if (networks.length === 0) {
+                renderView(_jsx(ErrorDisplay, { message: "No agents found in this account.", suggestion: "Nothing to delete here." }));
+                return null;
+            }
+            const currentNetworkId = session.network_id;
+            const { chosen } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "chosen",
+                    message: "Select agent to delete from:",
+                    choices: networks.map((n) => {
+                        const id = n._id || n.id;
+                        const isCurrent = id === currentNetworkId;
+                        const label = isCurrent
+                            ? `${n.name} ${chalk.green("← current")}`
+                            : n.name;
+                        return { name: label, value: { network: n } };
+                    }),
+                    pageSize: 15,
+                },
+            ]);
+            return chosen;
+        }
+        catch (error) {
+            spinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch agents." }));
+            return null;
+        }
+    }
+    async function fetchAllVersionsForAgent(client, agentManagementId) {
+        const all = [];
+        let page = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const resp = await client.agentManagement.listVersions(agentManagementId, page, 50);
+            all.push(...resp.items);
+            hasMore = page < resp.pages;
+            page++;
+        }
+        return all;
+    }
+    async function runDeleteAllVersions(client, args) {
+        const { agentManagementId, networkId, agentName, activeVersionId } = args;
+        const fetchSpinner = render(_jsx(Spinner, { label: "Fetching versions..." }));
+        let versions;
+        try {
+            versions = await fetchAllVersionsForAgent(client, agentManagementId);
+            fetchSpinner.unmount();
+        }
+        catch (error) {
+            fetchSpinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch versions." }));
+            return;
+        }
+        if (versions.length === 0) {
+            renderView(_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(StatusLine, { kind: "muted", label: "No versions to delete." }) }));
+            return;
+        }
+        const activeCount = versions.filter((v) => v.id === activeVersionId).length;
+        const deletableCount = versions.length - activeCount;
+        if (isJsonMode()) {
+            if (!args.skipConfirm) {
+                outputJson({
+                    requires_confirmation: true,
+                    message: "Refusing to delete in JSON mode without --yes. Re-run with --yes to confirm.",
+                    agent: { name: agentName, agent_management_id: agentManagementId, network_id: networkId },
+                    versions_total: versions.length,
+                    versions_deletable: deletableCount,
+                    versions_active_blocked: activeCount,
+                });
+                return;
+            }
+            stderrLog(`Deleting ${versions.length} version(s) of "${agentName}" one-by-one...`);
+            const results = await loopDeleteVersions(client, agentManagementId, versions, activeVersionId);
+            const cleared = clearSessionIfMatchesAgentVersionsAfterAll(versions, results);
+            outputJson({
+                scope: "all-versions",
+                agent: { name: agentName, agent_management_id: agentManagementId, network_id: networkId },
+                attempted: versions.length,
+                deleted: results.filter((r) => r.success).length,
+                failed: results.filter((r) => !r.success).map((r) => ({
+                    version_id: r.version.id,
+                    version: `v${r.version.version_number}.${r.version.version_revision_number}`,
+                    error: r.errorMessage,
+                })),
+                session_cleared: cleared,
+            });
+            return;
+        }
+        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", bold: true, children: "⚠ " }), _jsxs(Text, { bold: true, children: ["You are about to delete every version of \"", agentName, "\""] })] }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["  ", versions.length, " version(s) total \u00B7 ", deletableCount, " deletable", activeCount > 0 ? ` · ${activeCount} active (will be blocked by backend)` : ""] }) }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["  ", "This keeps the agent shell. Use 'Delete entire agent' for a full wipe."] }) })] }));
+        if (!args.skipConfirm) {
+            const { typed } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "typed",
+                    message: `Type the agent name (${agentName}) to confirm:`,
+                    validate: (v) => v.trim() === agentName ? true : `Type exactly: ${agentName}`,
+                },
+            ]);
+            if (typed.trim() !== agentName) {
+                logView(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+                return;
+            }
+        }
+        const loopSpinner = render(_jsx(Spinner, { label: `Deleting ${versions.length} version(s)...` }));
+        let results;
+        try {
+            results = await loopDeleteVersions(client, agentManagementId, versions, activeVersionId);
+        }
+        finally {
+            loopSpinner.unmount();
+        }
+        const succeeded = results.filter((r) => r.success);
+        const failed = results.filter((r) => !r.success);
+        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(StatusLine, { kind: failed.length === 0 ? "success" : "warning", label: `Deleted ${succeeded.length}/${versions.length} version(s) of "${agentName}".` }), failed.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "gray", children: "  Failed:" }), failed.slice(0, 10).map((r) => (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "    " }), _jsxs(Text, { color: "red", children: ["v", r.version.version_number, ".", r.version.version_revision_number] }), _jsxs(Text, { color: "gray", children: [" — ", r.errorMessage] })] }, r.version.id))), failed.length > 10 && (_jsxs(Text, { color: "gray", children: ["    ", "... and ", failed.length - 10, " more"] }))] }))] }));
+        const cleared = clearSessionIfMatchesAgentVersionsAfterAll(versions, results);
+        if (cleared) {
+            logView(_jsx(StatusLine, { kind: "muted", label: "Session version pointer cleared." }));
+        }
+    }
+    async function loopDeleteVersions(client, agentManagementId, versions, activeVersionId) {
+        const results = [];
+        // Delete non-active versions first; the active one (if any) attempts last.
+        const ordered = [
+            ...versions.filter((v) => v.id !== activeVersionId),
+            ...versions.filter((v) => v.id === activeVersionId),
+        ];
+        for (const v of ordered) {
+            try {
+                await client.agentManagement.deleteVersion(agentManagementId, v.id, session.user_id);
+                results.push({ version: v, success: true });
+            }
+            catch (err) {
+                results.push({ version: v, success: false, errorMessage: formatApiErrorBody(err) });
+            }
+        }
+        return results;
+    }
+    function clearSessionIfMatchesAgentVersionsAfterAll(versions, results) {
+        const current = loadSession();
+        if (!current?.version_id)
+            return false;
+        const currentDeleted = results.find((r) => r.success && r.version.id === current.version_id);
+        if (!currentDeleted)
+            return false;
+        delete current.version_id;
+        delete current.version_number;
+        delete current.version_revision_number;
+        saveSession(current);
+        return true;
+    }
+    async function runDeleteEntireAgent(client, args) {
+        let { networkId, agentName, agentManagementId } = args;
+        // Resolve a friendly name + version count for the preview
+        let totalVersions;
+        try {
+            if (!agentManagementId) {
+                const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: networkId });
+                const match = resp.items.find((a) => a.scope.network_id === networkId || a.id === networkId);
+                if (match) {
+                    agentManagementId = match.id;
+                    if (!agentName)
+                        agentName = match.name;
+                }
+            }
+            if (agentManagementId) {
+                const versionsResp = await client.agentManagement.listVersions(agentManagementId, 1, 1);
+                totalVersions = versionsResp.total;
+            }
+        }
+        catch {
+            // best-effort enrichment
+        }
+        if (!agentName)
+            agentName = networkId;
+        if (isJsonMode()) {
+            if (!args.skipConfirm) {
+                outputJson({
+                    requires_confirmation: true,
+                    message: "Refusing to delete in JSON mode without --yes. Re-run with --yes to confirm.",
+                    agent: { name: agentName, network_id: networkId, agent_management_id: agentManagementId },
+                    total_versions: totalVersions,
+                });
+                return;
+            }
+            stderrLog(`Deleting agent "${agentName}" (network ${networkId})...`);
+            try {
+                const result = await client.agentManagement.deleteAgentByNetwork(networkId, session.user_id);
+                const networkResult = await deleteNetworkBestEffort(client, networkId);
+                const cleared = clearSessionIfMatchesAgent(networkId, agentManagementId);
+                outputJson({
+                    deleted: true,
+                    scope: "agent",
+                    agent: { name: agentName, network_id: networkId, agent_management_id: agentManagementId },
+                    versions_deleted: result.versions_deleted ?? totalVersions,
+                    network_deleted: networkResult.deleted,
+                    ...(networkResult.deleted ? {} : { network_delete_error: networkResult.errorMessage }),
+                    session_cleared: cleared,
+                });
+            }
+            catch (error) {
+                const code = error instanceof Error && "status" in error
+                    ? `HTTP_${error.status}`
+                    : "DELETE_AGENT_FAILED";
+                outputJson({
+                    deleted: false,
+                    error: {
+                        code,
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            return;
+        }
+        renderView(_jsx(AgentDeletePreviewView, { scope: "agent", agentName: agentName, agentId: agentManagementId || networkId, networkId: networkId, totalVersions: totalVersions }));
+        if (!args.skipConfirm) {
+            const { typed } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "typed",
+                    message: `Type the agent name (${agentName}) to confirm:`,
+                    validate: (v) => v.trim() === agentName
+                        ? true
+                        : `Type exactly: ${agentName}`,
+                },
+            ]);
+            if (typed.trim() !== agentName) {
+                logView(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+                return;
+            }
+        }
+        // Two-call deletion (safer):
+        //   1. agent-settings DELETE  → removes versions, settings, agent record
+        //   2. networks DELETE         → safety net so the agent disappears from
+        //                                 the legacy networks listing immediately
+        const deleteSpinner = render(_jsx(Spinner, { label: "Deleting agent..." }));
+        try {
+            await client.agentManagement.deleteAgentByNetwork(networkId, session.user_id);
+            deleteSpinner.unmount();
+            logView(_jsx(StatusLine, { kind: "success", label: "Agent-management record deleted (versions, settings)." }));
+            const networkSpinner = render(_jsx(Spinner, { label: "Removing network shell..." }));
+            const networkResult = await deleteNetworkBestEffort(client, networkId);
+            networkSpinner.unmount();
+            if (networkResult.deleted) {
+                logView(_jsx(StatusLine, { kind: "success", label: "Network record removed." }));
+            }
+            else {
+                logView(_jsx(StatusLine, { kind: "warning", label: `Network shell could not be removed automatically: ${networkResult.errorMessage}. The agent may still appear in some legacy listings.` }));
+            }
+            const cleared = clearSessionIfMatchesAgent(networkId, agentManagementId);
+            renderView(_jsx(AgentDeleteResultView, { scope: "agent", agentName: agentName, cleared: cleared }));
+        }
+        catch (error) {
+            deleteSpinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: `Failed to delete agent: ${formatApiErrorBody(error)}` }));
+        }
+    }
+    async function runDeleteVersion(client, args) {
+        let { agentManagementId, networkId, versionId, agentName, versionLabel, versionStatus, isActiveVersion, } = args;
+        // Resolve agent_id from session/network if not provided
+        if (!agentManagementId) {
+            const networkLookup = networkId || session.network_id;
+            if (!networkLookup) {
+                renderView(_jsx(ErrorDisplay, { message: "Could not resolve which agent the version belongs to.", suggestion: "Pass --agent-id <id> (or --network-id <id>), or switch to an agent first with: aui agent --switch" }));
+                return;
+            }
+            try {
+                const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: networkLookup });
+                const match = resp.items.find((a) => a.scope.network_id === networkLookup || a.id === networkLookup);
+                if (match) {
+                    agentManagementId = match.id;
+                    if (!agentName)
+                        agentName = match.name;
+                    if (!networkId)
+                        networkId = match.scope.network_id || undefined;
+                }
+            }
+            catch {
+                // ignore
+            }
+            if (!agentManagementId) {
+                renderView(_jsx(ErrorDisplay, { message: "Agent not found for the given identifiers.", suggestion: "Run `aui agent --list` to see available agents." }));
+                return;
+            }
+        }
+        // Enrich version info from backend if missing
+        if (!versionLabel || !versionStatus || isActiveVersion === undefined) {
+            try {
+                const v = await client.agentManagement.getVersion(agentManagementId, versionId);
+                if (!versionLabel)
+                    versionLabel = `v${v.version_number}.${v.version_revision_number}`;
+                if (!versionStatus)
+                    versionStatus = v.status;
+                const agent = await client.agentManagement.getAgent(agentManagementId).catch(() => null);
+                if (agent && isActiveVersion === undefined) {
+                    isActiveVersion = agent.active_version_id === versionId;
+                }
+                if (agent && !agentName)
+                    agentName = agent.name;
+            }
+            catch {
+                // best-effort enrichment
+            }
+        }
+        if (!agentName)
+            agentName = agentManagementId;
+        if (isJsonMode()) {
+            if (!args.skipConfirm) {
+                outputJson({
+                    requires_confirmation: true,
+                    message: "Refusing to delete in JSON mode without --yes. Re-run with --yes to confirm.",
+                    agent: { name: agentName, agent_management_id: agentManagementId },
+                    version: { id: versionId, label: versionLabel, status: versionStatus, is_active: isActiveVersion },
+                });
+                return;
+            }
+            stderrLog(`Deleting version ${versionLabel ?? versionId} of "${agentName}"...`);
+            try {
+                await client.agentManagement.deleteVersion(agentManagementId, versionId, session.user_id);
+                const cleared = clearSessionIfMatchesVersion(versionId);
+                outputJson({
+                    deleted: true,
+                    scope: "version",
+                    agent: { name: agentName, agent_management_id: agentManagementId },
+                    version: { id: versionId, label: versionLabel },
+                    session_cleared: cleared,
+                });
+            }
+            catch (error) {
+                const code = error instanceof Error && "status" in error
+                    ? `HTTP_${error.status}`
+                    : "DELETE_VERSION_FAILED";
+                outputJson({
+                    deleted: false,
+                    error: {
+                        code,
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            return;
+        }
+        renderView(_jsx(AgentDeletePreviewView, { scope: "version", agentName: agentName, agentId: agentManagementId, networkId: networkId, versionLabel: versionLabel, versionId: versionId, versionStatus: versionStatus, isActiveVersion: isActiveVersion }));
+        if (!args.skipConfirm) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: isActiveVersion
+                        ? `${chalk.red("WARNING:")} this version is currently live. Continue?`
+                        : `Delete ${versionLabel ?? versionId} permanently?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                logView(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+                return;
+            }
+        }
+        const deleteSpinner = render(_jsx(Spinner, { label: "Deleting version..." }));
+        try {
+            await client.agentManagement.deleteVersion(agentManagementId, versionId, session.user_id);
+            deleteSpinner.unmount();
+            const cleared = clearSessionIfMatchesVersion(versionId);
+            renderView(_jsx(AgentDeleteResultView, { scope: "version", agentName: agentName, versionLabel: versionLabel, cleared: cleared }));
+        }
+        catch (error) {
+            deleteSpinner.unmount();
+            renderView(_jsx(ErrorDisplay, { error: error, message: `Failed to delete version: ${formatApiErrorBody(error)}` }));
+        }
+    }
+    function clearSessionIfMatchesAgent(deletedNetworkId, deletedAgentManagementId) {
+        const current = loadSession();
+        if (!current)
+            return false;
+        const matchesNetwork = current.network_id === deletedNetworkId;
+        const matchesAgentMgmt = !!deletedAgentManagementId &&
+            current.agent_management_id === deletedAgentManagementId;
+        if (!matchesNetwork && !matchesAgentMgmt)
+            return false;
+        delete current.network_id;
+        delete current.network_name;
+        delete current.agent_management_id;
+        delete current.version_id;
+        delete current.version_number;
+        delete current.version_revision_number;
+        saveSession(current);
+        return true;
+    }
+    function clearSessionIfMatchesVersion(deletedVersionId) {
+        const current = loadSession();
+        if (!current)
+            return false;
+        if (current.version_id !== deletedVersionId)
+            return false;
+        delete current.version_id;
+        delete current.version_number;
+        delete current.version_revision_number;
+        saveSession(current);
+        return true;
+    }
     async function handleCreateAgent(opts = {}) {
         const config = getConfig();
         const client = new AUIClient({