@zenera/cli 1.1.0 → 1.1.2

package/dist/commands/check.js

@@ -1,11 +1,11 @@
-import { basename, resolve } from 'node:path';
+import { basename, dirname, resolve } from 'node:path';
 import { one, parse } from "../args.js";
 import { KeyStore } from "../keys.js";
 import { Registry } from "../projects.js";
 import { project as resolveProject } from "../resolve.js";
-import { bold, count, cyan, dim, green, invalidError, json, red, table, write, writeAll, yellow, } from "../term.js";
+import { bold, count, cyan, dim, green, invalidError, json, progress, red, table, write, writeAll, yellow, } from "../term.js";
 import { validateProject, } from "../validate.js";
-const USAGE = 'zen check [dir] [--project <name|dir>] [--strict] [--quiet]';
+const USAGE = 'zen check [dir] [--project <name|dir>] [--no-sandbox] [--strict] [--quiet]';
 // ---------------------------------------------------------------------------
 // zen check
 //
@@ -16,19 +16,27 @@ const USAGE = 'zen check [dir] [--project <name|dir>] [--strict] [--quiet]';
 // stable code and a fix, and the whole thing goes to stdout — it is the answer,
 // not narration.
 //
-// Nothing here is contacted, started or paid for. That is the point: the check
-// has to work on the machine that is not set up yet, which is the machine that
-// most needs it.
+// Nothing is contacted or paid for. The one thing that *runs* is the sandbox:
+// the project's image is built and one command is executed in it, because a
+// Dockerfile that does not build is a broken project and nothing short of
+// building it says so. It happens against a temporary directory, the container
+// is removed on the way out, and `--no-sandbox` skips it — so the report is
+// still worth having on the machine that has no container engine at all.
 // ---------------------------------------------------------------------------
 export const check = {
     summary: 'Validate agents.yaml and every file it names, and report in full.',
     usage: USAGE,
     details: [
-        'Checks the whole project without running anything: the configuration',
-        'parses and satisfies the schema, every prompt, skill and catalog it',
-        'names is on disk, hand-offs and forks name agents that exist, tool',
-        'selectors resolve, skills bind to a catalog that holds them, and the',
-        'models it declares have a credential on this machine.',
+        'Checks the whole project: the configuration parses and satisfies the',
+        'schema, every prompt, skill and catalog it names is on disk, hand-offs',
+        'and forks name agents that exist, tool selectors resolve, skills bind to',
+        'a catalog that holds them, and the models it declares have a credential',
+        'on this machine.',
+        '',
+        'It also builds the sandbox image and runs one command in it, against a',
+        'temporary directory rather than your workspace. That is the only thing',
+        'it starts, and --no-sandbox skips it. No container engine is a warning,',
+        'not an error.',
         '',
         'Unlike a run, it does not stop at the first problem — the report lists',
         'everything it found, each with a code and the fix for it.',
@@ -39,6 +47,7 @@ export const check = {
     run: async (ctx) => {
         const { values, positionals } = parse(ctx.args, {
             project: { type: 'string' },
+            'no-sandbox': { type: 'boolean' },
             strict: { type: 'boolean' },
             quiet: { type: 'boolean' },
         }, USAGE);
@@ -58,12 +67,18 @@ export const check = {
         // the same key by the time the library asks.
         const keys = await KeyStore.open();
         keys.materialize();
+        const bar = progress();
         const report = await validateProject({
             dir,
             name,
             registered: entry !== undefined,
             keys,
+            sandbox: {
+                enabled: !values['no-sandbox'],
+                onProgress: (what) => bar.update(dim(what)),
+            },
         });
+        bar.done();
         if (ctx.json) {
             json(report);
         }
@@ -121,12 +136,22 @@ function render(report) {
         ? `${count(report.skills.entries.length, 'skill')} in ${report.skills.dirs.join(', ')}`
         : 'no catalog')}`);
     if (report.skills.entries.length) {
-        push(...table(report.skills.entries.map((s) => [
+        // A folder skill's own files travel with it: they are mounted at
+        // /skills/<folder> and the body may point the model straight at them,
+        // so say what is there and under which name.
+        const rows = table(report.skills.entries.map((s) => [
             `  ${s.name}`,
             dim(s.path),
             dim(s.tools?.length ? `unlocks ${s.tools.join(' ')}` : ''),
             dim(s.usedBy.length ? `used by ${s.usedBy.join(', ')}` : 'unused'),
-        ])));
+        ]));
+        report.skills.entries.forEach((s, i) => {
+            push(rows[i] ?? '');
+            if (s.files?.length) {
+                const at = basename(dirname(s.path));
+                push(dim(`    /skills/${at}/  ${s.files.join('  ')}`));
+            }
+        });
     }
     // Models ----------------------------------------------------------------
     push('', bold('Models'));
@@ -156,13 +181,21 @@ function render(report) {
         push('', bold('Sandbox'));
         push(...table([
             ['  image', report.sandbox.image ?? dim('the default image')],
+            ...(report.sandbox.dockerfile
+                ? [['  built from', report.sandbox.dockerfile]]
+                : []),
             [
                 '  reached by',
                 report.sandbox.used
                     ? 'at least one agent has the shell tools'
                     : dim('nothing — the block is declared but no agent can run a command'),
             ],
-            ['  requires', dim('podman on this machine: zen sandbox status')],
+            [
+                '  tried',
+                report.sandbox.probed
+                    ? green('built, started, and a command ran in it')
+                    : dim('no — nothing was built or started'),
+            ],
         ]));
     }
     // Findings --------------------------------------------------------------

package/dist/commands/sandbox.js

@@ -1,9 +1,15 @@
 import { readProjectConfig } from '@zenera/neo';
 import { parse } from "../args.js";
-import { ensurePodmanReady, ownedContainers, podmanStatus, removeContainers } from "../podman.js";
+import { resolveBuild } from "../image.js";
+import { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "../podman.js";
+import { dirSize, isProjectDir, Registry, sessionIds } from "../projects.js";
 import { project as findProject } from "../resolve.js";
-import { bold, dim, green, json, note, red, usageError, write, yellow } from "../term.js";
-const USAGE = 'zen sandbox [status|up|pull|clean] [options]';
+import { ago, bold, bytes, dim, green, json, note, red, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen sandbox [status|up|pull|clean|disk] [options]';
+/** Enough to see the pattern; the rest are a number. */
+const LISTED = 6;
+/** Under the labels, which is where the eye already is. */
+const INDENT = ' '.repeat(11);
 // ---------------------------------------------------------------------------
 // The container engine, on its own
 //
@@ -18,9 +24,10 @@ export const sandbox = {
     usage: USAGE,
     details: [
         '  status                 What is installed, running and pulled. Changes nothing.',
-        '  up                     Install if asked, start the machine, pull the image.',
-        '  pull                   Just the image.',
+        '  up                     Install if asked, start the machine, pull or build the image.',
+        '  pull                   Just the image: pulled, or built from the project\u2019s Dockerfile.',
         '  clean                  Remove every container this CLI created.',
+        '  disk                   What the engine and every known project occupy.',
         '',
         '  --project <name|dir>   Which project the image comes from.',
         '  --image <ref>          Use this image instead of the project\u2019s.',
@@ -34,22 +41,29 @@ export const sandbox = {
             image: { type: 'string' },
         }, USAGE);
         const what = positionals[0] ?? 'status';
-        if (!['status', 'up', 'pull', 'clean'].includes(what)) {
+        if (!['status', 'up', 'pull', 'clean', 'disk'].includes(what)) {
             throw usageError(`unknown subcommand: ${what}`, USAGE);
         }
         if (positionals.length > 1) {
             throw usageError('one subcommand at a time', USAGE);
         }
-        const image = values.image ?? (await projectImage(ctx.cwd, values));
+        // `clean` and `disk` are machine-wide questions, so asking which
+        // project they mean would be asking something they do not use.
+        const scoped = what === 'status' || what === 'up' || what === 'pull';
+        const found = values.image || !scoped ? undefined : await projectSandbox(ctx.cwd, values);
+        const image = values.image ?? found?.image;
+        const build = found?.build;
         switch (what) {
             case 'status':
-                return status(image, ctx.json);
+                return status(image, build, ctx.json);
             case 'up':
-                return up(image, ctx.json, ctx.json);
+                return up(image, build, ctx.json, ctx.json);
             case 'pull':
-                return up(image, true, ctx.json);
+                return up(image, build, true, ctx.json, true);
             case 'clean':
                 return clean(ctx.json);
+            case 'disk':
+                return disk(ctx.json);
         }
     },
 };
@@ -59,20 +73,22 @@ export const sandbox = {
  * not a failure — it just means there is no image to report on. Notably this
  * does *not* go through `target`: reading a setting must not create a session.
  */
-async function projectImage(cwd, values) {
+async function projectSandbox(cwd, values) {
     try {
         const found = await findProject({ cwd, project: values.project, yes: true });
-        return readProjectConfig(found.dir).config.sandbox?.image;
+        const { root, config } = readProjectConfig(found.dir);
+        const build = resolveBuild(root, config.sandbox);
+        return { image: build?.tag ?? config.sandbox?.image, build };
     }
     catch {
         return undefined;
     }
 }
-async function status(image, asJson) {
+async function status(image, build, asJson) {
     const found = await podmanStatus({ image });
     const containers = found.ready ? await ownedContainers(found.engine) : [];
     if (asJson) {
-        json({ ...found, containers });
+        json({ ...found, dockerfile: build?.dockerfile ?? null, containers });
         return;
     }
     const mark = (ok) => (ok ? green('ok') : red('no'));
@@ -85,28 +101,216 @@ async function status(image, asJson) {
     if (found.image) {
         write(`${bold('image')}      ${found.image} ${mark(Boolean(found.imagePresent))}`);
     }
-    const listed = containers.map((c) => c.state === 'running' ? `${c.name} ${green('running')}` : `${c.name} ${dim(c.state)}`);
-    write(`${bold('containers')} ${listed.length ? listed.join(', ') : dim('none')}`);
+    if (build) {
+        write(`${bold('dockerfile')} ${dim(build.dockerfile)}`);
+    }
+    writeAll(containerLines(containers));
     if (!found.installed || !found.ready) {
         note('');
         note(dim('run `zen sandbox up` to fix what can be fixed.'));
     }
 }
-async function up(image, yes, asJson) {
-    await ensurePodmanReady({ image, yes });
+/**
+ * One per line rather than one long line, because there is normally more than
+ * one and the interesting part — how old, and whether anything is still up —
+ * is at the end of a name too long to scan.
+ *
+ * The trailing note is there because the count surprises people: a container
+ * is per *session*, not per project, and `persist: true` is what leaves the
+ * stopped ones behind.
+ */
+function containerLines(containers) {
+    if (containers.length === 0) {
+        return [`${bold('containers')} ${dim('none')}`];
+    }
+    const running = containers.filter((c) => c.state === 'running').length;
+    const head = `${bold('containers')} ${containers.length} ${dim(running ? `· ${running} running` : '· none running')}`;
+    const rows = containers
+        .slice(0, LISTED)
+        .map((c) => [
+        INDENT.slice(2),
+        c.name,
+        c.state === 'running' ? green('running') : dim(c.state),
+        dim(ago(c.createdAt)),
+    ]);
+    const rest = containers.length - LISTED;
+    return [
+        head,
+        ...table(rows),
+        ...(rest > 0 ? [`${INDENT}${dim(`+${rest} more`)}`] : []),
+        `${INDENT}${dim('one per session, kept by `persist: true` — see: zen sandbox disk')}`,
+    ];
+}
+async function up(image, build, yes, asJson, rebuild = false) {
+    await ensurePodmanReady({ image, build, yes, rebuild });
     if (asJson) {
-        json({ ready: true, image });
+        json({ ready: true, image, dockerfile: build?.dockerfile ?? null });
         return;
     }
     write(`${green('ready')}${image ? ` ${dim(image)}` : ''}`);
 }
 async function clean(asJson) {
-    const names = (await ownedContainers()).map((c) => c.name);
+    const containers = await ownedContainers(undefined, undefined, { sizes: true });
+    const names = containers.map((c) => c.name);
+    const freed = containers.reduce((n, c) => n + (c.size ?? 0), 0);
     await removeContainers(names);
     if (asJson) {
-        json({ removed: names });
+        json({ removed: names, freed });
+        return;
+    }
+    if (names.length === 0) {
+        write(dim('nothing to remove'));
+        return;
+    }
+    write(`removed ${names.length} ${dim(`· ${bytes(freed)} freed`)}`);
+    write(dim('images are left alone — see: zen sandbox disk'));
+}
+async function disk(asJson) {
+    const found = await podmanStatus();
+    const [usage, containers] = found.ready
+        ? await Promise.all([
+            engineDisk(found.engine),
+            ownedContainers(found.engine, undefined, { sizes: true }),
+        ])
+        : [undefined, []];
+    const { projects, loose } = await projectDisk(containers);
+    if (asJson) {
+        json({ engine: found.engine, ready: found.ready, ...usage, projects, unclaimed: loose });
         return;
     }
-    write(names.length ? `removed ${names.length}: ${names.join(', ')}` : dim('nothing to remove'));
+    if (usage) {
+        write(`${bold('engine')} ${found.engine} ${dim(found.version ?? '')}`);
+        writeAll(engineRows(usage));
+        write('');
+    }
+    else {
+        write(dim(`${found.engine} did not answer — projects only`));
+        write('');
+    }
+    writeAll(projectRows(projects, loose));
+    if (usage && usage.images.reclaimable > 0) {
+        write('');
+        write(dim(`zen sandbox clean       every container above`));
+        write(dim(`podman image prune -a   ${bytes(usage.images.reclaimable)} of unused images`));
+    }
+}
+function engineRows(usage) {
+    // Dimming an empty cell is not empty: it is two escape codes of nothing,
+    // which `table` cannot trim and which leave trailing whitespace behind.
+    const hint = (s) => (s ? dim(s) : '');
+    const rows = [
+        [
+            bold('images'),
+            String(usage.images.count),
+            bytes(usage.images.size),
+            hint(usage.images.reclaimable > 0 ? `${bytes(usage.images.reclaimable)} unused` : ''),
+        ],
+        [
+            bold('containers'),
+            String(usage.containers.count),
+            bytes(usage.containers.size),
+            hint(usage.containers.active > 0 ? `${usage.containers.active} running` : ''),
+        ],
+        [bold('volumes'), String(usage.volumes.count), bytes(usage.volumes.size), ''],
+    ];
+    if (usage.store) {
+        rows.push([
+            bold('store'),
+            '',
+            bytes(usage.store.used),
+            hint(`of ${bytes(usage.store.capacity)}`),
+        ]);
+    }
+    if (usage.image) {
+        // The one number that is actually gone from this host's disk. It is
+        // larger than the store's own `used` because freeing blocks inside the
+        // machine does not hand them back until something trims them.
+        rows.push([
+            bold('on this host'),
+            '',
+            bytes(usage.image.allocated),
+            hint(`${usage.image.name} disk image, which never shrinks on its own`),
+        ]);
+    }
+    return table(rows);
+}
+function projectRows(projects, loose) {
+    if (projects.length === 0 && loose.length === 0) {
+        return [dim('no projects yet')];
+    }
+    const rows = [
+        [
+            bold('PROJECT'),
+            bold('SESSIONS'),
+            bold('ON DISK'),
+            bold('CONTAINERS'),
+            bold('IN PODMAN'),
+            '',
+        ],
+    ];
+    for (const p of projects) {
+        const style = p.present ? (s) => s : dim;
+        rows.push([
+            style(p.name),
+            style(String(p.sessions)),
+            style(bytes(p.files)),
+            style(p.containers ? String(p.containers) : dim('—')),
+            style(p.layers ? bytes(p.layers) : dim('—')),
+            p.present ? '' : dim('(missing)'),
+        ]);
+    }
+    if (loose.length > 0) {
+        // Containers whose session directory is gone, and faker's, which are
+        // labelled the same way and belong to no project at all.
+        const size = loose.reduce((n, c) => n + (c.size ?? 0), 0);
+        rows.push([
+            dim('(unclaimed)'),
+            dim('—'),
+            dim('—'),
+            dim(String(loose.length)),
+            dim(bytes(size)),
+            dim('no session owns these'),
+        ]);
+    }
+    const total = (pick) => projects.reduce((n, p) => n + pick(p), 0);
+    rows.push([
+        bold('total'),
+        bold(String(total((p) => p.sessions))),
+        bold(bytes(total((p) => p.files))),
+        bold(String(total((p) => p.containers) + loose.length)),
+        bold(bytes(total((p) => p.layers) + loose.reduce((n, c) => n + (c.size ?? 0), 0))),
+        '',
+    ]);
+    return table(rows);
+}
+/**
+ * Containers carry the session id that made them, and a session id is a
+ * directory name under a project — so the label is enough to attribute one,
+ * with no second index to keep in step with reality.
+ */
+async function projectDisk(containers) {
+    const registry = await Registry.open();
+    const claimed = new Set();
+    const projects = [];
+    for (const entry of registry.entries) {
+        const present = isProjectDir(entry.path);
+        const sessions = new Set(present ? sessionIds(entry.path) : []);
+        const mine = containers.filter((c) => c.key !== undefined && sessions.has(c.key));
+        for (const c of mine) {
+            claimed.add(c.name);
+        }
+        projects.push({
+            name: entry.name,
+            path: entry.path,
+            present,
+            sessions: sessions.size,
+            files: present ? dirSize(entry.path) : 0,
+            containers: mine.length,
+            layers: mine.reduce((n, c) => n + (c.size ?? 0), 0),
+        });
+    }
+    // By the column that is shown, so the order is one a reader can check.
+    projects.sort((a, b) => b.files - a.files);
+    return { projects, loose: containers.filter((c) => !claimed.has(c.name)) };
 }
 //# sourceMappingURL=sandbox.js.map

package/dist/engine.d.ts

@@ -1,5 +1,5 @@
 import { AgentRunner, type AgentEvent, type AgentProject, type AgentState, type Input, type RunResult } from '@zenera/neo';
-import type { Project } from './projects.ts';
+import { type Project } from './projects.ts';
 import { type SandboxSetup } from './sandbox.ts';
 import { type Held, type RunPaths, type SessionPaths } from './session.ts';
 export interface EngineOptions {

package/dist/engine.js

@@ -1,10 +1,11 @@
+import { AgentRunner, FileMemoryStore, FilePayloadStore, SANDBOX_MOUNT, SKILLS_MOUNT, assertState, buildRunReport, exaTools, lastText, loadProject, readProjectConfig, renderReportHtml, sandboxTools, turns, workspaceTools, } from '@zenera/neo';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { AgentRunner, FileMemoryStore, FilePayloadStore, SANDBOX_MOUNT, assertState, buildRunReport, exaTools, lastText, loadProject, readProjectConfig, renderReportHtml, sandboxTools, turns, workspaceTools, } from '@zenera/neo';
 import { auditModels, describeIssue } from "./audit.js";
 import { readJson, writeJson } from "./home.js";
 import { KeyStore, assertUsable } from "./keys.js";
+import { projectMounts } from "./projects.js";
 import { buildSandbox, preflight, teardown, usesSandbox } from "./sandbox.js";
 import { acquire, createRun, readSessionMeta, writeSessionMeta, } from "./session.js";
 import { CliError, EXIT, invalidError, warn } from "./term.js";
@@ -35,13 +36,17 @@ export async function open(opts) {
     let sandbox;
     let project;
     try {
-        const { config } = readProjectConfig(opts.project.dir);
+        const { root, config } = readProjectConfig(opts.project.dir);
+        // Assets and the skill catalog are mounted for both, under one name.
+        const mounts = projectMounts(root, config);
         sandbox = buildSandbox({
             config,
+            root,
             session: opts.session,
             workspace,
             readOnly: opts.readOnly,
             image: opts.image,
+            mounts,
         });
         project = await loadProject(opts.project.dir, {
             tools: [
@@ -52,6 +57,7 @@ export async function open(opts) {
                     root: workspace,
                     readOnly: opts.readOnly,
                     mount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
+                    mounts,
                 }),
                 ...sandboxTools(sandbox.pool),
                 // Registered whether or not a key exists: the credential is
@@ -60,6 +66,7 @@ export async function open(opts) {
                 // turn that tried.
                 ...exaTools(),
             ],
+            skillsAt: SKILLS_MOUNT,
             payloads,
             memory,
         });

package/dist/image.d.ts

@@ -0,0 +1,16 @@
+import { type SandboxConfig } from '@zenera/neo';
+export interface ResolvedBuild {
+    /** the image reference to run, and to build under */
+    tag: string;
+    /** absolute path to the Dockerfile */
+    dockerfile: string;
+    /** absolute path to the build context */
+    context: string;
+}
+/**
+ * What the config's `build:` block means on this machine, or nothing if it has
+ * none. Both paths are resolved against the project root and refused if they
+ * escape it — a project is data someone else may have written.
+ */
+export declare function resolveBuild(root: string, config?: SandboxConfig): ResolvedBuild | undefined;
+//# sourceMappingURL=image.d.ts.map

package/dist/image.js

@@ -0,0 +1,85 @@
+import { projectDir, projectFile } from '@zenera/neo';
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+// ---------------------------------------------------------------------------
+// Building the sandbox image
+//
+// `image:` names something to pull; `build:` names a Dockerfile to build. The
+// library never learns the difference — it is handed a resolved reference and
+// runs it — because building is a host concern with a container engine
+// attached to it, and that is the line this CLI exists on the other side of.
+//
+// The tag is a function of what goes into the image, and it has to be: the
+// container's name in @zenera/neo hashes `spec.image`, so a tag that stayed put
+// while the Dockerfile changed would leave a `persist: true` container running
+// last week's filesystem, with nothing anywhere saying so. Hashing the context
+// as well as the Dockerfile means an edit to either yields a new tag, a new
+// container name, and a build — which is the only honest answer.
+// ---------------------------------------------------------------------------
+/** Not scoped: a `/` or an `@` is not a legal image tag. */
+const TAG = 'localhost/zenera-sandbox';
+/**
+ * A build context is meant to be small — a Dockerfile and whatever it copies.
+ * Hashing a directory someone pointed at their whole home folder would hang
+ * before it was wrong, so it stops and says which key to narrow.
+ */
+const MAX_CONTEXT_FILES = 2_000;
+/**
+ * What the config's `build:` block means on this machine, or nothing if it has
+ * none. Both paths are resolved against the project root and refused if they
+ * escape it — a project is data someone else may have written.
+ */
+export function resolveBuild(root, config) {
+    if (!config?.build) {
+        return undefined;
+    }
+    const dockerfile = projectFile(root, config.build.dockerfile, 'sandbox.build.dockerfile');
+    const context = config.build.context
+        ? projectDir(root, config.build.context, 'sandbox.build.context')
+        : dirname(dockerfile);
+    return { tag: `${TAG}:${digest(dockerfile, context)}`, dockerfile, context };
+}
+/**
+ * The content address of a build: the Dockerfile, then every file the build can
+ * see, by path and by content.
+ *
+ * `.dockerignore` is not read. The engine honours it and we do not, so an
+ * ignored file that changes yields a new tag and a build that produces the same
+ * image — wasteful, never wrong, and the alternative is reimplementing a match
+ * syntax whose disagreements would be silent.
+ */
+function digest(dockerfile, context) {
+    const hash = createHash('sha256');
+    hash.update(readFileSync(dockerfile));
+    for (const rel of walk(context)) {
+        // The separator is hashed as posix so the same tree tags the same on
+        // any host.
+        hash.update(`\0${rel.split(sep).join('/')}\0`);
+        hash.update(readFileSync(join(context, rel)));
+    }
+    return hash.digest('hex').slice(0, 12);
+}
+/** Every file under `dir`, relative and sorted, so the digest is stable. */
+function walk(dir) {
+    const found = [];
+    const pending = [dir];
+    while (pending.length > 0) {
+        const at = pending.pop();
+        for (const entry of readdirSync(at, { withFileTypes: true })) {
+            const path = join(at, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(path);
+            }
+            else if (entry.isFile()) {
+                found.push(relative(dir, path));
+            }
+        }
+        if (found.length > MAX_CONTEXT_FILES) {
+            throw new Error(`sandbox.build.context: ${dir} holds more than ${MAX_CONTEXT_FILES} files — ` +
+                'point `context:` at the directory the build actually copies from');
+        }
+    }
+    return found.sort();
+}
+//# sourceMappingURL=image.js.map

package/dist/lib.d.ts

@@ -4,6 +4,6 @@ export type { Command, Context } from './command.ts';
 export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson } from './home.ts';
 export { assertNotEmpty, assertOwner, assertUsable, describe, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, type KeyCheck, type KeyEntry, type KeyOwner, type Liveness, type Provider, type Service, } from './keys.ts';
 export { probe, probeAll } from './liveness.ts';
-export { ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, type OwnedContainer, type PodmanOptions, type PodmanStatus, } from './podman.ts';
+export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, type DiskLine, type EngineDisk, type OwnedContainer, type PodmanOptions, type PodmanStatus, } from './podman.ts';
 export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.js

@@ -26,6 +26,6 @@ export { printBanner } from "./banner.js";
 export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson } from "./home.js";
 export { assertNotEmpty, assertOwner, assertUsable, describe, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, } from "./keys.js";
 export { probe, probeAll } from "./liveness.js";
-export { ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "./podman.js";
+export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "./podman.js";
 export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, json, note, pad, red, table, usageError, warn, write, writeAll, yellow, } from "./term.js";
 //# sourceMappingURL=lib.js.map