Report the Go build info version when linker flags set none (closes #422)

A `go install` of a tag sets no linker flags, so the binary reported
`dev`. Version, commit and commit date that the linker flags leave
unset now come from the build info Go records. Go records a
pseudo-version for an untagged commit and a `+dirty` suffix for a
modified checkout; `IsDevVersion` now counts both as development
builds, using `golang.org/x/mod`.

Model: opus-5-5

README.md

@@ -2,9 +2,9 @@
 
 `vaultik` is an incremental backup tool written in Go. It encrypts data using an
 `age` public key and uploads each encrypted blob directly to a remote
-S3-compatible object store. The backed-up system never needs the private key. A
+S3-compatible object store. It requires no private keys, secrets, or credentials
-backup needs only the public key and the credentials to write to the object
+(other than those required to PUT to encrypted object storage, such as S3 API
-store, such as S3 API keys.
+keys) stored on the backed-up system.
 
 ## quickstart
 
@@ -171,7 +171,6 @@ vaultik [--config <path>] config get <key>
 vaultik [--config <path>] config set <key> <value>
 vaultik [--config <path>] snapshot create [snapshot-names...] [--cron] [--prune] [--keep-newer-than <duration>]
 vaultik [--config <path>] snapshot list [--json]                  # alias: ls
-vaultik [--config <path>] snapshot files <snapshot-id> [path] [--json]
 vaultik [--config <path>] snapshot verify <snapshot-id> [--deep] [--json]
 vaultik [--config <path>] snapshot purge [--keep-latest | --older-than <duration>] [--snapshot <name>...] [--force]
 vaultik [--config <path>] snapshot remove <snapshot-id> [--dry-run] [--force] [--local-only] [--json]  # alias: rm
@@ -224,24 +223,12 @@ the backup can delete it; the new snapshot then cannot be restored.
 `remote nuke` deletes everything regardless. To not depend on the grace period,
 give each host or user its own prefix (or directory) on the destination.
 
-These read-only commands do not take the lock, so they are never blocked, even
+Read-only commands — `info`, `snapshot list`, `snapshot verify`, and
-while a backup is in progress:
+`remote info` — do not take the lock and are never blocked, so they run even
-
+while a backup is in progress. `snapshot restore` does not take the lock either:
-- `info`
+it writes only to the target directory you name, not the local index or the
-- `snapshot list`
+destination store. `config`, `database delete`, `completion`, and `version` do
-- `snapshot files`
+not take the lock.
-- `snapshot verify`
-- `remote info`
-
-`snapshot restore` does not take the lock either: it writes only to the target
-directory you name, not the local index or the destination store.
-
-These commands do not take the lock either:
-
-- `config`
-- `database delete`
-- `completion`
-- `version`
 
 ### stdout and stderr
 
@@ -274,9 +261,9 @@ work as written.
 ### environment variables
 
 - `VAULTIK_AGE_SECRET_KEY`: Age private key for decryption (required for
-  `snapshot restore`, `snapshot files` and `snapshot verify --deep`). May hold
+  `snapshot restore` and `snapshot verify --deep`). May hold the whole
-  the whole `age-keygen` file — comments and every identity in it are accepted.
+  `age-keygen` file — comments and every identity in it are accepted. Set it
-  Set it from the file, e.g.
+  from the file, e.g.
   `export VAULTIK_AGE_SECRET_KEY="$(cat vaultik_backup_private_key.txt)"`, so
   the key is not typed into your shell history.
 - `VAULTIK_CONFIG`: Path to config file (overridden by `--config`)
@@ -326,10 +313,12 @@ when the next path element is a number (so
 `vaultik config set age_recipients.0 age1...` works on a file without
 `age_recipients`), otherwise as a map. If the config loads, a change after which
 it would not, such as `vaultik config set compression_level 99`, is refused and
-the file is left unchanged. A config that does not load is checked one setting
+the file is left unchanged. A config that does not load, such as the one
-at a time. Examples are the file `config init` writes before `storage_url` is
+`config init` writes before `storage_url` is set or one with a `${ENV:...}`
-set, and one with a `${ENV:...}` reference to a variable not set in this shell.
+reference to a variable not set in this shell, is checked one setting at a time:
-In such a config, an unknown key or a value of the wrong type is refused.
+only a change after which the changed setting cannot be read, such as one giving
+it the wrong type (a single value where a list belongs or a word where a number
+belongs), is refused.
 
 **`snapshot create`**: Perform incremental backup of configured snapshots.
 
@@ -421,26 +410,6 @@ point behind.
   truncated listing all go to stderr through the logger, so stdout stays a
   single parseable document.
 
-**`snapshot files`**: List the files in a snapshot without restoring it. Each
-row of the table shows mode, size in bytes, modification time and path, sorted
-by path.
-
-- Requires `VAULTIK_AGE_SECRET_KEY`: the file list is only in the snapshot's
-  encrypted database, which the command downloads and decrypts.
-- Accepts the same identifiers as `snapshot restore`.
-- An optional path limits the list to that path and what is under it. A path
-  that matches nothing in the snapshot is an error.
-- `--json`: Output an array of objects with `path`, `size`, `mode` and `mtime`.
-- In the table, a path that holds a newline or another non-printable character
-  is shown in double quotes, with that character escaped, as in `"a\nb"`.
-- The mode is in Go's file-mode notation, in the table and in `--json`. Letters
-  before the nine permission characters show the file type and any special bit,
-  as in `dtrwxrwxrwx` for a sticky directory. These letters differ from `ls -l`:
-    - `L`: a symbolic link, which `ls -l` shows as `l`.
-    - `u`: setuid, which `ls -l` shows as `s` in place of the owner's `x`.
-    - `g`: setgid, which `ls -l` shows as `s` in place of the group's `x`.
-    - `t`: sticky, which `ls -l` shows as `t` in place of the others' `x`.
-
 **`snapshot verify`**: Verify snapshot integrity.
 
 - Default (shallow): checks that every blob the manifest lists is present in
@@ -755,7 +724,7 @@ annotated example also lives in
 | Field                | Default                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | -------------------- | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `age_recipients`     | (required by `snapshot create`) | Age public keys for encryption. Other commands run without one, so a machine that only restores can leave it empty                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `age_secret_key`     | (unset)                         | Age private key for decryption (`snapshot restore`, `snapshot files`, `snapshot verify --deep`). Setting it in the config file places the private key on the backed-up host, defeating the public-key-only design (see "why" above). Prefer the `VAULTIK_AGE_SECRET_KEY` environment variable, supplied only on the machine you restore from.                                                                                                                                                                                                                                                                                                                    |
+| `age_secret_key`     | (unset)                         | Age private key for decryption (`snapshot restore`, `snapshot verify --deep`). Setting it in the config file places the private key on the backed-up host, defeating the public-key-only design (see "why" above). Prefer the `VAULTIK_AGE_SECRET_KEY` environment variable, supplied only on the machine you restore from.                                                                                                                                                                                                                                                                                                                                      |
 | `snapshots`          | (required)                      | Named snapshot definitions with paths and excludes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `storage_url`        |                                 | Storage backend URL (`s3://`, `file://`, `rclone://`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `s3.*`               |                                 | Legacy S3 configuration (endpoint, bucket, credentials)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
@@ -872,27 +841,15 @@ environment variable is unset (https://no-color.org/).
   `database delete`.
 - **The data a command exists to produce** is written plain, with no marker and
   no color, because a marker would corrupt a table or a parsed document. This
-  covers the report or table of each of these commands:
+  covers the `version`, `info`, `remote info` and `snapshot verify` reports, the
-    - `version`
+  `snapshot list` table, `config get` values, and every `--json` document.
-    - `info`
+  `--quiet` silences the human reports and tables (`version`, `info`,
-    - `remote info`
+  `remote info`, `snapshot verify`, `snapshot list`) but never the
-    - `snapshot verify`
+  machine-consumed `config get` value or the `--json` documents, which a script
-    - `snapshot list`
+  depends on. The confirmation prompts of `database delete`, `prune`,
-    - `snapshot files`
+  `snapshot purge` and `snapshot remove`, each with what it asks to delete, are
-
+  also written this way and always shown: they are an interactive exchange the
-    `config get` values and every `--json` document are written plain too.
+  operator must see.
-    `--quiet` silences the reports and tables above, but never a `config get`
-    value or a `--json` document, which a script depends on.
-
-    These commands write their confirmation prompt plain too, with what it asks
-    to delete:
-    - `database delete`
-    - `prune`
-    - `snapshot purge`
-    - `snapshot remove`
-
-    `--quiet` never silences these prompts: each is an interactive exchange the
-    operator must see.
 
 `internal/ui` writes to stdout; it is the output the user asked for. The
 exceptions are the startup banner and the error a failed command ends with,

configs/config.example.yml

@@ -295,7 +295,6 @@ storage_url: "rclone://myremote/path/to/backups"
 
 # Path to local SQLite index database
 # This database tracks file state for incremental backups
-# It must be an absolute path; ~ is expanded
 # Default: the platform data directory, e.g.
 #   macOS: ~/Library/Application Support/vaultik/index.sqlite
 #   Linux: ~/.local/share/vaultik/index.sqlite

docs/REPOSTRUCTURE.md

@@ -265,23 +265,15 @@ so an operator can weigh them rather than discover them.
    blob holds hundreds of chunks, so individual chunk lengths are not visible in
    the blob's size; lowering the limit toward the chunk size begins to expose
    them.
-4. **Decrypted data on local disk.** These commands stage plaintext under
+4. **Decrypted data on local disk.** Several commands stage plaintext under
-   `$TMPDIR`:
+   `$TMPDIR`: `snapshot restore` writes decrypted blobs under
-    - `snapshot restore`: decrypted blobs under `vaultik-blobcache-*/`, with no
+   `vaultik-blobcache-*/` (no size cap) and the decrypted metadata database at
-      size cap, and the decrypted metadata database at
+   `vaultik-restore-*/snapshot.db`; `verify --deep` writes that database at
-      `vaultik-restore-*/snapshot.db`.
+   `vaultik-verify-*/snapshot.db`; `snapshot create` keeps a plaintext copy of
-    - `snapshot files`: the decrypted metadata database at
+   the index at `vaultik-snapshot-*/snapshot.db`. These files are created `0600`
-      `vaultik-restore-*/snapshot.db`.
+   and removed on success, but a `kill -9` or a power loss leaves them behind —
-    - `verify --deep`: the decrypted metadata database at
+   delete any leftover `vaultik-*` directory under `$TMPDIR` by hand. `$TMPDIR`
-      `vaultik-verify-*/snapshot.db`.
+   should be trusted to the same degree as the restore target.
-    - `snapshot create`: a plaintext copy of the index at
-      `vaultik-snapshot-*/snapshot.db`.
-
-    These files are created `0600` and removed on success, but a `kill -9` or a
-    power loss leaves them behind — delete any leftover `vaultik-*` directory
-    under `$TMPDIR` by hand. `$TMPDIR` should be trusted to the same degree as
-    the restore target.
-
 5. **Store permissions differ per command.** The backed-up host needs only PUT
    to run `snapshot create`: it writes blobs and metadata and neither reads nor
    deletes them. Other commands need more — `snapshot verify`,

internal/blobgen/negative_test.go

@@ -2,10 +2,8 @@ package blobgen_test
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"testing"
-	"testing/iotest"
 
 	"filippo.io/age"
 	"github.com/stretchr/testify/assert"
@@ -122,38 +120,6 @@ func TestNewReaderTrailingAndGarbage(t *testing.T) {
 	})
 }
 
-// TestNewReaderGarbageErrorQuotesNoBytes checks that lines of text in
-// place of a blob fail with ErrNotAgeStream, and that the error carries
-// none of their bytes. The lines end in a newline because age's own error
-// quotes the data's first line only when it reads a whole line.
-func TestNewReaderGarbageErrorQuotesNoBytes(t *testing.T) {
-	t.Parallel()
-
-	id, _ := makeIdentity(t)
-	garbage := bytes.Repeat([]byte("garbage-bytes-\n"), 100)
-
-	_, err := blobgen.NewReader(bytes.NewReader(garbage), id)
-
-	require.ErrorIs(t, err, blobgen.ErrNotAgeStream)
-	assert.NotContains(t, err.Error(), "garbage-bytes-")
-}
-
-// errConnectionReset stands for a storage read that fails.
-var errConnectionReset = errors.New("connection reset")
-
-// TestNewReaderReadFailure checks that a failed read of the age header is
-// returned as that read error, not as ErrNotAgeStream.
-func TestNewReaderReadFailure(t *testing.T) {
-	t.Parallel()
-
-	id, _ := makeIdentity(t)
-
-	_, err := blobgen.NewReader(iotest.ErrReader(errConnectionReset), id)
-
-	require.ErrorIs(t, err, errConnectionReset)
-	assert.NotErrorIs(t, err, blobgen.ErrNotAgeStream)
-}
-
 // TestNewWriterInvalidLevel covers the rejected end of issue case 9: an
 // out-of-range compression level errors and writes nothing to the destination.
 func TestNewWriterInvalidLevel(t *testing.T) {

internal/blobgen/reader.go

@@ -11,11 +11,6 @@ import (
 	"github.com/klauspost/compress/zstd"
 )
 
-// ErrNotAgeStream is returned by NewReader when the data cannot be opened
-// as an age stream, for example because its header is malformed. It
-// replaces age's own error, which can quote the data's first bytes.
-var ErrNotAgeStream = errors.New("not a valid age stream")
-
 // Reader wraps decompression and decryption with SHA256 verification
 type Reader struct {
 	reader       io.Reader
@@ -29,25 +24,11 @@ type Reader struct {
 // NewReader creates a new Reader that decrypts, decompresses, and verifies
 // data. Every supplied identity is offered to age.Decrypt, so a blob
 // encrypted to any one of them can be read.
-//
-// A failure to read r is returned as that error, and a blob encrypted to
-// none of the identities as age.NoIdentityMatchError. Any other failure
-// to open the age stream is ErrNotAgeStream.
 func NewReader(r io.Reader, identities ...age.Identity) (*Reader, error) {
-	src := &readErrorRecorder{reader: r}
+	// Create decryption reader
-
+	decReader, err := age.Decrypt(r, identities...)
-	decReader, err := age.Decrypt(src, identities...)
 	if err != nil {
-		var noMatch *age.NoIdentityMatchError
+		return nil, fmt.Errorf("creating decryption reader: %w", err)
-
-		switch {
-		case src.err != nil:
-			return nil, fmt.Errorf("reading age header: %w", src.err)
-		case errors.As(err, &noMatch):
-			return nil, fmt.Errorf("creating decryption reader: %w", err)
-		default:
-			return nil, ErrNotAgeStream
-		}
 	}
 
 	// Create decompression reader
@@ -71,23 +52,6 @@ func NewReader(r io.Reader, identities ...age.Identity) (*Reader, error) {
 	}, nil
 }
 
-// readErrorRecorder passes reads through to reader and keeps the first
-// error other than io.EOF, so NewReader can tell a failed read from bad
-// data.
-type readErrorRecorder struct {
-	reader io.Reader
-	err    error
-}
-
-func (r *readErrorRecorder) Read(p []byte) (int, error) {
-	n, err := r.reader.Read(p)
-	if err != nil && !errors.Is(err, io.EOF) && r.err == nil {
-		r.err = err
-	}
-
-	return n, err
-}
-
 // Read implements io.Reader
 func (r *Reader) Read(p []byte) (int, error) {
 	n, err := r.teeReader.Read(p)

internal/cli/app.go

@@ -7,9 +7,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"path/filepath"
 	"sync"
 	"time"
 
+	"github.com/adrg/xdg"
 	"github.com/spf13/cobra"
 	"go.uber.org/dig"
 	"go.uber.org/fx"
@@ -38,11 +40,10 @@ const (
 	// prune, remote nuke) write the local index or the remote store. They
 	// hold the PID lock so that at most one runs at a time.
 	mutating lockMode = iota
-	// readOnly commands (info, snapshot list, snapshot files, snapshot
+	// readOnly commands (info, snapshot list, snapshot verify, remote info,
-	// verify, remote info, snapshot restore) do not write the local index
+	// snapshot restore) do not write the local index or the remote store,
-	// or the remote store, so they run without the lock and are never
+	// so they run without the lock and are never blocked by a running
-	// blocked by a running mutator. restore writes only to the target
+	// mutator. restore writes only to the target directory it is given.
-	// directory it is given.
 	readOnly
 )
 
@@ -311,7 +312,7 @@ func RunOperation(
 }
 
 // runVaultikApp runs the standard single-operation command lifecycle
-// shared by the snapshot list/files/purge/remove and remote nuke subcommands:
+// shared by the snapshot list/purge/remove and remote nuke subcommands:
 // resolve the config, then run op against the Vaultik instance through
 // RunOperation, reporting a failure prefixed with failMsg on stderr. mode
 // says whether the command takes the PID lock. jsonOutput marks a command
@@ -338,7 +339,7 @@ func runVaultikApp(
 		},
 		Mode: mode,
 	}, op, func(err error) {
-		log.Info(failMsg, "error", err)
+		log.Error(failMsg, "error", err)
 		ReportErrorf("%s: %v", failMsg, err)
 	})
 }
@@ -350,7 +351,8 @@ func runVaultikApp(
 // only one runs at a time; a read-only command runs without it and is not
 // blocked while a mutator holds the lock (opts.Mode).
 func RunWithApp(ctx context.Context, opts AppOptions) error {
-	release, err := acquireLockIfMutating(opts.Mode, pidlock.Dir())
+	release, err := acquireLockIfMutating(opts.Mode,
+		filepath.Join(xdg.DataHome, "vaultik"))
 	if err != nil {
 		return err
 	}

internal/cli/config.go

@@ -49,14 +49,8 @@ var (
 	errWouldNotLoad     = errors.New(
 		"vaultik would not load the config after this change, " +
 			"so the file was not changed")
-	errSetS3KeysFirst = errors.New(
-		"set s3.access_key_id and s3.secret_access_key first, " +
-			"then storage_url")
 )
 
-// storageURLKey is the config key that selects the storage backend.
-const storageURLKey = "storage_url"
-
 // macOS is the value of runtime.GOOS on macOS.
 const macOS = "darwin"
 
@@ -282,8 +276,7 @@ storage_url: ""
 # Hostname used in snapshot IDs. Default: system hostname.
 # hostname: myserver
 
-# Path to the local SQLite index database. It must be an absolute path;
+# Path to the local SQLite index database.
-# ~ is expanded.
 # Default: the platform data directory, e.g.
 #   macOS: ~/Library/Application Support/vaultik/index.sqlite
 #   Linux: ~/.local/share/vaultik/index.sqlite
@@ -450,10 +443,11 @@ number, otherwise as a map.
 
 If the config loads, a change after which it would not, such as
 compression_level 99, is refused and the file is left unchanged. A
-config that does not load is checked one setting at a time. Examples
+config that does not load, such as the one config init writes before
-are the file config init writes before storage_url is set, and one
+storage_url is set or one with a ${ENV:...} reference to a variable
-with a ${ENV:...} reference to a variable not set in this shell. In
+not set here, is checked one setting at a time: only a change after
-such a config, an unknown key or a value of the wrong type is refused.
+which the changed setting cannot be read, such as one giving it the
+wrong type, is refused.
 
 Examples:
   vaultik config set storage_url "file:///mnt/backups"
@@ -490,13 +484,6 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 
 	keys := strings.Split(key, ".")
 
-	if keys[0] != config.EnvSection {
-		_, err = config.SettingType(keys)
-		if err != nil {
-			return err
-		}
-	}
-
 	err = yamlPathSet(root, keys, value)
 	if err != nil {
 		return err
@@ -519,7 +506,7 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 
 	err = checkConfigChange(oldData, data, settingData)
 	if err != nil {
-		return wouldNotLoadError(key, err)
+		return fmt.Errorf("%w: %w", errWouldNotLoad, err)
 	}
 
 	err = os.WriteFile(path, data, configFileMode)
@@ -543,21 +530,6 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 	return nil
 }
 
-// wouldNotLoadError returns the refusal of a change to key that vaultik
-// would not load for reason. When storage_url moves to s3:// before the S3
-// credentials are set, it says to set them first: they can be set while
-// the old storage_url is still in place.
-func wouldNotLoadError(key string, reason error) error {
-	if key == storageURLKey &&
-		(errors.Is(reason, config.ErrS3KeyIDRequired) ||
-			errors.Is(reason, config.ErrS3SecretRequired)) {
-		return fmt.Errorf("%w: %w; %w", errWouldNotLoad, reason,
-			errSetS3KeysFirst)
-	}
-
-	return fmt.Errorf("%w: %w", errWouldNotLoad, reason)
-}
-
 // checkConfigChange returns the reason vaultik would not load newData, the
 // config after a change, if the change brings that failure in. If oldData,
 // the config before it, loads, the new one must load too. A config that
@@ -767,11 +739,41 @@ func yamlPathSet(root *yaml.Node, keys []string, value string) error {
 }
 
 // configKeyIsString reports whether the dotted key names a string in
-// config.Config, as s3.access_key_id and snapshots.home.exclude.0 do.
+// config.Config, following the fields' yaml tags, as s3.access_key_id and
+// snapshots.home.exclude.0 do.
 func configKeyIsString(keys []string) bool {
-	typ, err := config.SettingType(keys)
+	typ := reflect.TypeFor[config.Config]()
 
-	return err == nil && typ.Kind() == reflect.String
+	for _, key := range keys {
+		switch {
+		case typ.Kind() == reflect.Map || typ.Kind() == reflect.Slice:
+			// The key is a snapshot name or a list index.
+			typ = typ.Elem()
+		case typ.Kind() == reflect.Struct:
+			field, ok := yamlField(typ, key)
+			if !ok {
+				return false
+			}
+
+			typ = field.Type
+		default:
+			return false
+		}
+	}
+
+	return typ.Kind() == reflect.String
+}
+
+// yamlField returns the field of struct type typ whose yaml tag names key.
+func yamlField(typ reflect.Type, key string) (reflect.StructField, bool) {
+	for field := range typ.Fields() {
+		name, _, _ := strings.Cut(field.Tag.Get("yaml"), ",")
+		if name == key {
+			return field, true
+		}
+	}
+
+	return reflect.StructField{}, false
 }
 
 // yamlSetInMapping resolves (creating if needed) the value node for the

internal/cli/config_test.go

@@ -2,7 +2,6 @@ package cli //nolint:testpackage // exercises unexported yamlPathGet/yamlPathSet
 
 import (
 	"bytes"
-	"errors"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -153,21 +152,6 @@ snapshots:
       - "~"
 `
 
-// testS3URL is an S3 storage_url, which needs credentials to load.
-const testS3URL = "s3://bucket/prefix?endpoint=https://s3.example.com"
-
-// configWithS3Keys loads: its storage_url is testS3URL and both S3 keys are
-// set.
-const configWithS3Keys = storageURLKey + ": " + testS3URL + `
-s3:
-  access_key_id: AKIAEXAMPLE
-  secret_access_key: example-secret
-snapshots:
-  home:
-    paths:
-      - "~"
-`
-
 // configWithUnsetReference loads only where VAULTIK_TEST_UNSET_SECRET is
 // set, as a backup job's environment might set it. No test sets it.
 const configWithUnsetReference = configWithoutRecipients + `s3:
@@ -241,7 +225,7 @@ func TestConfigSetIndexUnderMissingKey(t *testing.T) {
 // change after which the config would not load, with an error giving the
 // reason, and leaves the file as it was. On the file `config init` writes,
 // which does not load until storage_url is set, and on one that cannot be
-// read here, only an unknown key or a value of the wrong type is refused.
+// read here, only a value of the wrong type is refused.
 func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
 	t.Parallel()
 
@@ -253,14 +237,6 @@ func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
 		value  string
 		reason string
 	}{
-		// Keys that no setting has, on a config that loads and on one
-		// that does not.
-		{configWithoutRecipients, "nosuchkey", "1",
-			`unknown config key "nosuchkey"`},
-		{configWithoutRecipients, "snapshots.home.exlude", "/tmp",
-			`unknown config key "snapshots.home.exlude"`},
-		{defaultConfigText(macOS), "compression_lvl", "9",
-			`unknown config key "compression_lvl"`},
 		// Index 1 of the empty list the missing key gives.
 		{configWithoutRecipients, "age_recipients.1", testRecipient,
 			"index out of range"},
@@ -268,20 +244,12 @@ func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
 		{configWithoutRecipients, "snapshots.home.paths", "/srv",
 			"into []string"},
 		{configWithoutRecipients, "chunk_size", "fast",
-			`chunk_size: "fast" is not a size`},
+			"invalid size format"},
 		// Values of the right type that fail validation.
 		{configWithoutRecipients, "compression_level", "99",
 			"compression_level must be between 1 and 19"},
 		{configWithoutRecipients, "chunk_size", "1KB",
 			"chunk_size must be at least 1MB"},
-		// An s3:// URL before its credentials names them.
-		{configWithoutRecipients, storageURLKey, testS3URL,
-			"s3.access_key_id is required for s3:// URLs; " +
-				"set s3.access_key_id and s3.secret_access_key first"},
-		{configWithoutRecipients + "s3:\n  access_key_id: AKIAEXAMPLE\n",
-			storageURLKey, testS3URL,
-			"s3.secret_access_key is required for s3:// URLs; " +
-				"set s3.access_key_id and s3.secret_access_key first"},
 		// With its reference filled in, the config loads.
 		{levelReference, "blob_size_limit", "1MB",
 			"blob_size_limit must be at least"},
@@ -367,109 +335,6 @@ func TestConfigSetRefusesOnlyItsOwnFailure(t *testing.T) {
 	}
 }
 
-// TestConfigSetS3KeysBeforeStorageURL checks that the order the refusal
-// gives works on a config that loads with a file:// storage_url.
-func TestConfigSetS3KeysBeforeStorageURL(t *testing.T) {
-	t.Parallel()
-
-	path := filepath.Join(t.TempDir(), "config.yml")
-
-	err := os.WriteFile(path, []byte(configWithoutRecipients), configFileMode)
-	if err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	for _, set := range [][2]string{
-		{"s3.access_key_id", "AKIAEXAMPLE"},
-		{"s3.secret_access_key", "example-secret"},
-		{storageURLKey, testS3URL},
-	} {
-		err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
-			path, set[0], set[1])
-		if err != nil {
-			t.Fatalf("config set %s: %v", set[0], err)
-		}
-	}
-
-	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	if !strings.Contains(string(data), storageURLKey+": "+testS3URL) {
-		t.Errorf("config set storage_url wrote:\n%s", data)
-	}
-}
-
-// TestConfigSetRefusesClearingS3Key checks that clearing s3.access_key_id on
-// a config with an s3:// storage_url is refused without saying to set the
-// S3 keys first. That advice is only for a change to storage_url.
-func TestConfigSetRefusesClearingS3Key(t *testing.T) {
-	t.Parallel()
-
-	const key = "s3.access_key_id"
-
-	path := filepath.Join(t.TempDir(), "config.yml")
-
-	err := os.WriteFile(path, []byte(configWithS3Keys), configFileMode)
-	if err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false), path, key, "")
-	if !errors.Is(err, errWouldNotLoad) {
-		t.Errorf("clearing %s gives error %v, want one saying %q",
-			key, err, errWouldNotLoad)
-	}
-
-	if errors.Is(err, errSetS3KeysFirst) {
-		t.Errorf("clearing %s gives error %v, want one not saying %q",
-			key, err, errSetS3KeysFirst)
-	}
-
-	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	if string(data) != configWithS3Keys {
-		t.Errorf("clearing %s changed the file to:\n%s", key, data)
-	}
-}
-
-// TestConfigSetWritesEnvSection checks that config set writes a key under
-// the top-level env section, whose keys are not settings, on a config that
-// loads.
-func TestConfigSetWritesEnvSection(t *testing.T) {
-	const name = "VAULTIK_TEST_CONFIG_SET_ENV"
-
-	// Loading the changed config sets the variable; t.Setenv restores it
-	// after the test.
-	t.Setenv(name, "")
-
-	path := filepath.Join(t.TempDir(), "config.yml")
-
-	err := os.WriteFile(path, []byte(configWithoutRecipients), configFileMode)
-	if err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
-		path, "env."+name, "value")
-	if err != nil {
-		t.Fatalf("config set env.%s: %v", name, err)
-	}
-
-	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	if !strings.Contains(string(data), "env:\n  "+name+": value\n") {
-		t.Errorf("config set env.%s wrote:\n%s", name, data)
-	}
-}
-
 // TestConfigSetStringLooksLikeNumber sets string settings to values that
 // YAML reads as numbers or booleans when they are unquoted, and checks that
 // config.Load returns each one unchanged.

internal/cli/database.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"sneak.berlin/go/vaultik/internal/config"
-	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
@@ -101,16 +100,18 @@ Use --force to skip the confirmation prompt.`,
 				}
 			}
 
-			// Delete the database file and its side files. A side file
+			// Delete the database file
-			// may not exist, so only failing to delete the database file
+			err = os.Remove(dbPath)
-			// is an error.
+			if err != nil {
-			for _, indexFile := range database.IndexFiles(dbPath) {
+				return fmt.Errorf("failed to delete database: %w", err)
-				err = os.Remove(indexFile)
-				if err != nil && indexFile == dbPath {
-					return fmt.Errorf("failed to delete database: %w", err)
-				}
 			}
 
+			// Also delete WAL and SHM files if they exist
+			walPath := dbPath + "-wal"
+			shmPath := dbPath + "-shm"
+			_ = os.Remove(walPath) // Ignore errors - files may not exist
+			_ = os.Remove(shmPath)
+
 			out.Infof("Local state database deleted: %s.", dbPath)
 			log.Info("Local state database deleted", "path", dbPath)
 

internal/cli/database_test.go

@@ -5,11 +5,9 @@ import (
 	"errors"
 	"io"
 	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 
-	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 
@@ -48,28 +46,3 @@ func TestDatabaseDeleteDeclinedIsError(t *testing.T) {
 			out.String())
 	}
 }
-
-// TestDatabaseDeleteRemovesSideFiles checks that the side files SQLite
-// keeps beside the database file are deleted with it.
-//
-//nolint:paralleltest // mutates the process-global rootFlags
-func TestDatabaseDeleteRemovesSideFiles(t *testing.T) {
-	dir := t.TempDir()
-	dbPath, cfgPath := seedDatabaseDeleteConfig(t, dir)
-
-	indexFiles := database.IndexFiles(dbPath)
-	for _, indexFile := range indexFiles {
-		seedFile(t, dir, filepath.Base(indexFile), "data")
-	}
-
-	setRootFlags(t, RootFlags{ConfigPath: cfgPath})
-
-	mustExecute(t, newDatabaseDeleteCommand(), "--force")
-
-	for _, indexFile := range indexFiles {
-		_, err := os.Stat(indexFile)
-		if !os.IsNotExist(err) {
-			t.Errorf("database delete left %s: stat err = %v", indexFile, err)
-		}
-	}
-}

internal/cli/entry.go

@@ -85,10 +85,6 @@ func emitStartupBanner(args []string, w io.Writer) {
 // 🛑 ERROR: format. Use it from goroutine error paths (where returning
 // an error to cobra isn't an option) and anywhere else a CLI command
 // must surface a failure outside the normal RunE return path.
-//
-// This line is the one report of the failure. A caller that also logs
-// the failure logs it at info level, so the record appears only under
-// --verbose or --debug and the error is not printed twice.
 func ReportErrorf(format string, args ...any) {
 	ui.New(os.Stderr).Errorf(format, args...)
 }

internal/cli/entry_failure_once_test.go

@@ -1,205 +0,0 @@
-package cli //nolint:testpackage // shares the fixtures and capture helpers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"filippo.io/age"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/ui"
-)
-
-const (
-	// errorLinePrefix starts the final line that reports a failed command.
-	errorLinePrefix = "ERROR: "
-
-	flagVerbose = "--verbose"
-	cmdRestore  = "restore"
-
-	// blobsDir is the directory of a destination store that holds the
-	// blobs.
-	blobsDir = "blobs"
-)
-
-// TestEntryFailureIsPrintedOnce runs commands that fail after startup
-// against a destination they cannot use. `info` is not among them: it
-// cannot fail after startup.
-//
-//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
-func TestEntryFailureIsPrintedOnce(t *testing.T) {
-	for _, command := range [][]string{
-		{cmdSnapshot, cmdCreate},
-		{cmdSnapshot, cmdRemove, someSnapshotID},
-		{cmdSnapshot, cmdVerify, someSnapshotID},
-		{cmdRemote, cmdInfo},
-		{cmdPrune, flagJSON},
-	} {
-		for _, verbose := range []bool{false, true} {
-			name := fmt.Sprintf("%s verbose=%t", strings.Join(command, " "), verbose)
-
-			t.Run(name, func(t *testing.T) {
-				requireErrorPrintedOnce(t, verbose, append([]string{flagConfig,
-					writeUnusableDestinationConfig(t)}, command...)...)
-			})
-		}
-	}
-}
-
-// TestEntryBlobUploadFailureIsPrintedOnce backs up to a destination
-// whose blobs directory is a file, so the blob upload fails.
-//
-//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
-func TestEntryBlobUploadFailureIsPrintedOnce(t *testing.T) {
-	for _, verbose := range []bool{false, true} {
-		t.Run(fmt.Sprintf("verbose=%t", verbose), func(t *testing.T) {
-			configPath, storeDir := writeBackupConfig(t)
-
-			require.NoError(t, os.WriteFile(
-				filepath.Join(storeDir, blobsDir), nil, 0o600))
-
-			requireErrorPrintedOnce(t, verbose,
-				flagConfig, configPath, cmdSnapshot, cmdCreate)
-		})
-	}
-}
-
-// TestEntryBlobDownloadFailureIsPrintedOnce backs up, deletes the blobs
-// from the destination, and restores, so the blob download fails.
-//
-//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
-func TestEntryBlobDownloadFailureIsPrintedOnce(t *testing.T) {
-	for _, verbose := range []bool{false, true} {
-		t.Run(fmt.Sprintf("verbose=%t", verbose), func(t *testing.T) {
-			configPath, storeDir := writeBackupConfigWithPrivateKey(t)
-
-			code, _, _ := runEntry(t,
-				flagConfig, configPath, cmdSnapshot, cmdCreate)
-			require.Equal(t, 0, code)
-
-			require.NoError(t, os.RemoveAll(filepath.Join(storeDir, blobsDir)))
-
-			requireErrorPrintedOnce(t, verbose, flagConfig, configPath,
-				cmdSnapshot, cmdRestore, onlySnapshotID(t, configPath), t.TempDir())
-		})
-	}
-}
-
-// requireErrorPrintedOnce runs Entry with args, adding --verbose when
-// verbose is set. The command must fail, and stderr must carry its error
-// once, as the final ERROR: line. A log record carrying the same error
-// appears only under --verbose.
-func requireErrorPrintedOnce(t *testing.T, verbose bool, args ...string) {
-	t.Helper()
-
-	if verbose {
-		args = append(args, flagVerbose)
-	}
-
-	code, _, stderr := runEntry(t, args...)
-	require.Equal(t, 1, code)
-
-	errorLine, records := failureOutput(t, stderr)
-
-	if !verbose {
-		assert.Zero(t, records,
-			"without --verbose no log record repeats the error:\n%s", stderr)
-
-		return
-	}
-
-	assert.NotZero(t, records,
-		"--verbose must keep the log record of %q", errorLine)
-}
-
-// failureOutput requires stderr to hold exactly one ERROR: line and
-// returns it, with the number of log records whose error attribute is
-// the error that line reports. stderr is a pipe here, so every log
-// record is a JSON object on its own line.
-func failureOutput(t *testing.T, stderr string) (string, int) {
-	t.Helper()
-
-	var (
-		errorLines []string
-		records    []map[string]any
-	)
-
-	for line := range strings.Lines(stderr) {
-		var record map[string]any
-		if json.Unmarshal([]byte(line), &record) == nil {
-			records = append(records, record)
-
-			continue
-		}
-
-		if strings.Contains(line, errorLinePrefix) {
-			errorLines = append(errorLines, strings.TrimSpace(line))
-		}
-	}
-
-	require.Len(t, errorLines, 1,
-		"the error must be printed once as an ERROR: line:\n%s", stderr)
-
-	// An error can run over several lines; the ERROR: line holds the
-	// first of them.
-	repeats := 0
-
-	for _, record := range records {
-		failure, ok := record["error"].(string)
-		firstLine, _, _ := strings.Cut(failure, "\n")
-
-		if ok && strings.Contains(errorLines[0], firstLine) {
-			repeats++
-		}
-	}
-
-	return errorLines[0], repeats
-}
-
-// writeBackupConfigWithPrivateKey builds what writeBackupConfig builds,
-// with a generated key pair in place of its recipient. The config also
-// holds the private key, so that restore can decrypt the backup. Returns
-// the config path and the store directory.
-func writeBackupConfigWithPrivateKey(t *testing.T) (string, string) {
-	t.Helper()
-
-	configPath, storeDir := writeBackupConfig(t)
-
-	identity, err := age.GenerateX25519Identity()
-	require.NoError(t, err)
-
-	out := ui.NewWithColor(io.Discard, false)
-
-	require.NoError(t, writeConfigSet(out, configPath,
-		"age_recipients.0", identity.Recipient().String()))
-	require.NoError(t, writeConfigSet(out, configPath,
-		"age_secret_key", identity.String()))
-
-	return configPath, storeDir
-}
-
-// onlySnapshotID returns the ID of the one snapshot in the local index
-// that writeBackupConfig puts beside the config file.
-func onlySnapshotID(t *testing.T, configPath string) string {
-	t.Helper()
-
-	ctx := context.Background()
-
-	db, err := database.New(ctx,
-		filepath.Join(filepath.Dir(configPath), "index.sqlite"))
-	require.NoError(t, err)
-
-	defer func() { require.NoError(t, db.Close()) }()
-
-	backedUp, err := database.NewRepositories(db).Snapshots.GetOnlySnapshot(ctx)
-	require.NoError(t, err)
-
-	return backedUp.ID.String()
-}

internal/cli/entry_snapshot_create_index_and_lock_files_test.go

@@ -1,69 +0,0 @@
-package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/adrg/xdg"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// TestEntrySnapshotCreateSkipsIndexAndLockFiles backs up a directory
-// that holds vaultik's index and PID file beside one other file, with no
-// exclude pattern set. The summary counts only the other file. See
-// https://git.eeqj.de/sneak/vaultik/issues/421.
-//
-// Not parallel: it replaces os.Args, os.Stdout, os.Stderr and the xdg
-// globals.
-func TestEntrySnapshotCreateSkipsIndexAndLockFiles(t *testing.T) {
-	for _, testCase := range []struct {
-		name string
-		// linked sets index_path to a symlink outside the backed-up
-		// directory that points to the index inside it.
-		linked bool
-	}{
-		{name: "index in the backed-up directory"},
-		{name: "index_path links into the backed-up directory", linked: true},
-	} {
-		t.Run(testCase.name, func(t *testing.T) {
-			dir := t.TempDir()
-			configPath := filepath.Join(dir, "config.yml")
-			sourceDir := filepath.Join(dir, "source")
-			storeDir := filepath.Join(dir, "store")
-
-			indexPath := filepath.Join(sourceDir, "index.sqlite")
-
-			if testCase.linked {
-				link := filepath.Join(dir, "index.sqlite")
-				require.NoError(t, os.Symlink(indexPath, link))
-
-				indexPath = link
-			}
-
-			contents := fmt.Sprintf(hermeticConfig,
-				sourceDir, storeDir, indexPath)
-			require.NoError(t,
-				os.WriteFile(configPath, []byte(contents), configFileMode))
-			require.NoError(t, os.Mkdir(storeDir, 0o750))
-			require.NoError(t, os.Mkdir(sourceDir, 0o750))
-			require.NoError(t, os.WriteFile(
-				filepath.Join(sourceDir, "file.txt"), []byte("hello"), 0o600))
-
-			// The PID file goes in a directory under XDG_DATA_HOME, which
-			// xdg reads at package init.
-			t.Setenv("XDG_DATA_HOME", filepath.Join(sourceDir, "data"))
-			xdg.Reload()
-			t.Cleanup(xdg.Reload)
-
-			code, stdout, _ := runEntry(t,
-				flagConfig, configPath, cmdSnapshot, cmdCreate)
-
-			require.Equal(t, 0, code)
-			assert.Contains(t, stdout,
-				"Files: 1 examined, 1 backed up, 0 unchanged.")
-		})
-	}
-}

internal/cli/entry_snapshot_create_prune_test.go

@@ -61,8 +61,8 @@ func TestEntrySnapshotCreateRejectsKeepNewerThanBeforeBackup(t *testing.T) {
 
 // TestEntrySnapshotCreateReportsPostBackupPruneFailure makes the
 // post-backup prune fail after a good backup, by planting a manifest
-// that cannot be decoded, and checks that the failure is reported once,
+// that cannot be decoded, and checks that the failure is reported as the
-// as the prune's and not as a failed snapshot creation.
+// prune's and not as a failed snapshot creation.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreateReportsPostBackupPruneFailure(t *testing.T) {
@@ -83,9 +83,6 @@ func TestEntrySnapshotCreateReportsPostBackupPruneFailure(t *testing.T) {
 	assert.Contains(t, stderr, "Backup completed, but post-backup prune failed")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 
-	_, repeats := failureOutput(t, stderr)
-	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
-
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2,
@@ -96,8 +93,7 @@ func TestEntrySnapshotCreateReportsPostBackupPruneFailure(t *testing.T) {
 // empties the source directory, as a volume that is not mounted leaves
 // its mount point, and runs `snapshot create --prune`. The command exits
 // non-zero and reports the backup as completed, not as a failed snapshot
-// creation. The error is printed once. See
+// creation. See https://git.eeqj.de/sneak/vaultik/issues/388.
-// https://git.eeqj.de/sneak/vaultik/issues/388.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreatePruneExitsNonZeroWhenSourceIsEmpty(t *testing.T) {
@@ -118,9 +114,6 @@ func TestEntrySnapshotCreatePruneExitsNonZeroWhenSourceIsEmpty(t *testing.T) {
 		"Backup completed, but 1 source path(s) were empty")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 
-	_, repeats := failureOutput(t, stderr)
-	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
-
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2, "the older snapshot is kept")
@@ -131,8 +124,7 @@ func TestEntrySnapshotCreatePruneExitsNonZeroWhenSourceIsEmpty(t *testing.T) {
 // directory as a mount point, and runs `snapshot create --prune`, which
 // does not find it as one. The command exits non-zero, reports the
 // backup as completed, not as a failed snapshot creation, and keeps the
-// older snapshot. The error is printed once. See
+// older snapshot. See https://git.eeqj.de/sneak/vaultik/issues/395.
-// https://git.eeqj.de/sneak/vaultik/issues/395.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreatePruneExitsNonZeroWhenMountPointIsMissing(
@@ -167,9 +159,6 @@ func TestEntrySnapshotCreatePruneExitsNonZeroWhenMountPointIsMissing(
 		"an earlier snapshot recorded were not found")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 
-	_, repeats := failureOutput(t, stderr)
-	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
-
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2, "the older snapshot is kept")

internal/cli/entry_snapshot_files_test.go

@@ -1,47 +0,0 @@
-package cli //nolint:testpackage // shares runEntry and the backup config helpers
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// cmdFiles is the word of `snapshot files`, used to build argument
-// vectors below.
-const cmdFiles = "files"
-
-// TestEntrySnapshotFilesListsOnlyThePath backs up two files and runs
-// `snapshot files` with the snapshot ID and the path of one of them,
-// which must be the only file listed.
-//
-//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
-func TestEntrySnapshotFilesListsOnlyThePath(t *testing.T) {
-	configPath, _ := writeBackupConfigWithPrivateKey(t)
-
-	// writeBackupConfig puts file.txt in the source directory beside the
-	// config file.
-	sourceDir := filepath.Join(filepath.Dir(configPath), "source")
-	listed := filepath.Join(sourceDir, "file.txt")
-
-	require.NoError(t, os.WriteFile(
-		filepath.Join(sourceDir, "other.txt"), []byte("other"), 0o600))
-
-	code, _, stderr := runEntry(t,
-		flagConfig, configPath, cmdSnapshot, cmdCreate)
-	require.Equal(t, 0, code, stderr)
-
-	code, stdout, stderr := runEntry(t, flagConfig, configPath, cmdSnapshot,
-		cmdFiles, onlySnapshotID(t, configPath), listed, flagJSON)
-	require.Equal(t, 0, code, stderr)
-
-	var entries []vaultik.ListedFile
-
-	require.NoError(t, json.Unmarshal([]byte(stdout), &entries))
-	require.Len(t, entries, 1, "only the path given may be listed")
-	assert.Equal(t, listed, entries[0].Path)
-}

internal/cli/entry_test.go

@@ -48,7 +48,7 @@ func TestCLIEntry(t *testing.T) {
 	} else {
 		// Check snapshot subcommands
 		expectedSubCommands := []string{
-			"create", "list", "files", "purge", "verify", "remove", "restore",
+			"create", "list", "purge", "verify", "remove", "restore",
 		}
 		for _, expected := range expectedSubCommands {
 			found := false

internal/cli/info.go

@@ -39,7 +39,7 @@ func NewInfoCommand() *cobra.Command {
 			}, func(v *vaultik.Vaultik) error {
 				return v.ShowInfo()
 			}, func(err error) {
-				log.Info("Failed to show info", "error", err)
+				log.Error("Failed to show info", "error", err)
 				ReportErrorf("Failed to show info: %v", err)
 			})
 		},

internal/cli/prune.go

@@ -60,7 +60,7 @@ referenced.`,
 			}, func(v *vaultik.Vaultik) error {
 				return v.Prune(opts)
 			}, func(err error) {
-				log.Info("Prune operation failed", "error", err)
+				log.Error("Prune operation failed", "error", err)
 				ReportErrorf("Prune failed: %v", err)
 			})
 		},

internal/cli/remote.go

@@ -98,7 +98,7 @@ func newRemoteInfoCommand() *cobra.Command {
 			}, func(v *vaultik.Vaultik) error {
 				return v.RemoteInfo(jsonOutput)
 			}, func(err error) {
-				log.Info("Failed to get remote info", "error", err)
+				log.Error("Failed to get remote info", "error", err)
 				ReportErrorf("Failed to get remote info: %v", err)
 			})
 		},

internal/cli/snapshot.go

@@ -9,10 +9,6 @@ import (
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 
-// filesMaxArgs is the maximum positional argument count of
-// `snapshot files <snapshot-id> [path]`.
-const filesMaxArgs = 2
-
 var (
 	errSnapshotIDRequired  = errors.New("snapshot ID required")
 	errWrongArgCount       = errors.New("wrong argument count")
@@ -56,7 +52,6 @@ func NewSnapshotCommand() *cobra.Command {
 	// Add subcommands
 	cmd.AddCommand(newSnapshotCreateCommand())
 	cmd.AddCommand(newSnapshotListCommand())
-	cmd.AddCommand(newSnapshotFilesCommand())
 	cmd.AddCommand(newSnapshotPurgeCommand())
 	cmd.AddCommand(newSnapshotVerifyCommand())
 	cmd.AddCommand(newSnapshotRemoveCommand())
@@ -114,7 +109,7 @@ on Linux), then /etc/vaultik/config.yml.`,
 				return v.CreateSnapshot(opts)
 			}, func(err error) {
 				if errors.Is(err, vaultik.ErrPostBackupPruneFailed) {
-					log.Info("Post-backup prune failed", "error", err)
+					log.Error("Post-backup prune failed", "error", err)
 					ReportErrorf("Backup completed, but %v", err)
 
 					return
@@ -123,13 +118,13 @@ on Linux), then /etc/vaultik/config.yml.`,
 				if errors.Is(err, vaultik.ErrFilesUnreadable) ||
 					errors.Is(err, vaultik.ErrSourcePathEmpty) ||
 					errors.Is(err, vaultik.ErrVolumeNotMounted) {
-					log.Info("Backup completed with an error", "error", err)
+					log.Error("Backup completed with an error", "error", err)
 					ReportErrorf("Backup completed, but %v", err)
 
 					return
 				}
 
-				log.Info("Snapshot creation failed", "error", err)
+				log.Error("Snapshot creation failed", "error", err)
 				ReportErrorf("Snapshot creation failed: %v", err)
 			})
 		},
@@ -177,44 +172,6 @@ func newSnapshotListCommand() *cobra.Command {
 	return cmd
 }
 
-// newSnapshotFilesCommand creates the 'snapshot files' subcommand
-func newSnapshotFilesCommand() *cobra.Command {
-	var jsonOutput bool
-
-	cmd := &cobra.Command{
-		Use:   "files <snapshot-id> [path]",
-		Short: "List the files in a snapshot",
-		Long: `Lists the path, size, mode and modification time of every file in a
-snapshot, without restoring it. With a path, lists only that path and
-what is under it; a path that matches nothing is an error.
-
-The snapshot may be named by its ID or, on a host with no local index,
-by the remote key that 'snapshot list' prints for a remote-only snapshot
-(an unambiguous leading part is enough).
-
-The file list is only in the snapshot's encrypted database, so this
-downloads and decrypts it, and requires the age private key in the
-VAULTIK_AGE_SECRET_KEY environment variable, as 'snapshot restore' does.`,
-		Args: cobra.RangeArgs(1, filesMaxArgs),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			path := ""
-			if len(args) == filesMaxArgs {
-				path = args[1]
-			}
-
-			return runVaultikApp(cmd, readOnly, jsonOutput,
-				"Failed to list snapshot files",
-				func(v *vaultik.Vaultik) error {
-					return v.ListSnapshotFiles(args[0], path, jsonOutput)
-				})
-		},
-	}
-
-	cmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
-
-	return cmd
-}
-
 // newSnapshotPurgeCommand creates the 'snapshot purge' subcommand
 func newSnapshotPurgeCommand() *cobra.Command {
 	opts := &vaultik.SnapshotPurgeOptions{}
@@ -301,7 +258,7 @@ func newSnapshotVerifyCommand() *cobra.Command {
 					return
 				}
 
-				log.Info("Verification failed", "error", err)
+				log.Error("Verification failed", "error", err)
 				ReportErrorf("Verification failed: %v", err)
 			})
 		},

internal/cli/snapshot_restore.go

@@ -104,7 +104,7 @@ func runRestore(cmd *cobra.Command, args []string, opts *RestoreOptions) error {
 			SkipErrors: rootFlags.SkipErrors,
 		})
 	}, func(err error) {
-		log.Info("Restore operation failed", "error", err)
+		log.Error("Restore operation failed", "error", err)
 		ReportErrorf("Restore failed: %v", err)
 	})
 }

internal/config/config.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"reflect"
 	"sort"
 	"strings"
 	"time"
@@ -70,22 +69,14 @@ var (
 	errFileURLNotAbsolute = errors.New(
 		"a file:// storage_url needs an absolute path, " +
 			"as in file:///path/to/backup")
-	errIndexPathNotAbsolute = errors.New(
-		"index_path and VAULTIK_INDEX_PATH need an absolute path, " +
-			"as in ~/.local/share/vaultik/index.sqlite")
 	errNegativePruneGracePeriod = errors.New(
 		"prune_grace_period must not be negative")
 	errStorageNotConfigured = errors.New(
 		"storage not configured; set storage_url or provide s3.endpoint + " +
 			"s3.bucket + credentials")
 	errS3BucketRequired = errors.New("s3.bucket is required (or set storage_url)")
-)
+	errS3KeyIDRequired  = errors.New("s3.access_key_id is required")
-
+	errS3SecretRequired = errors.New("s3.secret_access_key is required")
-// Validate returns these when S3 storage is configured without its
-// credentials.
-var (
-	ErrS3KeyIDRequired  = errors.New("s3.access_key_id is required")
-	ErrS3SecretRequired = errors.New("s3.secret_access_key is required")
 )
 
 // expandTilde expands ~ at the start of a path to the user's home directory.
@@ -295,39 +286,15 @@ func Load(path string) (*Config, error) {
 }
 
 // Parse reads YAML config data as Load does, without validating it. It
-// refuses a key that no setting has and a size setting whose value is not a
+// applies default values for optional fields, fills in ${...} references
-// size, naming the setting. It applies default values for optional
+// using smartconfig, and expands ~ in paths.
-// fields, fills in ${...} references using smartconfig, and expands ~ in
-// paths.
 func Parse(data []byte) (*Config, error) {
-	// smartconfig drops line numbers, so keys are checked in the data as
-	// written.
-	var root yaml.Node
-
-	err := yaml.Unmarshal(data, &root)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse config: %w", err)
-	}
-
-	err = checkKeys(&root, reflect.TypeFor[Config](), "",
-		map[*yaml.Node]bool{}, map[nodeAndType]bool{})
-	if err != nil {
-		return nil, err
-	}
-
 	// Load config using smartconfig for interpolation
 	sc, err := smartconfig.NewFromReader(bytes.NewReader(data))
 	if err != nil {
 		return nil, fmt.Errorf("failed to load config file: %w", err)
 	}
 
-	// A ${...} reference can bring in keys that are not in the file, and
-	// is the value of a size setting only once it is filled in.
-	err = checkFilledConfig(sc.Data())
-	if err != nil {
-		return nil, err
-	}
-
 	cfg := &Config{
 		// Set defaults
 		BlobSizeLimit:    defaultBlobSizeLimit,
@@ -396,11 +363,7 @@ func Parse(data []byte) (*Config, error) {
 //     never the value. An empty list is accepted, because only snapshot
 //     create needs a recipient and it checks for one itself
 //   - At least one snapshot must be configured with at least one path
-//   - Every exclude pattern, global or in a snapshot, must compile; errors
-//     name the setting and quote the pattern
 //   - Storage must be configured (either storage_url or s3.* fields)
-//   - The index path must be absolute: a relative one would resolve against
-//     the working directory, so each directory would get its own index
 //   - Chunk size must be at least 1MB
 //   - Blob size limit must be at least the largest chunk the chunker can emit
 //     (chunk_size times chunker.ChunkSizeSpread), so a single-chunk blob never
@@ -418,26 +381,22 @@ func (c *Config) Validate() error {
 		}
 	}
 
-	err := c.validateSnapshots()
+	if len(c.Snapshots) == 0 {
-	if err != nil {
+		return errNoSnapshots
-		return err
 	}
 
-	err = c.validateExcludes()
+	for name, snap := range c.Snapshots {
-	if err != nil {
+		if len(snap.Paths) == 0 {
-		return err
+			return fmt.Errorf("%w: %q", errSnapshotNoPaths, name)
+		}
 	}
 
 	// Validate storage configuration
-	err = c.validateStorage()
+	err := c.validateStorage()
 	if err != nil {
 		return err
 	}
 
-	if !filepath.IsAbs(c.IndexPath) {
-		return fmt.Errorf("%w: %q", errIndexPathNotAbsolute, c.IndexPath)
-	}
-
 	if c.ChunkSize.Int64() < minChunkSize {
 		return errChunkSizeTooSmall
 	}
@@ -468,22 +427,6 @@ func (c *Config) Validate() error {
 	return nil
 }
 
-// validateSnapshots refuses a config with no snapshot or with a snapshot
-// that has no path.
-func (c *Config) validateSnapshots() error {
-	if len(c.Snapshots) == 0 {
-		return errNoSnapshots
-	}
-
-	for name, snap := range c.Snapshots {
-		if len(snap.Paths) == 0 {
-			return fmt.Errorf("%w: %q", errSnapshotNoPaths, name)
-		}
-	}
-
-	return nil
-}
-
 // validateAgeRecipient parses one age_recipients entry with the age library
 // and returns a value-free error on failure. A recipient string can be
 // sensitive (an operator may paste a secret key by mistake), so neither the
@@ -547,11 +490,11 @@ func (c *Config) validateStorage() error {
 	}
 
 	if c.S3.AccessKeyID == "" {
-		return ErrS3KeyIDRequired
+		return errS3KeyIDRequired
 	}
 
 	if c.S3.SecretAccessKey == "" {
-		return ErrS3SecretRequired
+		return errS3SecretRequired
 	}
 
 	return nil
@@ -578,11 +521,11 @@ func (c *Config) validateStorageURL() error {
 	case strings.HasPrefix(c.StorageURL, "s3://"):
 		// S3 storage needs credentials
 		if c.S3.AccessKeyID == "" {
-			return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired)
+			return fmt.Errorf("%w for s3:// URLs", errS3KeyIDRequired)
 		}
 
 		if c.S3.SecretAccessKey == "" {
-			return fmt.Errorf("%w for s3:// URLs", ErrS3SecretRequired)
+			return fmt.Errorf("%w for s3:// URLs", errS3SecretRequired)
 		}
 
 		return nil

internal/config/config_test.go

@@ -165,7 +165,6 @@ func TestValidateBlobSizeLimit(t *testing.T) {
 			AgeRecipients:    []string{testSneakAgePublicKey},
 			Snapshots:        map[string]SnapshotConfig{"test": {Paths: []string{"/tmp/src"}}},
 			StorageURL:       "file:///tmp/vaultik-test-store",
-			IndexPath:        "/tmp/vaultik-test-index.sqlite",
 			ChunkSize:        chunkSize,
 			BlobSizeLimit:    blobLimit,
 			CompressionLevel: 3,
@@ -511,65 +510,6 @@ func TestLoadRejectsRelativeFileURL(t *testing.T) {
 	}
 }
 
-// TestLoadIndexPath checks that a relative index_path fails at load, naming
-// the value. Accepted, it would resolve against the working directory, so a
-// backup run from another directory would start from an empty index. A path
-// starting with ~ is expanded and loads.
-func TestLoadIndexPath(t *testing.T) {
-	t.Parallel()
-
-	home, err := os.UserHomeDir()
-	if err != nil {
-		t.Fatalf("home directory: %v", err)
-	}
-
-	load := func(t *testing.T, indexPath string) (*Config, error) {
-		t.Helper()
-
-		data := "snapshots:\n" +
-			"  test:\n" +
-			"    paths: [/tmp/vaultik-test-source]\n" +
-			"storage_url: file:///tmp/vaultik-test-storage\n" +
-			"index_path: " + indexPath + "\n"
-
-		path := filepath.Join(t.TempDir(), "config.yml")
-
-		err := os.WriteFile(path, []byte(data), 0o600)
-		if err != nil {
-			t.Fatalf("write config: %v", err)
-		}
-
-		return Load(path)
-	}
-
-	t.Run("relative path is rejected", func(t *testing.T) {
-		t.Parallel()
-
-		_, err := load(t, "relative/index.sqlite")
-		if !errors.Is(err, errIndexPathNotAbsolute) {
-			t.Fatalf("Load() error = %v, want errIndexPathNotAbsolute", err)
-		}
-
-		if !strings.Contains(err.Error(), `"relative/index.sqlite"`) {
-			t.Errorf("error %q does not name the value", err.Error())
-		}
-	})
-
-	t.Run("path starting with ~ is expanded", func(t *testing.T) {
-		t.Parallel()
-
-		cfg, err := load(t, "~/vaultik/index.sqlite")
-		if err != nil {
-			t.Fatalf("Load() unexpected error: %v", err)
-		}
-
-		want := filepath.Join(home, "vaultik", "index.sqlite")
-		if cfg.IndexPath != want {
-			t.Errorf("IndexPath = %q, want %q", cfg.IndexPath, want)
-		}
-	})
-}
-
 // TestValidateAgeRecipients checks that recipients are parsed at config load
 // (a bad entry fails immediately, not mid-backup) and that no invalid entry —
 // least of all a pasted secret key — is echoed in the error. An empty list
@@ -582,7 +522,6 @@ func TestValidateAgeRecipients(t *testing.T) {
 			AgeRecipients:    recipients,
 			Snapshots:        map[string]SnapshotConfig{"test": {Paths: []string{"/tmp/src"}}},
 			StorageURL:       "file:///tmp/vaultik-test-store",
-			IndexPath:        "/tmp/vaultik-test-index.sqlite",
 			ChunkSize:        Size(10 * 1024 * 1024),
 			BlobSizeLimit:    Size(10 * 1024 * 1024 * 1024),
 			CompressionLevel: 3,

internal/config/exclude.go

@@ -1,39 +0,0 @@
-package config
-
-import (
-	"fmt"
-
-	"sneak.berlin/go/vaultik/internal/exclude"
-)
-
-// validateExcludes refuses an exclude pattern, global or in a snapshot,
-// that does not compile, naming the setting and quoting the pattern.
-func (c *Config) validateExcludes() error {
-	err := validateExcludeList("exclude", c.Exclude)
-	if err != nil {
-		return err
-	}
-
-	for _, name := range c.SnapshotNames() {
-		err = validateExcludeList("snapshots."+name+".exclude",
-			c.Snapshots[name].Exclude)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// validateExcludeList refuses the first pattern in patterns that does not
-// compile. setting is the name of the list, as in "exclude".
-func validateExcludeList(setting string, patterns []string) error {
-	for i, pattern := range patterns {
-		_, _, err := exclude.Compile(pattern)
-		if err != nil {
-			return fmt.Errorf("%s[%d]: %w", setting, i, err)
-		}
-	}
-
-	return nil
-}

internal/config/exclude_test.go

@@ -1,65 +0,0 @@
-package config_test
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"sneak.berlin/go/vaultik/internal/config"
-)
-
-// TestLoadRefusesBadExcludePattern checks that an exclude pattern that does
-// not compile, global or in a snapshot, fails at load with the setting and
-// the pattern named, rather than the backup storing what it meant to leave
-// out.
-func TestLoadRefusesBadExcludePattern(t *testing.T) {
-	t.Parallel()
-
-	const storage = "storage_url: file:///tmp/vaultik-test-storage\n"
-
-	tests := []struct {
-		name    string
-		config  string
-		wantErr string
-	}{
-		{
-			name: "global",
-			config: "exclude: ['*.tmp', '.cache', 'build[']\n" +
-				"snapshots:\n" +
-				"  home:\n" +
-				"    paths: [/tmp/vaultik-test-source]\n" + storage,
-			wantErr: `exclude[2]: "build[" is not a valid exclude pattern`,
-		},
-		{
-			name: "snapshot",
-			config: "snapshots:\n" +
-				"  home:\n" +
-				"    paths: [/tmp/vaultik-test-source]\n" +
-				"    exclude: ['/a/**/x[']\n" + storage,
-			wantErr: `snapshots.home.exclude[0]: "/a/**/x[" is not a valid exclude pattern`,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			path := filepath.Join(t.TempDir(), "config.yml")
-
-			err := os.WriteFile(path, []byte(tt.config), 0o600)
-			if err != nil {
-				t.Fatalf("write config: %v", err)
-			}
-
-			_, err = config.Load(path)
-			if err == nil {
-				t.Fatalf("Load() returned nil, want an error containing %q", tt.wantErr)
-			}
-
-			if !strings.Contains(err.Error(), tt.wantErr) {
-				t.Fatalf("Load() error = %q, want it to contain %q", err, tt.wantErr)
-			}
-		})
-	}
-}

internal/config/keys.go

@@ -1,220 +0,0 @@
-package config
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-// yamlMergeTag is the tag YAML gives a merge key (<<), which adds the keys
-// of the map it names to the map it sits in.
-const yamlMergeTag = "!!merge"
-
-// EnvSection is the top-level key of a map of environment variables that
-// smartconfig sets while it loads the config. It is not a vaultik setting,
-// so its keys are not checked.
-const EnvSection = "env"
-
-var (
-	errUnknownKey           = errors.New("unknown config key")
-	errAnchorContainsItself = errors.New("anchor contains itself")
-)
-
-// nodeAndType is a node of a parsed config and the setting type it is
-// checked against.
-type nodeAndType struct {
-	node *yaml.Node
-	typ  reflect.Type
-}
-
-// SettingType returns the type of the setting that the dotted key names in
-// Config, following the fields' yaml tags, as for s3.bucket or
-// snapshots.home.exclude.0. A snapshot name or a list index may be any
-// word. It returns an unknown key error when no setting has that key.
-func SettingType(keys []string) (reflect.Type, error) {
-	typ := reflect.TypeFor[Config]()
-
-	for _, key := range keys {
-		switch {
-		case typ.Kind() == reflect.Map || typ.Kind() == reflect.Slice:
-			typ = typ.Elem()
-		case typ.Kind() == reflect.Struct:
-			field, ok := yamlField(typ, key)
-			if !ok {
-				return nil, fmt.Errorf("%w %q", errUnknownKey, strings.Join(keys, "."))
-			}
-
-			typ = field.Type
-		default:
-			return nil, fmt.Errorf("%w %q", errUnknownKey, strings.Join(keys, "."))
-		}
-	}
-
-	return typ, nil
-}
-
-// yamlField returns the field of struct type typ whose yaml tag names key.
-func yamlField(typ reflect.Type, key string) (reflect.StructField, bool) {
-	for field := range typ.Fields() {
-		name, _, _ := strings.Cut(field.Tag.Get("yaml"), ",")
-		if name == key && name != "-" {
-			return field, true
-		}
-	}
-
-	return reflect.StructField{}, false
-}
-
-// checkKeys returns an error naming the first key in node, a parsed config
-// or part of one at the dotted path, that no setting in typ has. The error
-// gives the key's line in the file, when it has one. A value of the wrong
-// type is left for the YAML decoder to report. following holds the aliases
-// the walk is inside. Meeting one of them again means its anchor contains
-// itself, which is an error. checked holds each anchored node the walk has
-// checked completely, with the type it was checked against. An alias to
-// that node is not followed again for that type.
-func checkKeys(node *yaml.Node, typ reflect.Type, path string,
-	following map[*yaml.Node]bool, checked map[nodeAndType]bool,
-) error {
-	switch node.Kind {
-	case yaml.DocumentNode:
-		for _, child := range node.Content {
-			err := checkKeys(child, typ, path, following, checked)
-			if err != nil {
-				return err
-			}
-		}
-	case yaml.AliasNode:
-		if following[node] {
-			return fmt.Errorf("%w: %q on line %d",
-				errAnchorContainsItself, node.Value, node.Line)
-		}
-
-		target := nodeAndType{node.Alias, typ}
-		if checked[target] {
-			return nil
-		}
-
-		following[node] = true
-		defer delete(following, node)
-
-		err := checkKeys(node.Alias, typ, path, following, checked)
-		if err != nil {
-			return err
-		}
-
-		checked[target] = true
-	case yaml.SequenceNode:
-		if typ.Kind() != reflect.Slice {
-			return nil
-		}
-
-		for i, child := range node.Content {
-			err := checkKeys(child, typ.Elem(), joinKey(path, strconv.Itoa(i)),
-				following, checked)
-			if err != nil {
-				return err
-			}
-		}
-	case yaml.MappingNode:
-		return checkMappingKeys(node, typ, path, following, checked)
-	case yaml.ScalarNode:
-		// A scalar has no keys.
-	}
-
-	return nil
-}
-
-// checkFilledConfig checks data, the config after smartconfig has filled in
-// its ${...} references: its keys with checkKeys, then its size settings
-// with checkSizes. A key that a reference brings in is not in the file, and
-// the copy that Encode makes has no line numbers.
-func checkFilledConfig(data map[string]any) error {
-	var filled yaml.Node
-
-	err := filled.Encode(data)
-	if err != nil {
-		return fmt.Errorf("failed to marshal config data: %w", err)
-	}
-
-	err = checkKeys(&filled, reflect.TypeFor[Config](), "",
-		map[*yaml.Node]bool{}, map[nodeAndType]bool{})
-	if err != nil {
-		return err
-	}
-
-	return checkSizes(&filled, nil)
-}
-
-// checkMappingKeys is checkKeys for a map.
-func checkMappingKeys(node *yaml.Node, typ reflect.Type, path string,
-	following map[*yaml.Node]bool, checked map[nodeAndType]bool,
-) error {
-	for i := 0; i+1 < len(node.Content); i += 2 {
-		key, value := node.Content[i], node.Content[i+1]
-
-		if key.Tag == yamlMergeTag {
-			// The value is one map or a list of maps.
-			merged := []*yaml.Node{value}
-			if value.Kind == yaml.SequenceNode {
-				merged = value.Content
-			}
-
-			for _, m := range merged {
-				err := checkKeys(m, typ, path, following, checked)
-				if err != nil {
-					return err
-				}
-			}
-
-			continue
-		}
-
-		keyPath := joinKey(path, key.Value)
-		if keyPath == EnvSection {
-			continue
-		}
-
-		var valueType reflect.Type
-
-		switch {
-		case typ.Kind() == reflect.Map:
-			valueType = typ.Elem()
-		case typ.Kind() == reflect.Struct:
-			field, ok := yamlField(typ, key.Value)
-			if !ok && key.Line == 0 {
-				// A key that a ${...} reference brought in has no line.
-				return fmt.Errorf("%w %q", errUnknownKey, keyPath)
-			}
-
-			if !ok {
-				return fmt.Errorf("%w %q on line %d",
-					errUnknownKey, keyPath, key.Line)
-			}
-
-			valueType = field.Type
-		default:
-			return nil
-		}
-
-		err := checkKeys(value, valueType, keyPath, following, checked)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// joinKey appends key to the dotted path.
-func joinKey(path, key string) string {
-	if path == "" {
-		return key
-	}
-
-	return path + "." + key
-}

internal/config/keys_test.go

@@ -1,163 +0,0 @@
-package config //nolint:testpackage // checks the unexported errUnknownKey
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-// keysTestConfig loads; each case below adds one line to it.
-const keysTestConfig = "storage_url: file:///tmp/vaultik-test-storage\n" +
-	"s3:\n" +
-	"  region: us-east-1\n" +
-	"snapshots:\n" +
-	"  test:\n" +
-	"    paths: [/tmp/vaultik-test-source]\n"
-
-// TestParseRefusesUnknownKey checks that a key no setting has, at any
-// depth, fails the parse with an error naming the key and its line. A key
-// that a ${...} reference brings in is not in the file, so its error gives
-// no line.
-func TestParseRefusesUnknownKey(t *testing.T) {
-	t.Parallel()
-
-	snapshotPath := filepath.Join(t.TempDir(), "snapshot.yml")
-
-	err := os.WriteFile(snapshotPath, []byte("other:\n"+
-		"  paths: [/tmp/vaultik-test-source]\n"+
-		"  exlude: [/tmp/cache]\n"), 0o600)
-	if err != nil {
-		t.Fatalf("write snapshot: %v", err)
-	}
-
-	tests := []struct {
-		name string
-		yaml string
-		want string
-	}{
-		{"top level", keysTestConfig + "compression_lvl: 9\n",
-			`unknown config key "compression_lvl" on line 7`},
-		{"in a snapshot", keysTestConfig + "    exlude: [/tmp/cache]\n",
-			`unknown config key "snapshots.test.exlude" on line 7`},
-		{"in s3", strings.Replace(keysTestConfig, "  region:",
-			"  bukcet: b\n  region:", 1),
-			`unknown config key "s3.bukcet" on line 3`},
-		{"from a reference",
-			keysTestConfig + "  other: ${YAML:" + snapshotPath + ":other}\n",
-			`unknown config key "snapshots.other.exlude"`},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := Parse([]byte(tt.yaml))
-			if !errors.Is(err, errUnknownKey) {
-				t.Fatalf("Parse() error = %v, want errUnknownKey", err)
-			}
-
-			if err.Error() != tt.want {
-				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
-			}
-		})
-	}
-}
-
-// TestParseRefusesAnchorThatContainsItself checks that a YAML merge key (<<)
-// naming the anchor of the map it sits in fails the parse with an error.
-func TestParseRefusesAnchorThatContainsItself(t *testing.T) {
-	t.Parallel()
-
-	data := strings.Replace(keysTestConfig, "  test:", "  test: &test", 1) +
-		"    <<: *test\n"
-
-	_, err := Parse([]byte(data))
-	if !errors.Is(err, errAnchorContainsItself) {
-		t.Fatalf("Parse() error = %v, want errAnchorContainsItself", err)
-	}
-
-	want := `anchor contains itself: "test" on line 7`
-	if err.Error() != want {
-		t.Errorf("Parse() error = %q, want %q", err.Error(), want)
-	}
-}
-
-// TestParseRefusesExcessiveAliasing checks that Parse returns an error for
-// a file whose merge keys (<<) fan out. Each of eight snapshots merges the
-// one before it ten times. A key check that followed every alias would walk
-// the first snapshot over 10^8 times and run past the package's test
-// timeout.
-func TestParseRefusesExcessiveAliasing(t *testing.T) {
-	t.Parallel()
-
-	const snapshots, merges = 8, 10
-
-	var data strings.Builder
-
-	data.WriteString(strings.Replace(keysTestConfig, "  test:", "  test: &s0", 1))
-
-	for i := 1; i <= snapshots; i++ {
-		aliases := slices.Repeat([]string{"*s" + strconv.Itoa(i-1)}, merges)
-		fmt.Fprintf(&data, "  s%d: &s%d\n    <<: [%s]\n",
-			i, i, strings.Join(aliases, ", "))
-	}
-
-	_, err := Parse([]byte(data.String()))
-	if err == nil {
-		t.Fatal("Parse() returned no error")
-	}
-}
-
-// TestParseAcceptsKnownKeys checks that a config with a ${...} reference
-// and a YAML merge key (<<) still parses.
-func TestParseAcceptsKnownKeys(t *testing.T) {
-	t.Parallel()
-
-	levelPath := filepath.Join(t.TempDir(), "level")
-
-	err := os.WriteFile(levelPath, []byte("9"), 0o600)
-	if err != nil {
-		t.Fatalf("write level: %v", err)
-	}
-
-	data := strings.Replace(keysTestConfig, "  test:", "  test: &test", 1) +
-		"  other:\n" +
-		"    <<: *test\n" +
-		"    exclude: [/tmp/vaultik-test-source/cache]\n" +
-		"compression_level: ${FILE:" + levelPath + "}\n"
-
-	cfg, err := Parse([]byte(data))
-	if err != nil {
-		t.Fatalf("Parse() unexpected error: %v", err)
-	}
-
-	if cfg.CompressionLevel != 9 {
-		t.Errorf("compression_level = %d, want 9", cfg.CompressionLevel)
-	}
-
-	other := cfg.Snapshots["other"]
-	if len(other.Paths) != 1 || len(other.Exclude) != 1 {
-		t.Errorf("snapshot other = %+v, want the paths of test and one exclude",
-			other)
-	}
-}
-
-// TestParseAcceptsEnvSection checks that a config with a top-level env
-// section still parses. smartconfig sets the environment variables it
-// lists, so its keys are not settings.
-func TestParseAcceptsEnvSection(t *testing.T) {
-	const name = "VAULTIK_TEST_ENV_SECTION"
-
-	// Parse sets the variable; t.Setenv restores it after the test.
-	t.Setenv(name, "")
-
-	_, err := Parse([]byte(keysTestConfig + "env:\n  " + name + ": set\n"))
-	if err != nil {
-		t.Fatalf("Parse() unexpected error: %v", err)
-	}
-}

internal/config/size.go

@@ -4,20 +4,13 @@ import (
 	"errors"
 	"fmt"
 	"math"
-	"reflect"
-	"slices"
-	"strconv"
-	"strings"
 
 	"github.com/dustin/go-humanize"
-	"gopkg.in/yaml.v3"
 )
 
 var (
 	errSizeType     = errors.New("size must be a number or string")
 	errSizeTooLarge = errors.New("size exceeds maximum supported value")
-	errNotASize     = errors.New(
-		"is not a size; use a number of bytes or a unit such as 10MB")
 )
 
 // Size represents a byte size that can be specified in configuration files.
@@ -39,15 +32,6 @@ func (s *Size) UnmarshalYAML(unmarshal func(any) error) error {
 		return nil
 	}
 
-	// A number too large for an int64 decodes as a float64. Its text can be
-	// 1e+20, which is not a size string.
-	var floatVal float64
-
-	err = unmarshal(&floatVal)
-	if err == nil && floatVal > math.MaxInt64 {
-		return errSizeTooLarge
-	}
-
 	// Try to unmarshal as string
 	var strVal string
 
@@ -56,66 +40,17 @@ func (s *Size) UnmarshalYAML(unmarshal func(any) error) error {
 		return errSizeType
 	}
 
-	size, err := ParseSize(strVal)
+	// Parse the string using go-humanize
+	bytes, err := humanize.ParseBytes(strVal)
 	if err != nil {
-		return err
+		return fmt.Errorf("invalid size format: %w", err)
 	}
 
-	*s = size
+	if bytes > math.MaxInt64 {
-
+		return fmt.Errorf("%w: %s", errSizeTooLarge, strVal)
-	return nil
-}
-
-// checkSizes returns an error naming the first size setting in node whose
-// value is not a size. node is the config, or the part of it at the dotted
-// keys, after smartconfig has filled in its ${...} references.
-func checkSizes(node *yaml.Node, keys []string) error {
-	typ, err := SettingType(keys)
-	if err != nil {
-		// Unknown keys are refused before this check, so keys is in one of
-		// two places. The env section holds no settings. A value of the
-		// wrong shape, such as a map given for hostname or inside exclude,
-		// is reported later by the YAML decoder.
-		return nil //nolint:nilerr // not an error here
 	}
 
-	if typ == reflect.TypeFor[Size]() {
+	*s = Size(bytes)
-		var size Size
-
-		err = node.Decode(&size)
-		if err != nil {
-			return fmt.Errorf("%s: %w", strings.Join(keys, "."), err)
-		}
-
-		return nil
-	}
-
-	switch node.Kind {
-	case yaml.DocumentNode:
-		for _, child := range node.Content {
-			err = checkSizes(child, keys)
-			if err != nil {
-				return err
-			}
-		}
-	case yaml.MappingNode:
-		for i := 0; i+1 < len(node.Content); i += 2 {
-			err = checkSizes(node.Content[i+1],
-				slices.Concat(keys, []string{node.Content[i].Value}))
-			if err != nil {
-				return err
-			}
-		}
-	case yaml.SequenceNode:
-		for i, child := range node.Content {
-			err = checkSizes(child, slices.Concat(keys, []string{strconv.Itoa(i)}))
-			if err != nil {
-				return err
-			}
-		}
-	case yaml.ScalarNode, yaml.AliasNode:
-		// A scalar holds no settings, and the filled config has no aliases.
-	}
 
 	return nil
 }
@@ -135,17 +70,16 @@ func (s Size) String() string {
 	return humanize.Bytes(uint64(s))
 }
 
-// ParseSize parses a size string, such as "10MB", into a Size value. An
+// ParseSize parses a size string into a Size value
-// error quotes s.
 func ParseSize(s string) (Size, error) {
-	bytes, err := humanize.ParseBigBytes(s)
+	bytes, err := humanize.ParseBytes(s)
 	if err != nil {
-		return 0, fmt.Errorf("%q %w", s, errNotASize)
+		return 0, fmt.Errorf("invalid size format: %w", err)
 	}
 
-	if !bytes.IsInt64() {
+	if bytes > math.MaxInt64 {
 		return 0, fmt.Errorf("%w: %s", errSizeTooLarge, s)
 	}
 
-	return Size(bytes.Int64()), nil
+	return Size(bytes), nil
 }

internal/config/size_test.go

@@ -1,120 +0,0 @@
-package config //nolint:testpackage // checks errNotASize and errSizeTooLarge
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// TestParseRefusesValueThatIsNotASize checks that a size setting whose
-// value is not a size fails the parse with an error naming the setting and
-// quoting the value, also when a ${...} reference fills the value in.
-func TestParseRefusesValueThatIsNotASize(t *testing.T) {
-	t.Parallel()
-
-	sizePath := filepath.Join(t.TempDir(), "size")
-
-	err := os.WriteFile(sizePath, []byte("lots"), 0o600)
-	if err != nil {
-		t.Fatalf("write size: %v", err)
-	}
-
-	tests := []struct {
-		name string
-		yaml string
-		want string
-	}{
-		{"chunk_size", keysTestConfig + "chunk_size: banana\n",
-			`chunk_size: "banana" is not a size; ` +
-				"use a number of bytes or a unit such as 10MB"},
-		{"blob_size_limit", keysTestConfig + "blob_size_limit: 10XB\n",
-			`blob_size_limit: "10XB" is not a size; ` +
-				"use a number of bytes or a unit such as 10MB"},
-		{"s3.part_size", strings.Replace(keysTestConfig, "  region:",
-			"  part_size: big\n  region:", 1),
-			`s3.part_size: "big" is not a size; ` +
-				"use a number of bytes or a unit such as 10MB"},
-		{"from a reference",
-			keysTestConfig + "chunk_size: ${FILE:" + sizePath + "}\n",
-			`chunk_size: "lots" is not a size; ` +
-				"use a number of bytes or a unit such as 10MB"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := Parse([]byte(tt.yaml))
-			if !errors.Is(err, errNotASize) {
-				t.Fatalf("Parse() error = %v, want errNotASize", err)
-			}
-
-			if err.Error() != tt.want {
-				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
-			}
-		})
-	}
-}
-
-// TestParseRefusesSizeTooLarge checks that a size setting whose value is
-// too large for a size fails the parse with an error naming the setting.
-// YAML reads the second value as a float.
-func TestParseRefusesSizeTooLarge(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		value string
-		want  string
-	}{
-		{"100EB", "chunk_size: size exceeds maximum supported value: 100EB"},
-		{"99999999999999999999",
-			"chunk_size: size exceeds maximum supported value"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.value, func(t *testing.T) {
-			t.Parallel()
-
-			_, err := Parse([]byte(keysTestConfig + "chunk_size: " + tt.value + "\n"))
-			if !errors.Is(err, errSizeTooLarge) {
-				t.Fatalf("Parse() error = %v, want errSizeTooLarge", err)
-			}
-
-			if err.Error() != tt.want {
-				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
-			}
-		})
-	}
-}
-
-// TestParseAcceptsSizes checks that size settings given as a number of
-// bytes, as a unit, and through a ${...} reference still parse.
-func TestParseAcceptsSizes(t *testing.T) {
-	t.Parallel()
-
-	sizePath := filepath.Join(t.TempDir(), "size")
-
-	err := os.WriteFile(sizePath, []byte("20MB"), 0o600)
-	if err != nil {
-		t.Fatalf("write size: %v", err)
-	}
-
-	data := strings.Replace(keysTestConfig, "  region:",
-		"  part_size: 6000000\n  region:", 1) +
-		"chunk_size: ${FILE:" + sizePath + "}\n" +
-		"blob_size_limit: 1GB\n"
-
-	cfg, err := Parse([]byte(data))
-	if err != nil {
-		t.Fatalf("Parse() unexpected error: %v", err)
-	}
-
-	if cfg.ChunkSize != 20_000_000 || cfg.BlobSizeLimit != 1_000_000_000 ||
-		cfg.S3.PartSize != 6_000_000 {
-		t.Errorf("chunk_size, blob_size_limit, s3.part_size = %d, %d, %d, "+
-			"want 20000000, 1000000000, 6000000",
-			cfg.ChunkSize, cfg.BlobSizeLimit, cfg.S3.PartSize)
-	}
-}

internal/database/database.go

@@ -219,8 +219,7 @@ func retryOpen(ctx context.Context, path string) (*DB, error) {
 
 // errUntrustedSnapshotSchema is returned when a downloaded snapshot
 // database carries schema objects the real schema never defines, or is
-// missing a table the restore, deep-verify and `snapshot files` queries
+// missing a table the restore and deep-verify queries read.
-// read.
 var errUntrustedSnapshotSchema = errors.New(
 	"downloaded snapshot database has an untrusted schema")
 
@@ -242,12 +241,12 @@ func snapshotReadOnlyDSN(path string) string {
 
 // OpenReadOnly opens an already-materialized SQLite file for read-only
 // querying of a snapshot database downloaded from the store, used by
-// restore, deep verify and `snapshot files`. Unlike New it never applies
+// restore and deep verify. Unlike New it never applies schema migrations
-// schema migrations and never writes: the connection is opened read-only
+// and never writes: the connection is opened read-only with query_only
-// with query_only and trusted_schema=OFF. It refuses any file whose schema
+// and trusted_schema=OFF. It refuses any file whose schema carries a
-// carries a trigger, view or virtual table, or lacks an expected table, so
+// trigger, view or virtual table, or lacks an expected table, so a forged
-// a forged file cannot redefine what the restore queries return. The
+// file cannot redefine what the restore queries return. The caller owns
-// caller owns the file and must remove it.
+// the file and must remove it.
 func OpenReadOnly(ctx context.Context, path string) (*DB, error) {
 	conn, err := sql.Open("sqlite", snapshotReadOnlyDSN(path))
 	if err != nil {
@@ -277,9 +276,9 @@ func OpenReadOnly(ctx context.Context, path string) (*DB, error) {
 // the plain table set the real schema defines. Any trigger, view or
 // virtual table, or a missing expected table, fails the open.
 func verifySnapshotSchema(ctx context.Context, conn *sql.DB) error {
-	// expectedSnapshotTables are the tables the restore, deep-verify and
+	// expectedSnapshotTables are the tables the restore and deep-verify
-	// `snapshot files` queries read. A downloaded database missing any of
+	// queries read. A downloaded database missing any of them is not a
-	// them is not a genuine snapshot database and is refused.
+	// genuine snapshot database and is refused.
 	expectedSnapshotTables := []string{
 		"blob_chunks",
 		"blobs",

internal/database/module.go

@@ -20,17 +20,6 @@ const indexDirPerm = 0o700
 // backed-up path and chunk hash and must stay private.
 const indexFilePerm = 0o600
 
-// IndexFiles returns the path of the index at indexPath and the paths of
-// the side files SQLite keeps beside it while it writes.
-func IndexFiles(indexPath string) []string {
-	return []string{
-		indexPath,
-		indexPath + "-wal",
-		indexPath + "-shm",
-		indexPath + "-journal",
-	}
-}
-
 // ensureIndexFileMode makes the index file owner-only before the SQLite
 // driver opens it: it creates the file 0600 if absent, or chmods an existing
 // one to 0600. Doing this first matters because SQLite creates its -wal and

internal/database/snapshots.go

@@ -238,11 +238,10 @@ func (r *SnapshotRepository) GetByID(
 
 // GetOnlySnapshot returns the sole snapshot in an exported per-snapshot
 // metadata database. The backup path writes each snapshot's database with
-// exactly one snapshot row (see cleanSnapshotDB), so restore, deep verify
+// exactly one snapshot row (see cleanSnapshotDB), so restore and deep
-// and `snapshot files` expect exactly one. Zero rows return
+// verify expect exactly one. Zero rows return ErrNoSnapshotInDatabase and
-// ErrNoSnapshotInDatabase and more than one returns
+// more than one returns ErrMultipleSnapshotsInDatabase; callers treat
-// ErrMultipleSnapshotsInDatabase; callers treat either as a failed
+// either as a failed identity check on the downloaded database.
-// identity check on the downloaded database.
 func (r *SnapshotRepository) GetOnlySnapshot(ctx context.Context) (*Snapshot, error) {
 	query := `
 		SELECT id, hostname, vaultik_version, vaultik_git_revision,

internal/exclude/exclude.go

@@ -1,77 +0,0 @@
-// Package exclude compiles exclude patterns into globs.
-package exclude
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/gobwas/glob"
-)
-
-var errBadExcludePattern = errors.New("is not a valid exclude pattern")
-
-// Compile compiles one exclude pattern into the globs that match it.
-// anchored reports whether the pattern matches only from the root of the
-// source directory. An empty pattern yields no globs. Config.Validate and
-// the scanner both compile patterns with it, so a pattern that loads is one
-// the scanner can use.
-func Compile(pattern string) ([]glob.Glob, bool, error) {
-	if pattern == "" {
-		return nil, false, nil
-	}
-
-	// A leading "/" anchors the pattern to the source directory.
-	trimmed, anchored := strings.CutPrefix(pattern, "/")
-
-	// A trailing "/" marks a directory and is not matched.
-	trimmed = strings.TrimSuffix(trimmed, "/")
-
-	// A leading "**/" demands a "/" before the name and so misses an
-	// entry directly under the source path. It means "at every depth",
-	// which is what an unanchored pattern already does, so drop the
-	// prefix and match unanchored: as in gitignore, "**/x" and
-	// "/**/x" then also match a top-level "x".
-	if rest, found := strings.CutPrefix(trimmed, "**/"); found {
-		trimmed = rest
-		anchored = false
-	}
-
-	// Likewise "/**/" inside a pattern demands two slashes, so
-	// "a/**/*.log" misses "a/x.log". As in gitignore it stands for
-	// zero or more directories, so also compile the pattern with it
-	// made a single "/". The glob library's {a,b} is no help: with a
-	// "**" inside it in mid-pattern, it misses paths it should match.
-	var globs []glob.Glob
-
-	for _, variant := range doubleStarVariants(trimmed) {
-		g, err := glob.Compile(variant, '/')
-		if err != nil {
-			return nil, false, fmt.Errorf("%q %w: %w",
-				pattern, errBadExcludePattern, err)
-		}
-
-		globs = append(globs, g)
-	}
-
-	return globs, anchored, nil
-}
-
-// doubleStarVariants returns pattern once for every way of keeping each
-// "/**/" in it or making it a single "/".
-func doubleStarVariants(pattern string) []string {
-	const doubleStar = "/**/"
-
-	before, after, found := strings.Cut(pattern, doubleStar)
-	if !found {
-		return []string{pattern}
-	}
-
-	var variants []string
-
-	for _, rest := range doubleStarVariants(after) {
-		variants = append(variants, before+doubleStar+rest, before+"/"+rest)
-	}
-
-	return variants
-}

internal/exclude/exclude_test.go

@@ -1,73 +0,0 @@
-package exclude_test
-
-import (
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/gobwas/glob"
-	"sneak.berlin/go/vaultik/internal/exclude"
-)
-
-// TestCompile checks the error, the anchoring and the globs that Compile
-// returns for one exclude pattern.
-func TestCompile(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name         string
-		pattern      string
-		wantErr      string
-		wantAnchored bool
-		// wantMatches lists paths that one of the globs must match. When
-		// it is empty, Compile must return no globs.
-		wantMatches []string
-	}{
-		{name: "does not compile", pattern: "build[",
-			wantErr: `"build[" is not a valid exclude pattern`},
-		{name: "empty", pattern: ""},
-		{name: "leading slash anchors", pattern: "/build",
-			wantAnchored: true, wantMatches: []string{"build"}},
-		{name: "double star after the slash clears anchoring",
-			pattern: "/**/build", wantMatches: []string{"build"}},
-		{name: "double star in the middle", pattern: "a/**/*.log",
-			wantMatches: []string{"a/x.log", "a/b/x.log"}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			globs, anchored, err := exclude.Compile(tt.pattern)
-			if tt.wantErr == "" && err != nil {
-				t.Fatalf("Compile(%q) error = %v, want none", tt.pattern, err)
-			}
-
-			if tt.wantErr != "" &&
-				(err == nil || !strings.HasPrefix(err.Error(), tt.wantErr)) {
-				t.Fatalf("Compile(%q) error = %v, want one starting with %q",
-					tt.pattern, err, tt.wantErr)
-			}
-
-			if anchored != tt.wantAnchored {
-				t.Errorf("Compile(%q) anchored = %t, want %t",
-					tt.pattern, anchored, tt.wantAnchored)
-			}
-
-			if len(tt.wantMatches) == 0 && len(globs) != 0 {
-				t.Errorf("Compile(%q) returned %d globs, want none",
-					tt.pattern, len(globs))
-			}
-
-			for _, path := range tt.wantMatches {
-				matched := slices.ContainsFunc(globs, func(g glob.Glob) bool {
-					return g.Match(path)
-				})
-				if !matched {
-					t.Errorf("Compile(%q) globs do not match %q",
-						tt.pattern, path)
-				}
-			}
-		})
-	}
-}

internal/pidlock/pidlock.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/adrg/xdg"
 	"golang.org/x/sys/unix"
 )
 
@@ -30,20 +29,8 @@ const (
 	lockDirPerm = 0o700
 	// pidFilePerm is the mode for the PID file (owner-only).
 	pidFilePerm = 0o600
-	// pidFileName is the name of the PID file in the lock directory.
-	pidFileName = "vaultik.pid"
 )
 
-// Dir returns the directory that holds vaultik's PID file.
-func Dir() string {
-	return filepath.Join(xdg.DataHome, "vaultik")
-}
-
-// Path returns the path of the PID file that Acquire uses in lockDir.
-func Path(lockDir string) string {
-	return filepath.Join(lockDir, pidFileName)
-}
-
 // Acquire attempts to acquire a PID lock in the specified directory.
 // If another process holds the lock, it returns ErrAlreadyRunning with
 // that process's PID. On success, it writes the current PID to the lock
@@ -55,7 +42,7 @@ func Acquire(lockDir string) (*Lock, error) {
 		return nil, fmt.Errorf("creating lock directory: %w", err)
 	}
 
-	lockPath := Path(lockDir)
+	lockPath := filepath.Join(lockDir, "vaultik.pid")
 
 	// No O_TRUNC: the file may hold the PID of the process that has the
 	// lock, which the error below reports.

internal/snapshot/index_and_lock_files_test.go

@@ -1,65 +0,0 @@
-package snapshot_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/snapshot"
-)
-
-// A backup of the directory that holds vaultik's index and PID file
-// stores neither, with no exclude pattern set, and still stores the
-// files beside them. See https://git.eeqj.de/sneak/vaultik/issues/421.
-func TestScanSkipsIndexAndLockFiles(t *testing.T) {
-	t.Parallel()
-
-	const dataDir = "/home/user/.local/share/vaultik"
-
-	indexAndLockFiles := append(database.IndexFiles(dataDir+"/index.sqlite"),
-		dataDir+"/vaultik.pid")
-
-	fs := afero.NewMemMapFs()
-	for _, p := range append(indexAndLockFiles, dataDir+"/notes.txt") {
-		require.NoError(t, afero.WriteFile(fs, p, []byte("data"), 0o600))
-	}
-
-	db, err := database.NewTestDB()
-	require.NoError(t, err)
-
-	defer func() { _ = db.Close() }()
-
-	repos := database.NewRepositories(db)
-
-	scanner := snapshot.NewScanner(snapshot.ScannerConfig{
-		FS:               fs,
-		ChunkSize:        64 * 1024,
-		Repositories:     repos,
-		MaxBlobSize:      1024 * 1024,
-		CompressionLevel: 3,
-		AgeRecipients: []string{
-			"age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p"},
-		IndexAndLockFiles: indexAndLockFiles,
-	})
-	require.NotNil(t, scanner)
-
-	ctx := context.Background()
-	createSnapshotRecord(ctx, t, repos, "test-snapshot")
-
-	result, err := scanner.Scan(ctx, "/home/user", "test-snapshot")
-	require.NoError(t, err)
-
-	require.Equal(t, 1, result.FilesScanned)
-
-	stored, err := repos.Files.GetByPath(ctx, dataDir+"/notes.txt")
-	require.NoError(t, err)
-	require.NotNil(t, stored, "a file beside the index is stored")
-
-	for _, p := range indexAndLockFiles {
-		f, err := repos.Files.GetByPath(ctx, p)
-		require.NoError(t, err)
-		require.Nil(t, f, "%s is not stored", p)
-	}
-}

internal/snapshot/module.go

@@ -2,13 +2,11 @@ package snapshot
 
 import (
 	"os"
-	"path/filepath"
 
 	"github.com/spf13/afero"
 	"go.uber.org/fx"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/pidlock"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/ui"
 )
@@ -64,52 +62,9 @@ func provideScannerFactory(
 			EnableProgress:     params.EnableProgress,
 			UI:                 params.UI,
 			Exclude:            excludes,
-			IndexAndLockFiles:  indexAndLockFiles(cfg.IndexPath, pidlock.Dir()),
 			SkipErrors:         params.SkipErrors,
 			PreviousSnapshotID: params.PreviousSnapshotID,
 			DeviceNumber:       params.DeviceNumber,
 		})
 	}
 }
-
-// indexAndLockFiles returns the paths of the index at indexPath, its side
-// files and the PID file in lockDir. Symlinks in their directories are
-// resolved, as they are in the snapshot's source paths, so the scan finds
-// them under the same names. If indexPath is a symlink, the file it points
-// to and that file's side files are returned too.
-func indexAndLockFiles(indexPath, lockDir string) []string {
-	paths := append(database.IndexFiles(indexPath), pidlock.Path(lockDir))
-	for i, p := range paths {
-		paths[i] = resolveParentDir(p)
-	}
-
-	// SQLite writes the file a symlinked index points to and keeps the
-	// side files beside that file. The database package creates the index
-	// before the scanner is built, so the link resolves.
-	index := resolveParentDir(indexPath)
-
-	target, err := filepath.EvalSymlinks(index)
-	if err == nil && target != index {
-		paths = append(paths, database.IndexFiles(target)...)
-	}
-
-	return paths
-}
-
-// resolveParentDir returns the absolute form of path with the symlinks in
-// its parent directory resolved. If the parent directory cannot be
-// resolved, it returns the absolute form unresolved. If path has no
-// absolute form, it returns path.
-func resolveParentDir(path string) string {
-	abs, err := filepath.Abs(path)
-	if err != nil {
-		return path
-	}
-
-	dir, err := filepath.EvalSymlinks(filepath.Dir(abs))
-	if err != nil {
-		return abs
-	}
-
-	return filepath.Join(dir, filepath.Base(abs))
-}

internal/snapshot/module_test.go

@@ -1,32 +0,0 @@
-//nolint:testpackage // exercises the unexported indexAndLockFiles helper
-package snapshot
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-// The scan walks source paths with symlinks resolved, so vaultik's own
-// files are named the same way, or a symlinked home would back them up.
-func TestIndexAndLockFilesResolvesSymlinkedDirectory(t *testing.T) {
-	t.Parallel()
-
-	realDir, err := filepath.EvalSymlinks(t.TempDir())
-	require.NoError(t, err)
-
-	link := filepath.Join(t.TempDir(), "link")
-	require.NoError(t, os.Symlink(realDir, link))
-
-	paths := indexAndLockFiles(filepath.Join(link, "index.sqlite"), link)
-
-	require.Equal(t, []string{
-		filepath.Join(realDir, "index.sqlite"),
-		filepath.Join(realDir, "index.sqlite-wal"),
-		filepath.Join(realDir, "index.sqlite-shm"),
-		filepath.Join(realDir, "index.sqlite-journal"),
-		filepath.Join(realDir, "vaultik.pid"),
-	}, paths)
-}

internal/snapshot/scanner.go

@@ -20,7 +20,6 @@ import (
 	"sneak.berlin/go/vaultik/internal/blob"
 	"sneak.berlin/go/vaultik/internal/chunker"
 	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/exclude"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/types"
@@ -68,9 +67,6 @@ type Scanner struct {
 	currentSourcePath string
 	exclude           []string          // Glob patterns for files/directories to exclude
 	compiledExclude   []compiledPattern // Compiled glob patterns
-	// indexAndLockFiles holds the paths of vaultik's own working files,
-	// which the scan treats as excluded (ScannerConfig.IndexAndLockFiles).
-	indexAndLockFiles map[string]struct{}
 	progress          *ProgressReporter
 	// skipErrors skips files that cannot be opened or read (logged loudly);
 	// packer, database, encryption, and upload errors still abort the run.
@@ -137,11 +133,6 @@ type ScannerConfig struct {
 	EnableProgress   bool       // Enable the live progress reporter (ETAs, throughput)
 	UI               *ui.Writer // Where user-facing scanner messages go; nil = discard
 	Exclude          []string   // Glob patterns for files/directories to exclude
-	// IndexAndLockFiles are the absolute paths of vaultik's own working
-	// files: the index, its side files and the PID file. The scan treats
-	// them as excluded, whatever Exclude says, since a copy taken while
-	// they are being written is torn.
-	IndexAndLockFiles []string
 	// SkipErrors skips files that cannot be opened or read (log loudly but
 	// continue); packer, database, encryption, and upload errors still abort.
 	SkipErrors bool
@@ -222,12 +213,8 @@ func NewScanner(cfg ScannerConfig) *Scanner {
 		progress = NewProgressReporter()
 	}
 
-	compiledExclude, err := compileExcludePatterns(cfg.Exclude)
+	// Compile exclude patterns
-	if err != nil {
+	compiledExclude := compileExcludePatterns(cfg.Exclude)
-		log.Error("Failed to compile exclude patterns", "error", err)
-
-		return nil
-	}
 
 	uiw := cfg.UI
 	if uiw == nil {
@@ -239,11 +226,6 @@ func NewScanner(cfg ScannerConfig) *Scanner {
 		deviceNumber = deviceNumberFromStat
 	}
 
-	indexAndLockFiles := make(map[string]struct{}, len(cfg.IndexAndLockFiles))
-	for _, p := range cfg.IndexAndLockFiles {
-		indexAndLockFiles[filepath.Clean(p)] = struct{}{}
-	}
-
 	return &Scanner{
 		fs:                 cfg.FS,
 		chunker:            chunker.NewChunker(cfg.ChunkSize),
@@ -255,7 +237,6 @@ func NewScanner(cfg ScannerConfig) *Scanner {
 		ageRecipient:       strings.Join(cfg.AgeRecipients, ","),
 		exclude:            cfg.Exclude,
 		compiledExclude:    compiledExclude,
-		indexAndLockFiles:  indexAndLockFiles,
 		progress:           progress,
 		skipErrors:         cfg.SkipErrors,
 		previousSnapshotID: cfg.PreviousSnapshotID,
@@ -1880,13 +1861,7 @@ func (s *Scanner) uploadBlobIfNeeded(
 	err = s.storage.PutWithProgress(ctx, blobPath, blobWithReader.Reader,
 		finishedBlob.Compressed, progressCallback)
 	if err != nil {
-		// The record is at info level: the returned error ends the backup
+		log.Error("Failed to upload blob", "hash", finishedBlob.Hash, "error", err)
-		// and is printed as its ERROR: line. Only an interrupt cancels
-		// ctx, and the user is told about it, so an upload it stopped is
-		// not logged as a storage failure.
-		if ctx.Err() == nil {
-			log.Info("Failed to upload blob", "hash", finishedBlob.Hash, "error", err)
-		}
 
 		return 0, false, fmt.Errorf("uploading blob to storage: %w", err)
 	}
@@ -2273,9 +2248,8 @@ func (s *Scanner) detectDeletedFiles(
 
 // excludedOrInExcludedDir reports whether filePath, which is at or
 // beneath rootPath, or any directory between rootPath and it, matches an
-// exclude pattern or is one of vaultik's own files. A pattern such as
+// exclude pattern. A pattern such as */.local/share/Trash matches the
-// */.local/share/Trash matches the directory but not the files inside it,
+// directory but not the files inside it, which the walk skips too.
-// which the walk skips too.
 func (s *Scanner) excludedOrInExcludedDir(filePath, rootPath string) bool {
 	for p := filePath; len(p) > len(rootPath); p = filepath.Dir(p) {
 		if s.shouldExclude(p, rootPath) {
@@ -2323,18 +2297,51 @@ func wrapPermissionError(path string, err error) error {
 		"with --skip-errors to continue past unreadable files)", path, err)
 }
 
-// compileExcludePatterns compiles the exclude patterns into glob matchers.
+// compileExcludePatterns compiles the exclude patterns into glob matchers
-// Config.Validate has already refused a pattern that does not compile.
+func compileExcludePatterns(patterns []string) []compiledPattern {
-func compileExcludePatterns(patterns []string) ([]compiledPattern, error) {
 	var compiled []compiledPattern
 
 	for _, p := range patterns {
-		globs, anchored, err := exclude.Compile(p)
+		if p == "" {
-		if err != nil {
+			continue
-			return nil, err
 		}
 
-		for _, g := range globs {
+		// Check if pattern is anchored (starts with /)
+		anchored := strings.HasPrefix(p, "/")
+
+		pattern := p
+		if anchored {
+			pattern = p[1:] // Remove leading /
+		}
+
+		// Remove trailing slash if present (directory indicator)
+		pattern = strings.TrimSuffix(pattern, "/")
+
+		// A leading "**/" demands a "/" before the name and so misses an
+		// entry directly under the source path. It means "at every depth",
+		// which is what an unanchored pattern already does, so drop the
+		// prefix and match unanchored: as in gitignore, "**/x" and
+		// "/**/x" then also match a top-level "x".
+		if rest, found := strings.CutPrefix(pattern, "**/"); found {
+			pattern = rest
+			anchored = false
+		}
+
+		// Likewise "/**/" inside a pattern demands two slashes, so
+		// "a/**/*.log" misses "a/x.log". As in gitignore it stands for
+		// zero or more directories, so also compile the pattern with it
+		// made a single "/". The glob library's {a,b} is no help: with a
+		// "**" inside it in mid-pattern, it misses paths it should match.
+		for _, variant := range doubleStarVariants(pattern) {
+			// For patterns without path separators, we need to match them as components
+			// e.g., ".git" should match ".git" anywhere in the path
+			g, err := glob.Compile(variant, '/')
+			if err != nil {
+				log.Warn("Invalid exclude pattern, skipping", "pattern", p, "error", err)
+
+				break
+			}
+
 			compiled = append(compiled, compiledPattern{
 				pattern:  g,
 				anchored: anchored,
@@ -2343,18 +2350,32 @@ func compileExcludePatterns(patterns []string) ([]compiledPattern, error) {
 		}
 	}
 
-	return compiled, nil
+	return compiled
+}
+
+// doubleStarVariants returns pattern once for every way of keeping each
+// "/**/" in it or making it a single "/".
+func doubleStarVariants(pattern string) []string {
+	const doubleStar = "/**/"
+
+	before, after, found := strings.Cut(pattern, doubleStar)
+	if !found {
+		return []string{pattern}
+	}
+
+	var variants []string
+
+	for _, rest := range doubleStarVariants(after) {
+		variants = append(variants, before+doubleStar+rest, before+"/"+rest)
+	}
+
+	return variants
 }
 
 // shouldExclude checks if a path should be excluded based on exclude patterns
-// or because it is one of vaultik's own working files.
 // filePath is the full path to the file
 // rootPath is the root of the backup source directory
 func (s *Scanner) shouldExclude(filePath, rootPath string) bool {
-	if _, ok := s.indexAndLockFiles[filePath]; ok {
-		return true
-	}
-
 	if len(s.compiledExclude) == 0 {
 		return false
 	}

internal/snapshot/upload_cancel_log_test.go

@@ -1,135 +0,0 @@
-//nolint:testpackage // exercises the unexported uploadBlobIfNeeded
-package snapshot
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"sneak.berlin/go/vaultik/internal/blob"
-	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/storage"
-	"sneak.berlin/go/vaultik/internal/storage/faultstore"
-	"sneak.berlin/go/vaultik/internal/ui"
-)
-
-const uploadFailedLogMessage = "Failed to upload blob"
-
-// uploadTestBlob uploads a small blob through store.
-func uploadTestBlob(ctx context.Context, store storage.Storer) error {
-	data := []byte("blob data")
-	s := &Scanner{storage: store, ui: ui.NewWithColor(io.Discard, false)}
-
-	_, _, err := s.uploadBlobIfNeeded(ctx, "blobs/test", &blob.WithReader{
-		FinishedBlob: &blob.FinishedBlob{
-			Hash:       "test",
-			Compressed: int64(len(data)),
-		},
-		Reader: bytes.NewReader(data),
-	}, time.Now(), &ScanResult{})
-
-	return err
-}
-
-// captureLog runs fn and returns what the logger wrote to stderr
-// meanwhile, at the --verbose level. The logger writes to the os.Stderr
-// it finds when it is initialized, so os.Stderr is pointed at a file
-// first. Not parallel-safe: os.Stderr and the logger are process-global.
-func captureLog(t *testing.T, fn func()) string {
-	t.Helper()
-
-	stderrPath := filepath.Join(t.TempDir(), "stderr")
-
-	stderrFile, err := os.Create(stderrPath) //nolint:gosec // G304: test temp path
-	if err != nil {
-		t.Fatalf("creating stderr file: %v", err)
-	}
-
-	previous := os.Stderr
-	os.Stderr = stderrFile
-
-	log.Initialize(log.Config{Verbose: true})
-
-	fn()
-
-	os.Stderr = previous
-
-	log.Initialize(log.Config{})
-
-	_ = stderrFile.Close()
-
-	captured, err := os.ReadFile(stderrPath) //nolint:gosec // G304: test temp path
-	if err != nil {
-		t.Fatalf("reading stderr file: %v", err)
-	}
-
-	return string(captured)
-}
-
-// An upload stopped by Ctrl-C or SIGTERM is not logged as an error; the
-// interrupted message is all the user sees. See
-// https://git.eeqj.de/sneak/vaultik/issues/434.
-//
-//nolint:paralleltest // captureLog replaces os.Stderr
-func TestInterruptedUploadIsNotLoggedAsError(t *testing.T) {
-	inner, err := storage.NewFileStorer(t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	t.Cleanup(cancel)
-
-	// The user interrupts mid-upload. The injected error does not wrap
-	// context.Canceled, so only ctx shows why the upload failed.
-	store := faultstore.New(inner)
-	store.OnPut = func(string) faultstore.PutAction {
-		cancel()
-
-		return faultstore.PutFail
-	}
-
-	var uploadErr error
-
-	stderr := captureLog(t, func() { uploadErr = uploadTestBlob(ctx, store) })
-
-	if uploadErr == nil {
-		t.Fatal("expected the upload to fail")
-	}
-
-	if strings.Contains(stderr, uploadFailedLogMessage) {
-		t.Errorf("interrupted upload logged as a failure: %q", stderr)
-	}
-}
-
-// An upload that fails for any other reason is still logged.
-//
-//nolint:paralleltest // captureLog replaces os.Stderr
-func TestFailedUploadIsLogged(t *testing.T) {
-	inner, err := storage.NewFileStorer(t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	store := faultstore.New(inner)
-	store.OnPut = func(string) faultstore.PutAction { return faultstore.PutFail }
-
-	var uploadErr error
-
-	stderr := captureLog(t, func() {
-		uploadErr = uploadTestBlob(context.Background(), store)
-	})
-
-	if uploadErr == nil {
-		t.Fatal("expected the upload to fail")
-	}
-
-	if !strings.Contains(stderr, uploadFailedLogMessage) {
-		t.Errorf("failed upload not logged: %q", stderr)
-	}
-}

internal/ui/ui.go

@@ -17,9 +17,6 @@
 // Count, Percent) return ANSI-colored strings the caller composes into
 // the message body. When color is disabled (non-TTY output or NO_COLOR
 // set) all formatters return plain text.
-//
-// QuoteUnprintable is the same escaping without colour, for plain tables
-// that print paths from the snapshot database.
 package ui
 
 import (
@@ -230,17 +227,17 @@ func (w *Writer) Hex(s string) string {
 		short = s[:hexAbbrevLen] + "..."
 	}
 
-	return w.paint(ansiCyan, QuoteUnprintable(short))
+	return w.paint(ansiCyan, sanitize(short))
 }
 
 // Snapshot colorizes a snapshot ID (full, no abbreviation).
 func (w *Writer) Snapshot(id string) string {
-	return w.paint(ansiCyan+ansiBold, QuoteUnprintable(id))
+	return w.paint(ansiCyan+ansiBold, sanitize(id))
 }
 
 // Path colorizes a filesystem path.
 func (w *Writer) Path(p string) string {
-	return w.paint(ansiBlue, QuoteUnprintable(p))
+	return w.paint(ansiBlue, sanitize(p))
 }
 
 // Size colorizes a byte count using humanize.Bytes.
@@ -315,15 +312,14 @@ func (w *Writer) paint(color, s string) string {
 	return color + s + ansiReset
 }
 
-// QuoteUnprintable returns s unchanged when every rune in it is printable,
+// sanitize returns s unchanged when every rune in it is printable, and a
-// and a double-quoted, backslash-escaped form (\n, \x1b, …) otherwise. The
+// double-quoted, backslash-escaped form (\n, \x1b, …) otherwise. The
 // string value formatters escape their argument through this before
 // painting: identifiers, paths and symlink targets they render come from
 // the snapshot database, which is not trusted, and escaping must happen
 // before colour is applied — the painted result already contains the
 // escape codes the raw text would otherwise be indistinguishable from.
-// Plain tables call it directly.
+func sanitize(s string) string {
-func QuoteUnprintable(s string) string {
 	for _, r := range s {
 		if !unicode.IsPrint(r) {
 			return strconv.Quote(s)

internal/vaultik/blob_fetch.go

@@ -22,10 +22,6 @@ var errBlobHashMismatch = errors.New("blob hash mismatch")
 var errBlobNotFullyRead = errors.New(
 	"blob closed before fully read; hash not verified")
 
-// errWrongPrivateKeyForBlob is returned when the configured key parses
-// but is not one of the keys a blob was encrypted to.
-var errWrongPrivateKeyForBlob = errors.New("cannot decrypt this blob")
-
 // hashVerifyReader wraps a blobgen.Reader and verifies the double-SHA-256 hash
 // of decrypted plaintext when Close is called. It reuses the hash that
 // blobgen.Reader already computes internally via its TeeReader, avoiding
@@ -91,14 +87,10 @@ func (v *Vaultik) FetchAndDecryptBlob(
 		return nil, err
 	}
 
-	reader, err := v.newBlobReader(rc, identities)
+	reader, err := blobgen.NewReader(rc, identities...)
 	if err != nil {
 		_ = rc.Close()
 
-		if errors.Is(err, errWrongPrivateKeyForBlob) {
-			return nil, err
-		}
-
 		return nil, fmt.Errorf("creating blob reader: %w", err)
 	}
 
@@ -110,28 +102,6 @@ func (v *Vaultik) FetchAndDecryptBlob(
 	}, nil
 }
 
-// newBlobReader opens the decrypting reader for a blob. When none of the
-// identities can decrypt it, the error says in plain words that the
-// configured private key is not one of the keys the blob was encrypted
-// to and names where the key was configured.
-func (v *Vaultik) newBlobReader(
-	r io.Reader, identities []age.Identity,
-) (*blobgen.Reader, error) {
-	blobReader, err := blobgen.NewReader(r, identities...)
-
-	if _, ok := errors.AsType[*age.NoIdentityMatchError](err); ok {
-		return nil, fmt.Errorf(
-			"%w: the private key in %s is not one of the keys the blob was encrypted to",
-			errWrongPrivateKeyForBlob, v.Config.AgeSecretKeySourceName())
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return blobReader, nil
-}
-
 // FetchBlob downloads a blob and returns a reader for the encrypted data.
 // The reader is closed as soon as ctx is cancelled, which ends a read
 // blocked inside it. A storage error is returned as is: restore and deep
@@ -160,8 +130,7 @@ func (v *Vaultik) FetchBlob(
 // Not every backend's reader stops on cancel by itself (the file
 // backend's does not), and a read stalled on a slow or hung source would
 // otherwise outlast the shutdown timeout, so the process would exit
-// before restore, deep verify or `snapshot files` removed its decrypted
+// before restore or deep verify removed its decrypted temporary files.
-// temporary files.
 type closeOnCancelReader struct {
 	io.ReadCloser
 

internal/vaultik/destination_marker.go

@@ -51,7 +51,7 @@ func (v *Vaultik) checkDestinationMarker() error {
 	}
 
 	// Config is nil only in tests, which then record no binding (see
-	// checkStorageBinding).
+	// EnsureStorageBinding).
 	if v.Config != nil {
 		stored, configured, err := v.storageBinding()
 		if err != nil {
@@ -83,19 +83,11 @@ func (v *Vaultik) checkDestinationMarker() error {
 	return nil
 }
 
-// markDestination refuses a local index bound to a different
+// markDestination checks the backup destination store with
-// destination, checks the backup destination store for its marker,
+// checkDestinationMarker and then writes the marker, so a first backup
-// writes the marker, and then records the binding. A first backup marks
+// marks its destination and a later one writes the same text again.
-// its destination and a later one writes the same text again. The
-// binding is recorded last, so a first backup that cannot write to the
-// destination leaves the local index unbound.
 func (v *Vaultik) markDestination() error {
-	err := v.checkStorageBinding()
+	err := v.checkDestinationMarker()
-	if err != nil {
-		return err
-	}
-
-	err = v.checkDestinationMarker()
 	if err != nil {
 		return err
 	}
@@ -107,5 +99,5 @@ func (v *Vaultik) markDestination() error {
 			destinationMarkerKey, err)
 	}
 
-	return v.EnsureStorageBinding()
+	return nil
 }

internal/vaultik/prune.go

@@ -68,7 +68,7 @@ func (v *Vaultik) NukeRemote(force bool) error {
 	// the same way, so the advice below must not follow these errors.
 	// The listing also fails on a destination that answers that it has
 	// no marker while the local index holds snapshots.
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return err
 	}
@@ -192,7 +192,7 @@ type PruneBlobsResult struct {
 // PruneDatabase or PruneBlobs individually unless it specifically wants
 // one half.
 func (v *Vaultik) Prune(opts *PruneOptions) error {
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return err
 	}

internal/vaultik/restore.go

@@ -31,7 +31,7 @@ var (
 	errPathsNotInSnapshot    = errors.New("requested path(s) not in the snapshot")
 	errFilesFailedVerify     = errors.New("files failed verification")
 	errDecryptionKeyRequired = errors.New(
-		"decryption key required\n\n" +
+		"decryption key required for restore\n\n" +
 			"Set the VAULTIK_AGE_SECRET_KEY environment variable to your " +
 			"age private key file:\n" +
 			"  export VAULTIK_AGE_SECRET_KEY=\"$(cat vaultik_backup_private_key.txt)\"")
@@ -40,9 +40,6 @@ var (
 	// which is secret, so the message is safe to print and log.
 	errInvalidAgeSecretKey = errors.New(
 		"configured age secret key holds no usable age identity")
-	// errWrongPrivateKey is returned when the configured key parses but
-	// is not one of the keys the snapshot was encrypted to.
-	errWrongPrivateKey          = errors.New("cannot decrypt this snapshot")
 	errBlobMissingFromIndex     = errors.New("blob hash missing from blob index")
 	errChunkNotInAnyBlob        = errors.New("chunk not found in any blob")
 	errBlobIDNotInHashIndex     = errors.New("blob id missing from hash index")
@@ -109,12 +106,7 @@ type RestoreResult struct {
 	BytesDownloaded int64
 	Duration        time.Duration
 	FilesFailed     int
-	FailedFiles     []string // Paths of files that failed to restore for their own reason
+	FailedFiles     []string // Paths of files that failed to restore
-	// Blobs that could not be downloaded, and the paths of the files
-	// skipped because they need one of them. Those files are counted in
-	// FilesFailed but not listed in the summary.
-	BlobsFailed            int
-	FilesNeedingFailedBlob []string
 	// Verification results (only populated if Verify option is set)
 	FilesVerified     int
 	BytesVerified     int64
@@ -136,24 +128,26 @@ func (v *Vaultik) Restore(opts *RestoreOptions) error {
 		"paths", opts.Paths,
 	)
 
-	remoteKey, err := v.resolveSnapshotRemoteKey(opts.SnapshotID)
-	if err != nil {
-		return err
-	}
-
 	// Step 1: Download and decrypt the snapshot metadata database
 	log.Info("Downloading snapshot metadata...")
 
-	tempDB, tempDir, err := v.downloadSnapshotDB(opts.SnapshotID, remoteKey, identities)
+	tempDB, tempDir, err := v.downloadSnapshotDB(opts.SnapshotID, identities)
-	if errors.Is(err, errWrongPrivateKey) {
-		return err
-	}
-
 	if err != nil {
 		return fmt.Errorf("downloading snapshot database: %w", err)
 	}
 
-	defer v.closeSnapshotDB(tempDB, tempDir)
+	defer func() {
+		err := tempDB.Close()
+		if err != nil {
+			log.Debug("Failed to close temp database", "error", err)
+		}
+		// Remove the whole private directory, so the decrypted database
+		// and any SQLite side files it produced are gone on every path.
+		err = v.Fs.RemoveAll(tempDir)
+		if err != nil {
+			log.Debug("Failed to remove temp database directory", "error", err)
+		}
+	}()
 
 	repos := database.NewRepositories(tempDB)
 
@@ -232,11 +226,6 @@ func (v *Vaultik) finishRestore(
 	if result.FilesFailed > 0 {
 		v.UI.Warningf("%d file(s) failed to restore:", result.FilesFailed)
 
-		if result.BlobsFailed > 0 {
-			v.UI.Detailf("%d of them need a blob that could not be read (%d blob(s) in all).",
-				len(result.FilesNeedingFailedBlob), result.BlobsFailed)
-		}
-
 		for _, path := range result.FailedFiles {
 			v.UI.Detailf("%s", v.UI.Path(path))
 		}
@@ -314,10 +303,9 @@ func (v *Vaultik) reportUnmatchedPaths(unmatched []string) error {
 // identity it contains. The value may be a single key line or a whole
 // age-keygen file with several identities; all of them are returned so
 // blobgen (via age.Decrypt) can read a blob encrypted to any of their
-// recipients. This is the first step of restore, deep verify and
+// recipients. This is the first step of both restore and deep verify, so
-// `snapshot files`, so a missing or unparseable key fails before anything
+// a missing or unparseable key fails before anything is downloaded. The
-// is downloaded. The error names the configuration source but never the
+// error names the configuration source but never the key value.
-// key value.
 func (v *Vaultik) restoreIdentities() ([]age.Identity, error) {
 	if v.Config.AgeSecretKey == "" {
 		return nil, errDecryptionKeyRequired
@@ -335,28 +323,6 @@ func (v *Vaultik) restoreIdentities() ([]age.Identity, error) {
 	return identities, nil
 }
 
-// newSnapshotDBReader opens the decrypting reader for a snapshot
-// database. When none of the identities can decrypt it, the error says
-// in plain words that the configured private key is the wrong one and
-// names where it was configured.
-func (v *Vaultik) newSnapshotDBReader(
-	r io.Reader, identities []age.Identity,
-) (*blobgen.Reader, error) {
-	blobReader, err := blobgen.NewReader(r, identities...)
-
-	if _, ok := errors.AsType[*age.NoIdentityMatchError](err); ok {
-		return nil, fmt.Errorf(
-			"%w: the private key in %s is not one of the keys the backup was encrypted to",
-			errWrongPrivateKey, v.Config.AgeSecretKeySourceName())
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return blobReader, nil
-}
-
 // restoreAllFiles processes files in blob-locality order: drain every
 // file whose blob set is on disk, download the missing blobs for the
 // pending file with the smallest uncached count, repeat. This keeps
@@ -528,8 +494,8 @@ func (v *Vaultik) runRestoreLoop(
 // Returns false when nothing is pending download (the caller stops).
 //
 // A blob that cannot be downloaded is reported through
-// handleRestoreBlobError, so it aborts the restore unless --skip-errors
+// handleRestoreFileError for every pending file that references it, so
-// is set.
+// it aborts the restore unless --skip-errors is set.
 func (s *restoreSession) downloadNextBlobSet(
 	plan *restorePlan, filesByID map[types.FileID]*database.File,
 ) (bool, error) {
@@ -562,11 +528,12 @@ func (s *restoreSession) downloadNextBlobSet(
 				return false, err
 			}
 
-			blobErr := s.v.handleRestoreBlobError(
+			for _, fileID := range plan.filesReferencingBlob(hash) {
-				plan, s.opts, s.result, filesByID,
+				fileErr := s.v.handleRestoreFileError(
-				plan.filesReferencingBlob(hash), err)
+					plan, s.opts, s.result, filesByID[fileID], fileID, err)
-			if blobErr != nil {
+				if fileErr != nil {
-				return false, blobErr
+					return false, fileErr
+				}
 			}
 
 			// next is among the failed files, so the rest of its blob set
@@ -657,19 +624,19 @@ func (v *Vaultik) restoreProgressTick(
 
 // handleRestoreFileError records a per-file restore failure: fatal unless
 // --skip-errors is set, in which case the file is counted as failed and
-// dropped from the plan. A fatal failure is not logged here: the returned
+// dropped from the plan.
-// error is printed as the command's ERROR: line.
 func (v *Vaultik) handleRestoreFileError(
 	plan *restorePlan, opts *RestoreOptions, result *RestoreResult,
 	file *database.File, fileID types.FileID, err error,
 ) error {
+	log.Error("Failed to restore file", "path", file.Path, "error", err)
+
 	if !opts.SkipErrors {
 		return fmt.Errorf(
 			"restoring %s: %w (pass --skip-errors to continue past "+
 				"restore failures)", file.Path, err)
 	}
 
-	log.Error("Failed to restore file", "path", file.Path, "error", err)
 	v.UI.Errorf("Failed to restore %s: %v. Skipping (--skip-errors).",
 		v.UI.Path(file.Path.String()), err)
 
@@ -681,41 +648,6 @@ func (v *Vaultik) handleRestoreFileError(
 	return nil
 }
 
-// handleRestoreBlobError records a blob that could not be downloaded.
-// fileIDs are the pending files that need it, never empty. Without
-// --skip-errors the first of them fails the restore. With it, the blob is
-// reported once, and its files are counted as failed and dropped from
-// the plan without being reported one by one.
-func (v *Vaultik) handleRestoreBlobError(
-	plan *restorePlan, opts *RestoreOptions, result *RestoreResult,
-	filesByID map[types.FileID]*database.File, fileIDs []types.FileID,
-	err error,
-) error {
-	if !opts.SkipErrors {
-		return v.handleRestoreFileError(
-			plan, opts, result, filesByID[fileIDs[0]], fileIDs[0], err)
-	}
-
-	log.Error("Failed to restore files", "files", len(fileIDs), "error", err)
-	v.UI.Errorf("Failed to restore %d file(s): %v. Skipping them (--skip-errors).",
-		len(fileIDs), err)
-
-	result.BlobsFailed++
-
-	for _, fileID := range fileIDs {
-		path := filesByID[fileID].Path.String()
-
-		log.Debug("Skipped file that needs a failed blob", "path", path)
-
-		result.FilesFailed++
-		result.FilesNeedingFailedBlob = append(result.FilesNeedingFailedBlob, path)
-
-		plan.finishFile(fileID)
-	}
-
-	return nil
-}
-
 // printRestoreProgress emits a periodic restore-phase status line via
 // the UI writer, mirroring scanner.printProcessingProgress so the two
 // long-running commands have the same on-screen rhythm.
@@ -787,8 +719,8 @@ func (v *Vaultik) handleRestoreVerification(
 ) error {
 	// A file that failed to restore was not written and is already
 	// reported as such, so it is not verified.
-	failedToRestore := make(map[string]bool, result.FilesFailed)
+	failedToRestore := make(map[string]bool, len(result.FailedFiles))
-	for _, path := range slices.Concat(result.FailedFiles, result.FilesNeedingFailedBlob) {
+	for _, path := range result.FailedFiles {
 		failedToRestore[path] = true
 	}
 
@@ -822,12 +754,19 @@ func (v *Vaultik) handleRestoreVerification(
 	return nil
 }
 
-// downloadSnapshotDB downloads and decrypts the metadata database of the
+// downloadSnapshotDB downloads and decrypts the snapshot metadata
-// snapshot at remoteKey, which resolveSnapshotRemoteKey returned for
+// database. The identifier is resolved to the snapshot's remote key: a
-// snapshotID.
+// human ID is hashed, and a remote key (or its abbreviation, as printed
+// for a remote-only snapshot) is used as-is, so a host with no local
+// index can restore the snapshots it can only see on the store.
 func (v *Vaultik) downloadSnapshotDB(
-	snapshotID, remoteKey string, identities []age.Identity,
+	snapshotID string, identities []age.Identity,
 ) (*database.DB, string, error) {
+	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
+	if err != nil {
+		return nil, "", err
+	}
+
 	// Download encrypted database from storage
 	dbKey := fmt.Sprintf("metadata/%s/db.zst.age", remoteKey)
 
@@ -844,9 +783,9 @@ func (v *Vaultik) downloadSnapshotDB(
 	// the plaintext to a temp file. Neither the encrypted bytes nor the
 	// decrypted database is ever held whole in memory; a snapshot database
 	// can be large.
-	blobReader, err := v.newSnapshotDBReader(reader, identities)
+	blobReader, err := blobgen.NewReader(reader, identities...)
 	if err != nil {
-		return nil, "", err
+		return nil, "", fmt.Errorf("creating decryption reader: %w", err)
 	}
 
 	defer func() { _ = blobReader.Close() }()
@@ -870,34 +809,18 @@ func (v *Vaultik) downloadSnapshotDB(
 	return db, tempDir, nil
 }
 
-// closeSnapshotDB closes a database returned by downloadSnapshotDB and
-// removes its private directory, so the decrypted database and any SQLite
-// side files it produced are gone.
-func (v *Vaultik) closeSnapshotDB(db *database.DB, tempDir string) {
-	err := db.Close()
-	if err != nil {
-		log.Debug("Failed to close temp database", "error", err)
-	}
-
-	err = v.Fs.RemoveAll(tempDir)
-	if err != nil {
-		log.Debug("Failed to remove temp database directory", "error", err)
-	}
-}
-
 // verifySnapshotDBIdentity confirms the decrypted metadata database really
 // is the snapshot named by remoteKey. age decryption proves the database
 // is readable, not that the object served at
 // metadata/<remoteKey>/db.zst.age is the snapshot that was requested: an
 // attacker who swaps in another valid db.zst.age (which needs no key
-// material) would otherwise redirect restore, deep verify and
+// material) would otherwise redirect restore and deep verify to a
-// `snapshot files` to a different snapshot's contents. The exported
+// different snapshot's contents. The exported per-snapshot database holds
-// per-snapshot database holds exactly one snapshot row, and a snapshot's
+// exactly one snapshot row, and a snapshot's remote key is derived from
-// remote key is derived from that row's ID, so the database is the
+// that row's ID, so the database is the requested one exactly when its
-// requested one exactly when its sole snapshot hashes back to remoteKey.
+// sole snapshot hashes back to remoteKey. Comparing the requested
-// Comparing the requested identifier directly would not do: it may be a
+// identifier directly would not do: it may be a remote-key prefix a
-// remote-key prefix a recovery host uses in place of a human snapshot ID
+// recovery host uses in place of a human snapshot ID it cannot know.
-// it cannot know.
 func (v *Vaultik) verifySnapshotDBIdentity(
 	db *database.DB, requested, remoteKey string,
 ) error {

internal/vaultik/restore_skip_errors_test.go

@@ -51,72 +51,27 @@ func TestRestoreSkipErrorsSkipsFilesOfMissingBlob(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	backup := backupThenDeleteOneBlob(ctx, t)
+	assertRestoreSkipsLostFiles(ctx, t, backupThenDeleteOneBlob(ctx, t))
-	out := assertRestoreSkipsLostFiles(ctx, t, backup)
-
-	assertLostFilesCountedNotListed(t, backup, out)
-}
-
-// TestRestoreSkipErrorsReportsUnreadableBlobOnce restores with SkipErrors
-// after one blob of a two-blob snapshot was overwritten with other bytes
-// of the same size. The blob must be reported once, by its hash, as not a
-// valid age stream, without quoting its bytes, and its files must be
-// counted, not listed.
-func TestRestoreSkipErrorsReportsUnreadableBlobOnce(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	ctx := context.Background()
-	backup, lostBlob := backupThenOverwriteOneBlob(ctx, t)
-	out := assertRestoreSkipsLostFiles(ctx, t, backup)
-
-	assert.Equal(t, 1, strings.Count(out, "not a valid age stream"), out)
-	assert.Contains(t, out, lostBlob[:16])
-	assert.NotContains(t, out, overwriteBlobPattern)
-	assertLostFilesCountedNotListed(t, backup, out)
 }
 
 // TestRestoreSkipErrorsSkipsFilesWithChunkInNoBlob restores with
 // SkipErrors a snapshot whose metadata lists chunks that no blob holds, as
-// earlier backup defects left behind. Each such file fails for its own
+// earlier backup defects left behind.
-// reason, so each is listed.
 func TestRestoreSkipErrorsSkipsFilesWithChunkInNoBlob(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 
 	ctx := context.Background()
-	backup := backupThenDropOneBlobFromMetadata(ctx, t)
+	assertRestoreSkipsLostFiles(ctx, t, backupThenDropOneBlobFromMetadata(ctx, t))
-	out := assertRestoreSkipsLostFiles(ctx, t, backup)
-
-	for path := range backup.lost {
-		assert.Containsf(t, out, path, "%s must be reported", path)
-	}
 }
 
-// assertLostFilesCountedNotListed checks that the restore output out
+// assertRestoreSkipsLostFiles restores backup with SkipErrors. Every file
-// counts the files of the lost blob and names none of them.
+// stored in the lost blob must be reported as failed and left absent,
-func assertLostFilesCountedNotListed(
+// every other file must be restored intact, and Restore must still return
-	t *testing.T, backup *missingBlobBackup, out string,
+// an error.
-) {
-	t.Helper()
-
-	assert.Contains(t, out, fmt.Sprintf(
-		"%d of them need a blob that could not be read (1 blob(s) in all)",
-		len(backup.lost)))
-
-	for path := range backup.lost {
-		assert.NotContainsf(t, out, path,
-			"%s needs the lost blob and must be counted, not listed", path)
-	}
-}
-
-// assertRestoreSkipsLostFiles restores backup with SkipErrors and returns
-// what it printed. Every file stored in the lost blob must be left
-// absent, every other file must be restored intact, and Restore must
-// still return an error.
 func assertRestoreSkipsLostFiles(
 	ctx context.Context, t *testing.T, backup *missingBlobBackup,
-) string {
+) {
 	t.Helper()
 
 	var out bytes.Buffer
@@ -138,6 +93,8 @@ func assertRestoreSkipsLostFiles(
 		restored := filepath.Join(backup.restoreDir, path)
 
 		if backup.lost[path] {
+			assert.Containsf(t, out.String(), path,
+				"%s needs the lost blob and must be reported", path)
 			assert.NoFileExists(t, restored)
 
 			continue
@@ -147,8 +104,6 @@ func assertRestoreSkipsLostFiles(
 		require.NoErrorf(t, err, "%s does not need the lost blob", path)
 		assert.Equalf(t, content, got, "%s restored with wrong content", path)
 	}
-
-	return out.String()
 }
 
 // TestRestoreSkipErrorsVerifyChecksOnlyRestoredFiles restores with
@@ -189,9 +144,9 @@ func TestRestoreSkipErrorsVerifyChecksOnlyRestoredFiles(t *testing.T) {
 // TestRestoreSkipErrorsVerifyReportsFailuresApart restores with
 // SkipErrors and Verify after one blob of a two-blob snapshot was
 // deleted, while one file that does restore is written one byte too long.
-// The restore warning must count the files of the deleted blob without
+// The restore warning must list only the files of the deleted blob, the
-// listing them, the verification summary must list only the long file,
+// verification summary only the long file, each path once, and Restore
-// once, and Restore must return an error.
+// must return an error.
 func TestRestoreSkipErrorsVerifyReportsFailuresApart(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
@@ -231,9 +186,9 @@ func TestRestoreSkipErrorsVerifyReportsFailuresApart(t *testing.T) {
 		"Verification failed: 1 files did not match")
 	require.Truef(t, found, "no verification summary in:\n%s", out.String())
 
-	assertLostFilesCountedNotListed(t, backup, warning)
-
 	for path := range backup.lost {
+		assert.Equalf(t, 1, strings.Count(warning, path),
+			"%s must be listed once as failed to restore", path)
 		assert.NotContainsf(t, summary, path,
 			"%s was not restored and must not fail verification", path)
 	}
@@ -337,35 +292,6 @@ func backupThenDeleteOneBlob(
 	return backup
 }
 
-// overwriteBlobPattern repeats, each time followed by a newline, through
-// the bytes that backupThenOverwriteOneBlob writes over a blob. age's own
-// error quotes the data's first line only when it reads a whole line.
-const overwriteBlobPattern = "overwritten-blob-bytes-"
-
-// backupThenOverwriteOneBlob backs up missingBlobFileCount single-chunk
-// files, then overwrites the blob holding the first of them with as many
-// bytes of overwriteBlobPattern lines. It also returns that blob's hash.
-func backupThenOverwriteOneBlob(
-	ctx context.Context, t *testing.T,
-) (*missingBlobBackup, string) {
-	t.Helper()
-
-	backup, db, lostBlob := backupSingleChunkFiles(ctx, t)
-	require.NoError(t, db.Close())
-
-	key := fmt.Sprintf("blobs/%s/%s/%s", lostBlob[:2], lostBlob[2:4], lostBlob)
-
-	info, err := backup.storer.Stat(ctx, key)
-	require.NoError(t, err)
-
-	line := overwriteBlobPattern + "\n"
-	pattern := bytes.Repeat([]byte(line), int(info.Size)/len(line)+1)
-	require.NoError(t, backup.storer.Put(
-		ctx, key, bytes.NewReader(pattern[:info.Size])))
-
-	return backup, lostBlob
-}
-
 // backupThenDropOneBlobFromMetadata backs up missingBlobFileCount
 // single-chunk files, then removes the blob holding the first of them from
 // the snapshot and exports the snapshot metadata again. The exported

internal/vaultik/restore_wrong_key_test.go

@@ -1,161 +0,0 @@
-package vaultik_test
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"path"
-	"path/filepath"
-	"testing"
-
-	"filippo.io/age"
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/blobgen"
-	"sneak.berlin/go/vaultik/internal/config"
-	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/snapshot"
-	"sneak.berlin/go/vaultik/internal/ui"
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// TestWrongPrivateKeyError checks that restore and deep verify, given a
-// valid private key the backup was not encrypted to, fail with one plain
-// sentence that names where the key was configured.
-func TestWrongPrivateKeyError(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	store := NewMockStorer()
-
-	const snapshotID = "test-host_2026-01-01T00:00:00Z"
-
-	remoteKey := snapshot.RemoteSnapshotKey(snapshotID)
-
-	manifest, err := snapshot.EncodeManifest(
-		&snapshot.Manifest{SnapshotID: remoteKey}, 3)
-	require.NoError(t, err)
-	require.NoError(t, store.Put(ctx,
-		"metadata/"+remoteKey+"/manifest.json.zst", bytes.NewReader(manifest)))
-
-	// The database is encrypted to the test recipient only.
-	var db bytes.Buffer
-
-	writer, err := blobgen.NewWriter(&db, 1, []string{testAgePublicKey})
-	require.NoError(t, err)
-
-	_, err = writer.Write([]byte("snapshot database"))
-	require.NoError(t, err)
-	require.NoError(t, writer.Close())
-	require.NoError(t, store.Put(ctx,
-		"metadata/"+remoteKey+"/db.zst.age", &db))
-
-	otherKey, err := age.GenerateX25519Identity()
-	require.NoError(t, err)
-
-	v := &vaultik.Vaultik{
-		Config:  &config.Config{AgeSecretKey: otherKey.String()},
-		Storage: store,
-		Fs:      afero.NewMemMapFs(),
-		Stdout:  io.Discard,
-		Stderr:  io.Discard,
-		UI:      ui.NewWithColor(io.Discard, false),
-	}
-	v.SetContext(ctx)
-
-	// A Config built directly has no recorded source, so the error names
-	// the config-file field.
-	const want = "cannot decrypt this snapshot: the private key in " +
-		"age_secret_key is not one of the keys the backup was encrypted to"
-
-	err = v.Restore(&vaultik.RestoreOptions{
-		SnapshotID: snapshotID,
-		TargetDir:  t.TempDir(),
-	})
-	require.EqualError(t, err, want)
-
-	err = v.RunDeepVerify(snapshotID, &vaultik.VerifyOptions{Deep: true})
-	require.EqualError(t, err, want)
-}
-
-// TestWrongPrivateKeyForBlobError backs up a file, then backs it up again
-// from an empty local index with a second recipient added. The second
-// snapshot reuses the stored blob, which stays encrypted to the first
-// recipient only. With only the added key configured, restore and deep
-// verify read the database but fail on the blob with one plain sentence
-// that names where the key was configured.
-func TestWrongPrivateKeyForBlobError(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	fs := afero.NewOsFs()
-	tempDir := t.TempDir()
-	dataDir := filepath.Join(tempDir, "source")
-	dataPath := filepath.Join(dataDir, "data.bin")
-	storeDir := t.TempDir()
-	secondDBPath := filepath.Join(tempDir, "second.sqlite")
-
-	chunkSize := int64(64 * 1024)
-	maxBlobSize := int64(512 * 1024)
-
-	require.NoError(t, fs.MkdirAll(dataDir, 0o755))
-	require.NoError(t, afero.WriteFile(fs, dataPath,
-		bytesPattern("key-", int(chunkSize)), 0o644))
-
-	ctx := context.Background()
-
-	runFileStorageBackup(ctx, t, fs, dataDir, storeDir,
-		filepath.Join(tempDir, "first.sqlite"), chunkSize, maxBlobSize)
-
-	env := setupDedupBackupEnv(
-		ctx, t, fs, storeDir, secondDBPath, chunkSize, maxBlobSize)
-
-	defer func() { _ = env.db.Close() }()
-
-	addedKey, err := age.GenerateX25519Identity()
-	require.NoError(t, err)
-
-	env.cfg.AgeRecipients = append(env.cfg.AgeRecipients,
-		addedKey.Recipient().String())
-
-	snapshotID, result := runDedupSnapshot(ctx, t, env.sm, env.makeScanner(),
-		env.cfg.Hostname, "second", dataDir, secondDBPath)
-	require.Zero(t, result.BlobsUploaded,
-		"the second backup should reuse the stored blob")
-
-	require.NoError(t, env.db.Close())
-
-	blobKeys, err := env.storer.List(ctx, "blobs/")
-	require.NoError(t, err)
-	require.Len(t, blobKeys, 1)
-
-	blobHash := path.Base(blobKeys[0])
-
-	env.cfg.AgeSecretKey = addedKey.String()
-
-	v := &vaultik.Vaultik{
-		Config:  env.cfg,
-		Storage: env.storer,
-		Fs:      fs,
-		Stdout:  io.Discard,
-		Stderr:  io.Discard,
-		UI:      ui.NewWithColor(io.Discard, false),
-	}
-	v.SetContext(ctx)
-
-	const sentence = "cannot decrypt this blob: the private key in " +
-		"age_secret_key is not one of the keys the blob was encrypted to"
-
-	// Restore names the blob by the first 16 characters of its hash.
-	err = v.Restore(&vaultik.RestoreOptions{
-		SnapshotID: snapshotID,
-		TargetDir:  t.TempDir(),
-	})
-	require.EqualError(t, err, "restoring "+dataPath+": downloading blob "+
-		blobHash[:16]+": "+sentence+
-		" (pass --skip-errors to continue past restore failures)")
-
-	err = v.RunDeepVerify(snapshotID, &vaultik.VerifyOptions{Deep: true})
-	require.EqualError(t, err,
-		"blob "+blobHash+" verification failed: "+sentence)
-}

internal/vaultik/snapshot.go

@@ -115,9 +115,14 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 		"index_path", v.Config.IndexPath,
 	)
 
+	err := v.EnsureStorageBinding()
+	if err != nil {
+		return err
+	}
+
 	// Before PruneDatabase: it drops incomplete snapshots, which could
 	// leave the local index without one and so skip the marker check.
-	err := v.markDestination()
+	err = v.markDestination()
 	if err != nil {
 		return err
 	}
@@ -744,7 +749,7 @@ type SnapshotPurgeOptions struct {
 // snapshot name, not the latest globally. This prevents `home` and `system`
 // snapshots from cannibalizing each other.
 func (v *Vaultik) PurgeSnapshotsWithOptions(opts *SnapshotPurgeOptions) error {
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return err
 	}
@@ -959,22 +964,25 @@ func (v *Vaultik) VerifySnapshotWithOptions(
 		Mode:       "shallow",
 	}
 
-	// The key is kept so we can also check for the snapshot's encrypted
+	v.printVerifyHeader(snapshotID, opts)
-	// database below.
+
+	// Resolve the identifier to the snapshot's remote key. A human ID is
+	// hashed; a remote key (or its abbreviation, as printed for a
+	// remote-only snapshot) is used as-is, so a host with no local index
+	// can verify a snapshot it can only see on the store. The key is kept
+	// so we can also check for the snapshot's encrypted database below.
 	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
 	if err != nil {
 		if opts.JSON {
 			result.Status = verifyStatusFailed
-			result.ErrorMessage = err.Error()
+			result.ErrorMessage = fmt.Sprintf("resolving snapshot identifier: %v", err)
 
 			return v.outputVerifyJSON(result)
 		}
 
-		return err
+		return fmt.Errorf("resolving snapshot identifier: %w", err)
 	}
 
-	v.printVerifyHeader(snapshotID, opts)
-
 	manifest, err := v.downloadManifestByKey(remoteKey)
 	if err != nil {
 		if opts.JSON {
@@ -1272,7 +1280,7 @@ func (v *Vaultik) outputVerifyJSON(result *VerifyResult) error {
 // jq` fail (issue #108). The narration is duplicated as log records,
 // which go to stderr and so cannot corrupt the document.
 func (v *Vaultik) CleanupLocalSnapshots(opts *PruneOptions) error {
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return err
 	}
@@ -1462,12 +1470,12 @@ func (v *Vaultik) RemoveSnapshot(
 		SnapshotID: snapshotID,
 	}
 
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return result, err
 	}
 
-	inLocalIndex, err := v.checkSnapshotExists(snapshotID, opts.LocalOnly)
+	inLocalIndex, err := v.findSnapshotToRemove(snapshotID, opts)
 	if err != nil {
 		return result, err
 	}
@@ -1530,20 +1538,17 @@ func (v *Vaultik) RemoveSnapshot(
 	return result, nil
 }
 
-// checkSnapshotExists returns errSnapshotNotFound when the local index
+// findSnapshotToRemove reports whether the local index has a row for
-// has no row for snapshotID and, unless localOnly is set, the
+// snapshotID, and returns errSnapshotNotFound when there is nothing to
-// destination store has no metadata for it either. inLocalIndex reports
+// remove: no row and, unless LocalOnly is set, no metadata on the
-// whether the local index has that row. The destination store is
+// destination store either. The destination store is consulted only
-// consulted only when the local index has no row, so a snapshot in the
+// when the local index has no row, so a snapshot in the local index can
-// local index can still be removed from it while the destination store
+// still be removed from it while the destination store is unreachable,
-// is unreachable, and only after checkDestinationMarker passes, so an
+// and only after checkDestinationMarker passes, so an unplugged volume's
-// unplugged volume's empty mount point is not taken for a store without
+// empty mount point is not taken for a store without the snapshot.
-// the snapshot.
+func (v *Vaultik) findSnapshotToRemove(
-//
+	snapshotID string, opts *RemoveOptions,
-//nolint:nonamedreturns // the result name says what the bool means
+) (bool, error) {
-func (v *Vaultik) checkSnapshotExists(
-	snapshotID string, localOnly bool,
-) (inLocalIndex bool, err error) {
 	if v.Repositories != nil {
 		snap, err := v.Repositories.Snapshots.GetByID(v.ctx, snapshotID)
 		if err != nil {
@@ -1555,12 +1560,12 @@ func (v *Vaultik) checkSnapshotExists(
 		}
 	}
 
-	if localOnly {
+	if opts.LocalOnly {
 		return false, fmt.Errorf("%w in the local index: %s",
 			errSnapshotNotFound, snapshotID)
 	}
 
-	err = v.checkDestinationMarker()
+	err := v.checkDestinationMarker()
 	if err != nil {
 		return false, err
 	}
@@ -1702,7 +1707,7 @@ func (v *Vaultik) removeSnapshotRemote(
 // before it removes anything when the destination store cannot be
 // listed or is not present by checkDestinationMarker.
 func (v *Vaultik) RemoveAllSnapshots(opts *RemoveOptions) (*RemoveResult, error) {
-	err := v.checkStorageBinding()
+	err := v.EnsureStorageBinding()
 	if err != nil {
 		return nil, err
 	}

internal/vaultik/snapshot_files.go

@@ -1,115 +0,0 @@
-package vaultik
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"text/tabwriter"
-	"time"
-
-	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/ui"
-)
-
-// ListedFile is one entry printed by `snapshot files`. Mode is the Go
-// file mode string, which shows the entry type and the permission bits
-// (for example -rw-r--r-- or drwxr-xr-x).
-type ListedFile struct {
-	Path  string    `json:"path"`
-	Size  int64     `json:"size"`
-	Mode  string    `json:"mode"`
-	MTime time.Time `json:"mtime"`
-}
-
-// ListSnapshotFiles prints the path, size, mode and modification time of
-// every file the snapshot holds at or under path, or of every file when
-// path is empty. The file list is only in the snapshot's encrypted
-// database, so this downloads and decrypts it as restore does, and needs
-// the private key.
-func (v *Vaultik) ListSnapshotFiles(snapshotID, path string, jsonOutput bool) error {
-	identities, err := v.restoreIdentities()
-	if err != nil {
-		return err
-	}
-
-	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
-	if err != nil {
-		return err
-	}
-
-	db, tempDir, err := v.downloadSnapshotDB(snapshotID, remoteKey, identities)
-	if errors.Is(err, errWrongPrivateKey) {
-		return err
-	}
-
-	if err != nil {
-		return fmt.Errorf("downloading snapshot database: %w", err)
-	}
-
-	defer v.closeSnapshotDB(db, tempDir)
-
-	repos := database.NewRepositories(db)
-
-	var files []*database.File
-
-	if path == "" {
-		files, err = repos.Files.ListAll(v.ctx)
-	} else {
-		files, err = repos.Files.ListUnderPath(v.ctx, filepath.Clean(path))
-	}
-
-	if err != nil {
-		return fmt.Errorf("listing files: %w", err)
-	}
-
-	if path != "" && len(files) == 0 {
-		return fmt.Errorf("%w: %s", errPathsNotInSnapshot, path)
-	}
-
-	entries := make([]ListedFile, 0, len(files))
-
-	for _, file := range files {
-		entries = append(entries, ListedFile{
-			Path:  file.Path.String(),
-			Size:  file.Size,
-			Mode:  os.FileMode(file.Mode).String(),
-			MTime: file.MTime,
-		})
-	}
-
-	if jsonOutput {
-		encoder := json.NewEncoder(v.Stdout)
-		encoder.SetIndent("", "  ")
-
-		return encoder.Encode(entries)
-	}
-
-	if v.UI.Quiet() {
-		return nil
-	}
-
-	return v.printListedFileTable(entries)
-}
-
-// printListedFileTable writes the entries as a plain table to stdout.
-func (v *Vaultik) printListedFileTable(entries []ListedFile) error {
-	w := tabwriter.NewWriter(v.Stdout, 0, 0, tabPadding, ' ', 0)
-
-	_, err := fmt.Fprintln(w, "MODE\tSIZE\tMODIFIED\tPATH")
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		_, err = fmt.Fprintf(w, "%s\t%d\t%s\t%s\n",
-			entry.Mode, entry.Size,
-			entry.MTime.Format(time.RFC3339), ui.QuoteUnprintable(entry.Path))
-		if err != nil {
-			return err
-		}
-	}
-
-	return w.Flush()
-}

internal/vaultik/snapshot_files_test.go

@@ -1,197 +0,0 @@
-package vaultik_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/database"
-	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/storage"
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// These tests cover https://git.eeqj.de/sneak/vaultik/issues/435:
-// `snapshot files` lists what a snapshot holds without restoring it.
-
-// unprintableFileName is a file name holding a newline and an escape
-// sequence, which the table must not print raw.
-const unprintableFileName = "odd\nname\x1b[31m"
-
-// backUpForFileListing backs up the fault source tree, plus a file named
-// unprintableFileName at its top, and returns a reader whose stdout is
-// out, the snapshot ID, and the source directory.
-func backUpForFileListing(
-	t *testing.T, out *bytes.Buffer,
-) (*vaultik.Vaultik, string, string) {
-	t.Helper()
-
-	fs := afero.NewOsFs()
-	tempDir := t.TempDir()
-	dataDir := filepath.Join(tempDir, "src")
-	dbPath := filepath.Join(tempDir, "index.sqlite")
-
-	ctx := context.Background()
-	cfg := faultTestConfig()
-
-	writeFaultSourceTree(t, fs, dataDir)
-	require.NoError(t, afero.WriteFile(fs,
-		filepath.Join(dataDir, unprintableFileName), []byte("odd"), 0o644))
-
-	store, err := storage.NewFileStorer(t.TempDir())
-	require.NoError(t, err)
-
-	db, err := database.New(ctx, dbPath)
-	require.NoError(t, err)
-
-	id := fullFaultBackup(ctx, t, fs, store, cfg,
-		database.NewRepositories(db), dataDir, dbPath, "files")
-	require.NoError(t, db.Close())
-
-	v := newReaderVaultik(ctx, cfg, store, nil, fs)
-	v.Stdout = out
-
-	return v, id, dataDir
-}
-
-func TestSnapshotFilesJSONListsEveryFileWithItsMetadata(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, dataDir := backUpForFileListing(t, &out)
-
-	require.NoError(t, v.ListSnapshotFiles(id, "", true))
-
-	var entries []vaultik.ListedFile
-
-	require.NoError(t, json.Unmarshal(out.Bytes(), &entries))
-
-	byPath := make(map[string]vaultik.ListedFile, len(entries))
-	for _, entry := range entries {
-		byPath[entry.Path] = entry
-	}
-
-	for _, rel := range []string{"small.txt", "a.bin", "sub", "sub/b.bin", "sub/c.bin"} {
-		path := filepath.Join(dataDir, rel)
-
-		entry, ok := byPath[path]
-		require.True(t, ok, "%s must be listed", path)
-
-		info, err := afero.NewOsFs().Stat(path)
-		require.NoError(t, err)
-
-		assert.Equal(t, info.Mode().String(), entry.Mode, path)
-		assert.True(t, info.ModTime().Equal(entry.MTime),
-			"%s: mtime %v, listed %v", path, info.ModTime(), entry.MTime)
-
-		if !info.IsDir() {
-			assert.Equal(t, info.Size(), entry.Size, path)
-		}
-	}
-}
-
-func TestSnapshotFilesListsOnlyWhatIsUnderThePath(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, dataDir := backUpForFileListing(t, &out)
-
-	require.NoError(t, v.ListSnapshotFiles(id, filepath.Join(dataDir, "sub"), false))
-
-	text := out.String()
-	assert.Contains(t, text, filepath.Join(dataDir, "sub", "b.bin"))
-	assert.Contains(t, text, filepath.Join(dataDir, "sub", "c.bin"))
-	assert.NotContains(t, text, filepath.Join(dataDir, "small.txt"))
-	assert.True(t, strings.HasPrefix(text, "MODE"), "the table must have a header")
-}
-
-// TestSnapshotFilesTableEscapesAnUnprintablePath checks that the table
-// prints a path holding a newline and an escape sequence quoted and
-// escaped on one row: the newline must not start a forged row, and the
-// escape sequence must not reach the terminal.
-func TestSnapshotFilesTableEscapesAnUnprintablePath(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, dataDir := backUpForFileListing(t, &out)
-
-	require.NoError(t, v.ListSnapshotFiles(id, "", false))
-
-	text := out.String()
-	assert.Contains(t, text,
-		strconv.Quote(filepath.Join(dataDir, unprintableFileName)))
-	assert.NotContains(t, text, "\x1b", "no escape byte may reach the output")
-
-	for line := range strings.SplitSeq(text, "\n") {
-		assert.False(t, strings.HasPrefix(line, "name"),
-			"the newline in the name must not start a row: %q", line)
-	}
-}
-
-// TestSnapshotFilesQuietSuppressesTableNotJSON is the --quiet contract
-// for `snapshot files`: the table is silenced, but the --json document a
-// script depends on is still written.
-func TestSnapshotFilesQuietSuppressesTableNotJSON(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, _ := backUpForFileListing(t, &out)
-	v.UI.SetQuiet(true)
-
-	require.NoError(t, v.ListSnapshotFiles(id, "", false))
-	require.Empty(t, out.String(), "the table must be silenced under --quiet")
-
-	require.NoError(t, v.ListSnapshotFiles(id, "", true))
-
-	var entries []vaultik.ListedFile
-
-	require.NoError(t, json.Unmarshal(out.Bytes(), &entries))
-	assert.NotEmpty(t, entries,
-		"the --json document must still be written under --quiet")
-}
-
-func TestSnapshotFilesFailsOnAPathThatMatchesNothing(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, dataDir := backUpForFileListing(t, &out)
-	missing := filepath.Join(dataDir, "typo.txt")
-
-	err := v.ListSnapshotFiles(id, missing, false)
-
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), missing, "the error must name the path")
-	assert.Empty(t, out.String(), "nothing must be printed")
-}
-
-func TestSnapshotFilesRequiresThePrivateKey(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	var out bytes.Buffer
-
-	v, id, _ := backUpForFileListing(t, &out)
-	v.Config.AgeSecretKey = ""
-
-	err := v.ListSnapshotFiles(id, "", false)
-
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "VAULTIK_AGE_SECRET_KEY")
-}

internal/vaultik/snapshot_identifier.go

@@ -28,9 +28,8 @@ var (
 // Two forms are accepted, matching the two things a host can know:
 //
 //   - A human snapshot ID (hostname_name_timestamp), which a host holding
-//     the local index has. It is hashed to its remote key. An ID that
+//     the local index has. It is hashed to its remote key; the store is
-//     names no snapshot in the local index or on the destination store
+//     not consulted.
-//     is an error (see checkSnapshotExists).
 //   - A remote key, or the leading part of one, which is all a host with
 //     no local index can know — it is exactly what `snapshot list` prints
 //     for a remote-only snapshot (see formatRemoteOnlyID). It is resolved
@@ -42,11 +41,6 @@ var (
 // RFC3339 timestamp).
 func (v *Vaultik) resolveSnapshotRemoteKey(identifier string) (string, error) {
 	if !isRemoteKeyOrPrefix(identifier) {
-		_, err := v.checkSnapshotExists(identifier, false)
-		if err != nil {
-			return "", err
-		}
-
 		return snapshot.RemoteSnapshotKey(identifier), nil
 	}
 

internal/vaultik/snapshot_list.go

@@ -39,8 +39,7 @@ const maxRemoteOnlyRows = 1000
 // manifest reads need throttling.
 const remoteManifestFetchConcurrency = 8
 
-// tabPadding is the tabwriter cell padding for the `snapshot list` and
+// tabPadding is the tabwriter cell padding for the snapshot table.
-// `snapshot files` tables.
 const tabPadding = 3
 
 // ListSnapshots prints the table of snapshots known to this host: the

internal/vaultik/storage_bind.go

@@ -13,30 +13,35 @@ import (
 var errStorageBindingMismatch = errors.New(
 	"local index is bound to a different backup destination")
 
-// checkStorageBinding refuses when the local index database is bound to
+// EnsureStorageBinding guarantees that the local index database is
-// a different destination than the configured one, with an error that
+// bound to the currently-configured storage destination. Every mutating
-// tells the user how to recover (revert the config, or run `vaultik
+// command must call this before touching either the local index or the
-// database delete`). Every mutating command calls it before touching
+// destination store, because the two live in lockstep: the local index
-// either the local index or the destination store, because the two live
+// records which chunks/blobs already exist at the destination, and
-// in lockstep: the local index records which chunks/blobs already exist
+// mismatched destination + local index produces silent corruption (the
-// at the destination, and a mismatched pair produces silent corruption
+// scanner sees "known" chunks and skips uploads, then writes snapshots
-// (the scanner sees "known" chunks and skips uploads, then writes
+// whose manifests reference blobs that aren't on the new destination).
-// snapshots whose manifests reference blobs that aren't on the new
-// destination).
 //
-// It records nothing. Only a backup binds the local index, through
+// Behaviour:
-// EnsureStorageBinding, and it does so before adding anything to it. An
+//   - On first use (empty stored value), record the configured
-// unbound local index therefore holds nothing from any destination.
+//     destination (storage_url, or the s3.* endpoint, bucket and
+//     prefix) and log the binding.
+//   - When the stored value matches the configured destination, do
+//     nothing and return nil.
+//   - When the two differ, refuse with an error that tells the user
+//     how to recover (revert the config, or run `vaultik database
+//     delete` to discard the local index and rebuild against the new
+//     destination on the next backup).
 //
 // Read-only inspection commands (remote info, snapshot list, etc.)
 // deliberately don't call this: they can be run against a bare
 // destination store without any binding state.
-func (v *Vaultik) checkStorageBinding() error {
+func (v *Vaultik) EnsureStorageBinding() error {
 	if v.Repositories == nil || v.Config == nil {
 		// NewForTesting builds a Vaultik with no DB or config;
-		// there's no binding to check. Callers exercising the bind
+		// there's nothing to bind and no binding to check. Callers
-		// path use a real DB and populate Config explicitly (see
+		// exercising the bind path use a real DB and populate Config
-		// storage_bind_test.go).
+		// explicitly (see storage_bind_test.go).
 		return nil
 	}
 
@@ -45,24 +50,6 @@ func (v *Vaultik) checkStorageBinding() error {
 		return err
 	}
 
-	if stored == "" || stored == configured {
-		return nil
-	}
-
-	return fmt.Errorf("%w\n%s",
-		errStorageBindingMismatch, buildBindingMismatchMessage(stored, configured))
-}
-
-// EnsureStorageBinding records the configured destination (storage_url,
-// or the s3.* endpoint, bucket and prefix) as the binding of an unbound
-// local index. It refuses as checkStorageBinding does when the local
-// index is bound to a different destination.
-func (v *Vaultik) EnsureStorageBinding() error {
-	stored, configured, err := v.storageBinding()
-	if err != nil {
-		return err
-	}
-
 	if stored == "" {
 		err = v.Repositories.LocalMeta.Set(
 			v.ctx, database.LocalMetaKeyStorageURL, configured)
@@ -75,12 +62,12 @@ func (v *Vaultik) EnsureStorageBinding() error {
 		return nil
 	}
 
-	if stored != configured {
+	if stored == configured {
-		return fmt.Errorf("%w\n%s",
+		return nil
-			errStorageBindingMismatch, buildBindingMismatchMessage(stored, configured))
 	}
 
-	return nil
+	return fmt.Errorf("%w\n%s",
+		errStorageBindingMismatch, buildBindingMismatchMessage(stored, configured))
 }
 
 // storageBinding returns the destination the local index is bound to

internal/vaultik/storage_bind_test.go

@@ -2,7 +2,6 @@ package vaultik_test
 
 import (
 	"context"
-	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,126 +9,9 @@ import (
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/storage"
-	"sneak.berlin/go/vaultik/internal/storage/faultstore"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 
-// storageBindingOf returns the destination the local index is bound to,
-// or "" when it is not bound.
-func storageBindingOf(
-	ctx context.Context, t *testing.T, repos *database.Repositories,
-) string {
-	t.Helper()
-
-	got, err := repos.LocalMeta.Get(ctx, database.LocalMetaKeyStorageURL)
-	require.NoError(t, err)
-
-	return got
-}
-
-// TestFailedFirstBackupLeavesIndexUnbound checks that a first backup
-// the destination refuses, as a mistyped bucket would, leaves the local
-// index unbound, so a backup with the corrected destination succeeds.
-func TestFailedFirstBackupLeavesIndexUnbound(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	ctx := context.Background()
-	storeDir := t.TempDir()
-	v, repos := newFileDestinationVaultik(ctx, t, storeDir)
-	working := v.Storage
-
-	refusing := faultstore.New(working)
-	refusing.OnPut = func(string) faultstore.PutAction { return faultstore.PutFail }
-	refusing.OnStat = func(string) bool { return true }
-	v.Storage = refusing
-	v.Config.StorageURL = "file://" + filepath.Join(t.TempDir(), "typo")
-
-	require.ErrorIs(t, backUp(v, "first"), faultstore.ErrInjectedUpload)
-	assert.Empty(t, storageBindingOf(ctx, t, repos))
-
-	v.Storage = working
-	v.Config.StorageURL = "file://" + storeDir
-
-	require.NoError(t, backUp(v, "first"))
-	assert.Equal(t, "file://"+storeDir, storageBindingOf(ctx, t, repos))
-}
-
-// TestBackupToOtherDestinationWritesNoMarker checks that a backup
-// refuses a local index bound to a different destination before it
-// writes the marker to the configured one.
-func TestBackupToOtherDestinationWritesNoMarker(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	ctx := context.Background()
-	firstDir := t.TempDir()
-	v, _ := newFileDestinationVaultik(ctx, t, firstDir)
-	v.Config.StorageURL = "file://" + firstDir
-
-	require.NoError(t, backUp(v, "first"))
-
-	secondDir := t.TempDir()
-	secondStore, err := storage.NewFileStorer(secondDir)
-	require.NoError(t, err)
-
-	v.Storage = secondStore
-	v.Config.StorageURL = "file://" + secondDir
-
-	require.ErrorContains(t, backUp(v, "first"),
-		"local index is bound to a different backup destination")
-	assert.NoFileExists(t, filepath.Join(secondDir, markerFile))
-}
-
-// TestCommandsOtherThanBackupLeaveIndexUnbound checks that commands
-// other than a backup do not bind an unbound local index, whether or not
-// they fail. Each runs on a fresh local index.
-func TestCommandsOtherThanBackupLeaveIndexUnbound(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		run  func(v *vaultik.Vaultik) error
-	}{
-		{"prune", func(v *vaultik.Vaultik) error {
-			return v.Prune(&vaultik.PruneOptions{Force: true})
-		}},
-		{"snapshot purge", func(v *vaultik.Vaultik) error {
-			return v.PurgeSnapshotsWithOptions(
-				&vaultik.SnapshotPurgeOptions{KeepLatest: true, Force: true})
-		}},
-		{"snapshot remove", func(v *vaultik.Vaultik) error {
-			_, err := v.RemoveSnapshot("host_first_2026-01-02T03:04:05Z",
-				&vaultik.RemoveOptions{Force: true})
-
-			return err
-		}},
-		{"snapshot remove --all", func(v *vaultik.Vaultik) error {
-			_, err := v.RemoveAllSnapshots(&vaultik.RemoveOptions{Force: true})
-
-			return err
-		}},
-		{"remote nuke", func(v *vaultik.Vaultik) error {
-			return v.NukeRemote(true)
-		}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			ctx := context.Background()
-			v, repos := newFileDestinationVaultik(ctx, t, t.TempDir())
-
-			_ = tt.run(v)
-
-			assert.Empty(t, storageBindingOf(ctx, t, repos))
-		})
-	}
-}
-
 // buildBindTestVaultik returns a minimal Vaultik wired with a real
 // in-memory DB and a config carrying the given StorageURL. Enough to
 // exercise EnsureStorageBinding without spinning up storage or fx.

internal/vaultik/unknown_snapshot_test.go

@@ -1,62 +0,0 @@
-package vaultik_test
-
-import (
-	"bytes"
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/config"
-	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// TestUnknownSnapshotID checks that restore and verify, given an ID that
-// names no snapshot in the local index or on the destination store, say
-// so in the words `snapshot remove` uses and print nothing else.
-func TestUnknownSnapshotID(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	const unknownID = "host1_home_2026-01-01T00:00:00Z"
-
-	commands := map[string]func(v *vaultik.Vaultik) error{
-		"restore": func(v *vaultik.Vaultik) error {
-			return v.Restore(&vaultik.RestoreOptions{
-				SnapshotID: unknownID,
-				TargetDir:  t.TempDir(),
-			})
-		},
-		"verify": func(v *vaultik.Vaultik) error {
-			return v.VerifySnapshotWithOptions(unknownID, &vaultik.VerifyOptions{})
-		},
-		"verify --deep": func(v *vaultik.Vaultik) error {
-			return v.VerifySnapshotWithOptions(unknownID,
-				&vaultik.VerifyOptions{Deep: true})
-		},
-	}
-
-	for name, run := range commands {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			store := newTestStorer()
-			addManifest(t, store, "snapshot-001", nil)
-
-			// A backup wrote to this destination, so it carries the marker.
-			require.NoError(t, store.Put(context.Background(), markerFile,
-				bytes.NewReader(nil)))
-
-			tv := vaultik.NewForTesting(store)
-			tv.Config = &config.Config{AgeSecretKey: testAgeSecretKey}
-			tv.Repositories = newLocalIndex(t, "snapshot-001")
-
-			err := run(tv.Vaultik)
-
-			require.EqualError(t, err, "snapshot not found in the local "+
-				"index or on the destination store: "+unknownID)
-			assert.Empty(t, tv.Stdout.String())
-		})
-	}
-}

internal/vaultik/verify.go

@@ -120,17 +120,12 @@ func (v *Vaultik) RunDeepVerify(snapshotID string, opts *VerifyOptions) error {
 
 	log.Info("Starting snapshot verification", "snapshot_id", snapshotID, "mode", "deep")
 
-	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
-	if err != nil {
-		return v.deepVerifyFailure(result, opts, err.Error(), err)
-	}
-
 	if !opts.JSON && !v.UI.Quiet() {
 		v.stdoutf("Deep verification of snapshot: %s\n\n", snapshotID)
 	}
 
 	manifest, tempDB, dbBlobs, err := v.loadVerificationData(
-		snapshotID, remoteKey, opts, result, identities)
+		snapshotID, opts, result, identities)
 	if err != nil {
 		return err
 	}
@@ -175,13 +170,21 @@ func (v *Vaultik) RunDeepVerify(snapshotID string, opts *VerifyOptions) error {
 	return nil
 }
 
-// loadVerificationData downloads manifest, database, and blob list for
+// loadVerificationData downloads manifest, database, and blob list for verification
-// verification of the snapshot at remoteKey, which
-// resolveSnapshotRemoteKey returned for snapshotID.
 func (v *Vaultik) loadVerificationData(
-	snapshotID, remoteKey string, opts *VerifyOptions, result *VerifyResult,
+	snapshotID string, opts *VerifyOptions, result *VerifyResult,
 	identities []age.Identity,
 ) (*snapshot.Manifest, *tempDB, []snapshot.BlobInfo, error) {
+	// Resolve the identifier to the snapshot's remote key. A human ID is
+	// hashed; a remote key (or its abbreviation, as printed for a
+	// remote-only snapshot) is used as-is, so a host with no local index
+	// can verify a snapshot it can only see on the store.
+	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
+	if err != nil {
+		return nil, nil, nil, v.deepVerifyFailure(result, opts,
+			fmt.Sprintf("resolving snapshot identifier: %v", err), err)
+	}
+
 	// Download manifest. downloadManifestByKey is the single reader for
 	// remote manifests; see its doc comment.
 	log.Info("Downloading manifest", "remote_key", remoteKey)
@@ -264,10 +267,6 @@ func (v *Vaultik) downloadVerifiedSnapshotDB(
 	defer func() { _ = dbReader.Close() }()
 
 	tdb, err := v.decryptAndLoadDatabase(dbReader, identities)
-	if errors.Is(err, errWrongPrivateKey) {
-		return nil, v.deepVerifyFailure(result, opts, err.Error(), err)
-	}
-
 	if err != nil {
 		return nil, v.deepVerifyFailure(result, opts,
 			fmt.Sprintf("failed to decrypt database: %v", err),
@@ -352,9 +351,9 @@ func (v *Vaultik) decryptAndLoadDatabase(
 	reader io.ReadCloser, identities []age.Identity,
 ) (*tempDB, error) {
 	// Decrypt and decompress through the shared blobgen reader.
-	blobReader, err := v.newSnapshotDBReader(reader, identities)
+	blobReader, err := blobgen.NewReader(reader, identities...)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create decryption reader: %w", err)
 	}
 
 	defer func() { _ = blobReader.Close() }()
@@ -427,11 +426,7 @@ func (v *Vaultik) verifyBlob(
 	// the plaintext as it is read. A blob's hash — its remote name — is the
 	// double SHA-256 of that plaintext (see blobgen.DoubleSHA256), not of the
 	// encrypted bytes.
-	blobReader, err := v.newBlobReader(reader, identities)
+	blobReader, err := blobgen.NewReader(reader, identities...)
-	if errors.Is(err, errWrongPrivateKeyForBlob) {
-		return err
-	}
-
 	if err != nil {
 		return fmt.Errorf("failed to create blob reader: %w", err)
 	}