aui-agent-builder 0.3.76 → 0.3.78

package/dist/commands/version-snapshot.js

@@ -0,0 +1,669 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render } from "ink";
+import { Box, Text } from "ink";
+import inquirer from "inquirer";
+import { getConfig, loadSession, loadProjectConfig, findProjectRoot, loadAgentSettingsApiKey, } from "../config/index.js";
+import { AUIClient } from "../api-client/index.js";
+import { AuthenticationError } from "../errors/index.js";
+import { isJsonMode, outputJson, outputJsonError, stderrLog } from "../utils/json-output.js";
+import { Header, StatusLine, Spinner, ErrorDisplay, Divider, KeyValueGroup, } from "../ui/components/index.js";
+import { colors } from "../ui/theme.js";
+// ─── Ink Rendering Helpers ───
+function log(node) {
+    const { unmount } = render(node);
+    unmount();
+}
+function startSpinner(label) {
+    const inst = render(_jsx(Spinner, { label: label }));
+    return {
+        succeed(msg) {
+            inst.unmount();
+            log(_jsx(StatusLine, { kind: "success", label: msg }));
+        },
+        warn(msg) {
+            inst.unmount();
+            log(_jsx(StatusLine, { kind: "warning", label: msg }));
+        },
+        fail(msg) {
+            inst.unmount();
+            log(_jsx(StatusLine, { kind: "error", label: msg }));
+        },
+        stop() {
+            inst.unmount();
+        },
+    };
+}
+// ─── Helpers ───
+function getAuthenticatedClient() {
+    const config = getConfig();
+    if (!config.isAuthenticated) {
+        throw new AuthenticationError("Not logged in.");
+    }
+    const client = new AUIClient({
+        baseUrl: config.apiUrl,
+        authToken: config.authToken,
+        accountId: config.accountId,
+        organizationId: config.organizationId,
+        environment: config.environment,
+    });
+    const key = loadAgentSettingsApiKey();
+    if (key)
+        client.setAgentSettingsApiKey(key);
+    return client;
+}
+/**
+ * Resolve the agent for snapshot commands. Tries (in order):
+ *   1. Explicit agent ID (assumed to be agent-management ID)
+ *   2. .auirc agent_id (network ID) → agent-management lookup (project context)
+ *   3. Session's agent_management_id
+ *   4. Session's network_id → agent-management lookup
+ *
+ * Project config takes priority over session — if you're inside a project,
+ * that's the agent you mean.
+ */
+async function resolveAgentForSnapshot(client, explicitAgentId) {
+    if (explicitAgentId) {
+        return client.agentManagement.getAgent(explicitAgentId);
+    }
+    const session = loadSession();
+    const projectRoot = findProjectRoot();
+    const projectConfig = projectRoot ? loadProjectConfig(projectRoot) : null;
+    const projectNetworkId = projectConfig?.agent_id;
+    // 1. Project config wins
+    if (projectNetworkId) {
+        try {
+            const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: projectNetworkId });
+            const match = resp.items.find((a) => a.scope.network_id === projectNetworkId || a.id === projectNetworkId);
+            if (match)
+                return match;
+        }
+        catch {
+            // fall through
+        }
+    }
+    // 2. Session agent (only if not inside a project)
+    if (!projectNetworkId && session?.agent_management_id) {
+        try {
+            return await client.agentManagement.getAgent(session.agent_management_id);
+        }
+        catch {
+            // stale ID, fall through
+        }
+    }
+    // 3. Session network_id as last resort
+    const fallbackNetworkId = session?.network_id;
+    if (fallbackNetworkId) {
+        try {
+            const resp = await client.agentManagement.listAgents(client.getOrganizationId(), 1, 50, { network_id: fallbackNetworkId });
+            const match = resp.items.find((a) => a.scope.network_id === fallbackNetworkId || a.id === fallbackNetworkId);
+            if (match)
+                return match;
+        }
+        catch {
+            // fall through
+        }
+    }
+    throw new Error("Could not resolve agent. Pass --agent-id explicitly, or run `aui import-agent` first.");
+}
+/**
+ * Resolve the version to use for snapshot commands. Tries (in order):
+ *   1. Explicit version ID
+ *   2. .auirc version_id
+ *   3. Active version on the agent
+ *   4. Interactive prompt
+ */
+async function resolveVersionForSnapshot(client, agent, explicitVersionId) {
+    if (explicitVersionId) {
+        return client.agentManagement.getVersion(agent.id, explicitVersionId);
+    }
+    const projectRoot = findProjectRoot();
+    const projectConfig = projectRoot ? loadProjectConfig(projectRoot) : null;
+    if (projectConfig?.version_id) {
+        try {
+            return await client.agentManagement.getVersion(agent.id, projectConfig.version_id);
+        }
+        catch {
+            // stale, fall through
+        }
+    }
+    const versionsResp = await client.agentManagement.listVersions(agent.id, 1, 50);
+    const versions = versionsResp.items;
+    if (versions.length === 0) {
+        throw new Error("No versions found for this agent.");
+    }
+    if (agent.active_version_id) {
+        const active = versions.find((v) => v.id === agent.active_version_id);
+        if (active)
+            return active;
+    }
+    if (isJsonMode()) {
+        return versions[0];
+    }
+    const { selected } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selected",
+            message: "Select version:",
+            choices: versions.map((v) => ({
+                name: `v${v.version_number} [${v.status}] ${v.label || ""}`,
+                value: v,
+            })),
+            pageSize: 15,
+        },
+    ]);
+    return selected;
+}
+/**
+ * Probe the snapshot endpoint to discover all snapshots for a version.
+ * Snapshots are tagged v{N}.0, v{N}.1, v{N}.2, ... where N is the version number.
+ * The first push to a version creates v{N}.0; subsequent pushes increment.
+ * We probe sequentially and stop after a 404 (allowing one gap for safety).
+ */
+async function discoverSnapshots(client, agentId, versionId, versionNumber, maxProbes = 200) {
+    const found = [];
+    let consecutive404s = 0;
+    for (let i = 0; i <= maxProbes; i++) {
+        const tag = `v${versionNumber}.${i}`;
+        try {
+            const data = await client.agentManagement.getSnapshot(agentId, versionId, {
+                versionTag: tag,
+                expiresIn: 15,
+            });
+            found.push(data);
+            consecutive404s = 0;
+        }
+        catch (err) {
+            const status = err.statusCode
+                ?? err.status;
+            if (status === 404) {
+                consecutive404s++;
+                // Stop after 2 consecutive 404s to handle a possible gap at i=0 vs i=1
+                if (consecutive404s >= 2)
+                    break;
+                continue;
+            }
+            throw err;
+        }
+    }
+    return found;
+}
+// ─── Interactive Menu ───
+export async function versionSnapshotMenu() {
+    const client = getAuthenticatedClient();
+    log(_jsx(Header, { title: "Version Snapshots" }));
+    const agent = await resolveAgentForSnapshot(client);
+    log(_jsx(StatusLine, { kind: "info", label: `Agent: ${agent.name}` }));
+    const version = await resolveVersionForSnapshot(client, agent);
+    log(_jsx(StatusLine, { kind: "info", label: `Version: v${version.version_number} [${version.status}]` }));
+    const { action } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "action",
+            message: "What would you like to do?",
+            choices: [
+                { name: "List snapshots for this version", value: "list" },
+                { name: "View a snapshot's manifest", value: "get" },
+                { name: "Diff two snapshots", value: "diff" },
+                new inquirer.Separator(),
+                { name: "Back", value: "back" },
+            ],
+        },
+    ]);
+    if (action === "back")
+        return;
+    const spinner = startSpinner(`Discovering snapshots for v${version.version_number}...`);
+    const snapshots = await discoverSnapshots(client, agent.id, version.id, version.version_number);
+    spinner.succeed(`Found ${snapshots.length} snapshot(s)`);
+    if (snapshots.length === 0) {
+        log(_jsx(StatusLine, { kind: "muted", label: "No snapshots yet. Push to this version to create one." }));
+        return;
+    }
+    if (action === "list") {
+        renderSnapshotList(snapshots);
+        return;
+    }
+    if (action === "get") {
+        const { tag } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "tag",
+                message: "Select snapshot:",
+                choices: snapshots.map((s) => ({
+                    name: `${s.manifest.version_tag} — ${s.manifest.files.length} file(s) — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                    value: s.manifest.version_tag,
+                })),
+                pageSize: 15,
+            },
+        ]);
+        const snap = snapshots.find((s) => s.manifest.version_tag === tag);
+        renderSnapshotDetails(snap);
+        return;
+    }
+    if (action === "diff") {
+        if (snapshots.length < 2) {
+            log(_jsx(StatusLine, { kind: "warning", label: "Need at least 2 snapshots to diff." }));
+            return;
+        }
+        const { tagA } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "tagA",
+                message: "Select first snapshot (older):",
+                choices: snapshots.map((s) => ({
+                    name: `${s.manifest.version_tag} — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                    value: s.manifest.version_tag,
+                })),
+                pageSize: 15,
+            },
+        ]);
+        const { tagB } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "tagB",
+                message: "Select second snapshot (newer):",
+                choices: snapshots
+                    .filter((s) => s.manifest.version_tag !== tagA)
+                    .map((s) => ({
+                    name: `${s.manifest.version_tag} — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                    value: s.manifest.version_tag,
+                })),
+                pageSize: 15,
+            },
+        ]);
+        const a = snapshots.find((s) => s.manifest.version_tag === tagA);
+        const b = snapshots.find((s) => s.manifest.version_tag === tagB);
+        const { showFull } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "showFull",
+                message: "Download changed files and show JSON-level diff?",
+                default: false,
+            },
+        ]);
+        await renderSnapshotDiff(a, b, showFull);
+    }
+}
+export async function versionSnapshotList(options = {}) {
+    const client = getAuthenticatedClient();
+    const json = isJsonMode();
+    try {
+        const agent = await resolveAgentForSnapshot(client, options.agentId);
+        const version = await resolveVersionForSnapshot(client, agent, options.versionId);
+        if (json)
+            stderrLog(`Discovering snapshots for v${version.version_number}...`);
+        const spinner = json ? null : startSpinner(`Discovering snapshots for v${version.version_number}...`);
+        const snapshots = await discoverSnapshots(client, agent.id, version.id, version.version_number);
+        if (spinner)
+            spinner.succeed(`Found ${snapshots.length} snapshot(s)`);
+        else
+            stderrLog(`Found ${snapshots.length} snapshot(s)`);
+        if (json) {
+            outputJson({
+                agent: { id: agent.id, name: agent.name },
+                version: { id: version.id, version_number: version.version_number, status: version.status },
+                snapshots: snapshots.map((s) => ({
+                    version_tag: s.manifest.version_tag,
+                    created_at: s.manifest.created_at,
+                    file_count: s.manifest.files.length,
+                    total_size: s.manifest.files.reduce((sum, f) => sum + f.size, 0),
+                    files: s.manifest.files.map((f) => ({
+                        filename: f.filename,
+                        size: f.size,
+                        sha256: f.sha256,
+                    })),
+                })),
+            });
+            return;
+        }
+        if (snapshots.length === 0) {
+            log(_jsx(StatusLine, { kind: "muted", label: "No snapshots yet. Push to this version to create one." }));
+            return;
+        }
+        renderSnapshotList(snapshots);
+    }
+    catch (error) {
+        if (json) {
+            outputJsonError({
+                code: "SNAPSHOT_LIST_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error }));
+        }
+    }
+}
+// ─── Get ───
+export async function versionSnapshotGet(tagArg, options = {}) {
+    const client = getAuthenticatedClient();
+    const json = isJsonMode();
+    try {
+        const agent = await resolveAgentForSnapshot(client, options.agentId);
+        const version = await resolveVersionForSnapshot(client, agent, options.versionId);
+        let tag = tagArg;
+        if (!tag) {
+            const spinner = json ? null : startSpinner(`Discovering snapshots for v${version.version_number}...`);
+            const snapshots = await discoverSnapshots(client, agent.id, version.id, version.version_number);
+            if (spinner)
+                spinner.succeed(`Found ${snapshots.length} snapshot(s)`);
+            if (snapshots.length === 0) {
+                if (json) {
+                    outputJsonError({ code: "NO_SNAPSHOTS", message: "No snapshots found for this version." });
+                }
+                else {
+                    log(_jsx(StatusLine, { kind: "muted", label: "No snapshots found for this version." }));
+                }
+                return;
+            }
+            if (json) {
+                tag = snapshots[snapshots.length - 1].manifest.version_tag;
+            }
+            else {
+                const answer = await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "tag",
+                        message: "Select snapshot:",
+                        choices: snapshots.map((s) => ({
+                            name: `${s.manifest.version_tag} — ${s.manifest.files.length} file(s) — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                            value: s.manifest.version_tag,
+                        })),
+                        pageSize: 15,
+                    },
+                ]);
+                tag = answer.tag;
+            }
+        }
+        const fetchSpinner = json ? null : startSpinner(`Fetching snapshot ${tag}...`);
+        const snap = await client.agentManagement.getSnapshot(agent.id, version.id, {
+            versionTag: tag,
+            expiresIn: 15,
+        });
+        if (fetchSpinner)
+            fetchSpinner.succeed(`Snapshot ${tag} fetched`);
+        if (json) {
+            outputJson(snap);
+            return;
+        }
+        renderSnapshotDetails(snap);
+    }
+    catch (error) {
+        if (json) {
+            outputJsonError({
+                code: "SNAPSHOT_GET_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error }));
+        }
+    }
+}
+export async function versionSnapshotDiff(tagA, tagB, options = {}) {
+    const client = getAuthenticatedClient();
+    const json = isJsonMode();
+    try {
+        const agent = await resolveAgentForSnapshot(client, options.agentId);
+        const version = await resolveVersionForSnapshot(client, agent, options.versionId);
+        let resolvedA = tagA;
+        let resolvedB = tagB;
+        if (!resolvedA || !resolvedB) {
+            const spinner = json ? null : startSpinner(`Discovering snapshots for v${version.version_number}...`);
+            const snapshots = await discoverSnapshots(client, agent.id, version.id, version.version_number);
+            if (spinner)
+                spinner.succeed(`Found ${snapshots.length} snapshot(s)`);
+            if (snapshots.length < 2) {
+                if (json) {
+                    outputJsonError({
+                        code: "INSUFFICIENT_SNAPSHOTS",
+                        message: "Need at least 2 snapshots to diff.",
+                    });
+                }
+                else {
+                    log(_jsx(StatusLine, { kind: "warning", label: "Need at least 2 snapshots to diff." }));
+                }
+                return;
+            }
+            if (!resolvedA) {
+                if (json) {
+                    resolvedA = snapshots[snapshots.length - 2].manifest.version_tag;
+                }
+                else {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "tag",
+                            message: "Select first snapshot (older):",
+                            choices: snapshots.map((s) => ({
+                                name: `${s.manifest.version_tag} — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                                value: s.manifest.version_tag,
+                            })),
+                            pageSize: 15,
+                        },
+                    ]);
+                    resolvedA = answer.tag;
+                }
+            }
+            if (!resolvedB) {
+                if (json) {
+                    resolvedB = snapshots[snapshots.length - 1].manifest.version_tag;
+                }
+                else {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "tag",
+                            message: "Select second snapshot (newer):",
+                            choices: snapshots
+                                .filter((s) => s.manifest.version_tag !== resolvedA)
+                                .map((s) => ({
+                                name: `${s.manifest.version_tag} — ${new Date(s.manifest.created_at).toLocaleString()}`,
+                                value: s.manifest.version_tag,
+                            })),
+                            pageSize: 15,
+                        },
+                    ]);
+                    resolvedB = answer.tag;
+                }
+            }
+        }
+        const fetchSpinner = json ? null : startSpinner(`Fetching ${resolvedA} and ${resolvedB}...`);
+        const [snapA, snapB] = await Promise.all([
+            client.agentManagement.getSnapshot(agent.id, version.id, {
+                versionTag: resolvedA,
+                expiresIn: 15,
+            }),
+            client.agentManagement.getSnapshot(agent.id, version.id, {
+                versionTag: resolvedB,
+                expiresIn: 15,
+            }),
+        ]);
+        if (fetchSpinner)
+            fetchSpinner.succeed("Snapshots fetched");
+        await renderSnapshotDiff(snapA, snapB, options.full ?? false, json);
+    }
+    catch (error) {
+        if (json) {
+            outputJsonError({
+                code: "SNAPSHOT_DIFF_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error }));
+        }
+    }
+}
+// ─── Renderers ───
+function renderSnapshotList(snapshots) {
+    log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "\u25C6 " }), _jsxs(Text, { bold: true, children: [snapshots.length, " snapshot(s)"] })] }), _jsxs(Box, { children: [_jsx(Box, { width: 12, children: _jsx(Text, { bold: true, color: colors.muted, children: "Tag" }) }), _jsx(Box, { width: 26, children: _jsx(Text, { bold: true, color: colors.muted, children: "Created" }) }), _jsx(Box, { width: 10, children: _jsx(Text, { bold: true, color: colors.muted, children: "Files" }) }), _jsx(Box, { children: _jsx(Text, { bold: true, color: colors.muted, children: "Total Size" }) })] }), _jsx(Divider, { width: 70 }), snapshots.map((s) => {
+                const totalSize = s.manifest.files.reduce((sum, f) => sum + f.size, 0);
+                return (_jsxs(Box, { children: [_jsx(Box, { width: 12, children: _jsx(Text, { color: colors.success, bold: true, children: s.manifest.version_tag }) }), _jsx(Box, { width: 26, children: _jsx(Text, { color: colors.muted, children: new Date(s.manifest.created_at).toLocaleString() }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: colors.muted, children: s.manifest.files.length }) }), _jsx(Box, { children: _jsx(Text, { color: colors.muted, children: formatBytes(totalSize) }) })] }, s.manifest.version_tag));
+            })] }));
+}
+function renderSnapshotDetails(snap) {
+    const totalSize = snap.manifest.files.reduce((sum, f) => sum + f.size, 0);
+    log(_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Header, { title: `Snapshot ${snap.manifest.version_tag}` }), _jsx(KeyValueGroup, { items: [
+                    { label: "Tag:", value: snap.manifest.version_tag },
+                    { label: "Agent ID:", value: snap.manifest.agent_id },
+                    { label: "Version ID:", value: snap.manifest.version_id },
+                    { label: "Created:", value: new Date(snap.manifest.created_at).toLocaleString() },
+                    { label: "Expires:", value: new Date(snap.expires_at).toLocaleString() },
+                    { label: "Files:", value: String(snap.manifest.files.length) },
+                    { label: "Total size:", value: formatBytes(totalSize) },
+                ] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "Files:" }) }), snap.manifest.files.map((f) => (_jsxs(Box, { marginLeft: 2, children: [_jsx(Box, { width: 36, children: _jsx(Text, { children: f.filename }) }), _jsx(Box, { width: 12, children: _jsx(Text, { color: colors.muted, children: formatBytes(f.size) }) }), _jsx(Box, { children: _jsxs(Text, { color: colors.muted, children: [f.sha256.substring(0, 12), "\u2026"] }) })] }, f.filename))), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.muted, children: "Use " }), _jsx(Text, { bold: true, children: "aui version snapshot diff" }), _jsx(Text, { color: colors.muted, children: " to compare with another snapshot." })] })] }));
+}
+function computeManifestDiff(a, b) {
+    const aMap = new Map(a.manifest.files.map((f) => [f.filename, f]));
+    const bMap = new Map(b.manifest.files.map((f) => [f.filename, f]));
+    const allNames = new Set([...aMap.keys(), ...bMap.keys()]);
+    const entries = [];
+    for (const name of allNames) {
+        const oldFile = aMap.get(name);
+        const newFile = bMap.get(name);
+        if (oldFile && !newFile) {
+            entries.push({ filename: name, status: "removed", oldFile });
+        }
+        else if (!oldFile && newFile) {
+            entries.push({ filename: name, status: "added", newFile });
+        }
+        else if (oldFile && newFile) {
+            if (oldFile.sha256 !== newFile.sha256) {
+                entries.push({ filename: name, status: "modified", oldFile, newFile });
+            }
+            else {
+                entries.push({ filename: name, status: "unchanged", oldFile, newFile });
+            }
+        }
+    }
+    return entries;
+}
+async function downloadSnapshotFile(url) {
+    const resp = await globalThis.fetch(url);
+    if (!resp.ok) {
+        throw new Error(`Failed to download file: ${resp.status} ${resp.statusText}`);
+    }
+    return resp.json();
+}
+function diffJson(oldObj, newObj, prefix = "") {
+    const diffs = [];
+    if (oldObj !== null &&
+        newObj !== null &&
+        typeof oldObj === "object" &&
+        typeof newObj === "object" &&
+        !Array.isArray(oldObj) &&
+        !Array.isArray(newObj)) {
+        const oldRecord = oldObj;
+        const newRecord = newObj;
+        const allKeys = new Set([...Object.keys(oldRecord), ...Object.keys(newRecord)]);
+        for (const key of allKeys) {
+            const p = prefix ? `${prefix}.${key}` : key;
+            if (!(key in oldRecord)) {
+                diffs.push({ path: p, type: "added", newValue: newRecord[key] });
+            }
+            else if (!(key in newRecord)) {
+                diffs.push({ path: p, type: "removed", oldValue: oldRecord[key] });
+            }
+            else {
+                diffs.push(...diffJson(oldRecord[key], newRecord[key], p));
+            }
+        }
+        return diffs;
+    }
+    if (JSON.stringify(oldObj) !== JSON.stringify(newObj)) {
+        diffs.push({ path: prefix || "(root)", type: "changed", oldValue: oldObj, newValue: newObj });
+    }
+    return diffs;
+}
+function truncate(value, maxLen = 100) {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    if (str === undefined)
+        return "(undefined)";
+    return str.length > maxLen ? str.substring(0, maxLen) + "…" : str;
+}
+async function renderSnapshotDiff(a, b, showFull, json = false) {
+    const entries = computeManifestDiff(a, b);
+    const changed = entries.filter((e) => e.status !== "unchanged");
+    const unchanged = entries.filter((e) => e.status === "unchanged").length;
+    if (json) {
+        const fullDiffs = [];
+        for (const entry of changed) {
+            const result = { ...entry };
+            if (showFull && entry.status === "modified") {
+                try {
+                    const [oldData, newData] = await Promise.all([
+                        downloadSnapshotFile(a.files[entry.filename]),
+                        downloadSnapshotFile(b.files[entry.filename]),
+                    ]);
+                    result.json_diff = diffJson(oldData, newData);
+                }
+                catch {
+                    // skip
+                }
+            }
+            fullDiffs.push(result);
+        }
+        outputJson({
+            from: a.manifest.version_tag,
+            to: b.manifest.version_tag,
+            changed: changed.length,
+            unchanged,
+            diffs: fullDiffs,
+        });
+        return;
+    }
+    log(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { title: `${a.manifest.version_tag}  →  ${b.manifest.version_tag}` }), _jsxs(Box, { children: [_jsx(Text, { color: colors.muted, children: "Changed: " }), _jsx(Text, { color: "yellow", bold: true, children: changed.length }), _jsx(Text, { color: colors.muted, children: "   Unchanged: " }), _jsx(Text, { color: colors.muted, children: unchanged })] })] }));
+    if (changed.length === 0) {
+        log(_jsx(StatusLine, { kind: "success", label: "Snapshots are identical." }));
+        return;
+    }
+    log(_jsx(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: changed.map((e) => {
+            const symbol = e.status === "added" ? "+" : e.status === "removed" ? "-" : "~";
+            const color = e.status === "added" ? "green" : e.status === "removed" ? "red" : "yellow";
+            const sizeInfo = e.status === "modified"
+                ? `${formatBytes(e.oldFile.size)} → ${formatBytes(e.newFile.size)}`
+                : e.status === "added"
+                    ? formatBytes(e.newFile.size)
+                    : formatBytes(e.oldFile.size);
+            return (_jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: color, bold: true, children: symbol }) }), _jsx(Box, { width: 36, children: _jsx(Text, { children: e.filename }) }), _jsx(Box, { children: _jsxs(Text, { color: colors.muted, children: [e.status, " (", sizeInfo, ")"] }) })] }, e.filename));
+        }) }));
+    if (showFull) {
+        log(_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "Field-level changes:" }) }));
+        for (const entry of changed) {
+            if (entry.status !== "modified")
+                continue;
+            const fileSpinner = startSpinner(`Downloading ${entry.filename}...`);
+            try {
+                const [oldData, newData] = await Promise.all([
+                    downloadSnapshotFile(a.files[entry.filename]),
+                    downloadSnapshotFile(b.files[entry.filename]),
+                ]);
+                fileSpinner.stop();
+                const fieldDiffs = diffJson(oldData, newData);
+                log(_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: "yellow", bold: true, children: ["~ ", entry.filename] }) }), fieldDiffs.length === 0 ? (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: colors.muted, children: "(no field-level diff)" }) })) : (fieldDiffs.map((fd, i) => {
+                            if (fd.type === "added") {
+                                return (_jsxs(Box, { marginLeft: 2, children: [_jsxs(Text, { color: "green", bold: true, children: ["+ ", fd.path, ": "] }), _jsx(Text, { color: colors.muted, children: truncate(fd.newValue) })] }, i));
+                            }
+                            if (fd.type === "removed") {
+                                return (_jsxs(Box, { marginLeft: 2, children: [_jsxs(Text, { color: "red", bold: true, children: ["- ", fd.path, ": "] }), _jsx(Text, { color: colors.muted, children: truncate(fd.oldValue) })] }, i));
+                            }
+                            return (_jsxs(Box, { marginLeft: 2, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["~ ", fd.path, ": "] }), _jsx(Text, { color: colors.muted, children: truncate(fd.oldValue) }), _jsx(Text, { color: colors.muted, children: " \u2192 " }), _jsx(Text, { color: colors.muted, children: truncate(fd.newValue) })] }, i));
+                        }))] }));
+            }
+            catch (err) {
+                fileSpinner.fail(`Failed to download ${entry.filename}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    else {
+        log(_jsxs(Box, { marginTop: 1, paddingX: 1, children: [_jsx(Text, { color: colors.muted, children: "Tip: Use " }), _jsx(Text, { bold: true, children: "--full" }), _jsx(Text, { color: colors.muted, children: " to download files and see field-level JSON diffs." })] }));
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+//# sourceMappingURL=version-snapshot.js.map