@zenera/cli 1.1.25 → 1.1.26

package/dist/resources.js

@@ -0,0 +1,856 @@
+import { runProcess } from '@zenera/neo';
+import { cpus as hostCpus, platform as hostPlatform, totalmem } from 'node:os';
+import { basename, join } from 'node:path';
+import { idleContainers, ownedContainers } from "./podman.js";
+import { isProjectDir, Registry, sessionIds, sessionsDir } from "./projects.js";
+import { ago, bytes } from "./term.js";
+import { wrap } from "./tui/wrap.js";
+const MIB = 1024 * 1024;
+const GIB = 1024 * MIB;
+/** Process ids, footprints and container names are all short; a listing of many is not. */
+const LISTING_BYTES = 16 * MIB;
+/** How long a project-to-session map is trusted before the registry is read again. */
+const OWNERS_TTL_MS = 30_000;
+/** A helper started this close to the hypervisor belongs to the same machine. */
+const SAME_START_S = 120;
+/** What starts the machine, by executable name. */
+const HYPERVISORS = new Set(['vfkit', 'krunkit', 'qemu-system-aarch64', 'qemu-system-x86_64']);
+/** macOS runs a vfkit machine's memory in this XPC service, not in vfkit. */
+const APPLE_VM = 'com.apple.Virtualization.VirtualMachine';
+const NETWORK = new Set(['gvproxy']);
+/** Reads one sample at a time and remembers the last, so each view has an interval. */
+export class ResourceSampler {
+    engine;
+    #exec;
+    #platform;
+    #owners;
+    #now;
+    #previous;
+    #machine;
+    #cached;
+    constructor(opts = {}) {
+        this.engine = opts.engine ?? 'podman';
+        this.#exec = opts.exec ?? runProcess;
+        this.#platform = opts.platform ?? hostPlatform();
+        this.#owners = opts.owners ?? registryOwners;
+        this.#now = opts.now ?? Date.now;
+    }
+    async next() {
+        const sample = await this.sample();
+        const view = viewOf(sample, this.#previous);
+        this.#previous = sample;
+        return view;
+    }
+    async sample() {
+        const at = this.#now();
+        const problems = [];
+        const native = this.#platform === 'linux';
+        const [guest, stats, owned, processes, machine, owners] = await Promise.all([
+            guestMemory(this.engine, this.#exec),
+            containerStats(this.engine, this.#exec),
+            ownedContainers(this.engine, this.#exec),
+            this.#platform === 'darwin' ? hostProcesses(this.#exec) : Promise.resolve([]),
+            native ? Promise.resolve(undefined) : this.#machineName(),
+            this.#ownersCached(at),
+        ]);
+        if (!guest) {
+            problems.push(native
+                ? `${this.engine} did not answer — is it installed? zen sandbox up`
+                : `${this.engine} did not answer — is the machine running? zen sandbox up`);
+        }
+        if (stats === undefined && owned.some((c) => c.state === 'running')) {
+            problems.push(`${this.engine} stats did not answer, so no container figures`);
+        }
+        const orphans = idleContainers(owned, owners.dirs)
+            .filter((c) => c.state === 'running')
+            .map((c) => c.name);
+        return {
+            at,
+            platform: this.#platform,
+            engine: this.engine,
+            ready: guest !== undefined,
+            machine,
+            host: { memory: totalmem(), cpus: hostCpus().length, processes },
+            guest,
+            stats: stats ?? [],
+            owned,
+            orphans,
+            projects: owners.names,
+            problems,
+        };
+    }
+    #machineName() {
+        this.#machine ??= this.#exec(this.engine, ['machine', 'list', '--format', 'json'], {
+            timeoutMs: 30_000,
+        })
+            .then((res) => {
+            if (res.code !== 0) {
+                return undefined;
+            }
+            const all = JSON.parse(res.stdout.trim() || '[]');
+            return (all.find((m) => m.Default) ?? all[0])?.Name;
+        })
+            .catch(() => undefined);
+        return this.#machine;
+    }
+    async #ownersCached(at) {
+        if (this.#cached && at - this.#cached.at < OWNERS_TTL_MS) {
+            return this.#cached.owners;
+        }
+        const owners = await this.#owners().catch(() => ({
+            dirs: new Map(),
+            names: new Map(),
+        }));
+        this.#cached = { at, owners };
+        return owners;
+    }
+}
+/** Every session on this machine, by id: where it lives and which project it is in. */
+export async function registryOwners() {
+    const dirs = new Map();
+    const names = new Map();
+    for (const entry of (await Registry.open()).entries) {
+        if (isProjectDir(entry.path)) {
+            for (const id of sessionIds(entry.path)) {
+                dirs.set(id, join(sessionsDir(entry.path), id));
+                names.set(id, entry.name);
+            }
+        }
+    }
+    return { dirs, names };
+}
+// ---------------------------------------------------------------------------
+// Reading each layer
+// ---------------------------------------------------------------------------
+async function guestMemory(engine, exec) {
+    const res = await exec(engine, ['info', '--format', 'json'], { timeoutMs: 30_000 }).catch(() => undefined);
+    if (!res || res.code !== 0) {
+        return undefined;
+    }
+    return parseInfo(res.stdout);
+}
+export function parseInfo(stdout) {
+    let host;
+    try {
+        host = JSON.parse(stdout).host;
+    }
+    catch {
+        return undefined;
+    }
+    const num = (key) => {
+        const v = host?.[key];
+        return typeof v === 'number' && Number.isFinite(v) ? v : 0;
+    };
+    const total = num('memTotal');
+    if (total <= 0) {
+        return undefined;
+    }
+    const free = num('memFree');
+    // An older podman reports no `memAvailable`; free alone undercounts, but
+    // it never claims room that is not there.
+    const available = num('memAvailable') || free;
+    return {
+        total,
+        free,
+        available,
+        swapTotal: num('swapTotal'),
+        swapFree: num('swapFree'),
+        cpus: num('cpus'),
+    };
+}
+/**
+ * Every running container, not only zen's: what the machine is short of is
+ * shared by everything in it, and an unlabelled container eats from the same
+ * memory a session needs. The raw `ContainerStats` rather than podman's own
+ * columns, which are strings like `2.5MB / 4.3GB` rounded for a person.
+ */
+async function containerStats(engine, exec) {
+    const res = await exec(engine, ['stats', '--no-stream', '--no-reset', '--format', '{{json .ContainerStats}}'], { timeoutMs: 30_000, maxBytes: LISTING_BYTES }).catch(() => undefined);
+    if (!res || res.code !== 0) {
+        return undefined;
+    }
+    return parseStats(res.stdout);
+}
+export function parseStats(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        const text = line.trim();
+        if (!text.startsWith('{')) {
+            continue;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (!raw.Name) {
+            continue;
+        }
+        const nets = Object.values(raw.Network ?? {});
+        out.push({
+            id: (raw.ContainerID ?? '').slice(0, 12),
+            name: raw.Name,
+            cpuNano: raw.CPUNano ?? 0,
+            systemNano: raw.SystemNano ?? 0,
+            avgCpu: raw.AvgCPU ?? raw.CPU ?? 0,
+            memory: raw.MemUsage ?? 0,
+            limit: raw.MemLimit ?? 0,
+            pids: raw.PIDs ?? 0,
+            netIn: nets.reduce((n, i) => n + (i.RxBytes ?? 0), 0),
+            netOut: nets.reduce((n, i) => n + (i.TxBytes ?? 0), 0),
+            blockIn: raw.BlockInput ?? 0,
+            blockOut: raw.BlockOutput ?? 0,
+        });
+    }
+    return out;
+}
+/**
+ * The processes on this Mac that make up the machine. `ps` says how much cpu
+ * each has burned and what is in RAM; `footprint` says what Activity Monitor
+ * says, which is the number people come here about — it counts the pages
+ * macOS compressed or swapped too, and for a virtual machine that is nearly
+ * all of it.
+ */
+async function hostProcesses(exec) {
+    const res = await exec('ps', ['-axww', '-o', 'pid=,rss=,time=,etime=,comm='], {
+        timeoutMs: 10_000,
+        maxBytes: LISTING_BYTES,
+    }).catch(() => undefined);
+    if (!res || res.code !== 0) {
+        return [];
+    }
+    const found = machineProcesses(parsePs(res.stdout));
+    if (found.length === 0) {
+        return found;
+    }
+    const args = ['-f', 'bytes', '--noCategories', ...found.flatMap((p) => ['-p', String(p.pid)])];
+    const fp = await exec('footprint', args, { timeoutMs: 10_000 }).catch(() => undefined);
+    const sizes = fp && fp.code === 0 ? parseFootprint(fp.stdout) : new Map();
+    return found.map((p) => {
+        const size = sizes.get(p.pid);
+        return size ? { ...p, footprint: size.footprint, peak: size.peak } : p;
+    });
+}
+export function parsePs(stdout) {
+    const rows = [];
+    for (const line of stdout.split('\n')) {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
+        if (!m) {
+            continue;
+        }
+        rows.push({
+            pid: Number(m[1]),
+            rss: Number(m[2]) * 1024,
+            cpuSeconds: clock(m[3]),
+            ageSeconds: clock(m[4]),
+            command: m[5],
+        });
+    }
+    return rows;
+}
+/** `[[dd-]hh:]mm:ss[.cc]` — how `ps` prints both cpu time and elapsed time. */
+export function clock(text) {
+    const [days, rest] = text.includes('-') ? text.split('-', 2) : ['0', text];
+    const parts = (rest ?? '').split(':').map(Number).reverse();
+    if (parts.some((n) => !Number.isFinite(n))) {
+        return 0;
+    }
+    const [s = 0, m = 0, h = 0] = parts;
+    return Number(days) * 86400 + h * 3600 + m * 60 + s;
+}
+/**
+ * Picks the machine out of every process on the host. A Mac can run more than
+ * one virtual machine through the same framework, so the Apple service and
+ * the network helper are matched to the hypervisor by when they started.
+ */
+export function machineProcesses(rows) {
+    const named = (row) => basename(row.command);
+    const near = (a, b) => Math.abs(a.ageSeconds - b.ageSeconds) <= SAME_START_S;
+    const closest = (pool, to) => pool
+        .filter((r) => near(r, to))
+        .sort((a, b) => Math.abs(a.ageSeconds - to.ageSeconds) - Math.abs(b.ageSeconds - to.ageSeconds))[0];
+    const out = [];
+    const apple = rows.filter((r) => named(r) === APPLE_VM);
+    const helpers = rows.filter((r) => NETWORK.has(named(r)));
+    for (const hv of rows.filter((r) => HYPERVISORS.has(named(r)))) {
+        const name = named(hv);
+        const vm = name === 'vfkit' ? closest(apple, hv) : undefined;
+        const as = (row, role, label) => ({
+            pid: row.pid,
+            role,
+            name: label,
+            rss: row.rss,
+            cpuSeconds: row.cpuSeconds,
+        });
+        if (vm) {
+            out.push(as(vm, 'vm', `Virtual Machine Service for ${name}`));
+            out.push(as(hv, 'hypervisor', name));
+        }
+        else {
+            // krunkit and qemu hold the guest's memory in their own process.
+            out.push(as(hv, 'vm', name));
+        }
+        const net = closest(helpers, hv);
+        if (net) {
+            out.push(as(net, 'network', named(net)));
+        }
+    }
+    return out;
+}
+/** `footprint -f bytes` output: one block per process. */
+export function parseFootprint(stdout) {
+    const out = new Map();
+    let pid;
+    for (const line of stdout.split('\n')) {
+        const head = /\[(\d+)\]:.*Footprint:\s*(\d+)\s*B/.exec(line);
+        if (head) {
+            pid = Number(head[1]);
+            out.set(pid, { footprint: Number(head[2]) });
+            continue;
+        }
+        const entry = pid === undefined ? undefined : out.get(pid);
+        const exact = /^\s*phys_footprint:\s*(\d+)\s*B/.exec(line);
+        if (entry && exact) {
+            entry.footprint = Number(exact[1]);
+        }
+        const peak = /^\s*phys_footprint_peak:\s*(\d+)\s*B/.exec(line);
+        if (entry && peak) {
+            entry.peak = Number(peak[1]);
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// From samples to a view
+// ---------------------------------------------------------------------------
+export function viewOf(now, before) {
+    const seconds = before ? (now.at - before.at) / 1000 : undefined;
+    const processes = now.host.processes.map((p) => {
+        const prior = before?.host.processes.find((q) => q.pid === p.pid);
+        const cpu = prior && seconds && seconds > 0
+            ? Math.max(0, ((p.cpuSeconds - prior.cpuSeconds) / seconds) * 100)
+            : undefined;
+        return {
+            pid: p.pid,
+            role: p.role,
+            name: p.name,
+            memory: p.footprint ?? p.rss,
+            rss: p.rss,
+            footprint: p.footprint,
+            peak: p.peak,
+            cpu,
+        };
+    });
+    const vm = processes.find((p) => p.role === 'vm');
+    const machine = now.guest ? machineOf(now.guest, now.machine, vm) : undefined;
+    const owned = new Map(now.owned.map((c) => [c.name, c]));
+    const orphans = new Set(now.orphans);
+    const containers = now.stats.map((s) => {
+        const own = owned.get(s.name);
+        const prior = before?.stats.find((p) => p.id === s.id);
+        const span = prior ? s.systemNano - prior.systemNano : 0;
+        const measured = prior !== undefined && span > 0;
+        const kind = !own ? 'other' : own.key?.startsWith('faker-') ? 'faker' : 'zen';
+        return {
+            name: s.name,
+            id: s.id,
+            kind,
+            project: own?.key ? now.projects.get(own.key) : undefined,
+            orphaned: orphans.has(s.name),
+            cpu: measured ? Math.max(0, ((s.cpuNano - prior.cpuNano) / span) * 100) : s.avgCpu,
+            cpuOver: measured ? 'interval' : 'lifetime',
+            memory: s.memory,
+            // A container with no cap reports the whole machine as its limit.
+            limit: s.limit > 0 && (!now.guest || s.limit < now.guest.total * 0.99)
+                ? s.limit
+                : undefined,
+            pids: s.pids,
+            netIn: s.netIn,
+            netOut: s.netOut,
+            blockIn: s.blockIn,
+            blockOut: s.blockOut,
+            createdAt: own?.createdAt,
+        };
+    });
+    const running = new Set(containers.map((c) => c.name));
+    const view = {
+        at: new Date(now.at).toISOString(),
+        interval: seconds,
+        platform: now.platform,
+        engine: now.engine,
+        ready: now.ready,
+        host: {
+            memory: now.host.memory,
+            cpus: now.host.cpus,
+            vm,
+            helpers: processes.filter((p) => p !== vm),
+        },
+        machine,
+        containers,
+        stopped: now.owned.filter((c) => !running.has(c.name) && c.state !== 'running').length,
+        totals: {
+            running: containers.length,
+            zen: containers.filter((c) => c.kind === 'zen').length,
+            faker: containers.filter((c) => c.kind === 'faker').length,
+            other: containers.filter((c) => c.kind === 'other').length,
+            orphaned: containers.filter((c) => c.orphaned).length,
+            memory: containers.reduce((n, c) => n + c.memory, 0),
+            cpu: containers.reduce((n, c) => n + c.cpu, 0),
+        },
+        hints: [],
+        problems: [...now.problems],
+    };
+    view.hints = hintsOf(view);
+    return view;
+}
+function machineOf(g, name, vm) {
+    const used = Math.max(0, g.total - g.available);
+    const cache = Math.max(0, g.available - g.free);
+    const touched = g.total - g.free;
+    const held = vm?.footprint !== undefined ? Math.max(0, vm.footprint - touched) : undefined;
+    return {
+        name,
+        total: g.total,
+        used,
+        cache,
+        free: g.free,
+        available: g.available,
+        swapTotal: g.swapTotal,
+        swapUsed: Math.max(0, g.swapTotal - g.swapFree),
+        cpus: g.cpus,
+        held,
+    };
+}
+/** What a person can do about what the view shows, most useful first. */
+function hintsOf(v) {
+    const out = [];
+    const m = v.machine;
+    const vm = v.host.vm;
+    const lost = v.containers.filter((c) => c.orphaned);
+    if (lost.length > 0) {
+        out.push(`${lost.length === 1 ? '1 container is' : `${lost.length} containers are`} still running ` +
+            `for zen runs that are gone, holding ${bytes(lost.reduce((n, c) => n + c.memory, 0))}. ` +
+            'Remove them with: zen sandbox clean --idle');
+    }
+    if (m && m.available < m.total * 0.15) {
+        out.push(`The machine is nearly out of memory: ${bytes(m.available)} left of ${bytes(m.total)}. ` +
+            'Commands may be killed with exit 137. Stop what you do not need, or give the machine more memory.');
+    }
+    for (const c of v.containers) {
+        if (c.limit && c.memory > c.limit * 0.9) {
+            out.push(`${c.name} is using ${pct((c.memory / c.limit) * 100)} of its own limit (${bytes(c.limit)}). ` +
+                'Its next big command may be killed with exit 137; raise `sandbox.memory` in agents.yaml.');
+        }
+    }
+    if (m && m.swapUsed > 64 * MIB) {
+        out.push(`The machine has moved ${bytes(m.swapUsed)} to disk (swap): it ran out of RAM at some point, ` +
+            'which slows everything inside it down.');
+    }
+    if (vm && m && vm.memory - m.used > GIB && vm.memory > m.used * 2) {
+        out.push(`macOS counts ${bytes(vm.memory)} for the machine, but programs inside use only ${bytes(m.used)}. ` +
+            'The rest is cache and memory used earlier that Linux does not hand back to macOS. ' +
+            'To get it back now: podman machine stop && podman machine start ' +
+            '(cuts off any command running in a session).');
+    }
+    if (vm && m && m.total > v.host.memory * 0.5) {
+        out.push(`The machine may grow to ${bytes(m.total)}, ${pct((m.total / v.host.memory) * 100)} of this computer's memory. ` +
+            'To cap it lower: podman machine stop; podman machine set --memory 8192; podman machine start');
+    }
+    return out;
+}
+export const SORTS = ['memory', 'cpu', 'name'];
+const sp = (text, tone) => ({ text, tone });
+/** Where a note starts: label, value and detail all fit before it. */
+const NOTE_COLUMN = 48;
+/** A note that does not fit beside its row goes under it, indented this far. */
+const NOTE_INDENT = 6;
+const LABEL = 14;
+const VALUE = 9;
+const BAR = 30;
+export function pct(n) {
+    return `${n < 10 ? n.toFixed(1) : Math.round(n)}%`;
+}
+function pressure(fraction) {
+    return fraction >= 0.9 ? 'bad' : fraction >= 0.7 ? 'warn' : 'good';
+}
+/** One stacked bar: each part a run of its own character and tone. */
+function bar(parts, width) {
+    let left = width;
+    const spans = [];
+    parts.forEach(([fraction, char, tone], i) => {
+        const n = i === parts.length - 1
+            ? left
+            : Math.min(left, Math.round(Math.max(0, fraction) * width));
+        left -= n;
+        if (n > 0) {
+            spans.push(sp(char.repeat(n), tone));
+        }
+    });
+    return spans;
+}
+/** Drops trailing padding, which a styled span cannot have trimmed afterwards. */
+function finish(line) {
+    const last = line.at(-1);
+    if (last) {
+        line[line.length - 1] = sp(last.text.trimEnd(), last.tone);
+    }
+    return line.filter((s) => s.text !== '');
+}
+class Lines {
+    out = [];
+    #o;
+    constructor(o) {
+        this.#o = o;
+    }
+    blank() {
+        this.out.push([]);
+    }
+    push(...spans) {
+        this.out.push(finish(spans));
+    }
+    /** A heading in capitals, then what follows it on the same line, quieter. */
+    heading(title, rest) {
+        this.push(sp(title, 'heading'), sp(rest ? `  ${rest}` : '', 'dim'));
+    }
+    /** A sentence under a heading, wrapped, only when explaining. */
+    intro(text) {
+        if (!this.#o.explain || this.#o.intros === false) {
+            return;
+        }
+        for (const line of wrap(text, Math.max(20, this.#o.width - 2))) {
+            this.push(sp(`  ${line}`, 'dim'));
+        }
+    }
+    /**
+     * `label  value  detail  note`. The note is what the figure means: beside
+     * the figure when it fits, wrapped under the row in a report, and in its
+     * short form on a live screen too narrow for the long one.
+     */
+    row(label, value, tone, detail = [], note = '', short = '') {
+        const head = [sp(`  ${label.padEnd(LABEL)}`, 'dim'), sp(value.padStart(VALUE), tone)];
+        const used = [...head, ...detail].reduce((n, s) => n + s.text.length, 0);
+        if (!this.#o.explain || !note) {
+            this.push(...head, ...detail);
+            return;
+        }
+        const column = Math.max(NOTE_COLUMN, used + 2);
+        const gap = sp(' '.repeat(column - used));
+        if (column + note.length <= this.#o.width) {
+            this.push(...head, ...detail, gap, sp(note, 'dim'));
+            return;
+        }
+        if (!this.#o.wrapNotes) {
+            this.push(...head, ...detail, gap, sp(short || note, 'dim'));
+            return;
+        }
+        this.push(...head, ...detail);
+        for (const l of wrap(note, Math.max(20, this.#o.width - NOTE_INDENT))) {
+            this.push(sp(`${' '.repeat(NOTE_INDENT)}${l}`, 'dim'));
+        }
+    }
+}
+/** Containers keep at least this many rows on a short screen before the hints get any. */
+const MIN_CONTAINER_ROWS = 3;
+export function layout(view, o) {
+    const full = sections(view, o);
+    if (o.rows === undefined) {
+        return [...full.top, ...full.head, ...full.rows, ...full.tail];
+    }
+    // Too tall: the prose under the headings goes first, then container rows
+    // and hints share what is left, the containers getting a floor.
+    const fits = (s) => s.top.length + s.head.length + s.rows.length + s.tail.length <= o.rows;
+    const s = fits(full) || !o.explain ? full : sections(view, { ...o, intros: false });
+    if (fits(s)) {
+        return [...s.top, ...s.head, ...s.rows, ...s.tail];
+    }
+    const avail = Math.max(0, o.rows - s.top.length - s.head.length);
+    const floor = Math.min(s.rows.length, MIN_CONTAINER_ROWS, avail);
+    let shown = Math.max(floor, Math.min(s.rows.length, avail - s.tail.length));
+    const cut = shown < s.rows.length;
+    if (cut) {
+        shown = Math.max(0, shown - 1);
+    }
+    const hints = Math.max(0, avail - shown - (cut ? 1 : 0));
+    const more = cut
+        ? [[sp(`  +${s.rows.length - shown} more — a taller window shows them`, 'dim')]]
+        : [];
+    const tail = hints >= s.tail.length
+        ? s.tail
+        : hints > 0
+            ? [
+                ...s.tail.slice(0, wholeHints(s.tail, hints - 1)),
+                [sp('  … a taller window shows the rest', 'dim')],
+            ]
+            : [];
+    return [...s.top, ...s.head, ...s.rows.slice(0, shown), ...more, ...tail].slice(0, o.rows);
+}
+const HINT_MARK = '  • ';
+/** The longest prefix of `n` lines or fewer that ends between two hints, never inside one. */
+function wholeHints(tail, n) {
+    let k = n;
+    while (k > 0 && k < tail.length && tail[k][0]?.text !== HINT_MARK) {
+        k--;
+    }
+    return k;
+}
+function sections(view, o) {
+    const top = new Lines(o);
+    const when = new Date(view.at).toLocaleTimeString();
+    const how = o.live !== undefined
+        ? `refreshing every ${o.live}s · ${when}`
+        : view.interval
+            ? `cpu measured over ${view.interval.toFixed(1)}s · ${when}`
+            : when;
+    top.push(sp('zen sandbox', 'strong'), sp(' · memory and cpu', 'plain'), sp(`   ${how}`, 'dim'));
+    for (const p of view.problems) {
+        top.push(sp(`  ✗ ${p}`, 'bad'));
+    }
+    top.blank();
+    hostSection(top, view);
+    machineSection(top, view, o);
+    const head = new Lines(o);
+    containerHead(head, view, o);
+    const tail = new Lines(o);
+    hintSection(tail, view, o);
+    return { top: top.out, head: head.out, rows: containerRows(view, o), tail: tail.out };
+}
+function hostSection(l, v) {
+    const vm = v.host.vm;
+    if (!vm) {
+        return;
+    }
+    const mac = v.platform === 'darwin' ? 'THIS MAC' : 'THIS COMPUTER';
+    l.heading(mac, `${bytes(v.host.memory)} memory · ${v.host.cpus} cores`);
+    l.intro('Containers do not run on this computer directly: they run inside one Linux virtual ' +
+        'machine, and these rows are what that machine costs it.');
+    const share = vm.memory / v.host.memory;
+    l.row('machine', bytes(vm.memory), pressure(share * 2), [
+        sp('  '),
+        ...bar([
+            [share, '█', pressure(share * 2)],
+            [1, '░', 'dim'],
+        ], 20),
+        sp(`  ${pct(share * 100)}`, 'dim'),
+    ], vm.footprint !== undefined
+        ? `what Activity Monitor shows for “${vm.name}”: memory the machine has touched, which grows and rarely shrinks`
+        : `memory held by ${vm.name}`, vm.footprint !== undefined ? 'Activity Monitor’s figure' : '');
+    if (vm.footprint !== undefined && vm.rss < vm.footprint * 0.8) {
+        l.row('in RAM now', bytes(vm.rss), 'plain', [sp(`  ${pct((vm.rss / vm.footprint) * 100)} of it`, 'dim')], 'the part physically in RAM; macOS has compressed or swapped the rest', 'rest compressed or swapped');
+    }
+    if (vm.peak !== undefined && vm.peak > vm.memory * 1.02) {
+        l.row('peak', bytes(vm.peak), 'plain', [], 'the most it has held since the machine started', 'most since it started');
+    }
+    l.row('cpu', vm.cpu === undefined ? '…' : pct(vm.cpu), vm.cpu === undefined ? 'dim' : pressure(vm.cpu / 100 / Math.max(1, v.host.cpus)), [sp('  of one core', 'dim')], '100% is one core kept fully busy by everything inside the machine', '100% = one core busy');
+    if (v.host.helpers.length > 0) {
+        const mem = v.host.helpers.reduce((n, p) => n + p.memory, 0);
+        l.row('helpers', bytes(mem), 'plain', [sp(`  ${v.host.helpers.map((p) => p.name).join(', ')}`, 'dim')], 'programs beside the machine: vfkit starts it, gvproxy carries its network', 'start it, carry its network');
+    }
+    l.blank();
+}
+function machineSection(l, v, o) {
+    const m = v.machine;
+    if (!m) {
+        return;
+    }
+    const native = v.platform === 'linux';
+    l.heading(native ? 'THIS COMPUTER' : 'INSIDE THE MACHINE', [m.name, `${bytes(m.total)} memory`, `${m.cpus} cpus`].filter(Boolean).join(' · '));
+    l.intro(native
+        ? 'Containers run directly on this computer, so they share its memory with everything else on it.'
+        : 'The Linux machine every container shares. Its size was set when it was created; ' +
+            '`podman machine set --memory` changes it.');
+    const width = Math.max(10, Math.min(BAR * 2, o.width - 4));
+    l.push(sp('  '), ...bar([
+        [m.used / m.total, '█', pressure(m.used / m.total)],
+        [m.cache / m.total, '▒', 'accent'],
+        [1, '░', 'dim'],
+    ], width));
+    if (o.explain) {
+        l.push(sp('  '), sp('█', pressure(m.used / m.total)), sp(' in use  ', 'dim'), sp('▒', 'accent'), sp(' cache  ', 'dim'), sp('░ free', 'dim'));
+    }
+    const of = (n) => [sp(`  ${pct((n / m.total) * 100).padStart(4)}`, 'dim')];
+    l.row('in use', bytes(m.used), pressure(m.used / m.total), of(m.used), 'held by programs: the containers and the machine’s own services', 'held by programs');
+    l.row('cache', bytes(m.cache), 'accent', of(m.cache), 'recently read files kept for speed; given back the moment a program needs room', 'file cache, freed on demand');
+    l.row('free', bytes(m.free), 'plain', of(m.free), 'not used for anything', 'unused');
+    l.row('available', bytes(m.available), pressure(1 - m.available / m.total), of(m.available), 'what a new command could get right now: free plus cache', 'free + cache: room left');
+    l.row('swap', bytes(m.swapUsed), m.swapUsed > 64 * MIB ? 'warn' : 'plain', [sp(`  of ${bytes(m.swapTotal)}`, 'dim')], 'memory moved to disk when RAM ran out; above zero means it ran short and slowed down', 'RAM spilled to disk');
+    if (m.held !== undefined && m.held > 256 * MIB) {
+        l.row('held, unused', bytes(m.held), 'warn', [], 'counted by macOS, used by nothing inside: freed after earlier use, never handed back', 'macOS counts it, nothing uses it');
+    }
+    l.blank();
+}
+function containerHead(l, v, o) {
+    const t = v.totals;
+    const kinds = [
+        t.zen ? `${t.zen} zen` : '',
+        t.faker ? `${t.faker} faker` : '',
+        t.other ? `${t.other} other` : '',
+    ]
+        .filter(Boolean)
+        .join(', ');
+    l.heading('CONTAINERS', t.running === 0
+        ? `none running${v.stopped ? ` · ${v.stopped} stopped` : ''}`
+        : [
+            `${t.running} running${kinds ? ` (${kinds})` : ''}`,
+            `${bytes(t.memory)} memory`,
+            `cpu ${pct(t.cpu)}`,
+            v.stopped ? `${v.stopped} stopped` : '',
+        ]
+            .filter(Boolean)
+            .join(' · '));
+    l.intro('Running ones only: a stopped container keeps its files but uses no memory or cpu. ' +
+        'zen makes one per session; zen faker servers and anything else in podman are listed too.');
+    if (t.running === 0) {
+        return;
+    }
+    if (o.explain && o.intros !== false) {
+        const over = v.interval ? `the last ${v.interval.toFixed(0)}s` : 'its whole life so far';
+        const legend = [
+            `CPU — share of one core over ${over}; 100% is one core fully busy.`,
+            'MEMORY — what its programs hold now, cache not counted; the bar is how close it is to LIMIT.',
+            'LIMIT — the most it may use (`sandbox.memory` in agents.yaml); past it a command is killed with exit 137.',
+            'NET — received ↓ and sent ↑ since it started.  orphaned — its zen run is gone, yet it keeps running.',
+        ];
+        for (const text of legend) {
+            for (const line of wrap(text, Math.max(20, o.width - 4))) {
+                l.push(sp(`  ${line}`, 'dim'));
+            }
+        }
+    }
+    l.push(sp('  '), ...tableColumns(o.width).flatMap((c, i) => [
+        sp(i > 0 ? ' ' : ''),
+        sp(c.align === 'right' ? c.title.padStart(c.width) : c.title.padEnd(c.width), 'strong'),
+    ]));
+}
+/** The name gets whatever the other columns leave, but never less than this. */
+const NAME_MIN = 24;
+const COLUMNS = [
+    {
+        title: 'CPU',
+        width: 7,
+        align: 'right',
+        keep: 0,
+        cell: (c) => [sp(pct(c.cpu), c.cpuOver === 'lifetime' ? 'dim' : pressure(c.cpu / 100))],
+    },
+    {
+        title: 'MEMORY',
+        width: 9,
+        align: 'right',
+        keep: 0,
+        cell: (c) => [sp(bytes(c.memory), c.limit ? pressure(c.memory / c.limit) : 'plain')],
+    },
+    {
+        title: '',
+        width: 10,
+        align: 'left',
+        keep: 3,
+        cell: (c) => c.limit
+            ? bar([
+                [c.memory / c.limit, '█', pressure(c.memory / c.limit)],
+                [1, '░', 'dim'],
+            ], 10)
+            : [sp('·', 'dim')],
+    },
+    {
+        title: 'LIMIT',
+        width: 9,
+        align: 'right',
+        keep: 4,
+        cell: (c) => [sp(c.limit ? bytes(c.limit) : 'none', 'dim')],
+    },
+    {
+        title: 'PIDS',
+        width: 5,
+        align: 'right',
+        keep: 2,
+        cell: (c) => [sp(String(c.pids))],
+    },
+    {
+        title: 'NET ↓ / ↑',
+        width: 19,
+        align: 'left',
+        keep: 1,
+        cell: (c) => [sp(`${bytes(c.netIn)} ↓ ${bytes(c.netOut)} ↑`, 'dim')],
+    },
+    {
+        title: 'AGE',
+        width: 5,
+        align: 'left',
+        keep: 2,
+        cell: (c) => [
+            sp(c.createdAt ? ago(c.createdAt).replace(' ago', '').replace('just now', 'now') : '', 'dim'),
+        ],
+    },
+    {
+        title: 'WHAT',
+        width: 8,
+        align: 'left',
+        keep: 0,
+        cell: (c) => [
+            sp(c.orphaned ? 'orphaned' : c.kind, c.orphaned ? 'warn' : c.kind === 'other' ? 'dim' : 'plain'),
+        ],
+    },
+    {
+        title: 'PROJECT',
+        width: 14,
+        align: 'left',
+        keep: 5,
+        cell: (c) => [sp(clipTo(c.project ?? (c.kind === 'faker' ? '(faker)' : '—'), 14))],
+    },
+];
+/** The columns that fit, in order, dropping the least needed until the name has room. */
+function tableColumns(width) {
+    let cols = [...COLUMNS];
+    const used = () => 2 + cols.reduce((n, c) => n + c.width + 1, 0);
+    const order = [...COLUMNS].filter((c) => c.keep > 0).sort((a, b) => a.keep - b.keep);
+    for (const drop of order) {
+        if (used() + NAME_MIN <= width) {
+            break;
+        }
+        cols = cols.filter((c) => c !== drop);
+    }
+    return [...cols, { title: 'NAME', width: 0, align: 'left', keep: 0, cell: () => [] }];
+}
+function containerRows(v, o) {
+    const sorted = [...v.containers].sort((a, b) => {
+        switch (o.sort ?? 'memory') {
+            case 'cpu':
+                return b.cpu - a.cpu;
+            case 'name':
+                return a.name.localeCompare(b.name);
+            default:
+                return b.memory - a.memory;
+        }
+    });
+    const cols = tableColumns(o.width).slice(0, -1);
+    const room = Math.max(NAME_MIN, o.width - 2 - cols.reduce((n, c) => n + c.width + 1, 0));
+    return sorted.map((c) => finish([
+        sp('  '),
+        ...cols.flatMap((col) => {
+            const spans = col.cell(c);
+            const len = spans.reduce((n, s) => n + s.text.length, 0);
+            const pad = sp(' '.repeat(Math.max(0, col.width - len)));
+            return col.align === 'right' ? [pad, ...spans, sp(' ')] : [...spans, pad, sp(' ')];
+        }),
+        sp(clipTo(c.name, room), 'dim'),
+    ]));
+}
+function clipTo(text, width) {
+    return text.length <= width ? text : `${text.slice(0, width - 1)}…`;
+}
+function hintSection(l, v, o) {
+    if (v.hints.length === 0) {
+        return;
+    }
+    l.blank();
+    l.heading('WHAT TO DO', '');
+    for (const hint of v.hints) {
+        const [first = '', ...rest] = wrap(hint, Math.max(20, o.width - 6));
+        l.push(sp(HINT_MARK, 'warn'), sp(first));
+        for (const line of rest) {
+            l.push(sp(`    ${line}`));
+        }
+    }
+}
+//# sourceMappingURL=resources.js.map