vaultik/internal/cli/restore.go

package cli

import (
	"context"
	"fmt"

	"git.eeqj.de/sneak/vaultik/internal/config"
	"git.eeqj.de/sneak/vaultik/internal/database"
	"git.eeqj.de/sneak/vaultik/internal/globals"
	"git.eeqj.de/sneak/vaultik/internal/log"
	"git.eeqj.de/sneak/vaultik/internal/storage"
	"github.com/spf13/cobra"
	"go.uber.org/fx"
)

// RestoreOptions contains options for the restore command
type RestoreOptions struct {
	TargetDir string
}

// RestoreApp contains all dependencies needed for restore
type RestoreApp struct {
	Globals      *globals.Globals
	Config       *config.Config
	Repositories *database.Repositories
	Storage      storage.Storer
	DB           *database.DB
	Shutdowner   fx.Shutdowner
}

// NewRestoreCommand creates the restore command
func NewRestoreCommand() *cobra.Command {
	opts := &RestoreOptions{}

	cmd := &cobra.Command{
		Use:   "restore <snapshot-id> <target-dir>",
		Short: "Restore files from backup",
		Long: `Download and decrypt files from a backup snapshot.

This command will restore all files from the specified snapshot to the target directory.
The age_secret_key must be configured in the config file for decryption.`,
		Args: cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			snapshotID := args[0]
			opts.TargetDir = args[1]

			// Use unified config resolution
			configPath, err := ResolveConfigPath()
			if err != nil {
				return err
			}

			// Use the app framework like other commands
			rootFlags := GetRootFlags()
			return RunWithApp(cmd.Context(), AppOptions{
				ConfigPath: configPath,
				LogOptions: log.LogOptions{
					Verbose: rootFlags.Verbose,
					Debug:   rootFlags.Debug,
				},
				Modules: []fx.Option{
					fx.Provide(fx.Annotate(
						func(g *globals.Globals, cfg *config.Config, repos *database.Repositories,
							storer storage.Storer, db *database.DB, shutdowner fx.Shutdowner) *RestoreApp {
							return &RestoreApp{
								Globals:      g,
								Config:       cfg,
								Repositories: repos,
								Storage:      storer,
								DB:           db,
								Shutdowner:   shutdowner,
							}
						},
					)),
				},
				Invokes: []fx.Option{
					fx.Invoke(func(app *RestoreApp, lc fx.Lifecycle) {
						lc.Append(fx.Hook{
							OnStart: func(ctx context.Context) error {
								// Start the restore operation in a goroutine
								go func() {
									// Run the restore operation
									if err := app.runRestore(ctx, snapshotID, opts); err != nil {
										if err != context.Canceled {
											log.Error("Restore operation failed", "error", err)
										}
									}

									// Shutdown the app when restore completes
									if err := app.Shutdowner.Shutdown(); err != nil {
										log.Error("Failed to shutdown", "error", err)
									}
								}()
								return nil
							},
							OnStop: func(ctx context.Context) error {
								log.Debug("Stopping restore operation")
								return nil
							},
						})
					}),
				},
			})
		},
	}

	return cmd
}

// runRestore executes the restore operation
func (app *RestoreApp) runRestore(ctx context.Context, snapshotID string, opts *RestoreOptions) error {
	// Check for age_secret_key
	if app.Config.AgeSecretKey == "" {
		return fmt.Errorf("age_secret_key required for restore - set in config file or VAULTIK_AGE_SECRET_KEY environment variable")
	}

	log.Info("Starting restore operation",
		"snapshot_id", snapshotID,
		"target_dir", opts.TargetDir,
		"bucket", app.Config.S3.Bucket,
		"prefix", app.Config.S3.Prefix,
	)

	// TODO: Implement restore logic
	// 1. Download and decrypt database from S3
	// 2. Download and decrypt blobs
	// 3. Reconstruct files from chunks
	// 4. Write files to target directory with proper metadata

	fmt.Printf("Restoring snapshot %s to %s\n", snapshotID, opts.TargetDir)
	fmt.Println("TODO: Implement restore logic")

	return nil
}