{ 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 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 = ""; }; }; }; }