Fix missing-key errors for restore and deep verify to name both key sources (closes #401)

The missing-key error for restore and deep verify is one value, errDecryptionKeyRequired, whose text names both places the key can be set: the VAULTIK_AGE_SECRET_KEY environment variable first, then the age_secret_key config file field.

Model: deepseek-v4-pro

README.md

@@ -446,9 +446,6 @@ once the store is reachable to remove the snapshot's metadata from it
 (`vaultik prune` does not). For a snapshot that is only on the
 destination store, that failure is an error. To wipe everything on the
 destination in one go, use `vaultik remote nuke --force`.
-* Accepts a snapshot ID, or — for a snapshot only on the destination
-  store — its remote key (or an unambiguous leading part of it) as shown
-  by `snapshot list`.
 * `--local-only`: Skip remote cleanup; only touch the local index
 * `--dry-run`: Show what would be deleted without deleting
 * `--force`: Skip confirmation prompt

internal/cli/snapshot.go

@@ -288,10 +288,6 @@ know about), which is what 'vaultik prune' does. The command prints the
 'vaultik prune' invocation to run as a follow-up only when it removed the
 snapshot's metadata from the destination store, and never under --json.
 
-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).
-
 An ID that names no snapshot in the local index or on the destination
 store is an error.
 

internal/vaultik/remove_snapshot_test.go

@@ -451,100 +451,6 @@ func TestRemoveSnapshot_NotInLocalIndex(t *testing.T) {
 	assert.Contains(t, out, "Removed snapshot metadata from remote storage")
 }
 
-// TestRemoveSnapshot_RemoteOnlyByRemoteKey checks that a snapshot only
-// on the destination store, on a host with no local index, is removed by
-// the remote key that 'snapshot list' prints for such a snapshot, and by
-// an unambiguous leading part of it — the same identifiers verify and
-// restore accept. Snapshot remove used to hash the argument again, so
-// the hashed key never matched and only the plain snapshot ID worked.
-func TestRemoveSnapshot_RemoteOnlyByRemoteKey(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	remoteKey := snapshot.RemoteSnapshotKey("snapshot-001")
-
-	identifiers := map[string]string{
-		"full key":     remoteKey,
-		"leading part": remoteKey[:8],
-	}
-
-	for name, identifier := range identifiers {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			store := newTestStorer()
-			addManifest(t, store, "snapshot-001", nil)
-
-			// No local index: a host that sees the snapshot only remotely.
-			tv := vaultik.NewForTesting(store)
-			tv.Repositories = newLocalIndex(t)
-
-			result, err := tv.RemoveSnapshot(identifier,
-				&vaultik.RemoveOptions{Force: true})
-
-			require.NoError(t, err)
-			assert.True(t, result.RemoteRemoved)
-			assert.False(t, store.hasKey(remoteKeyPath("snapshot-001")))
-
-			out := tv.Stdout.String()
-			assert.NotContains(t, out, "from local database")
-			assert.Contains(t, out, "Removed snapshot metadata from remote storage")
-		})
-	}
-}
-
-// TestRemoveSnapshot_LocalIndexByRemoteKey checks that a remote key (or
-// its unambiguous leading part) that names a snapshot the local index
-// holds removes that snapshot's local row and its remote metadata
-// together. `snapshot list --json` prints a remote key for every
-// snapshot, including local ones.
-func TestRemoveSnapshot_LocalIndexByRemoteKey(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	remoteKey := snapshot.RemoteSnapshotKey("snapshot-001")
-
-	identifiers := map[string]string{
-		"full key":     remoteKey,
-		"leading part": remoteKey[:8],
-	}
-
-	for name, identifier := range identifiers {
-		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, and the local index holds the snapshot.
-			require.NoError(t, store.Put(context.Background(), markerFile,
-				bytes.NewReader(nil)))
-
-			tv := vaultik.NewForTesting(store)
-			repos := newLocalIndex(t, "snapshot-001")
-			tv.Repositories = repos
-
-			result, err := tv.RemoveSnapshot(identifier,
-				&vaultik.RemoveOptions{Force: true})
-
-			require.NoError(t, err)
-			assert.True(t, result.RemoteRemoved)
-			assert.False(t, store.hasKey(remoteKeyPath("snapshot-001")))
-
-			row, err := repos.Snapshots.GetByID(
-				context.Background(), "snapshot-001")
-			require.NoError(t, err)
-			assert.Nil(t, row)
-
-			out := tv.Stdout.String()
-			assert.Contains(t, out,
-				"Removed snapshot 'snapshot-001' from local database")
-			assert.Contains(t, out, "Removed snapshot metadata from remote storage")
-		})
-	}
-}
-
 // TestRemoveSnapshot_NotInLocalIndexDeleteFails checks that removing a
 // snapshot only the destination store holds fails when its metadata
 // cannot be deleted there, under --force and under --json: nothing was

internal/vaultik/restore.go

@@ -31,10 +31,9 @@ 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" +
+		"age secret key is missing; set it in the " +
-			"Set the VAULTIK_AGE_SECRET_KEY environment variable to your " +
+			"VAULTIK_AGE_SECRET_KEY environment variable or the " +
-			"age private key file:\n" +
+			"age_secret_key config file field")
-			"  export VAULTIK_AGE_SECRET_KEY=\"$(cat vaultik_backup_private_key.txt)\"")
 	// errInvalidAgeSecretKey is returned when the configured key does not
 	// parse as any age identity. It names the source but never the value,
 	// which is secret, so the message is safe to print and log.

internal/vaultik/restore_identity_test.go

@@ -106,3 +106,23 @@ func TestRestoreIdentitiesMissingKey(t *testing.T) {
 	_, err := v.restoreIdentities()
 	require.ErrorIs(t, err, errDecryptionKeyRequired)
 }
+
+// TestMissingKeyErrorsNameBothSources asserts restore and deep verify
+// return the same missing-key error, whose text names both places the key
+// can be set: the VAULTIK_AGE_SECRET_KEY environment variable first since
+// it is preferred, then the age_secret_key config file field.
+func TestMissingKeyErrorsNameBothSources(t *testing.T) {
+	t.Parallel()
+
+	const want = "age secret key is missing; set it in " +
+		"the VAULTIK_AGE_SECRET_KEY environment variable or the " +
+		"age_secret_key config file field"
+
+	v := &Vaultik{Config: &config.Config{}}
+
+	_, err := v.restoreIdentities()
+	require.Equal(t, want, err.Error())
+
+	err = v.RunDeepVerify("any-snapshot", &VerifyOptions{})
+	require.Equal(t, want, err.Error())
+}

internal/vaultik/snapshot.go

@@ -1480,7 +1480,7 @@ func (v *Vaultik) RemoveSnapshot(
 		return result, err
 	}
 
-	inLocalIndex, localID, remoteKey, err := v.findSnapshotToRemove(snapshotID, opts)
+	inLocalIndex, err := v.findSnapshotToRemove(snapshotID, opts)
 	if err != nil {
 		return result, err
 	}
@@ -1502,16 +1502,16 @@ func (v *Vaultik) RemoveSnapshot(
 	}
 
 	if inLocalIndex {
-		log.Info("Removing snapshot from local database", "snapshot_id", localID)
+		log.Info("Removing snapshot from local database", "snapshot_id", snapshotID)
 
-		err = v.deleteSnapshotFromLocalDB(localID)
+		err = v.deleteSnapshotFromLocalDB(snapshotID)
 		if err != nil {
 			return result, fmt.Errorf("removing from local database: %w", err)
 		}
 	}
 
 	result.RemoteRemoved, err = v.removeSnapshotRemote(
-		snapshotID, remoteKey, inLocalIndex, markerErr, opts)
+		snapshotID, inLocalIndex, markerErr, opts)
 	if err != nil {
 		return result, err
 	}
@@ -1530,7 +1530,7 @@ func (v *Vaultik) RemoveSnapshot(
 
 	if inLocalIndex {
 		v.UI.Infof("Removed snapshot '%s' from local database.",
-			v.UI.Snapshot(localID))
+			v.UI.Snapshot(snapshotID))
 	}
 
 	if result.RemoteRemoved {
@@ -1543,68 +1543,50 @@ func (v *Vaultik) RemoveSnapshot(
 	return result, nil
 }
 
-// findSnapshotToRemove resolves snapshotID, the identifier remove was
+// findSnapshotToRemove reports whether the local index has a row for
-// given, and returns whether the local index holds that snapshot, the
+// snapshotID, and returns errSnapshotNotFound when there is nothing to
-// human ID of its row when it does, and the remote key to strip from
+// remove: no row and, unless LocalOnly is set, no metadata on the
-// the destination store. A human ID is looked up in the local index
+// destination store either. The destination store is consulted only
-// literally and hashed without consulting the store; a remote key, or
+// when the local index has no row, so a snapshot in the local index can
-// an unambiguous leading part of one, is resolved against the store's
+// still be removed from it while the destination store is unreachable,
-// metadata listing the way verify and restore do, and then matched back
+// and only after checkDestinationMarker passes, so an unplugged volume's
-// to the local row whose hashed ID equals it, so removing by such a key
+// empty mount point is not taken for a store without the snapshot.
-// removes the local row too. The destination store is consulted only
-// after checkDestinationMarker, so an unplugged volume's empty mount
-// point is not taken for a store without the snapshot. The identifier
-// naming nothing, on the local index or, unless LocalOnly is set, on
-// the store, is errSnapshotNotFound; a remote-key form that matches
-// nothing or more than one directory surfaces
-// resolveSnapshotRemoteKey's errSnapshotKeyNotFound or
-// errSnapshotKeyAmbiguous.
 func (v *Vaultik) findSnapshotToRemove(
 	snapshotID string, opts *RemoveOptions,
-) (bool, string, string, error) {
+) (bool, error) {
 	if v.Repositories != nil {
 		snap, err := v.Repositories.Snapshots.GetByID(v.ctx, snapshotID)
 		if err != nil {
-			return false, "", "", fmt.Errorf("looking up snapshot in local index: %w", err)
+			return false, fmt.Errorf("looking up snapshot in local index: %w", err)
 		}
 
 		if snap != nil {
-			return true, snapshotID, snapshot.RemoteSnapshotKey(snapshotID), nil
+			return true, nil
 		}
 	}
 
 	if opts.LocalOnly {
-		return false, "", "", fmt.Errorf("%w in the local index: %s",
+		return false, fmt.Errorf("%w in the local index: %s",
 			errSnapshotNotFound, snapshotID)
 	}
 
 	err := v.checkDestinationMarker()
 	if err != nil {
-		return false, "", "", err
+		return false, err
 	}
 
-	remoteKey, err := v.resolveSnapshotRemoteKey(snapshotID)
+	objects, err := v.remoteSnapshotObjects(snapshot.RemoteSnapshotKey(snapshotID))
 	if err != nil {
-		return false, "", "", err
+		return false, fmt.Errorf("looking up snapshot on destination store: %w", err)
-	}
-
-	objects, err := v.remoteSnapshotObjects(remoteKey)
-	if err != nil {
-		return false, "", "", fmt.Errorf("looking up snapshot on destination store: %w", err)
 	}
 
 	if len(objects) == 0 {
-		return false, "", "", fmt.Errorf(
+		return false, fmt.Errorf(
 			"%w in the local index or on the destination store: %s",
 			errSnapshotNotFound, snapshotID)
 	}
 
-	localID, err := v.localSnapshotIDForRemoteKey(remoteKey)
+	return false, nil
-	if err != nil {
-		return false, "", "", err
-	}
-
-	return localID != "", localID, remoteKey, nil
 }
 
 // removeSnapshotDryRun reports what RemoveSnapshot would do without
@@ -1667,20 +1649,19 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions)
 }
 
 // removeSnapshotRemote strips the snapshot's metadata from the
-// destination store. remoteKey is the resolved metadata directory name
+// destination store. It returns true only when the delete finished
-// to delete, as returned by findSnapshotToRemove. It returns true only
+// without an error and removed at least one object; under LocalOnly it
-// when the delete finished without an error and removed at least one
+// does nothing. markerErr is the result of checkDestinationMarker; when
-// object; under LocalOnly it does nothing. markerErr is the result of
+// it is set, nothing is deleted and it is the failure. When the snapshot
-// checkDestinationMarker; when it is set, nothing is deleted and it is
+// is only on the destination store, a failure is returned as an error,
-// the failure. When the snapshot is only on the destination store, a
+// because that removal is all the command does. When the snapshot was in
-// failure is returned as an error, because that removal is all the
+// the local index, its removal there has already happened, so a failure
-// command does. When the snapshot was in the local index, its removal
+// is only a warning telling the user to run `vaultik snapshot remove`
-// there has already happened, so a failure is only a warning telling
+// for the snapshot again once the destination store is reachable
-// the user to run `vaultik snapshot remove` for the snapshot again once
+// (`vaultik prune` never removes snapshot metadata that has its
-// the destination store is reachable (`vaultik prune` never removes
+// manifest).
-// snapshot metadata that has its manifest).
 func (v *Vaultik) removeSnapshotRemote(
-	snapshotID, remoteKey string, inLocalIndex bool, markerErr error,
+	snapshotID string, inLocalIndex bool, markerErr error,
 	opts *RemoveOptions,
 ) (bool, error) {
 	if opts.LocalOnly {
@@ -1694,7 +1675,8 @@ func (v *Vaultik) removeSnapshotRemote(
 
 	err := markerErr
 	if err == nil {
-		deleted, err = v.deleteRemoteSnapshotByKey(remoteKey)
+		deleted, err = v.deleteRemoteSnapshotByKey(
+			snapshot.RemoteSnapshotKey(snapshotID))
 	}
 
 	if err != nil && !inLocalIndex {
@@ -1808,23 +1790,6 @@ func (v *Vaultik) localSnapshotIDs() ([]string, error) {
 	return ids, nil
 }
 
-// localSnapshotIDForRemoteKey returns the human snapshot ID of the local
-// index row whose RemoteSnapshotKey is key, or "" when no row has it.
-func (v *Vaultik) localSnapshotIDForRemoteKey(key string) (string, error) {
-	ids, err := v.localSnapshotIDs()
-	if err != nil {
-		return "", fmt.Errorf("listing local snapshots: %w", err)
-	}
-
-	for _, id := range ids {
-		if snapshot.RemoteSnapshotKey(id) == key {
-			return id, nil
-		}
-	}
-
-	return "", nil
-}
-
 // listAllRemoteSnapshotKeys collects the hashed remote keys
 // (subdirectories under metadata/) currently present in the
 // destination store. Returns (nil, err) when the store cannot be

internal/vaultik/verify.go

@@ -23,8 +23,6 @@ import (
 // Sentinel errors for snapshot verification failures.
 var (
 	errVerificationFailed  = errors.New("verification failed")
-	errSecretKeyRequired  = errors.New(
-		"VAULTIK_AGE_SECRET_KEY not set; required for deep verification")
 	errChunksOutOfOrder    = errors.New("chunks out of order")
 	errChunkHashMismatch   = errors.New("chunk hash mismatch")
 	errNegativeChunkLength = errors.New("chunk length is negative")
@@ -106,13 +104,9 @@ func (v *Vaultik) RunDeepVerify(snapshotID string, opts *VerifyOptions) error {
 		Mode:       "deep",
 	}
 
-	if !v.CanDecrypt() {
-		return v.deepVerifyFailure(result, opts,
-			errSecretKeyRequired.Error(), errSecretKeyRequired)
-	}
-
 	// Parse the age secret key once, the same way restore does, and reuse
-	// the identities for the database and every blob.
+	// the identities for the database and every blob. A missing key fails
+	// here, before anything is downloaded.
 	identities, err := v.restoreIdentities()
 	if err != nil {
 		return v.deepVerifyFailure(result, opts, err.Error(), err)