EXTENSIONS
Halogen Flash Server
Install and manage Peonist Halogen Flash Server containers on AMD Strix Halo systems.
Renovate
What is out of date in the repositories on disk, as swamp data: Renovate run in its local mode, with no forge, no token and no pull request.
Docker Compose
Two methods for `@smith/docker-compose` that end-to-end setups need.
Container Image
Build, push, and inspect OCI container images. Registry-agnostic — works with ECR, GHCR, DockerHub, or any OCI-compliant registry. Supports docker, podman, nerdctl, and buildah. Produces typed, versioned build metadata.
Container Image
Build, run, and push container images via Docker, Podman, or Apple
Docker Ps
A read-only container listing of a Docker host over SSH, narrow enough to hand to an unattended triage agent. It answers the first question an alert usually raises -- what is running on that host, and which container holds that port -- with name, image, state, status, published ports and creation time per container. It runs `docker ps` with an explicit, per-field `--format` template and rebuilds each row from those fields alone, so no environment variable and no label value ever leaves the host: `docker inspect` returns every container's environment, which is where compose files keep database passwords and API tokens, and `docker ps --format '{{json .}}'` includes the Labels field. The type has exactly one method and no free-form command or format argument, so a model instance exposes no write verb at all. Host key checking stays on by default.
Docker Reclaim
Measure what a Docker host's disk is actually spent on, plan what can be freed without destroying a rollback target, and free it. The command people reach for is the wrong one: `docker image prune` — dangling or `-a` — never touches the BUILD CACHE, and on a host that builds its own images the build cache is usually most of the footprint. On the host this was written against it was 59.5GB of a 77GB reclaim, which no amount of image pruning would have recovered. Three behaviours are deliberate because each one corresponds to a way the obvious command does damage or lies. `docker image prune -a` removes every image no container references, which is precisely the set of previous versions a rollback needs; this model instead protects the newest `keepVersions` tags of each repository and removes specific image IDs, so reclaiming space does not quietly cost you the ability to go back. `docker builder prune -af` deletes the cache that makes the next build fast, and cache that is minutes old is the most valuable cache there is; pruning is therefore age-filtered via `--filter until=`, so a scheduled run takes cold layers and leaves the working set. The prune runs with `-a` and the age filter as its guard, because without `-a` BuildKit leaves out records shared with the image store, and on a Docker engine an age-filtered prune then frees almost nothing. The prune names the engine's own builder (`--builder "$(docker context show)"`) rather than whichever buildx builder is current, and an `engine-builder` pre-flight check refuses `reclaim` unless that builder uses the docker driver, so cache is never pruned on an engine the model did not measure. And Docker reports sizes as rounded human strings where 1000 versus 1024 is a real 7% at terabyte scale, so parsing is explicit and unit-aware and the freed figure is measured by observing free space before and after rather than by summing estimates. Each method writes its own data instance — `usage`, `plan`, `reclaim` — so an expression always gets the schema it expects rather than whichever method ran last. `observe` and `plan` are read-only and safe to schedule at any frequency; `reclaim` is dry-run unless passed `apply: true`, and even then never removes an image that any container references, running or stopped. Host key checking is left ON by default — `StrictHostKeyChecking=no` is available but is not the default, because a model whose entire purpose is running destructive commands as a privileged user is the last place to accept an unverified host key. For a Docker engine on the machine swamp itself runs on, such as Docker Desktop on a workstation, set `sshHost: local`: each command runs through `sh -c` as the invoking user, with no SSH server required, and the commands and protections are identical to the SSH path.
Dockerhub Pulls
Record Docker Hub images' pulls, stars and tags over time.
Webshot
Full-page screenshots of web pages (PNG, JPEG, WebP). Runs headless Chrome in a fresh, version-pinned Docker container with Noto fonts (or a local Chrome), scrolls to the bottom so lazy content renders, hides cookie banners and fixed overlays, stitches pages taller than Chrome's capture limit, records the HTTP status, and stores the image plus capture metadata as swamp data.
Whisper Transcriber
Transcribe meeting audio locally with Whisper (faster-whisper, large-v3 by default) in a container under Apple's container CLI or Docker. Writes a timestamped text transcript plus SRT, WebVTT and JSON with word-level timestamps; the image builds itself on first use and model weights are cached between runs.
Slidev
Work on Slidev decks entirely inside a container (boxcutter/slidev by default) with Docker or Apple's container CLI, so the host needs no Node. A slide fit check opens every slide with all clicks revealed and flags content that runs off the bottom or right edge, bumps against the bottom, or is hidden inside a box that scrolls or clips (a code block with maxHeight, a wide table), with each slide's source file and line and a screenshot. Also creates new decks, and with the @taylor/slidev-new-deck workflow checks it builds and turns it into a GitHub repository with page numbers, a README, a licence and a Pages site deployed by GitHub Actions; serves the deck in the background, exports it to PDF, and lists and upgrades Slidev, vue and playwright-chromium while leaving pinned versions alone. Bundles a slide-fit skill for agent-driven fit passes.
Nexus
Run a Sonatype Nexus Repository instance with Docker or Apple's container CLI, configured far enough that the onboarding wizard never appears, then declare what goes in it: realms, blob stores, roles, users, and apt, docker, npm, pypi and raw repositories (hosted, proxy and group). apply creates and updates them in dependency order and can prune what is not declared; sync reports drift without changing anything. Pre-flight checks catch a stopped runtime, a taken port and typos in privileges or references before anything changes.
Netbox
Run a NetBox instance for development and testing with Docker Compose: NetBox, its background worker, PostgreSQL and Valkey from the netbox-docker images. Start generates the internal secrets on first run, waits for every service to be healthy, sets the superuser's password from a vault and, optionally, gives it a v2 API token from a vault. Also reports status and stops or removes the project, keeping the volumes unless asked.
Docker
Manage Docker Engine and Docker Compose lifecycle on remote hosts over SSH, including install, build, run, inspect, exec, and compose service operations.
Swamp Version
Read the swamp version a host or container is running and report how far it has drifted behind the published channel. Read-only — it never updates, installs, or restarts anything; it tells you a newer build exists and stops there. Fills the gap `swamp update --check` leaves: that answers for the binary invoking it, on the platform invoking it, which is no help when the install you care about is a pinned binary inside a container on another host. `sync` records what a target reports about itself — its version and, via `uname`, the artifact platform it runs on. `drift` resolves the newest build published on a channel for THAT platform and reports status (`current`/`behind`/`ahead`) plus the lag in hours. `repoDrift` covers the second, independent axis a `swamp serve` install goes stale on — the git checkout it serves. A container can run the newest published binary while serving a branch it last fetched weeks ago, because a serve entrypoint typically fetches at boot only; `drift` reports `current` throughout and so does every healthcheck. It fetches before comparing, which is load-bearing rather than tidy: a checkout's own `origin/<ref>` is frozen at its last boot, so trusting it reports a badly stale target as up to date. It then reports the exact number of commits behind — enumerable here, unlike the binary axis, because git has the list — the lag in hours, and `current`/`behind`/`ahead`/`diverged`, keeping `diverged` distinct because the fix for `behind` is a restart and a restart hard-resets, destroying the very commits that make a checkout diverged. Targets are reached three ways: the local binary, `docker exec` (optionally through a named docker context, so one host can check a container on another), or SSH with BatchMode so an unattended run fails fast instead of hanging on a password prompt. The channel is resolved by a single HEAD against the `stable` alias, reading the resolved version out of its website-redirect metadata — one request rather than the ~90 MB the archive weighs — and the same pass verifies the platform-specific archive is actually fetchable, which is the precondition for pinning a rebuild to it. Versions are compared numerically because the build ordinal in `YYYYMMDD.HHMMSS.N` is not zero-padded: as strings `20260808.001107.10` sorts below `...9`, so a string compare reports a target one build behind as up to date the day a tenth build ships. `hoursBehind` is derived from the timestamps embedded in each version and is documented as a lag, not a count of missed builds — swamp publishes no release list, so the builds in between cannot be enumerated and this extension does not pretend otherwise. An unreachable target, an unparseable version at either end, a channel alias that answers without its redirect header, and a resolved archive that 404s are all raised as errors rather than folded into a reassuring `current`.
Arcane
Management of an Arcane Docker instance through its REST API: GitOps sync setup, compose project lifecycle with a validated deploy for each mode, swarm stack deploy (validated after render, polled until converged), secret/config rotation, and volume/prune cleanup.
Session Execute
The headless runtime of the session-* suite. Runs a filled analysis template — R/qmd in a pinned nix R env (`run`), a targets pipeline via a harvester (`run-targets`), or Python/ipynb via papermill in the locked conda/Docker env (`run-notebook`) — with the recorder armed or a swamp.returns contract verified. Also faithfully REPLAYS a captured session: `replay` re-runs recorded R against frozen tolerance rules (nix preferred, docker fallback), and the Python host-replay shim serves a captured session's host.* calls offline (or falls through to the live API in hybrid mode). Reproduce a governed run — or a foreign Claude Science session — deterministically.
Image Updater
Auto-applier for docker image updates — pulls + restarts compose stacks with deny lists, cooling periods, and a per-run cap.
Caddy
Render, validate, and remotely apply Caddy JSON reverse-proxy configuration using a containerized Caddy runtime.
Docker Host
Docker container discovery + autoheal across a Proxmox cluster — SSHes to each PVE node, runs `pct exec <vmid> docker ps` on every docker-tagged LXC; the autoheal method restarts unhealthy containers within deny-list/cooldown/cap guardrails.
Colima
Lifecycle management for a Colima VM (macOS container runtime, https://github.com/abiosoft/colima) via the local colima CLI: start and provision, stop, restart, delete, sync VM status, and exec commands inside the VM. One model instance targets one Colima profile.
Compose Project
Tracks a Docker Compose project's structure (services, volumes, networks) and flexible key/value configuration as swamp-managed data. Data-only — pair it with @keeb/docker/compose for actual lifecycle execution. Every parameter, service field, and volume/network option is validated against the official compose-spec JSON Schema before it's written, so typos and malformed values are rejected at write time rather than surfacing later as a broken `docker compose` run. Ships with a bundled schema snapshot so it works fully offline out of the box; run the updateSchema method on an instance to refresh it from the canonical compose-spec repository when you need a newer field.
Step
Manage the X.509 certificate lifecycle (issue, renew, revoke, inspect) against a Smallstep step-ca certificate authority over the network — CA-agnostic, works with any reachable local or remote step-ca via its root fingerprint. Secondarily includes an optional model to stand up and tear down a local step-ca instance in Docker for development.
Docker Compose Refresher
Keep :latest-tagged (and untagged) services in local or SSH-reachable docker compose projects up to date. Compares each running container's image digest against the registry (docker buildx imagetools) so already-current services are left untouched, then pulls and recreates only stale ones with a health-gate. Dry-run by default. Supports sudo-prefixed docker and per-host SSH config.