Honor NO_COLOR in the terminal log handler (closes #402)

The TTY log handler always wrote ANSI color, unlike internal/ui, which
disables color when NO_COLOR is set. Add a color flag to TTYHandler,
set from NO_COLOR with the same test internal/ui uses, and route every
color code through a paint helper that returns plain text when color is
off. The README's color sentence now covers log lines too.

Model: deepseek-v4-pro (implementation); opus-5-5 (rebase)

README.md

@@ -831,7 +831,8 @@ Work planned after 1.0. Loosely ordered by priority.
 
 Every command's user-facing output is governed by `internal/ui`, in one of two
 ways. Color is enabled when the stream written to is a TTY and the `NO_COLOR`
-environment variable is unset (https://no-color.org/).
+environment variable is unset (https://no-color.org/). The same rule governs the
+colorized log lines `internal/log` writes to a terminal.
 
 - **Status, progress, warnings, and errors** go through the `internal/ui`
   message methods below: marker-prefixed, colored on a TTY, and — except

internal/cli/database.go

@@ -7,7 +7,6 @@ import (
 	"github.com/spf13/cobra"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 
 // NewDatabaseCommand creates the database command group
@@ -91,12 +90,12 @@ Use --force to skip the confirmation prompt.`,
 
 				var confirm string
 
-				// A failure to read the answer means no confirmation.
-				_, err = fmt.Fscanln(cmd.InOrStdin(), &confirm)
+				_, err = fmt.Scanln(&confirm)
 				if err != nil || confirm != "yes" {
 					_, _ = fmt.Fprintln(w, "Aborted.")
 
-					return vaultik.ErrNotConfirmed
+					//nolint:nilerr // a failed/aborted confirmation is a clean abort
+					return nil
 				}
 			}
 

internal/cli/database_test.go

@@ -1,48 +0,0 @@
-package cli //nolint:testpackage // sets the unexported rootFlags directly
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"os"
-	"strings"
-	"testing"
-
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// TestDatabaseDeleteDeclinedIsError checks that answering anything but
-// "yes" keeps the database and returns ErrNotConfirmed, so the command
-// exits non-zero.
-//
-//nolint:paralleltest // mutates the process-global rootFlags
-func TestDatabaseDeleteDeclinedIsError(t *testing.T) {
-	dir := t.TempDir()
-	dbPath, cfgPath := seedDatabaseDeleteConfig(t, dir)
-
-	setRootFlags(t, RootFlags{ConfigPath: cfgPath})
-
-	var out bytes.Buffer
-
-	cmd := newDatabaseDeleteCommand()
-	cmd.SetOut(&out)
-	cmd.SetErr(io.Discard)
-	cmd.SetIn(strings.NewReader("no\n"))
-	cmd.SetArgs(nil)
-
-	err := cmd.Execute()
-	if !errors.Is(err, vaultik.ErrNotConfirmed) {
-		t.Errorf("declined database delete returned %v, want %v",
-			err, vaultik.ErrNotConfirmed)
-	}
-
-	_, err = os.Stat(dbPath)
-	if err != nil {
-		t.Errorf("declined database delete removed the file: %v", err)
-	}
-
-	if !strings.Contains(out.String(), "Aborted.") {
-		t.Errorf("declined database delete printed %q, want Aborted.",
-			out.String())
-	}
-}

internal/log/tty_handler.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"log/slog"
+	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -60,6 +61,12 @@ type TTYHandler struct {
 	mu   *sync.Mutex
 	out  io.Writer
 
+	// color reports whether records are written with ANSI color. It is
+	// false when NO_COLOR is set, matching internal/ui's shouldColor
+	// test; the caller already chose this handler for a terminal, so
+	// TTY-ness is not re-checked here.
+	color bool
+
 	// attrs are the attributes accumulated through WithAttrs, emitted
 	// ahead of each record's own attributes. Their keys already carry
 	// the group path that was open when they were added, so no
@@ -72,16 +79,19 @@ type TTYHandler struct {
 	groups []string
 }
 
-// NewTTYHandler creates a new TTY handler with colored output.
+// NewTTYHandler creates a new TTY handler. Color is enabled unless the
+// NO_COLOR environment variable is set to a non-empty value, the same
+// test internal/ui applies to status lines.
 func NewTTYHandler(out io.Writer, opts *slog.HandlerOptions) *TTYHandler {
 	if opts == nil {
 		opts = &slog.HandlerOptions{}
 	}
 
 	return &TTYHandler{
-		out:  out,
-		opts: *opts,
-		mu:   &sync.Mutex{},
+		out:   out,
+		opts:  *opts,
+		mu:    &sync.Mutex{},
+		color: os.Getenv("NO_COLOR") == "",
 	}
 }
 
@@ -124,10 +134,10 @@ func (h *TTYHandler) Handle(_ context.Context, r slog.Record) error {
 	// are written around it: it can carry text from an untrusted source
 	// (a storage error, for one), and a raw control character would
 	// otherwise reach the terminal.
-	_, _ = fmt.Fprintf(h.out, "%s%s%s %s%s%s %s%s%s",
-		colorGray, timestamp, colorReset,
-		levelColor, level, colorReset,
-		colorBold, sanitize(r.Message), colorReset)
+	_, _ = fmt.Fprintf(h.out, "%s %s %s",
+		h.paint(colorGray, timestamp),
+		h.paint(levelColor, level),
+		h.paint(colorBold, sanitize(r.Message)))
 
 	// Attributes carried by the handler come first, then the record's
 	// own. Handler attributes were qualified when they were added; the
@@ -236,6 +246,7 @@ func (h *TTYHandler) clone() *TTYHandler {
 		opts:   h.opts,
 		mu:     h.mu,
 		out:    h.out,
+		color:  h.color,
 		attrs:  make([]slog.Attr, len(h.attrs), len(h.attrs)+1),
 		groups: make([]string, len(h.groups), len(h.groups)+1),
 	}
@@ -273,9 +284,19 @@ func (h *TTYHandler) writeAttr(a slog.Attr) {
 	// the snapshot database — so a control character in one of them must
 	// be rendered as an escape sequence rather than reaching the terminal,
 	// where it could move the cursor or inject its own colours.
-	_, _ = fmt.Fprintf(h.out, " %s%s%s=%s%s%s",
-		colorCyan, sanitize(a.Key), colorReset,
-		colorBlue, sanitize(value), colorReset)
+	_, _ = fmt.Fprintf(h.out, " %s=%s",
+		h.paint(colorCyan, sanitize(a.Key)),
+		h.paint(colorBlue, sanitize(value)))
+}
+
+// paint wraps s in the given ANSI color when color is enabled, and
+// returns s unchanged otherwise.
+func (h *TTYHandler) paint(color, s string) string {
+	if !h.color {
+		return s
+	}
+
+	return color + s + colorReset
 }
 
 // sanitize returns s unchanged when every rune in it is printable, and a

internal/log/tty_handler_test.go

@@ -421,3 +421,44 @@ func TestTTYHandlerEmptyGroupAndAttrsAreNoOps(t *testing.T) {
 	assert.Contains(t, plain, "kept=yes")
 	assert.NotContains(t, plain, " =")
 }
+
+// TestTTYHandlerRespectsNoColor checks that only a non-empty NO_COLOR
+// turns color off, matching internal/ui's shouldColor test. The handler
+// is only ever chosen for a terminal, so this is the one remaining
+// condition that can still leave color in log output.
+func TestTTYHandlerRespectsNoColor(t *testing.T) {
+	cases := []struct {
+		name    string
+		noColor string
+		colored bool
+	}{
+		{
+			name:    "NO_COLOR turns color off",
+			noColor: "1",
+		},
+		{
+			name:    "empty NO_COLOR keeps color on",
+			noColor: "",
+			colored: true,
+		},
+	}
+
+	for _, testCase := range cases {
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Setenv("NO_COLOR", testCase.noColor)
+
+			var buf bytes.Buffer
+
+			logger := slog.New(log.NewTTYHandler(&buf, debugHandlerOptions()))
+			logger.Info("hello", "key", "value")
+
+			if testCase.colored {
+				assert.Contains(t, buf.String(), "\x1b[",
+					"an empty NO_COLOR must leave ANSI color in log output")
+			} else {
+				assert.NotContains(t, buf.String(), "\x1b[",
+					"NO_COLOR must suppress every ANSI escape in log output")
+			}
+		})
+	}
+}

internal/vaultik/prune.go

@@ -267,7 +267,7 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
 
 	if !v.confirmPrune(opts, len(unreferencedBlobs), totalSize,
 		dirsWithoutManifest) {
-		return ErrNotConfirmed
+		return nil
 	}
 
 	v.deleteUnreferencedBlobs(unreferencedBlobs, allBlobs, result)

internal/vaultik/prune_metadata_dir_test.go

@@ -176,8 +176,7 @@ func TestPruneDeclinedKeepsMetadataDirWithoutManifest(t *testing.T) {
 
 	env.v.Stdin = strings.NewReader("n\n")
 
-	require.ErrorIs(t, env.v.PruneBlobs(&vaultik.PruneOptions{}),
-		vaultik.ErrNotConfirmed)
+	require.NoError(t, env.v.PruneBlobs(&vaultik.PruneOptions{}))
 
 	assert.True(t, env.store.hasKey(leftDB),
 		"a declined prune must keep the directory")

internal/vaultik/remove_quiet_test.go

@@ -54,10 +54,9 @@ func TestPurgeSnapshots_QuietPromptListsSnapshots(t *testing.T) {
 	v.UI.SetQuiet(true)
 
 	// Stdin is empty, so the prompt reads no answer and cancels.
-	err := v.PurgeSnapshotsWithOptions(&vaultik.SnapshotPurgeOptions{
+	require.NoError(t, v.PurgeSnapshotsWithOptions(&vaultik.SnapshotPurgeOptions{
 		KeepLatest: true,
-	})
-	require.ErrorIs(t, err, vaultik.ErrNotConfirmed)
+	}))
 
 	assert.Contains(t, out.String(), snapHomeT0)
 	assert.Contains(t, out.String(), "Delete 1 snapshot(s)? [y/N]")
@@ -78,8 +77,7 @@ func TestPruneBlobs_QuietPromptShowsBlobTotal(t *testing.T) {
 	addBlob(t, env.store.testStorer, testBlobHashA)
 
 	// Stdin is empty, so the prompt reads no answer and cancels.
-	require.ErrorIs(t, env.v.PruneBlobs(&vaultik.PruneOptions{}),
-		vaultik.ErrNotConfirmed)
+	require.NoError(t, env.v.PruneBlobs(&vaultik.PruneOptions{}))
 
 	assert.Contains(t, env.stdout.String(),
 		"Found 1 unreferenced blob(s) totaling")

internal/vaultik/remove_snapshot_test.go

@@ -337,27 +337,6 @@ func TestRemoveSnapshot_DefaultRemovesMetadataNotBlobs(t *testing.T) {
 	assert.Contains(t, out, "vaultik prune")
 }
 
-// TestRemoveSnapshot_DeclinedIsError checks that answering no to the
-// prompt keeps the snapshot and returns ErrNotConfirmed, so the command
-// exits non-zero.
-func TestRemoveSnapshot_DeclinedIsError(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	store := newTestStorer()
-	addManifest(t, store, "snapshot-001", nil)
-
-	tv := vaultik.NewForTesting(store)
-	tv.Repositories = newLocalIndex(t, "snapshot-001")
-	tv.Stdin.WriteString("n\n")
-
-	_, err := tv.RemoveSnapshot("snapshot-001", &vaultik.RemoveOptions{})
-
-	require.ErrorIs(t, err, vaultik.ErrNotConfirmed)
-	assert.True(t, store.hasKey(remoteKeyPath("snapshot-001")))
-	assert.Contains(t, tv.Stdout.String(), "Cancelled")
-}
-
 func TestRemoveSnapshot_DryRun(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()

internal/vaultik/snapshot.go

@@ -881,12 +881,17 @@ func (v *Vaultik) confirmAndExecutePurge(
 
 		var confirm string
 
-		// A failure to read the answer means no confirmation.
 		_, err := v.scanStdin(&confirm)
-		if err != nil || strings.ToLower(confirm) != "y" {
+		if err != nil {
 			v.printlnStdout("Cancelled")
 
-			return ErrNotConfirmed
+			return nil //nolint:nilerr // treat EOF or read error as "no"
+		}
+
+		if strings.ToLower(confirm) != "y" {
+			v.printlnStdout("Cancelled")
+
+			return nil
 		}
 	} else if !quiet {
 		v.UI.Infof("The following snapshots will be deleted:")
@@ -1485,7 +1490,7 @@ func (v *Vaultik) RemoveSnapshot(
 	}
 
 	if !v.confirmRemoveSnapshot(snapshotID, opts) {
-		return result, ErrNotConfirmed
+		return result, nil
 	}
 
 	// Checked before the local record is deleted: it may be the last

internal/vaultik/snapshot_list_test.go

@@ -345,9 +345,8 @@ func TestSnapshotListAndPurgePrintSizesLikeRemoteInfo(t *testing.T) {
 	// Without --force and with nothing on stdin the purge lists what it
 	// would delete, reads no confirmation, and deletes nothing.
 	env.stdout.Reset()
-	require.ErrorIs(t, env.v.PurgeSnapshotsWithOptions(
-		&vaultik.SnapshotPurgeOptions{OlderThan: "1d"}),
-		vaultik.ErrNotConfirmed)
+	require.NoError(t, env.v.PurgeSnapshotsWithOptions(
+		&vaultik.SnapshotPurgeOptions{OlderThan: "1d"}))
 	assert.Contains(t, findTableRow(t, env.stdout.String(), listLocalID),
 		wantSize, "snapshot purge")
 }

internal/vaultik/vaultik.go

@@ -5,7 +5,6 @@ package vaultik
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -185,12 +184,6 @@ func (v *Vaultik) printlnStdout(args ...any) {
 	_, _ = fmt.Fprintln(v.Stdout, args...)
 }
 
-// ErrNotConfirmed is returned when a confirmation prompt gets any answer
-// but the one it asks for (`y` or `Y`, or `yes` for `database delete`), or
-// stdin ends first. Nothing the prompt asked about is deleted, and the
-// command exits non-zero.
-var ErrNotConfirmed = errors.New("deletion not confirmed")
-
 // scanStdin reads a line of input from stdin.
 func (v *Vaultik) scanStdin(a ...any) (int, error) {
 	return fmt.Fscanln(v.Stdin, a...)