Every command ends on SIGINT, SIGTERM or SIGHUP; an interrupted age -o leaves no file (closes #48)

SIGINT, SIGTERM and SIGHUP are no longer caught for the whole run, so they end any command at once, the mnemonic prompt included. One package, internal/cli/signals, catches them only where cleanup is needed, and only those not ignored at start, so nohup still works: ssh to and ssh install while their child runs, and age encrypt -o and age decrypt -o while they write. A signal received by the time the input ends leaves no new file and exits 1; otherwise the whole file is put in place, never an unfinished one.

Judgement call: the guarantee is stated for a signal keyfunc has received, as Go cannot promise more; the main goroutine stays on the main thread so a Ctrl-C on a pipeline is seen first on Linux. Unverified on macOS.

Model: opus-5-5 (implementation); fable-5-1 (design)

internal/cli/signals/signals.go

@@ -0,0 +1,53 @@
+// Package signals catches the signals that end the tool, for the
+// commands that clean up before they end.
+package signals
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// Context is signal.NotifyContext for SIGINT, SIGTERM and SIGHUP: the
+// context it returns is cancelled when one of them arrives, and stop
+// stops catching them. It leaves out any of the three the tool was
+// started with set to be ignored, as nohup does with SIGHUP, because
+// catching a signal turns an ignored one back on and would end a run
+// that was meant to survive it.
+func Context(parent context.Context) (context.Context, context.CancelFunc) {
+	endings := caught()
+
+	// Given no signals at all, NotifyContext would catch every one.
+	if len(endings) == 0 {
+		return context.WithCancel(parent)
+	}
+
+	return signal.NotifyContext(parent, endings...)
+}
+
+// Notify is signal.Notify for the signals Context catches: each one
+// that arrives is sent to c, until signal.Stop(c).
+func Notify(c chan<- os.Signal) {
+	endings := caught()
+
+	// Given no signals at all, Notify would catch every one.
+	if len(endings) > 0 {
+		signal.Notify(c, endings...)
+	}
+}
+
+// caught returns those of SIGINT, SIGTERM and SIGHUP that the tool was
+// not started with set to be ignored.
+func caught() []os.Signal {
+	endings := []os.Signal{syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP}
+	kept := make([]os.Signal, 0, len(endings))
+
+	for _, ending := range endings {
+		if !signal.Ignored(ending) {
+			kept = append(kept, ending)
+		}
+	}
+
+	return kept
+}