Add snapshot files to list a snapshot's files without restoring it (closes #435)

`vaultik snapshot files <snapshot-id> [path] [--json]` downloads and decrypts the snapshot database, as restore does, and prints mode, size, modification time and path for every file at or under the path. A path that matches nothing is an error. It needs the private key. The mode is in Go's file-mode notation, which the README spells out. The table quotes a path that holds a non-printable character. Named `files` because `ls` is already the alias of `snapshot list`. The missing-key error no longer says "for restore", since this command and deep verify return it too. The README opening now states the private-key rule first. Model: opus-5-5
2026-11-13 23:01:16 +01:00
1 parent 5ca0d46932
commit 1df6867cd4
@@ -160,7 +160,8 @@ 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 or deep verify removed its decrypted temporary files.
+// before restore, deep verify or `snapshot files` removed its decrypted
+// temporary files.
 type closeOnCancelReader struct {
 	io.ReadCloser

@@ -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 for restore\n\n" +
+		"decryption key required\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)\"")
@@ -153,18 +153,7 @@ func (v *Vaultik) Restore(opts *RestoreOptions) error {
 		return fmt.Errorf("downloading snapshot database: %w", err)
 	}

-	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)
-		}
-	}()
+	defer v.closeSnapshotDB(tempDB, tempDir)

 	repos := database.NewRepositories(tempDB)

@@ -325,9 +314,10 @@ 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 both restore and deep verify, so
-// a missing or unparseable key fails before anything is downloaded. The
-// error names the configuration source but never the key value.
+// recipients. This is the first step of restore, deep verify and
+// `snapshot files`, so a missing or unparseable key fails before anything
+// is downloaded. The error names the configuration source but never the
+// key value.
 func (v *Vaultik) restoreIdentities() ([]age.Identity, error) {
 	if v.Config.AgeSecretKey == "" {
 		return nil, errDecryptionKeyRequired
@@ -880,18 +870,34 @@ 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 and deep verify to a
-// different snapshot's contents. The exported per-snapshot database holds
-// exactly one snapshot row, and a snapshot's remote key is derived from
-// that row's ID, so the database is the requested one exactly when its
-// sole snapshot hashes back to remoteKey. Comparing the requested
-// identifier directly would not do: it may be a remote-key prefix a
-// recovery host uses in place of a human snapshot ID it cannot know.
+// material) would otherwise redirect restore, deep verify and
+// `snapshot files` to a different snapshot's contents. The exported
+// per-snapshot database holds exactly one snapshot row, and a snapshot's
+// remote key is derived from that row's ID, so the database is the
+// requested one exactly when its sole snapshot hashes back to remoteKey.
+// Comparing the requested identifier directly would not do: it may be a
+// remote-key prefix a recovery host uses in place of a human snapshot ID
+// it cannot know.
 func (v *Vaultik) verifySnapshotDBIdentity(
 	db *database.DB, requested, remoteKey string,
 ) error {
@@ -0,0 +1,115 @@
+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()
+}
@@ -0,0 +1,197 @@
+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")
+}
@@ -39,7 +39,8 @@ const maxRemoteOnlyRows = 1000
 // manifest reads need throttling.
 const remoteManifestFetchConcurrency = 8

-// tabPadding is the tabwriter cell padding for the snapshot table.
+// tabPadding is the tabwriter cell padding for the `snapshot list` and
+// `snapshot files` tables.
 const tabPadding = 3

 // ListSnapshots prints the table of snapshots known to this host: the