Files
nixos-setup/modules/nixos/common/ssh-notify.nix
T
2026-09-18 21:10:19 -04:00

92 lines
3.9 KiB
Nix

{ config, lib, pkgs, ... }:
let
cfg = config.skyg.nixos.common.ssh-notify;
# Client-side listen socket. Fixed/shared is fine here: socat's `fork`
# mode accepts unbounded connections over this path's lifetime, one per
# `notify-send` call from any concurrently forwarded SSH session.
#
# NOTE: assumes a single interactive uid (1000) on the desktop host, same
# as the rest of this single-user setup.
localSocketPath = "/run/user/1000/ssh-notify/listener.sock";
# Remote-side (server) forwarded socket. Uses OpenSSH's %C token (hash of
# local host/port/user + remote host/port/user, requires OpenSSH >= 8.9)
# so each concurrent SSH connection gets its own bind path on the server —
# this is what the old shared /tmp/ssh-notify.sock path got wrong: only
# one concurrent session could ever bind it, and every other session's
# `RemoteForward` silently failed ("remote port forwarding failed for
# listen path ..."), falling back to a broken direct D-Bus notify-send.
remoteSocketPath = "/tmp/ssh-notify-%C.sock";
# Detect if this host is acting as the notification client (the machine you sit in front of)
isClient =
cfg.role == "client"
|| (cfg.role == "auto" && (config.skyg.nixos.desktop.enable or false));
isServer =
cfg.role == "server"
|| (cfg.role == "auto" && !isClient);
in
{
options.skyg.nixos.common.ssh-notify = {
enable = lib.mkEnableOption
"forward libnotify messages from SSH sessions back to the client desktop (prefixed with hostname)";
role = lib.mkOption {
type = lib.types.enum [ "auto" "client" "server" ];
default = "auto";
description = ''
auto = client on hosts with skyg.nixos.desktop.enable, server otherwise
client = force desktop listener + RemoteForward
server = force wrapper only
'';
};
};
config = lib.mkIf cfg.enable {
# hiPrio: desktop hosts (e.g. hl-fwdesk) also pull in the real libnotify
# via the tiler module's "always-on plumbing" packages, and both provide
# bin/notify-send. Force ours to win that collision unconditionally.
environment.systemPackages = [ (lib.hiPrio pkgs.ssh-notify) ];
# Client: ask SSH to forward this connection's notification socket back
# to the shared local listener, and tell the server-side wrapper (via
# SetEnv, expanded here with the same %C the RemoteForward bind uses)
# which socket to connect to.
programs.ssh.extraConfig = lib.mkIf isClient ''
RemoteForward ${remoteSocketPath} ${localSocketPath}
SetEnv SSH_NOTIFY_SOCK=${remoteSocketPath}
'';
# Server: accept the SSH_NOTIFY_SOCK env var forwarded by the client
# above (SSH only passes through an allow-listed set by default).
services.openssh.settings.AcceptEnv = lib.mkIf isServer [ "SSH_NOTIFY_SOCK" ];
# %C is a deterministic hash of (local host, remote user, remote host,
# remote port) -- the same value every time you connect to this host
# from this client, not a per-connection nonce. Without this, a socket
# left behind by an abnormally-ended session (network drop, kill) blocks
# every subsequent connection to the same host with "remote port
# forwarding failed for listen path ...". Tell sshd to unlink and rebind
# instead of refusing.
services.openssh.settings.StreamLocalBindUnlink = lib.mkIf isServer true;
# Client listener: one persistent socket, forked per connection, that
# turns each incoming JSON payload into a real local notification.
systemd.user.services.ssh-notify-listener = lib.mkIf isClient {
description = "Receive notify-send from remote hosts over SSH and display locally";
after = [ "default.target" ];
wantedBy = [ "default.target" ];
serviceConfig = {
ExecStart = "${pkgs.ssh-notify}/bin/ssh-notify-listener";
Restart = "always";
RestartSec = 2;
};
};
# On servers we rely purely on the wrapper; no extra services needed.
};
}