Files
skyg-linux-tracker/nix/module.nix
T
ariandClaude Sonnet 5.5 34da657fdf WS-H: NixOS module, VM test, README section
Module: Origin/Host allowlists from allowedHosts and the FQDN, credentials
refreshed on reload so SIGHUP rotates the TLS cert, string cert/key paths
kept out of the store, docker.enable asserts virtualisation.docker.
VM test covers healthz, 401, token mint/revoke via sudo -u, /mcp, Origin 403,
root refusal and a TLS node. Package skips two unit tests that need host
state the sandbox lacks.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017WMgwyHQQU9cB4ruRDrKow
2026-10-16 17:15:18 -04:00

220 lines
7.7 KiB
Nix

{ config, lib, pkgs, ... }:
let
cfg = config.services.skyg-linux-tracker;
inherit (lib) mkOption mkEnableOption mkIf types;
name = "skyg-linux-tracker";
credDir = "/run/credentials/${name}.service";
toml = pkgs.formats.toml { };
scheme = if cfg.tls.enable then "https" else "http";
hostName = config.networking.fqdnOrHostName;
# Names clients use, with the port, so both the Host and the Origin
# allowlists on /mcp accept them. Entries with a scheme are origins only.
withPort = h: if lib.hasInfix ":" h then h else "${h}:${toString cfg.port}";
hosts = lib.unique (map withPort (
lib.optional (hostName != "") hostName
++ lib.filter (h: !lib.hasInfix "://" h) cfg.allowedHosts
));
moduleDefaults = {
server = {
bind = cfg.bind;
port = cfg.port;
allowed_hosts = hosts;
allowed_origins = map (h: "${scheme}://${h}") (lib.filter (h: !lib.hasInfix "://" h) hosts)
++ lib.filter (h: lib.hasInfix "://" h) cfg.allowedHosts;
} // lib.optionalAttrs cfg.tls.enable {
tls = {
enabled = true;
cert_file = "${credDir}/cert";
key_file = "${credDir}/key";
};
};
auth.db_path = "/var/lib/${name}/db.sqlite";
} // lib.optionalAttrs cfg.docker.enable {
sources.docker_socket = "/var/run/docker.sock";
};
settings = lib.recursiveUpdate moduleDefaults cfg.settings;
configFile = toml.generate "${name}.toml" settings;
port = settings.server.port;
bind = settings.server.bind;
authEnabled = settings.auth.enabled or true;
isLoopback = a: lib.hasPrefix "127." a || a == "::1";
in
{
options.services.skyg-linux-tracker = {
enable = mkEnableOption "skyg-linux-tracker, a read-only systemd/journal/Docker monitor (REST, MCP, OTel)";
package = mkOption {
type = types.package;
description = "The skyg-linux-tracker package (provides `slinuxm`).";
};
port = mkOption {
type = types.port;
default = 1984;
description = "TCP port for the REST API and /mcp.";
};
bind = mkOption {
type = types.str;
default = "127.0.0.1";
description = ''
Listen address. A non-loopback address requires authentication to stay
enabled. Bearer tokens over plain HTTP are readable on a LAN; prefer
loopback plus a TLS proxy or Tailscale, or enable `tls`.
'';
};
tls = {
enable = mkEnableOption "native TLS for REST and /mcp";
certFile = mkOption {
type = types.nullOr types.str;
default = null;
description = "Absolute path, kept out of the store (use a string, not a path literal). PEM certificate chain. Passed through systemd LoadCredential, so the service user needs no access to the original file.";
};
keyFile = mkOption {
type = types.nullOr types.str;
default = null;
description = "Absolute path, kept out of the store (use a string, not a path literal). PEM private key. Passed through systemd LoadCredential.";
};
};
openFirewall = mkOption {
type = types.bool;
default = false;
description = "Open the port on all interfaces.";
};
firewallInterfaces = mkOption {
type = types.listOf types.str;
default = [ ];
example = [ "enp3s0" ];
description = "Open the port only on these interfaces (the recommended LAN setup).";
};
allowedHosts = mkOption {
type = types.listOf types.str;
default = [ ];
example = [ "monitor.lan:1984" ];
description = "Extra Host/Origin names accepted on /mcp. `networking.hostName` is added automatically.";
};
docker.enable = mkEnableOption ''
Docker access by adding the service user to the `docker` group.
WARNING: that group is root-equivalent; prefer a read-only socket proxy
and `settings.sources.docker_socket`'';
settings = mkOption {
type = toml.type;
default = { };
example = { limits.max_lines = 500; };
description = "Freeform config merged over the module defaults and written to /etc/skyg-linux-tracker.toml. Never put secrets here.";
};
environmentFile = mkOption {
type = types.nullOr types.path;
default = null;
example = "/run/secrets/skyg-linux-tracker.env";
description = "systemd EnvironmentFile for secrets such as `SKYG_OTEL__HEADERS__AUTHORIZATION`, kept out of the store.";
};
};
config = mkIf cfg.enable {
assertions = [
{
assertion = isLoopback bind || authEnabled;
message = "services.skyg-linux-tracker: a non-loopback bind (${bind}) requires auth.enabled = true.";
}
{
assertion = !cfg.docker.enable || config.virtualisation.docker.enable;
message = "services.skyg-linux-tracker.docker.enable needs virtualisation.docker.enable (or use a socket proxy via settings.sources.docker_socket instead).";
}
{
assertion = !cfg.tls.enable || (cfg.tls.certFile != null && cfg.tls.keyFile != null);
message = "services.skyg-linux-tracker.tls.enable requires tls.certFile and tls.keyFile.";
}
];
users.users.${name} = {
isSystemUser = true;
group = name;
extraGroups = lib.optional cfg.docker.enable "docker";
};
users.groups.${name} = { };
# Same path the app reads by default, so `slinuxm` and the service agree.
environment.etc."${name}.toml".source = configFile;
# Plain binary, no wrapper. Mint tokens with
# sudo -u skyg-linux-tracker slinuxm token create <name>
environment.systemPackages = [ cfg.package ];
networking.firewall = lib.mkMerge [
(mkIf cfg.openFirewall { allowedTCPPorts = [ port ]; })
{
interfaces = lib.genAttrs cfg.firewallInterfaces (_: {
allowedTCPPorts = [ port ];
});
}
];
systemd.services.${name} = {
description = "skyg-linux-tracker: read-only systemd, journal and Docker monitor (REST, MCP, OTel)";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ] ++ lib.optional cfg.docker.enable "docker.service";
restartTriggers = [ configFile ];
# Mirrors systemd/skyg-linux-tracker.service; keep the two in step.
serviceConfig = {
Type = "simple";
ExecStart = "${lib.getExe cfg.package} serve --config /etc/${name}.toml";
ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
# Credentials are copied at start; refresh them so a reload rotates the cert.
RefreshOnReload = mkIf cfg.tls.enable "credentials";
Restart = "on-failure";
RestartSec = 5;
TimeoutStopSec = 30;
User = name;
Group = name;
SupplementaryGroups = [ "systemd-journal" ] ++ lib.optional cfg.docker.enable "docker";
StateDirectory = name;
StateDirectoryMode = "0700";
EnvironmentFile = mkIf (cfg.environmentFile != null) cfg.environmentFile;
LoadCredential = mkIf cfg.tls.enable [
"cert:${toString cfg.tls.certFile}"
"key:${toString cfg.tls.keyFile}"
];
NoNewPrivileges = true;
ProtectSystem = "strict";
ProtectHome = true;
PrivateTmp = true;
PrivateDevices = true;
ProtectKernelTunables = true;
ProtectKernelModules = true;
ProtectControlGroups = true;
ProtectClock = true;
RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];
RestrictNamespaces = true;
RestrictRealtime = true;
LockPersonality = true;
MemoryDenyWriteExecute = true;
SystemCallArchitectures = "native";
SystemCallFilter = [ "@system-service" "~@privileged @resources" ];
ProtectProc = "invisible";
ProcSubset = "pid";
RestrictSUIDSGID = true;
UMask = "0077";
CapabilityBoundingSet = "";
AmbientCapabilities = "";
};
};
};
}