@yuuki824/kanshi 0.3.0

package/.env.example

@@ -0,0 +1,34 @@
+# Copy to .env (Docker Compose) or kanshi.env (the standalone binary) to
+# override. Every value here is the built-in default.
+
+# Who can open the dashboard. This computer (localhost) always can. Add any of:
+#   lan        other devices on your local network, wired or Wi-Fi
+#   tailscale  your devices on your tailnet
+#   all        every interface — kanshi has no login, so only behind a firewall
+# Combine with commas, e.g. KANSHI_ACCESS=lan,tailscale
+KANSHI_ACCESS=local
+KANSHI_PORT=8100
+
+# Live metrics
+KANSHI_POLL_INTERVAL=5
+KANSHI_DOCKER_CONCURRENCY=8
+KANSHI_IDLE_TIMEOUT=30
+
+# Storage map. "auto" is / plus every drive under /mnt on Linux, or C:\, your
+# user folder and every other fixed drive on Windows. List paths to replace
+# that, or mix: auto,/srv
+KANSHI_STORAGE_ROOTS=auto
+# A cached folder size older than this many seconds is measured again the next
+# time the folder around it is opened.
+KANSHI_STORAGE_INTERVAL=21600
+# Paths to skip entirely, comma separated. The biggest win on a Docker host is
+# /var/lib/docker — ~100k overlay2 files.
+KANSHI_STORAGE_EXCLUDE=
+# Share of one core, in percent, the walk may average. 100 = unthrottled.
+KANSHI_STORAGE_CPU=25
+# Folder levels remembered from each measurement. Deeper folders are measured
+# when they are opened.
+KANSHI_TREE_DEPTH=4
+# Where folder sizes are cached. Defaults to ~/.cache/kanshi/storage.cache on
+# Linux and %LocalAppData%\kanshi\storage.cache on Windows.
+#KANSHI_STORAGE_CACHE=

package/Dockerfile

@@ -0,0 +1,53 @@
+# Build stage. It always runs on the build machine's own architecture and
+# cross-compiles for the target, which Go does natively — so a multi-arch
+# image builds at full speed with no QEMU emulation. The module has no
+# third-party dependencies, so there is nothing to download.
+FROM --platform=$BUILDPLATFORM golang:1.27-alpine AS build
+
+ARG TARGETOS=linux
+ARG TARGETARCH
+ARG VERSION=dev
+
+WORKDIR /src
+COPY go.mod ./
+COPY main.go main_other.go ./
+COPY internal ./internal
+COPY web ./web
+
+# CGO off because nothing here needs libc: /proc is read as plain files and the
+# Docker socket is a plain unix socket. That is what makes a scratch image
+# possible at all.
+ENV CGO_ENABLED=0
+RUN GOOS=$TARGETOS GOARCH=$TARGETARCH go build -trimpath \
+      -ldflags="-s -w -X main.version=${VERSION}" -o /kanshi .
+
+# Runtime stage. The web assets are embedded in the binary, so the image is one
+# static file and nothing else — no shell, no package manager, no CVE surface.
+FROM scratch
+
+ARG VERSION=dev
+LABEL org.opencontainers.image.title="kanshi" \
+      org.opencontainers.image.description="A one-page, mobile-first glance at a homeserver: CPU, memory, a storage treemap and Docker containers." \
+      org.opencontainers.image.source="https://github.com/rene-roid/kanshi" \
+      org.opencontainers.image.licenses="AGPL-3.0-only" \
+      org.opencontainers.image.version="${VERSION}"
+
+COPY --from=build /kanshi /kanshi
+
+# The Compose file mounts the host's / here; the storage map then finds the
+# host's drives under /hostfs/mnt on its own.
+ENV KANSHI_HOST_ROOT=/hostfs
+
+# Folder sizes are cached here so a restart does not walk the disk again. The
+# root filesystem is read-only, so this has to be a volume.
+ENV KANSHI_STORAGE_CACHE=/data/storage.cache
+VOLUME /data
+
+EXPOSE 8100
+
+# The probe is the binary itself: a scratch image has no curl to call. It asks
+# 127.0.0.1, which is listened on in every access mode.
+HEALTHCHECK --interval=60s --timeout=5s --start-period=10s --retries=3 \
+  CMD ["/kanshi", "-healthcheck"]
+
+ENTRYPOINT ["/kanshi"]