pixie-lab 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

pixie/catalog/__init__.py

@@ -22,4 +22,28 @@ readiness; no ready/pending vocabulary, no auto-fetch, no misses page.
 
 from __future__ import annotations
 
-DEFAULT_CATALOG_URL = "https://github.com/safl/nosi/releases/latest/download/catalog.toml"
+from importlib.resources import files
+
+# Default "Import catalog" + live-env TUI source. Points at PIXIE's own
+# release copy of the curated catalog (a subset of nosi's, restricted to
+# the netboot-capable images pixie tests + supports), NOT the upstream
+# nosi catalog. Operators can still import the full nosi catalog by URL;
+# this is just the convenience default.
+DEFAULT_CATALOG_URL = "https://github.com/safl/pixie/releases/latest/download/catalog.toml"
+
+# The same curated catalog shipped INSIDE the package, used to seed a
+# fresh (empty) catalog on first start so a plain deploy comes up with
+# the known-good set offline -- no network, no release dependency.
+BUNDLED_CATALOG_RESOURCE = "catalog.toml"
+
+# Startup seeding is gated on this env (default on). Tests + operators
+# who want an empty catalog set it to ``0``. A one-shot settings marker
+# (below) records that the seed already ran so a later restart never
+# re-seeds after an operator curated the catalog down.
+SEED_CATALOG_ENV = "PIXIE_SEED_CATALOG"
+CATALOG_SEEDED_KEY = "catalog.seeded"
+
+
+def bundled_catalog_bytes() -> bytes:
+    """The curated ``catalog.toml`` shipped inside the package."""
+    return (files("pixie.catalog") / BUNDLED_CATALOG_RESOURCE).read_bytes()

pixie/catalog/_live_env.py

@@ -0,0 +1,128 @@
+"""Fetch + stage the pixie live-env (the netboot-pc bake).
+
+The live env -- ``vmlinuz`` + ``initrd`` + ``live.squashfs`` that the
+``pixie-flash-*`` / ``pixie-inventory`` / ``pixie-tui`` boot modes chain
+into -- was the one artifact pixie could not retrieve itself: it had to
+be baked locally (``make build VARIANT=netboot-pc``) or hand-copied into
+``PIXIE_LIVE_ENV_DIR``. This module pulls it from a single tarball
+``src`` (the same ``https://`` / ``oras://`` schemes the catalog fetch
+speaks) and stages the three files atomically, reusing the catalog
+fetch pipeline's curl download + resume plumbing.
+
+Contract with CI's ``publish-release`` job: the tarball carries exactly
+``vmlinuz`` + ``initrd`` + ``live.squashfs`` at the archive root. Any
+other member is ignored; a missing one is a hard error (better a loud
+"tarball is wrong" than a live env that half-stages and boots into a
+mysterious squashfs-fetch hang).
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tarfile
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from pixie._util import CHUNK
+from pixie.catalog._fetcher import (
+    FetchError,
+    ProgressReporter,
+    _resolve_fetch_url,
+    _stream_to_tmpfile,
+)
+
+# The three files a target's iPXE chain pulls from
+# ``/boot/pixie-live-env/``. Names match what ``pixie-live-env.j2``
+# references (note ``live.squashfs``, not the bake's raw ``*.squashfs``
+# -- the CI tar step renames it).
+LIVE_ENV_FILES: frozenset[str] = frozenset({"vmlinuz", "initrd", "live.squashfs"})
+
+
+@dataclass
+class LiveEnvResult:
+    """Outcome of a successful stage: the src it came from, the sha256
+    of the downloaded tarball, its byte size, and the staged file
+    sizes."""
+
+    src: str
+    sha256: str
+    size: int
+    files: dict[str, int] = field(default_factory=dict)
+
+
+def _unpack_live_env_tar(tar_path: Path, live_env_dir: Path) -> dict[str, int]:
+    """Extract the live-env trio from ``tar_path`` into ``live_env_dir``
+    atomically. Returns ``{name: size_bytes}``.
+
+    Hardening mirrors :func:`pixie.catalog._fetcher._unpack_netboot_bundle`:
+    only basenames in :data:`LIVE_ENV_FILES` at the archive root are
+    accepted; nested paths, parent traversal, and dotfiles are dropped.
+    Files land in a staging subdir first, then each is ``os.replace``'d
+    onto its final name so a target fetching mid-stage sees the old
+    file or the new one, never a half-written squashfs.
+    """
+    live_env_dir.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix=".staging-", dir=str(live_env_dir)))
+    try:
+        # ``r:*`` transparently handles .tar / .tar.gz / .tar.xz so the
+        # CI side can pick whatever compression without a pixie change.
+        with tarfile.open(str(tar_path), mode="r:*") as tar:
+            for member in tar.getmembers():
+                if not member.isfile():
+                    continue
+                name = os.path.basename(member.name)
+                if not name or name.startswith(".") or name != member.name:
+                    continue
+                if name not in LIVE_ENV_FILES:
+                    continue
+                extracted = tar.extractfile(member)
+                if extracted is None:
+                    continue
+                with (staging / name).open("wb") as out:
+                    shutil.copyfileobj(extracted, out, length=CHUNK)
+
+        missing = LIVE_ENV_FILES - {p.name for p in staging.iterdir()}
+        if missing:
+            raise FetchError(
+                f"live-env tarball {tar_path.name} missing required file(s): {sorted(missing)}"
+            )
+
+        sizes: dict[str, int] = {}
+        for name in sorted(LIVE_ENV_FILES):
+            final = live_env_dir / name
+            os.replace(staging / name, final)
+            sizes[name] = final.stat().st_size
+        return sizes
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def stage_live_env(
+    src: str,
+    live_env_dir: Path,
+    *,
+    progress: ProgressReporter = None,
+) -> LiveEnvResult:
+    """Download the live-env tarball at ``src`` and stage its three
+    files into ``live_env_dir``.
+
+    Reuses the catalog fetch's curl transport (resume + retry + stall
+    detection). The tarball lands in ``live_env_dir`` itself so the
+    unpack + ``os.replace`` stay on one filesystem. Raises
+    :class:`FetchError` on an empty/bad src, an unsupported scheme, a
+    download failure, or a tarball missing a required file.
+    """
+    if not (src or "").strip():
+        raise FetchError("no live-env src configured (set PIXIE_LIVE_ENV_SRC)")
+    url, headers = _resolve_fetch_url(src.strip())
+    live_env_dir.mkdir(parents=True, exist_ok=True)
+    tmp_tar, sha256, size = _stream_to_tmpfile(url, headers, live_env_dir, progress)
+    try:
+        if progress is not None:
+            progress({"phase": "unpacking"})
+        sizes = _unpack_live_env_tar(tmp_tar, live_env_dir)
+    finally:
+        tmp_tar.unlink(missing_ok=True)
+    return LiveEnvResult(src=src.strip(), sha256=sha256, size=size, files=sizes)

pixie/catalog/catalog.toml

@@ -0,0 +1,81 @@
+version = 1
+
+# pixie curated catalog -- a strict SUBSET of the upstream nosi catalog
+# (https://github.com/safl/nosi/releases/latest/download/catalog.toml),
+# restricted to the images that ship a netboot bundle. Those are the
+# only images pixie's nbdboot chain (and the flash / inventory / tui
+# live-env chains that ride the same bundle) actually test + support,
+# so shipping just this subset keeps a fresh pixie's catalog to the
+# known-good set instead of the full nosi menu (desktop / proxmox /
+# rpios / freebsd variants have no netboot bundle and are omitted).
+#
+# Pixie seeds a fresh (empty) catalog from this file on first start and
+# defaults its "Import catalog" + live-env TUI to the pixie release copy
+# of it, rather than the nosi catalog. Override either freely; this is a
+# convenience default, not a lock-in.
+#
+# Refs use the rolling ``:latest`` oras tags so the shipped catalog
+# stays current without re-releasing pixie; the layer digest is still
+# verified at fetch time. Each disk image cross-references its bundle by
+# URL via ``netboot_src`` (pixie's tight form), so the nbdboot renderer
+# resolves the pair without the legacy name-string ``netboot_ref``.
+
+[[images]]
+name = "nosi debian-13-headless"
+src = "oras://ghcr.io/safl/nosi/debian-13-headless:latest"
+format = "img.gz"
+arch = "x86_64"
+description = "Debian 13 (trixie) headless. General-purpose headless base with the nosi dev toolset."
+netboot_src = "oras://ghcr.io/safl/nosi/debian-13-headless-netboot:latest"
+
+[[images]]
+name = "nosi debian-13-headless netboot bundle"
+src = "oras://ghcr.io/safl/nosi/debian-13-headless-netboot:latest"
+format = "tar.gz"
+arch = "x86_64"
+description = "Netboot bundle for debian-13-headless: vmlinuz + initrd so pixie can nbdboot it over NBD."
+
+[[images]]
+name = "nosi ubuntu-2404-headless"
+src = "oras://ghcr.io/safl/nosi/ubuntu-2404-headless:latest"
+format = "img.gz"
+arch = "x86_64"
+description = "Ubuntu 24.04 LTS (noble) headless. Broad driver support for CUDA / ROCm devices and Mellanox NICs / DPUs."
+netboot_src = "oras://ghcr.io/safl/nosi/ubuntu-2404-headless-netboot:latest"
+
+[[images]]
+name = "nosi ubuntu-2404-headless netboot bundle"
+src = "oras://ghcr.io/safl/nosi/ubuntu-2404-headless-netboot:latest"
+format = "tar.gz"
+arch = "x86_64"
+description = "Netboot bundle for ubuntu-2404-headless: vmlinuz + initrd so pixie can nbdboot it over NBD."
+
+[[images]]
+name = "nosi ubuntu-2604-headless"
+src = "oras://ghcr.io/safl/nosi/ubuntu-2604-headless:latest"
+format = "img.gz"
+arch = "x86_64"
+description = "Ubuntu 26.04 LTS (resolute) headless. A more recent kernel and user-land on Ubuntu LTS."
+netboot_src = "oras://ghcr.io/safl/nosi/ubuntu-2604-headless-netboot:latest"
+
+[[images]]
+name = "nosi ubuntu-2604-headless netboot bundle"
+src = "oras://ghcr.io/safl/nosi/ubuntu-2604-headless-netboot:latest"
+format = "tar.gz"
+arch = "x86_64"
+description = "Netboot bundle for ubuntu-2604-headless: vmlinuz + initrd so pixie can nbdboot it over NBD."
+
+[[images]]
+name = "nosi fedora-44-headless"
+src = "oras://ghcr.io/safl/nosi/fedora-44-headless:latest"
+format = "img.gz"
+arch = "x86_64"
+description = "Fedora 44 headless. An RHEL-family alternative (dnf, SELinux, EL package universe)."
+netboot_src = "oras://ghcr.io/safl/nosi/fedora-44-headless-netboot:latest"
+
+[[images]]
+name = "nosi fedora-44-headless netboot bundle"
+src = "oras://ghcr.io/safl/nosi/fedora-44-headless-netboot:latest"
+format = "tar.gz"
+arch = "x86_64"
+description = "Netboot bundle for fedora-44-headless: vmlinuz + initrd so pixie can nbdboot it over NBD."

pixie/events/_kinds.py

@@ -193,6 +193,24 @@ EVENTS_CLEARED = "events.cleared"
 right after the wipe so the freshly-empty log still records who reset
 it and when; carries the deleted-row count in ``details``."""
 
+# ---------- live-env fetch ------------------------------------------
+#
+# The operator "Fetch live-env" action pulls the netboot-pc bake into
+# PIXIE_LIVE_ENV_DIR. No subject (``subject_kind`` = ""): the live env
+# is per-pixie, not per-resource. Dotted ``.done`` / ``.failed`` names
+# mirror the catalog-fetch kinds so ``.failed`` auto-classifies as an
+# error via the ERROR_KINDS ``LIKE '%.failed'`` probe.
+
+LIVE_ENV_FETCH_DONE = "live_env.fetch.done"
+"""``POST /ui/live-env/fetch`` downloaded + staged vmlinuz + initrd +
+live.squashfs into PIXIE_LIVE_ENV_DIR. Carries the src + content sha in
+``details``."""
+
+LIVE_ENV_FETCH_FAILED = "live_env.fetch.failed"
+"""The live-env fetch failed (bad src scheme, download error, or a
+tarball missing a required file). Carries the src + error in
+``details``."""
+
 
 # The canonical closed set. Every kind above is registered here; the
 # ``EventsLog.emit`` call rejects anything not in this frozenset.
@@ -228,6 +246,8 @@ KNOWN_EVENT_KINDS: frozenset[str] = frozenset(
         AUTH_LOGIN_SUCCEEDED,
         AUTH_LOGIN_FAILED,
         EVENTS_CLEARED,
+        LIVE_ENV_FETCH_DONE,
+        LIVE_ENV_FETCH_FAILED,
     }
 )
 

pixie/tui/_app.py

@@ -328,9 +328,11 @@ def collect_lshw(*, timeout: float = 30.0) -> object | None:
 # v0.46 stopped publishing a pixie-side catalog.toml mirror and pointed
 # pixie at the upstream image-builder (``safl/nosi``); the wizard's
 # ``[d] default`` shortcut tracks the same source so both consumers
-# resolve to one catalog. The pixie release no longer ships a
-# catalog.toml asset, so the old URL would 404.
-_BTY_DEFAULT_CATALOG_URL = "https://github.com/safl/nosi/releases/latest/download/catalog.toml"
+# resolve to one catalog. Points at pixie's curated catalog (the
+# netboot-capable nosi subset) shipped as a pixie release asset, so the
+# live-env wizard defaults to the same known-good set the appliance
+# seeds -- not the full upstream nosi catalog.
+_BTY_DEFAULT_CATALOG_URL = "https://github.com/safl/pixie/releases/latest/download/catalog.toml"
 
 
 # ---------------------------------------------------------------------------

pixie/web/_overlays.py

@@ -0,0 +1,225 @@
+"""View-model + stats for the persistent-overlay management surface.
+
+The ``overlays`` table (see :class:`pixie.exports._store.OverlaysStore`)
+holds one row per ``(mac, image_sha, profile)`` triple, each pointing at
+a qcow2 on pixie's data volume. The per-machine bind form only ever
+shows ONE machine's profiles, so an operator watching disk pressure
+across the fleet has no aggregate view. This module joins each overlay
+row against the machine registry (is this the target's *current*
+binding?), the catalog (what base image does it wrap?), the NBD
+supervisor (is a qemu-nbd serving it right now?), and the qcow2 on disk
+(how much has it actually grown to?) so the Overlays page can render one
+honest row per overlay.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from pixie.catalog._store import CatalogStore
+from pixie.exports._store import Overlay, OverlaysStore
+from pixie.exports._supervisor import NbdServer
+from pixie.machines._store import MachinesStore
+from pixie.pxe._renderer import _overlay_export_name
+
+# State classification. ``active`` = backs the machine's next boot;
+# ``idle`` = kept but not the current binding; ``missing`` = a row whose
+# qcow2 is gone from disk; ``orphaned`` = a qcow2 for a machine pixie no
+# longer tracks. Only ``missing`` + ``orphaned`` are auto-reclaimable --
+# an ``idle`` overlay is a deliberate keep for a future rebind, so Prune
+# leaves it alone.
+STATE_ACTIVE = "active"
+STATE_IDLE = "idle"
+STATE_MISSING = "missing"
+STATE_ORPHANED = "orphaned"
+RECLAIMABLE_STATES = frozenset({STATE_MISSING, STATE_ORPHANED})
+
+# Sort buckets: live first, deliberate keeps next, junk last. Biggest
+# consumer first within a bucket so the operator's eye lands on what is
+# both live and heavy before what is reclaimable.
+_STATE_ORDER = {STATE_ACTIVE: 0, STATE_IDLE: 1, STATE_ORPHANED: 2, STATE_MISSING: 3}
+
+
+def overlay_key(mac: str, image_sha: str, profile: str) -> str:
+    """Stable per-overlay DOM/JSON key. ``|`` cannot appear in a MAC, a
+    hex sha, or the profile allowlist, so it round-trips cleanly and the
+    live-refresh JS can address each row without ambiguity."""
+    return f"{mac}|{image_sha}|{profile}"
+
+
+@dataclass
+class OverlayView:
+    """One overlay row joined against machine + catalog + NBD + disk."""
+
+    mac: str
+    image_sha: str
+    profile: str
+    qcow2_path: str
+    export_name: str
+    created_at: str
+    last_boot_at: str
+    file_exists: bool
+    used_bytes: int
+    apparent_bytes: int
+    mtime: str
+    running: bool
+    nbd_port: int
+    machine_exists: bool
+    machine_labels: list[str] = field(default_factory=list)
+    is_active: bool = False
+    image_name: str = ""
+    base_bytes: int = 0
+    state: str = STATE_IDLE
+
+    @property
+    def key(self) -> str:
+        return overlay_key(self.mac, self.image_sha, self.profile)
+
+    @property
+    def reclaimable(self) -> bool:
+        return self.state in RECLAIMABLE_STATES
+
+    def to_json(self) -> dict[str, Any]:
+        """The subset the live-refresh poll needs to update in place."""
+        return {
+            "key": self.key,
+            "used_bytes": self.used_bytes,
+            "apparent_bytes": self.apparent_bytes,
+            "mtime": self.mtime,
+            "running": self.running,
+            "nbd_port": self.nbd_port,
+            "state": self.state,
+            "file_exists": self.file_exists,
+        }
+
+
+def _stat_file(path: Path) -> tuple[bool, int, int, str]:
+    """``(exists, allocated_bytes, apparent_bytes, mtime_iso)``.
+
+    A growing qcow2's *allocated* size (``st_blocks * 512``) is the
+    honest "space consumed" figure -- ``st_size`` is the apparent length,
+    which over-counts a sparse/COW file. Missing or unreadable returns
+    all-zero + an empty mtime so the row still renders (as ``missing``).
+    ``mtime`` is emitted in the same ``...Z`` shape as ``now_iso`` so the
+    ``fmt_ts`` filter / ``format_ts`` render it in the operator's tz.
+    """
+    try:
+        st = path.stat()
+    except OSError:
+        return (False, 0, 0, "")
+    allocated = int(getattr(st, "st_blocks", 0)) * 512
+    mtime = datetime.fromtimestamp(st.st_mtime, UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+    return (True, allocated, int(st.st_size), mtime)
+
+
+def build_overlay_view(
+    ov: Overlay,
+    *,
+    machines: MachinesStore,
+    image_names: dict[str, str],
+    image_sizes: dict[str, int],
+    nbd: NbdServer,
+) -> OverlayView:
+    """Enrich one :class:`Overlay` row into an :class:`OverlayView`."""
+    export_name = _overlay_export_name(ov)
+    exists, used, apparent, mtime = _stat_file(Path(ov.qcow2_path))
+    port = nbd.port_for(export_name)
+    machine = machines.get(ov.mac)
+    is_active = bool(
+        machine is not None
+        and machine.boot_mode == "nbdboot"
+        and machine.image_content_sha256 == ov.image_sha
+        and machine.overlay_profile == ov.profile
+    )
+    if not exists:
+        state = STATE_MISSING
+    elif machine is None:
+        state = STATE_ORPHANED
+    elif is_active:
+        state = STATE_ACTIVE
+    else:
+        state = STATE_IDLE
+    return OverlayView(
+        mac=ov.mac,
+        image_sha=ov.image_sha,
+        profile=ov.profile,
+        qcow2_path=ov.qcow2_path,
+        export_name=export_name,
+        created_at=ov.created_at,
+        last_boot_at=ov.last_boot_at,
+        file_exists=exists,
+        used_bytes=used,
+        apparent_bytes=apparent,
+        mtime=mtime,
+        running=port is not None,
+        nbd_port=port or 0,
+        machine_exists=machine is not None,
+        machine_labels=list(machine.labels) if machine is not None else [],
+        is_active=is_active,
+        image_name=image_names.get(ov.image_sha, ""),
+        base_bytes=image_sizes.get(ov.image_sha, 0),
+        state=state,
+    )
+
+
+def build_overlay_views(
+    *,
+    overlays: OverlaysStore,
+    machines: MachinesStore,
+    catalog: CatalogStore,
+    nbd: NbdServer,
+) -> list[OverlayView]:
+    """Every overlay, enriched + sorted for the Overlays page."""
+    entries = catalog.list_entries()
+    image_names = {e.content_sha256: e.name for e in entries if e.content_sha256}
+    image_sizes = {
+        e.content_sha256: int(getattr(e, "size_bytes", 0) or 0) for e in entries if e.content_sha256
+    }
+    views = [
+        build_overlay_view(
+            ov,
+            machines=machines,
+            image_names=image_names,
+            image_sizes=image_sizes,
+            nbd=nbd,
+        )
+        for ov in overlays.list_all()
+    ]
+    views.sort(key=lambda v: (_STATE_ORDER.get(v.state, 9), -v.used_bytes, v.mac, v.profile))
+    return views
+
+
+@dataclass
+class OverlayTotals:
+    """Fleet-wide roll-up shown in the summary strip + polled live."""
+
+    count: int
+    used_bytes: int
+    running: int
+    active: int
+    reclaimable: int
+    reclaimable_bytes: int
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "count": self.count,
+            "used_bytes": self.used_bytes,
+            "running": self.running,
+            "active": self.active,
+            "reclaimable": self.reclaimable,
+            "reclaimable_bytes": self.reclaimable_bytes,
+        }
+
+
+def overlay_totals(views: list[OverlayView]) -> OverlayTotals:
+    return OverlayTotals(
+        count=len(views),
+        used_bytes=sum(v.used_bytes for v in views),
+        running=sum(1 for v in views if v.running),
+        active=sum(1 for v in views if v.state == STATE_ACTIVE),
+        reclaimable=sum(1 for v in views if v.reclaimable),
+        reclaimable_bytes=sum(v.used_bytes for v in views if v.reclaimable),
+    )

pixie/web/_settings_store.py

@@ -64,6 +64,18 @@ DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S %Z"
 KEY_LIVE_ENV_EXTRA_CMDLINE = "live_env.extra_cmdline"
 ENV_LIVE_ENV_EXTRA_CMDLINE = "PIXIE_LIVE_ENV_EXTRA_CMDLINE"
 
+# Where the operator "Fetch live-env" action pulls the netboot-pc bake
+# from: a single tarball ``src`` (``https://`` or ``oras://``, the same
+# schemes the catalog fetch speaks) that unpacks to vmlinuz + initrd +
+# live.squashfs. Defaults to the pixie GitHub release's stable-named
+# asset via ``/releases/latest/download/`` so a plain deploy can pull
+# the live env with no config; override for an air-gapped mirror.
+KEY_LIVE_ENV_SRC = "live_env.src"
+ENV_LIVE_ENV_SRC = "PIXIE_LIVE_ENV_SRC"
+DEFAULT_LIVE_ENV_SRC = (
+    "https://github.com/safl/pixie/releases/latest/download/pixie-live-env-x86_64.tar.gz"
+)
+
 
 class SettingValueError(ValueError):
     """A stored override failed validation at resolve time. The
@@ -168,6 +180,17 @@ class SettingsStore:
             or ""
         )
 
+    def resolve_live_env_src(self) -> str:
+        """Effective live-env fetch src: DB override -> env -> default
+        (the pixie GitHub release asset). Never empty; the caller feeds
+        it straight to the live-env fetch, which raises on a bad
+        scheme."""
+        return (
+            self.get(KEY_LIVE_ENV_SRC)
+            or (os.environ.get(ENV_LIVE_ENV_SRC) or "").strip()
+            or DEFAULT_LIVE_ENV_SRC
+        )
+
 
 def parse_iso_utc(raw: str) -> datetime | None:
     """Parse the ISO-8601 strings pixie writes to state.db. Accepts a

pixie/web/_templates/catalog.html

@@ -21,7 +21,9 @@
             <input type="url" id="catalog_url" name="url"
                    class="form-control form-control-sm"
                    style="max-width: 22rem; min-width: 0;"
+                   value="{{ default_catalog_url }}"
                    placeholder="catalog.toml URL"
+                   title="Defaults to pixie's curated catalog (the netboot-capable subset). Replace to import a different catalog.toml, e.g. the full nosi catalog."
                    required>
             <button type="submit" class="btn btn-sm btn-primary flex-shrink-0 text-nowrap">
                 Import

pixie/web/_templates/dashboard.html

@@ -132,44 +132,45 @@
     </div>
 </div>
 
-{# Live-env media state. The pixie live env (netboot-pc bake) has to
-   be staged under PIXIE_LIVE_ENV_DIR before any pixie-* boot mode
-   works; without it the plan renderer emits an "unavailable" iPXE
-   chain and a bound target sits at a legible "media not staged"
-   screen. Surface the readiness signal + per-file bytes so an
-   operator can tell at a glance whether the boot modes are live. #}
+{# Live-env media readiness (OUTPUT ONLY). The dashboard reports
+   whether the pixie-* boot modes have their media; the Fetch action +
+   source / cmdline config live on the dedicated /ui/live-env pane. #}
+{% set lfs = stats.live_env_fetch_state or {} %}
 <div class="card shadow-sm mb-4">
-    <div class="card-header bg-light d-flex align-items-center">
+    <div class="card-header bg-light d-flex align-items-center gap-2">
         <h2 class="h5 mb-0"><i class="bi bi-boombox me-2"></i>Live-env media</h2>
-        {% if stats.live_env_ready %}
-        <span class="badge text-bg-success ms-auto">
-            <i class="bi bi-check-circle me-1"></i>ready
-        </span>
-        {% else %}
-        <span class="badge text-bg-warning ms-auto">
-            <i class="bi bi-exclamation-triangle me-1"></i>not staged
-        </span>
-        {% endif %}
+        <div class="ms-auto d-flex align-items-center gap-2">
+            {% if lfs.state == 'fetching' %}
+            <span class="badge text-bg-info"><span class="spinner-border spinner-border-sm me-1" role="status"></span>fetching</span>
+            {% elif stats.live_env_ready %}
+            <span class="badge text-bg-success"><i class="bi bi-check-circle me-1"></i>ready</span>
+            {% else %}
+            <span class="badge text-bg-warning"><i class="bi bi-exclamation-triangle me-1"></i>not staged</span>
+            {% endif %}
+            <a href="/ui/live-env" class="btn btn-sm btn-outline-primary text-nowrap"
+               title="Fetch + configure the live env">
+                <i class="bi bi-boombox me-1"></i>Manage
+            </a>
+        </div>
     </div>
     <div class="card-body">
         {% if stats.live_env_ready %}
         <p class="small mb-2">
-            The three files below are staged at
-            <code>{{ stats.live_env_dir }}</code> and
-            <code>pixie-tui</code>, <code>pixie-inventory</code>, and
-            <code>pixie-flash-*</code> can serve the live env from
-            <code>/boot/pixie-live-env/</code>.
+            Staged at <code>{{ stats.live_env_dir }}</code>;
+            <code>pixie-tui</code> / <code>pixie-inventory</code> /
+            <code>pixie-flash-*</code> can serve the live env.
         </p>
         {% else %}
         <p class="small text-warning mb-2">
-            Live-env media is missing under
-            <code>{{ stats.live_env_dir or '(unset)' }}</code>.
-            Every <code>pixie-*</code> boot_mode falls back to the
-            "unavailable" iPXE plan until the three files below are
-            present. Copy vmlinuz + initrd + live.squashfs from the
-            latest <code>pixie-netboot-pc-x86_64</code> bake into
-            that directory. Restart the container is NOT required
-            (the renderer checks the files each render).
+            Live-env media is missing under <code>{{ stats.live_env_dir or '(unset)' }}</code>.
+            Every <code>pixie-*</code> boot_mode falls back to the "unavailable" iPXE
+            plan until it is staged. <a href="/ui/live-env">Fetch it &rarr;</a>
+        </p>
+        {% endif %}
+        {% if lfs.state == 'error' %}
+        <p class="small text-danger mb-2">
+            <i class="bi bi-exclamation-triangle me-1"></i>Last fetch failed &mdash; see
+            <a href="/ui/live-env">Live env</a>.
         </p>
         {% endif %}
         <dl class="row small mb-0">
@@ -186,6 +187,12 @@
         </dl>
     </div>
 </div>
+{% if lfs.state == 'fetching' %}
+{# The fetch runs on the server's thread pool; poll the page so the
+   spinner flips to "ready" (or an error) on its own. A big squashfs
+   download takes a while, so 5 s is frequent enough without hammering. #}
+<script>setTimeout(function () { location.reload(); }, 5000);</script>
+{% endif %}
 
 <div class="card shadow-sm">
     <div class="card-header bg-light d-flex align-items-center">

pixie/web/_templates/layout.html

@@ -285,6 +285,12 @@
                 <a class="nav-btn {% if page == 'catalog' %}active{% endif %}" href="/ui/catalog">
                     <i class="bi bi-collection"></i>Catalog
                 </a>
+                <a class="nav-btn {% if page == 'overlays' %}active{% endif %}" href="/ui/overlays">
+                    <i class="bi bi-layers"></i>Overlays
+                </a>
+                <a class="nav-btn {% if page == 'live-env' %}active{% endif %}" href="/ui/live-env">
+                    <i class="bi bi-boombox"></i>Live env
+                </a>
                 <a class="nav-btn {% if page == 'events' %}active{% endif %}" href="/ui/events">
                     <i class="bi bi-clock-history"></i>Events
                 </a>