fixes (the last)

Reviewed-on: #4

.gitignore

@@ -1,4 +1,7 @@
 /cli
 /server
+/web
 /env/
 /build/
+*.exe
+/config.json

.vscode/launch.json

@@ -4,13 +4,30 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
-
         {
-            "name": "Launch Package",
+            "name": "web",
             "type": "go",
             "request": "launch",
             "mode": "auto",
-            "args": ["list", "-a", "http://localhost:8080"],
+            "args": ["-config", "${workspaceFolder}/env/config.json"],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}/cmd/web"
+        },
+        {
+            "name": "server",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "args": ["-document-root", "${workspaceFolder}/env"],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}/cmd/server"
+        },
+        {
+            "name": "cli",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "args": ["sync"],
             "console": "integratedTerminal",
             "program": "${workspaceFolder}/cmd/cli"
         }

LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Aurélie DELHAIE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,58 @@
+# CloudSave
+
+The software is still in alpha.
+
+A client/server that allows unsynchronized games (such as emulators, old games, etc.) to be kept up to date on multiple computers.
+
+## Build
+
+You need go1.24
+
+After downloading the go toolchain, just run the script `./build.sh`
+
+## Usage
+
+### Server
+
+The server needs an empty directory. After creating this directory, you need to make a file that contains your credential. The format is "username:password". The server only understand bcrypt password hash for now.
+
+e.g.:
+```
+test:$2y$10$uULsuyROe3LVdTzFoBH7HO0zhvyKp6CX2FDNl7quXMFYqzitU0kc.
+```
+
+To generate bcrypt password, I recommand [hash_utils](https://git.thelilfrog.com/thelilfrog/hash_utils), which is offline and secure
+
+The default path to this directory is `/var/lib/cloudsave`, this can be changed with the `-document-root` argument
+
+### Client
+
+#### Register a game
+
+You can register a game with the verb `add`
+```bash
+cloudsave add /home/user/gamedata
+```
+
+You can also change the name of the registration and add a remote
+```bash
+cloudsave add -name "My Game" -remote "http://localhost:8080" /home/user/gamedata
+```
+
+#### Make an archive of the current state
+
+This is a command line tool, it cannot auto detect changes.
+Run this command to start the scan, if needed, the tool will create a new archive
+
+```bash
+cloudsave scan
+```
+#### Send everything on the server
+
+This will pull and push data to the server.
+
+Note: If multiple computers are pushing to this server, a conflict may be generated. If so, the tool will ask for the version to keep
+
+```bash
+cloudsave sync
+```

build.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 
 MAKE_PACKAGE=false
+VERSION=0.0.4
 
 usage() {
  echo "Usage: $0 [OPTIONS]"
@@ -35,20 +36,44 @@ fi
 ## SERVER
 
 platforms=("linux/amd64" "linux/arm64" "linux/riscv64" "linux/ppc64le")
-CGO_ENABLED=0
 
 for platform in "${platforms[@]}"; do
     echo "* Compiling server for $platform..."
     platform_split=(${platform//\// })
 
-    GOOS=${platform_split[0]}
+    EXT=""
-    GOARCH=${platform_split[1]}
+    if [ "${platform_split[0]}" == "windows" ]; then
-
+      EXT=.exe
-    go build -o build/server_${platform_split[0]}_${platform_split[1]}.bin ./cmd/server
+    fi
 
     if [ "$MAKE_PACKAGE" == "true" ]; then
-        tar -czf build/server_${platform_split[0]}_${platform_split[1]}.tar.gz build/server_${platform_split[0]}_${platform_split[1]}.bin
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} GORISCV64=rva22u64 GOAMD64=v3 GOARM64=v8.2 go build -o build/cloudsave_server$EXT -a ./cmd/server
-        rm build/server_${platform_split[0]}_${platform_split[1]}.bin
+        tar -czf build/server_${platform_split[0]}_${platform_split[1]}.tar.gz build/cloudsave_server$EXT
+        rm build/cloudsave_server$EXT
+    else
+      CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} GORISCV64=rva22u64 GOAMD64=v3 GOARM64=v8.2 go build -o build/cloudsave_server_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/server
+    fi
+done
+
+# WEB
+
+platforms=("linux/amd64" "linux/arm64" "linux/riscv64" "linux/ppc64le")
+
+for platform in "${platforms[@]}"; do
+    echo "* Compiling web server for $platform..."
+    platform_split=(${platform//\// })
+
+    EXT=""
+    if [ "${platform_split[0]}" == "windows" ]; then
+      EXT=.exe
+    fi
+
+    if [ "$MAKE_PACKAGE" == "true" ]; then
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_web$EXT -a ./cmd/web
+        tar -czf build/web_${platform_split[0]}_${platform_split[1]}.tar.gz build/cloudsave_web$EXT
+        rm build/cloudsave_web$EXT
+    else
+      CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_web_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/web
     fi
 done
 
@@ -60,12 +85,16 @@ for platform in "${platforms[@]}"; do
     echo "* Compiling client for $platform..."
     platform_split=(${platform//\// })
 
-    GOOS=${platform_split[0]}
+    EXT=""
-    GOARCH=${platform_split[1]}
+    if [ "${platform_split[0]}" == "windows" ]; then
+      EXT=.exe
+    fi
 
-    go build -o build/cli_${platform_split[0]}_${platform_split[1]}.bin ./cmd/cli
     if [ "$MAKE_PACKAGE" == "true" ]; then
-        tar -czf build/cli_${platform_split[0]}_${platform_split[1]}.tar.gz build/cli_${platform_split[0]}_${platform_split[1]}.bin
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave$EXT -a ./cmd/cli
-        rm build/cli_${platform_split[0]}_${platform_split[1]}.bin
+        tar -czf build/cli_${platform_split[0]}_${platform_split[1]}.tar.gz build/cloudsave$EXT
+        rm build/cloudsave$EXT
+    else
+        CGO_ENABLED=0 GOOS=${platform_split[0]} GOARCH=${platform_split[1]} go build -o build/cloudsave_${platform_split[0]}_${platform_split[1]}$EXT -a ./cmd/cli
     fi
 done

cmd/cli/commands/add/add.go

@@ -1,7 +1,7 @@
 package add
 
 import (
-	"cloudsave/pkg/game"
+	"cloudsave/pkg/data"
 	"context"
 	"flag"
 	"fmt"
@@ -13,20 +13,26 @@ import (
 
 type (
 	AddCmd struct {
+		Service *data.Service
 		name    string
+		remote  string
 	}
 )
 
 func (*AddCmd) Name() string     { return "add" }
-func (*AddCmd) Synopsis() string { return "Add a folder to the sync list" }
+func (*AddCmd) Synopsis() string { return "add a folder to the sync list" }
 func (*AddCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave add [-name] [-remote] <PATH>
-  Add a folder to the sync list
+
+Add a folder to the track list
+	
+Options:
 `
 }
 
 func (p *AddCmd) SetFlags(f *flag.FlagSet) {
 	f.StringVar(&p.name, "name", "", "Override the name of the game")
+	f.StringVar(&p.remote, "remote", "", "Defines a remote server to sync with")
 }
 
 func (p *AddCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
@@ -44,13 +50,16 @@ func (p *AddCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
 		p.name = filepath.Base(path)
 	}
 
-	m, err := game.Add(p.name, path)
+	gameID, err := p.Service.Add(p.name, path, p.remote)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to add game reference:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to add this gamesave to the datastore:", err)
 		return subcommands.ExitFailure
 	}
 
-	fmt.Println(m.ID)
+	if _, err := p.Service.Scan(gameID); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to scan:", err)
+		return subcommands.ExitFailure
+	}
 
 	return subcommands.ExitSuccess
 }

cmd/cli/commands/apply/apply.go

@@ -0,0 +1,54 @@
+package apply
+
+import (
+	"cloudsave/pkg/data"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/google/subcommands"
+)
+
+type (
+	ApplyCmd struct {
+		Service *data.Service
+	}
+)
+
+func (*ApplyCmd) Name() string     { return "apply" }
+func (*ApplyCmd) Synopsis() string { return "apply a backup" }
+func (*ApplyCmd) Usage() string {
+	return `Usage: cloudsave apply <GAME_ID> [BACKUP_ID]
+
+Apply a backup
+`
+}
+
+func (p *ApplyCmd) SetFlags(f *flag.FlagSet) {
+}
+
+func (p *ApplyCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	if f.NArg() < 1 {
+		fmt.Fprintln(os.Stderr, "error: missing game ID and/or backup uuid")
+		return subcommands.ExitUsageError
+	}
+
+	gameID := f.Arg(0)
+	uuid := f.Arg(1)
+
+	if len(uuid) == 0 {
+		if err := p.Service.ApplyCurrent(gameID); err != nil {
+			fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
+			return subcommands.ExitFailure
+		}
+		return subcommands.ExitSuccess
+	}
+
+	if err := p.Service.ApplyBackup(gameID, uuid); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	return subcommands.ExitSuccess
+}

cmd/cli/commands/list/list.go

@@ -1,9 +1,9 @@
 package list
 
 import (
-	"cloudsave/pkg/game"
+	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/tools/prompt/credentials"
 	"context"
 	"flag"
 	"fmt"
@@ -14,20 +14,26 @@ import (
 
 type (
 	ListCmd struct {
+		Service *data.Service
 		remote  bool
+		backup  bool
 	}
 )
 
 func (*ListCmd) Name() string     { return "list" }
 func (*ListCmd) Synopsis() string { return "list all game registered" }
 func (*ListCmd) Usage() string {
-	return `list:
+	return `Usage: cloudsave list [-include-backup] [-a]
+
 List all game registered
+
+Options:
 `
 }
 
 func (p *ListCmd) SetFlags(f *flag.FlagSet) {
 	f.BoolVar(&p.remote, "a", false, "list all including remote data")
+	f.BoolVar(&p.backup, "include-backup", false, "include backup uuids in the output")
 }
 
 func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
@@ -39,25 +45,25 @@ func (p *ListCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 		username, password, err := credentials.Read()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "failed to read std output: %s", err)
+			fmt.Fprintf(os.Stderr, "error: failed to read std output: %s", err)
 			return subcommands.ExitFailure
 		}
 
-		if err := remote(f.Arg(0), username, password); err != nil {
+		if err := p.server(f.Arg(0), username, password, p.backup); err != nil {
 			fmt.Fprintln(os.Stderr, "error:", err)
 			return subcommands.ExitFailure
 		}
 		return subcommands.ExitSuccess
 	}
-	if err := local(); err != nil {
+	if err := p.local(p.backup); err != nil {
 		fmt.Fprintln(os.Stderr, "error:", err)
 		return subcommands.ExitFailure
 	}
 	return subcommands.ExitSuccess
 }
 
-func local() error {
+func (p *ListCmd) local(includeBackup bool) error {
-	games, err := game.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		return fmt.Errorf("failed to load datastore: %w", err)
 	}
@@ -65,14 +71,28 @@ func local() error {
 	for _, g := range games {
 		fmt.Println("ID:", g.ID)
 		fmt.Println("Name:", g.Name)
-		fmt.Println("Last Version:", g.Date, "( Version Number", g.Version, ")")
+		fmt.Println("Last Version:", g.Date)
+		fmt.Println("Version:", g.Version)
+		fmt.Println("MD5:", g.MD5)
+		if includeBackup {
+			bk, err := p.Service.AllBackups(g.ID)
+			if err != nil {
+				return fmt.Errorf("failed to list backup files: %w", err)
+			}
+			if len(bk) > 0 {
+				fmt.Println("Backup:")
+				for _, b := range bk {
+					fmt.Printf("   - %s (%s)\n", b.UUID, b.CreatedAt)
+				}
+			}
+		}
 		fmt.Println("---")
 	}
 
 	return nil
 }
 
-func remote(url, username, password string) error {
+func (p *ListCmd) server(url, username, password string, includeBackup bool) error {
 	cli := client.New(url, username, password)
 
 	if err := cli.Ping(); err != nil {
@@ -90,7 +110,25 @@ func remote(url, username, password string) error {
 	for _, g := range games {
 		fmt.Println("ID:", g.ID)
 		fmt.Println("Name:", g.Name)
-		fmt.Println("Last Version:", g.Date, "( Version Number", g.Version, ")")
+		fmt.Println("Last Version:", g.Date)
+		fmt.Println("Version:", g.Version)
+		fmt.Println("MD5:", g.MD5)
+		if includeBackup {
+			bk, err := cli.ListArchives(g.ID)
+			if err != nil {
+				return fmt.Errorf("failed to list backup files: %w", err)
+			}
+			if len(bk) > 0 {
+				fmt.Println("Backup:")
+				for _, uuid := range bk {
+					b, err := cli.ArchiveInfo(g.ID, uuid)
+					if err != nil {
+						return fmt.Errorf("failed to list backup files: %w", err)
+					}
+					fmt.Printf("   - %s (%s)\n", b.UUID, b.CreatedAt)
+				}
+			}
+		}
 		fmt.Println("---")
 	}
 

cmd/cli/commands/pull/pull.go

@@ -1,28 +1,28 @@
 package pull
 
 import (
-	"cloudsave/pkg/game"
+	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/tools/archive"
-	"cloudsave/pkg/tools/prompt/credentials"
 	"context"
 	"flag"
 	"fmt"
 	"os"
-	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 type (
 	PullCmd struct {
+		Service *data.Service
 	}
 )
 
 func (*PullCmd) Name() string     { return "pull" }
 func (*PullCmd) Synopsis() string { return "pull a game save from the remote" }
 func (*PullCmd) Usage() string {
-	return `list:
+	return `Usage: cloudsave pull <GAME_ID>
+
 Pull a game save from the remote
 `
 }
@@ -43,45 +43,33 @@ func (p *PullCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 	username, password, err := credentials.Read()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to read std output: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to read std output: %s", err)
 		return subcommands.ExitFailure
 	}
 
 	cli := client.New(url, username, password)
 
 	if err := cli.Ping(); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to connect to the remote: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to connect to the remote: %s", err)
 		return subcommands.ExitFailure
 	}
 
-	archivePath := filepath.Join(game.DatastorePath(), gameID, "data.tar.gz")
+	if err := p.Service.PullCurrent(gameID, path, cli); err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to pull current archive: %s", err)
+		return subcommands.ExitFailure
+	}
 
-	m, err := cli.Metadata(gameID)
+	ids, err := cli.ListArchives(gameID)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to get metadata: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to list backup archive: %s", err)
 		return subcommands.ExitFailure
 	}
 
-	err = game.Register(m, path)
+	for _, id := range ids {
-	if err != nil {
+		if err := p.Service.PullBackup(gameID, id, cli); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to register local metadata: %s", err)
+			fmt.Fprintf(os.Stderr, "error: failed to pull backup archive %s: %s", id, err)
 			return subcommands.ExitFailure
 		}
-
-	if err := cli.Pull(gameID, archivePath); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to pull from the remote: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	fi, err := os.OpenFile(archivePath, os.O_RDONLY, 0)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to open archive: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	if err := archive.Untar(fi, path); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to unarchive file: %s", err)
-		return subcommands.ExitFailure
 	}
 
 	return subcommands.ExitSuccess

cmd/cli/commands/remote/remote.go

@@ -1,7 +1,7 @@
 package remote
 
 import (
-	"cloudsave/pkg/game"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote"
 	"cloudsave/pkg/remote/client"
 	"context"
@@ -14,16 +14,24 @@ import (
 
 type (
 	RemoteCmd struct {
+		Service *data.Service
 		set     bool
 		list    bool
 	}
 )
 
 func (*RemoteCmd) Name() string     { return "remote" }
-func (*RemoteCmd) Synopsis() string { return "manage remote" }
+func (*RemoteCmd) Synopsis() string { return "add or update the remote url" }
 func (*RemoteCmd) Usage() string {
-	return `remote:
+	return `Usage: cloudsave remote <-set|-list>
-  manage remove
+
+The -list argument lists all remotes for each registered game.
+This command performs a connection test.
+
+The -set argument allow you to set (create or update) 
+the URL to the remote for a game
+
+Options
 `
 }
 
@@ -36,7 +44,7 @@ func (p *RemoteCmd) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface
 	switch {
 	case p.list:
 		{
-			if err := list(); err != nil {
+			if err := p.print(); err != nil {
 				fmt.Fprintln(os.Stderr, "error:", err)
 				return subcommands.ExitFailure
 			}
@@ -61,8 +69,8 @@ func (p *RemoteCmd) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface
 	return subcommands.ExitSuccess
 }
 
-func list() error {
+func (p *RemoteCmd) print() error {
-	games, err := game.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		return fmt.Errorf("failed to load datastore: %w", err)
 	}
@@ -70,7 +78,7 @@ func list() error {
 	for _, g := range games {
 		r, err := remote.One(g.ID)
 		if err != nil {
-			return fmt.Errorf("failed to load datastore: %w", err)
+			continue
 		}
 
 		cli := client.New(r.URL, "", "")

cmd/cli/commands/remove/remove.go

@@ -1,7 +1,7 @@
 package remove
 
 import (
-	"cloudsave/pkg/game"
+	"cloudsave/pkg/data"
 	"context"
 	"flag"
 	"fmt"
@@ -11,14 +11,18 @@ import (
 )
 
 type (
-	RemoveCmd struct{}
+	RemoveCmd struct {
+		Service *data.Service
+	}
 )
 
 func (*RemoveCmd) Name() string     { return "remove" }
 func (*RemoveCmd) Synopsis() string { return "unregister a game" }
 func (*RemoveCmd) Usage() string {
-	return `remove:
+	return `Usage: cloudsave remove <GAME_ID>
+
 Unregister a game
+Caution: all the backup are deleted
 `
 }
 
@@ -31,7 +35,7 @@ func (p *RemoveCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}
 		return subcommands.ExitUsageError
 	}
 
-	err := game.Remove(f.Arg(0))
+	err := p.Service.RemoveGame(f.Arg(0))
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to unregister the game:", err)
 		return subcommands.ExitFailure

cmd/cli/commands/run/run.go

@@ -1,162 +1,54 @@
 package run
 
 import (
-	"archive/tar"
+	"cloudsave/pkg/data"
-	"cloudsave/pkg/game"
-	"compress/gzip"
 	"context"
 	"flag"
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
-	"time"
 
 	"github.com/google/subcommands"
-	"github.com/schollz/progressbar/v3"
 )
 
 type (
 	RunCmd struct {
+		Service *data.Service
 	}
 )
 
-func (*RunCmd) Name() string     { return "run" }
+func (*RunCmd) Name() string     { return "scan" }
-func (*RunCmd) Synopsis() string { return "Check and process all the folder" }
+func (*RunCmd) Synopsis() string { return "check and process all the folder" }
 func (*RunCmd) Usage() string {
-	return `run:
+	return `Usage: cloudsave scan
-  Check and process all the folder
+
+Check if the files have been modified. If so,
+the current archive is moved to the backup list
+and a new archive is created with a new version number. 
 `
 }
 
 func (p *RunCmd) SetFlags(f *flag.FlagSet) {}
 
 func (p *RunCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	datastore, err := game.All()
+	datastore, err := p.Service.AllGames()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
 		return subcommands.ExitFailure
 	}
 
-	pg := progressbar.New(len(datastore))
-	defer pg.Close()
-
 	for _, metadata := range datastore {
-		pg.Describe("Scanning " + metadata.Name + "...")
+		changed, err := p.Service.Scan(metadata.ID)
-		metadataPath := filepath.Join(game.DatastorePath(), metadata.ID)
-		//todo transaction
-		err := archiveIfChanged(metadata.ID, metadata.Path, filepath.Join(metadataPath, "data.tar.gz"), filepath.Join(metadataPath, ".last_run"))
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
+			fmt.Println("❌", metadata.Name, ":", err.Error())
-			return subcommands.ExitFailure
+			continue
 		}
-		if err := game.SetVersion(metadata.ID, metadata.Version+1); err != nil {
+		if changed {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
+			fmt.Println("✅", metadata.Name, ": backed up")
-			return subcommands.ExitFailure
+		} else {
+			fmt.Println("🆗", metadata.Name, ": up to date")
 		}
-		if err := game.SetDate(metadata.ID, time.Now()); err != nil {
-			fmt.Fprintf(os.Stderr, "error: cannot process the data of %s: %s\n", metadata.ID, err)
-			return subcommands.ExitFailure
-		}
-		pg.Add(1)
 	}
 
-	pg.Finish()
+	fmt.Println("done.")
-
 	return subcommands.ExitSuccess
 }
-
-// archiveIfChanged will archive srcDir into destTarGz only if any file
-// in srcDir has a modification time > the last run time stored in stateFile.
-// After archiving, it updates stateFile to the current time.
-func archiveIfChanged(id, srcDir, destTarGz, stateFile string) error {
-	// 1) Load last run time
-	var lastRun time.Time
-	data, err := os.ReadFile(stateFile)
-	if err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("reading state file: %w", err)
-	}
-	if err == nil {
-		lastRun, err = time.Parse(time.RFC3339, string(data))
-		if err != nil {
-			return fmt.Errorf("parsing state file timestamp: %w", err)
-		}
-	}
-
-	// 2) Check for changes
-	changed := false
-	err = filepath.Walk(srcDir, func(path string, info os.FileInfo, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if info.ModTime().After(lastRun) {
-			changed = true
-			return io.EOF // early exit
-		}
-		return nil
-	})
-	if err != nil && err != io.EOF {
-		return fmt.Errorf("scanning source directory: %w", err)
-	}
-
-	if !changed {
-		return nil
-	}
-
-	// 3) Create tar.gz
-	f, err := os.Create(destTarGz)
-	if err != nil {
-		return fmt.Errorf("creating archive file: %w", err)
-	}
-	defer f.Close()
-
-	gw := gzip.NewWriter(f)
-	defer gw.Close()
-
-	tw := tar.NewWriter(gw)
-	defer tw.Close()
-
-	// Walk again to add files
-	err = filepath.Walk(srcDir, func(path string, info os.FileInfo, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		// Create tar header
-		header, err := tar.FileInfoHeader(info, path)
-		if err != nil {
-			return err
-		}
-		// Preserve directory structure relative to srcDir
-		relPath, err := filepath.Rel(filepath.Dir(srcDir), path)
-		if err != nil {
-			return err
-		}
-		header.Name = relPath
-
-		if err := tw.WriteHeader(header); err != nil {
-			return err
-		}
-		if info.Mode().IsRegular() {
-			file, err := os.Open(path)
-			if err != nil {
-				return err
-			}
-			defer file.Close()
-			if _, err := io.Copy(tw, file); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return fmt.Errorf("writing tar entries: %w", err)
-	}
-
-	// 4) Update state file
-	now := time.Now().UTC().Format(time.RFC3339)
-	if err := os.WriteFile(stateFile, []byte(now), 0644); err != nil {
-		return fmt.Errorf("updating state file: %w", err)
-	}
-
-	return nil
-}

cmd/cli/commands/show/show.go

@@ -0,0 +1,51 @@
+package show
+
+import (
+	"cloudsave/pkg/data"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/google/subcommands"
+)
+
+type (
+	ShowCmd struct {
+		Service *data.Service
+	}
+)
+
+func (*ShowCmd) Name() string     { return "show" }
+func (*ShowCmd) Synopsis() string { return "show metadata about game" }
+func (*ShowCmd) Usage() string {
+	return `Usage: cloudsave show <GAME_ID>
+
+Show metdata about a game
+`
+}
+
+func (p *ShowCmd) SetFlags(f *flag.FlagSet) {
+}
+
+func (p *ShowCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	if f.NArg() != 1 {
+		fmt.Fprintln(os.Stderr, "error: missing game ID")
+		return subcommands.ExitUsageError
+	}
+
+	gameID := f.Arg(0)
+	g, err := p.Service.One(gameID)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: failed to apply: %s", err)
+		return subcommands.ExitFailure
+	}
+
+	fmt.Println(g.Name)
+	fmt.Println("------")
+	fmt.Println("Version: ", g.Version)
+	fmt.Println("Path: ", g.Path)
+	fmt.Println("MD5: ", g.MD5)
+
+	return subcommands.ExitSuccess
+}

cmd/cli/commands/sync/sync.go

@@ -2,32 +2,35 @@ package sync
 
 import (
 	"cloudsave/cmd/cli/tools/prompt"
-	"cloudsave/pkg/game"
+	"cloudsave/cmd/cli/tools/prompt/credentials"
+	"cloudsave/pkg/data"
 	"cloudsave/pkg/remote"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/tools/prompt/credentials"
+	"cloudsave/pkg/repository"
 	"context"
 	"errors"
 	"flag"
 	"fmt"
 	"log/slog"
 	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/google/subcommands"
+	"github.com/schollz/progressbar/v3"
 )
 
 type (
 	SyncCmd struct {
+		Service *data.Service
 	}
 )
 
 func (*SyncCmd) Name() string     { return "sync" }
 func (*SyncCmd) Synopsis() string { return "list all game registered" }
 func (*SyncCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave sync
-  List all game registered
+
+Synchronize the archives with the server defined for each game.
 `
 }
 
@@ -35,7 +38,7 @@ func (p *SyncCmd) SetFlags(f *flag.FlagSet) {
 }
 
 func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	games, err := game.All()
+	games, err := p.Service.AllGames()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
 		return subcommands.ExitFailure
@@ -46,18 +49,26 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		r, err := remote.One(g.ID)
 		if err != nil {
 			if errors.Is(err, remote.ErrNoRemote) {
+				fmt.Println(g.Name + ": no remote configured")
 				continue
 			}
 			fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
 			return subcommands.ExitFailure
 		}
-
 		cli, err := connect(remoteCred, r)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "error: failed to connect to the remote:", err)
 			return subcommands.ExitFailure
 		}
 
+		pg := progressbar.New(-1)
+		destroyPg := func() {
+			pg.Finish()
+			pg.Clear()
+			pg.Close()
+		}
+
+		pg.Describe(fmt.Sprintf("[%s] Checking status...", g.Name))
 		exists, err := cli.Exists(r.GameID)
 		if err != nil {
 			slog.Error(err.Error())
@@ -65,75 +76,90 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		}
 
 		if !exists {
-			if err := push(r.GameID, g, cli); err != nil {
+			pg.Describe(fmt.Sprintf("[%s] Pushing data...", g.Name))
+			if err := p.push(g, cli); err != nil {
+				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
+			pg.Describe(fmt.Sprintf("[%s] Pushing backup...", g.Name))
+			if err := p.pushBackup(g, cli); err != nil {
+				destroyPg()
+				slog.Warn("failed to push backup files", "err", err)
+			}
+			destroyPg()
+			fmt.Println(g.Name + ": pushed")
 			continue
 		}
 
-		hlocal, err := game.Hash(r.GameID)
+		pg.Describe(fmt.Sprintf("[%s] Fetching metadata...", g.Name))
-		if err != nil {
-			slog.Error(err.Error())
-			continue
-		}
-
-		hremote, err := cli.Hash(r.GameID)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "error: failed to get the file hash from the remote:", err)
-			continue
-		}
-
-		vlocal, err := game.Version(r.GameID)
-		if err != nil {
-			slog.Error(err.Error())
-			continue
-		}
 
 		remoteMetadata, err := cli.Metadata(r.GameID)
 		if err != nil {
+			destroyPg()
 			fmt.Fprintln(os.Stderr, "error: failed to get the game metadata from the remote:", err)
 			continue
 		}
 
-		if hlocal == hremote {
+		pg.Describe(fmt.Sprintf("[%s] Pulling backup...", g.Name))
-			if vlocal != remoteMetadata.Version {
+		if err := p.pullBackup(g, cli); err != nil {
+			slog.Warn("failed to pull backup files", "err", err)
+		}
+
+		pg.Describe(fmt.Sprintf("[%s] Pushing backup...", g.Name))
+		if err := p.pushBackup(g, cli); err != nil {
+			slog.Warn("failed to push backup files", "err", err)
+		}
+
+		if g.MD5 == remoteMetadata.MD5 {
+			destroyPg()
+			if g.Version != remoteMetadata.Version {
 				slog.Debug("version is not the same, but the hash is equal. Updating local database")
-				if err := game.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
+				if err := p.Service.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
 					fmt.Fprintln(os.Stderr, "error: failed to synchronize version number:", err)
 					continue
 				}
 			}
-			fmt.Println("already up-to-date")
+			fmt.Println(g.Name + ": already up-to-date")
 			continue
 		}
 
-		if vlocal > remoteMetadata.Version {
+		if g.Version > remoteMetadata.Version {
-			if err := push(r.GameID, g, cli); err != nil {
+			pg.Describe(fmt.Sprintf("[%s] Pushing data...", g.Name))
+			if err := p.push(g, cli); err != nil {
+				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
+			destroyPg()
+			fmt.Println(g.Name + ": pushed")
 			continue
 		}
 
-		if vlocal < remoteMetadata.Version {
+		if g.Version < remoteMetadata.Version {
-			if err := pull(r.GameID, cli); err != nil {
+			destroyPg()
+			if err := p.pull(r.GameID, cli); err != nil {
+				destroyPg()
 				fmt.Fprintln(os.Stderr, "failed to push:", err)
 				return subcommands.ExitFailure
 			}
-			if err := game.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
+
-				fmt.Fprintln(os.Stderr, "error: failed to synchronize version number:", err)
+			g.Version = remoteMetadata.Version
-				continue
+			g.Date = remoteMetadata.Date
-			}
+
-			if err := game.SetDate(r.GameID, remoteMetadata.Date); err != nil {
+			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
-				fmt.Fprintln(os.Stderr, "error: failed to synchronize date:", err)
+				destroyPg()
-				continue
+				fmt.Fprintln(os.Stderr, "failed to push:", err)
+				return subcommands.ExitFailure
 			}
+			fmt.Println(g.Name + ": pulled")
 			continue
 		}
 
-		if vlocal == remoteMetadata.Version {
+		destroyPg()
-			if err := conflict(r.GameID, g, remoteMetadata, cli); err != nil {
+
+		if g.Version == remoteMetadata.Version {
+			if err := p.conflict(r.GameID, g, remoteMetadata, cli); err != nil {
 				fmt.Fprintln(os.Stderr, "error: failed to resolve conflict:", err)
 				continue
 			}
@@ -141,11 +167,12 @@ func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 		}
 	}
 
+	fmt.Println("done.")
 	return subcommands.ExitSuccess
 }
 
-func conflict(gameID string, m, remoteMetadata game.Metadata, cli *client.Client) error {
+func (p *SyncCmd) conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.Client) error {
-	g, err := game.One(gameID)
+	g, err := p.Service.One(gameID)
 	if err != nil {
 		slog.Warn("a conflict was found but the game is not found in the database")
 		slog.Debug("debug info", "gameID", gameID)
@@ -164,37 +191,83 @@ func conflict(gameID string, m, remoteMetadata game.Metadata, cli *client.Client
 	switch res {
 	case prompt.My:
 		{
-			if err := push(gameID, m, cli); err != nil {
+			if err := p.push(m, cli); err != nil {
 				return fmt.Errorf("failed to push: %w", err)
 			}
 		}
 
 	case prompt.Their:
 		{
-			if err := pull(gameID, cli); err != nil {
+			if err := p.pull(gameID, cli); err != nil {
 				return fmt.Errorf("failed to push: %w", err)
 			}
-			if err := game.SetVersion(gameID, remoteMetadata.Version); err != nil {
+			g.Version = remoteMetadata.Version
-				return fmt.Errorf("failed to synchronize version number: %w", err)
+			g.Date = remoteMetadata.Date
-			}
+
-			if err := game.SetDate(gameID, remoteMetadata.Date); err != nil {
+			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
-				return fmt.Errorf("failed to synchronize date: %w", err)
+				return fmt.Errorf("failed to push: %w", err)
 			}
 		}
 	}
 	return nil
 }
 
-func push(gameID string, m game.Metadata, cli *client.Client) error {
+func (p *SyncCmd) push(m repository.Metadata, cli *client.Client) error {
-	archivePath := filepath.Join(game.DatastorePath(), gameID, "data.tar.gz")
+	return p.Service.PushArchive(m.ID, "", cli)
-
-	return cli.Push(gameID, archivePath, m)
 }
 
-func pull(gameID string, cli *client.Client) error {
+func (p *SyncCmd) pushBackup(m repository.Metadata, cli *client.Client) error {
-	archivePath := filepath.Join(game.DatastorePath(), gameID, "data.tar.gz")
+	bs, err := p.Service.AllBackups(m.ID)
+	if err != nil {
+		return err
+	}
 
-	return cli.Pull(gameID, archivePath)
+	for _, b := range bs {
+		binfo, err := cli.ArchiveInfo(m.ID, b.UUID)
+		if err != nil {
+			if !errors.Is(err, client.ErrNotFound) {
+				return fmt.Errorf("failed to get remote information about the backup file: %w", err)
+			}
+		}
+
+		if binfo.MD5 != b.MD5 {
+			if err := cli.PushBackup(b, m); err != nil {
+				return fmt.Errorf("failed to push backup: %w", err)
+			}
+		}
+
+	}
+	return nil
+}
+
+func (p *SyncCmd) pullBackup(m repository.Metadata, cli *client.Client) error {
+	bs, err := cli.ListArchives(m.ID)
+	if err != nil {
+		return err
+	}
+
+	for _, uuid := range bs {
+		rinfo, err := cli.ArchiveInfo(m.ID, uuid)
+		if err != nil {
+			return err
+		}
+
+		linfo, err := p.Service.Backup(m.ID, uuid)
+		if err != nil {
+			return err
+		}
+
+		if linfo.MD5 != rinfo.MD5 {
+			if err := p.Service.PullBackup(m.ID, uuid, cli); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (p *SyncCmd) pull(gameID string, cli *client.Client) error {
+	return p.Service.PullArchive(gameID, "", cli)
 }
 
 func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.Client, error) {

cmd/cli/commands/version/version.go

@@ -1,9 +1,9 @@
 package version
 
 import (
+	"cloudsave/cmd/cli/tools/prompt/credentials"
 	"cloudsave/pkg/constants"
 	"cloudsave/pkg/remote/client"
-	"cloudsave/pkg/tools/prompt/credentials"
 	"context"
 	"flag"
 	"fmt"
@@ -23,8 +23,11 @@ type (
 func (*VersionCmd) Name() string     { return "version" }
 func (*VersionCmd) Synopsis() string { return "show version and system information" }
 func (*VersionCmd) Usage() string {
-	return `add:
+	return `Usage: cloudsave version [-a]
-  Show version and system information
+
+Print the version of the software
+
+Options:
 `
 }
 

cmd/cli/main.go

@@ -2,34 +2,60 @@ package main
 
 import (
 	"cloudsave/cmd/cli/commands/add"
+	"cloudsave/cmd/cli/commands/apply"
 	"cloudsave/cmd/cli/commands/list"
 	"cloudsave/cmd/cli/commands/pull"
 	"cloudsave/cmd/cli/commands/remote"
 	"cloudsave/cmd/cli/commands/remove"
 	"cloudsave/cmd/cli/commands/run"
+	"cloudsave/cmd/cli/commands/show"
 	"cloudsave/cmd/cli/commands/sync"
 	"cloudsave/cmd/cli/commands/version"
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/repository"
 	"context"
 	"flag"
 	"os"
+	"path/filepath"
 
 	"github.com/google/subcommands"
 )
 
 func main() {
+	roaming, err := os.UserConfigDir()
+	if err != nil {
+		panic("failed to get user config path: " + err.Error())
+	}
+
+	datastorepath := filepath.Join(roaming, "cloudsave", "data")
+	err = os.MkdirAll(datastorepath, 0740)
+	if err != nil {
+		panic("cannot make the datastore:" + err.Error())
+	}
+
+	repo, err := repository.NewLazyRepository(datastorepath)
+	if err != nil {
+		panic("cannot make the datastore:" + err.Error())
+	}
+
+	s := data.NewService(repo)
+
 	subcommands.Register(subcommands.HelpCommand(), "help")
 	subcommands.Register(subcommands.FlagsCommand(), "help")
 	subcommands.Register(subcommands.CommandsCommand(), "help")
 	subcommands.Register(&version.VersionCmd{}, "help")
 
-	subcommands.Register(&add.AddCmd{}, "management")
+	subcommands.Register(&add.AddCmd{Service: s}, "management")
-	subcommands.Register(&run.RunCmd{}, "management")
+	subcommands.Register(&run.RunCmd{Service: s}, "management")
-	subcommands.Register(&list.ListCmd{}, "management")
+	subcommands.Register(&list.ListCmd{Service: s}, "management")
-	subcommands.Register(&remove.RemoveCmd{}, "management")
+	subcommands.Register(&remove.RemoveCmd{Service: s}, "management")
+	subcommands.Register(&show.ShowCmd{Service: s}, "management")
 
-	subcommands.Register(&remote.RemoteCmd{}, "remote")
+	subcommands.Register(&apply.ApplyCmd{Service: s}, "restore")
-	subcommands.Register(&sync.SyncCmd{}, "remote")
+
-	subcommands.Register(&pull.PullCmd{}, "remote")
+	subcommands.Register(&remote.RemoteCmd{Service: s}, "remote")
+	subcommands.Register(&sync.SyncCmd{Service: s}, "remote")
+	subcommands.Register(&pull.PullCmd{Service: s}, "remote")
 
 	flag.Parse()
 	ctx := context.Background()

cmd/server/api/api.go

@@ -1,14 +1,10 @@
 package api
 
 import (
-	"cloudsave/cmd/server/data"
+	"cloudsave/pkg/data"
-	"cloudsave/pkg/game"
+	"cloudsave/pkg/repository"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
 	"os"
@@ -23,21 +19,23 @@ import (
 type (
 	HTTPServer struct {
 		Server       *http.Server
+		Service      *data.Service
 		documentRoot string
 	}
 )
 
 // NewServer start the http server
-func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServer {
+func NewServer(documentRoot string, srv *data.Service, creds map[string]string, port int) *HTTPServer {
 	if !filepath.IsAbs(documentRoot) {
 		panic("the document root is not an absolute path")
 	}
 	s := &HTTPServer{
+		Service:      srv,
 		documentRoot: documentRoot,
 	}
 	router := chi.NewRouter()
 	router.NotFound(func(writer http.ResponseWriter, request *http.Request) {
-		notFound("This route does not exist", writer, request)
+		notFound("id not found", writer, request)
 	})
 	router.MethodNotAllowed(func(writer http.ResponseWriter, request *http.Request) {
 		methodNotAllowed(writer, request)
@@ -62,8 +60,12 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 					gamesRouter.Group(func(saveRouter chi.Router) {
 						saveRouter.Post("/{id}/data", s.upload)
 						saveRouter.Get("/{id}/data", s.download)
-						saveRouter.Get("/{id}/hash", s.hash)
 						saveRouter.Get("/{id}/metadata", s.metadata)
+
+						saveRouter.Get("/{id}/hist", s.allHist)
+						saveRouter.Post("/{id}/hist/{uuid}/data", s.histUpload)
+						saveRouter.Get("/{id}/hist/{uuid}/data", s.histDownload)
+						saveRouter.Get("/{id}/hist/{uuid}/info", s.histExists)
 					})
 				})
 			})
@@ -77,43 +79,13 @@ func NewServer(documentRoot string, creds map[string]string, port int) *HTTPServ
 }
 
 func (s HTTPServer) all(w http.ResponseWriter, r *http.Request) {
-	path := filepath.Join(s.documentRoot, "data")
+	datastore, err := s.Service.AllGames()
-	datastore := make([]game.Metadata, 0)
+	if err != nil {
-
+		slog.Error(err.Error())
-	if _, err := os.Stat(path); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			ok(datastore, w, r)
-			return
-		}
-		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
 		internalServerError(w, r)
 		return
 	}
 
-	ds, err := os.ReadDir(path)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
-		internalServerError(w, r)
-		return
-	}
-
-	for _, d := range ds {
-		content, err := os.ReadFile(filepath.Join(path, d.Name(), "metadata.json"))
-		if err != nil {
-			slog.Error("error: failed to load metadata.json", "err", err)
-			continue
-		}
-
-		var m game.Metadata
-		err = json.Unmarshal(content, &m)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "corrupted datastore: failed to parse %s/metadata.json: %s", d.Name(), err)
-			internalServerError(w, r)
-		}
-
-		datastore = append(datastore, m)
-	}
-
 	ok(datastore, w, r)
 }
 
@@ -121,32 +93,19 @@ func (s HTTPServer) download(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
 
-	sdir, err := os.Stat(path)
+	fi, err := os.Stat(filepath.Join(path, "data.tar.gz"))
 	if err != nil {
 		notFound("id not found", w, r)
 		return
 	}
 
-	if !sdir.IsDir() {
+	f, err := s.Service.Repository().ReadBlob(repository.NewGameIdentifier(id))
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
 	if err != nil {
-		notFound("id not found", w, r)
+		slog.Error(err.Error())
-		return
-	}
-	defer f.Close()
-
-	// Get file info to set headers
-	fi, err := f.Stat()
-	if err != nil || fi.IsDir() {
 		internalServerError(w, r)
 		return
 	}
+	defer f.Close()
 
 	// Set headers
 	w.Header().Set("Content-Disposition", "attachment; filename=\"data.tar.gz\"")
@@ -193,14 +152,20 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 	defer file.Close()
 
 	//TODO make a transaction
-	if err := data.UpdateMetadata(id, s.documentRoot, m); err != nil {
+	if err := s.Service.UpdateMetadata(id, m); err != nil {
 		fmt.Fprintln(os.Stderr, "error: failed to write metadata to disk:", err)
 		internalServerError(w, r)
 		return
 	}
 
-	if err := data.Write(id, s.documentRoot, file); err != nil {
+	if err := s.Service.Copy(id, file); err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to write file to disk:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to write data to disk:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	if err := s.Service.ReloadCache(id); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to reload data from the disk:", err)
 		internalServerError(w, r)
 		return
 	}
@@ -209,121 +174,170 @@ func (s HTTPServer) upload(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusCreated)
 }
 
-func (s HTTPServer) hash(w http.ResponseWriter, r *http.Request) {
+func (s HTTPServer) allHist(w http.ResponseWriter, r *http.Request) {
-	id := chi.URLParam(r, "id")
+	gameID := chi.URLParam(r, "id")
-	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
+	datastore := make([]string, 0)
 
-	sdir, err := os.Stat(path)
+	ds, err := s.Service.AllBackups(gameID)
 	if err != nil {
-		notFound("id not found", w, r)
+		fmt.Fprintln(os.Stderr, "failed to open datastore (", s.documentRoot, "):", err)
-		return
-	}
-
-	if !sdir.IsDir() {
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		notFound("id not found", w, r)
-		return
-	}
-	defer f.Close()
-
-	// Create MD5 hasher
-	hasher := md5.New()
-
-	// Copy file content into hasher
-	if _, err := io.Copy(hasher, f); err != nil {
-		fmt.Fprintln(os.Stderr, "error: an error occured while reading data:", err)
 		internalServerError(w, r)
 		return
 	}
 
-	// Get checksum result
+	for _, d := range ds {
-	sum := hasher.Sum(nil)
+		datastore = append(datastore, d.UUID)
-	ok(hex.EncodeToString(sum), w, r)
+	}
+
+	ok(datastore, w, r)
+}
+
+func (s HTTPServer) histUpload(w http.ResponseWriter, r *http.Request) {
+	const (
+		sizeLimit int64 = 500 << 20 // 500 MB
+	)
+
+	gameID := chi.URLParam(r, "id")
+	uuid := chi.URLParam(r, "uuid")
+
+	// Limit max upload size
+	r.Body = http.MaxBytesReader(w, r.Body, sizeLimit)
+
+	// Parse multipart form
+	err := r.ParseMultipartForm(sizeLimit)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to load payload:", err)
+		badRequest("bad payload", w, r)
+		return
+	}
+
+	// Retrieve file
+	file, _, err := r.FormFile("payload")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error: cannot find payload in the form:", err)
+		badRequest("payload not found", w, r)
+		return
+	}
+	defer file.Close()
+
+	if err := s.Service.CopyBackup(gameID, uuid, file); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to write data to the disk:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	if err := s.Service.ReloadCache(gameID); err != nil {
+		fmt.Fprintln(os.Stderr, "error: failed to reload data from the disk:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	// Respond success
+	w.WriteHeader(http.StatusCreated)
+}
+
+func (s HTTPServer) histDownload(w http.ResponseWriter, r *http.Request) {
+	id := chi.URLParam(r, "id")
+	uuid := chi.URLParam(r, "uuid")
+	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id, "hist", uuid))
+
+	fi, err := os.Stat(filepath.Join(path, "data.tar.gz"))
+	if err != nil {
+		notFound("id not found", w, r)
+		return
+	}
+
+	f, err := s.Service.Repository().ReadBlob(repository.NewBackupIdentifier(id, uuid))
+	if err != nil {
+		slog.Error(err.Error())
+		internalServerError(w, r)
+		return
+	}
+	defer f.Close()
+
+	// Set headers
+	w.Header().Set("Content-Disposition", "attachment; filename=\"data.tar.gz\"")
+	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
+	w.WriteHeader(200)
+
+	// Stream the file content
+	http.ServeContent(w, r, "data.tar.gz", fi.ModTime(), f)
+}
+
+func (s HTTPServer) histExists(w http.ResponseWriter, r *http.Request) {
+	gameID := chi.URLParam(r, "id")
+	uuid := chi.URLParam(r, "uuid")
+
+	finfo, err := s.Service.Backup(gameID, uuid)
+	if err != nil {
+		if errors.Is(err, repository.ErrNotFound) {
+			notFound("not found", w, r)
+			return
+		}
+		fmt.Fprintln(os.Stderr, "error: failed to read data:", err)
+		internalServerError(w, r)
+		return
+	}
+
+	ok(finfo, w, r)
 }
 
 func (s HTTPServer) metadata(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
-	path := filepath.Clean(filepath.Join(s.documentRoot, "data", id))
+	metadata, err := s.Service.One(id)
-
-	sdir, err := os.Stat(path)
 	if err != nil {
+		if errors.Is(err, repository.ErrNotFound) {
 			notFound("id not found", w, r)
 			return
 		}
-
+		slog.Error(err.Error())
-	if !sdir.IsDir() {
-		notFound("id not found", w, r)
-		return
-	}
-
-	path = filepath.Join(path, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		notFound("id not found", w, r)
-		return
-	}
-	defer f.Close()
-
-	var metadata game.Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: an error occured while reading data:", err)
 		internalServerError(w, r)
 		return
 	}
-
 	ok(metadata, w, r)
 }
 
-func parseFormMetadata(gameID string, values map[string][]string) (game.Metadata, error) {
+func parseFormMetadata(gameID string, values map[string][]string) (repository.Metadata, error) {
 	var name string
 	if v, ok := values["name"]; ok {
 		if len(v) == 0 {
-			return game.Metadata{}, fmt.Errorf("error: corrupted metadata")
+			return repository.Metadata{}, fmt.Errorf("error: corrupted metadata")
 		}
 		name = v[0]
 	} else {
-		return game.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
+		return repository.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
 	}
 
 	var version int
 	if v, ok := values["version"]; ok {
 		if len(v) == 0 {
-			return game.Metadata{}, fmt.Errorf("error: corrupted metadata")
+			return repository.Metadata{}, fmt.Errorf("error: corrupted metadata")
 		}
 		if v, err := strconv.Atoi(v[0]); err == nil {
 			version = v
 		} else {
-			return game.Metadata{}, err
+			return repository.Metadata{}, err
 		}
 	} else {
-		return game.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
+		return repository.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
 	}
 
 	var date time.Time
 	if v, ok := values["date"]; ok {
 		if len(v) == 0 {
-			return game.Metadata{}, fmt.Errorf("error: corrupted metadata")
+			return repository.Metadata{}, fmt.Errorf("error: corrupted metadata")
 		}
 		if v, err := time.Parse(time.RFC3339, v[0]); err == nil {
 			date = v
 		} else {
-			return game.Metadata{}, err
+			return repository.Metadata{}, err
 		}
 	} else {
-		return game.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
+		return repository.Metadata{}, fmt.Errorf("error: cannot find metadata in the form")
 	}
 
-	return game.Metadata{
+	return repository.Metadata{
 		ID:      gameID,
 		Version: version,
 		Name:    name,

cmd/server/api/responses.go

@@ -3,13 +3,13 @@ package api
 import (
 	"cloudsave/pkg/remote/obj"
 	"encoding/json"
-	"log"
+	"log/slog"
 	"net/http"
 	"time"
 )
 
 func internalServerError(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusInternalServerError,
 			Path:      r.RequestURI,
@@ -19,20 +19,16 @@ func internalServerError(w http.ResponseWriter, r *http.Request) {
 		Message: "The server encountered an unexpected condition that prevented it from fulfilling the request.",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusInternalServerError)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func notFound(message string, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusNotFound,
 			Path:      r.RequestURI,
@@ -42,20 +38,16 @@ func notFound(message string, w http.ResponseWriter, r *http.Request) {
 		Message: message,
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusNotFound)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusMethodNotAllowed,
 			Path:      r.RequestURI,
@@ -65,20 +57,16 @@ func methodNotAllowed(w http.ResponseWriter, r *http.Request) {
 		Message: "The server knows the request method, but the target resource doesn't support this method",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusMethodNotAllowed)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func unauthorized(w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusUnauthorized,
 			Path:      r.RequestURI,
@@ -88,21 +76,17 @@ func unauthorized(w http.ResponseWriter, r *http.Request) {
 		Message: "The request has not been completed because it lacks valid authentication credentials for the requested resource.",
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.Header().Add("WWW-Authenticate", "Custom realm=\"loginUserHandler via /api/login\"")
 	w.WriteHeader(http.StatusUnauthorized)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func ok(o interface{}, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPObject{
+	payload := obj.HTTPObject{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusOK,
 			Path:      r.RequestURI,
@@ -110,20 +94,15 @@ func ok(o interface{}, w http.ResponseWriter, r *http.Request) {
 		},
 		Data: o,
 	}
-
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }
 
 func badRequest(message string, w http.ResponseWriter, r *http.Request) {
-	e := obj.HTTPError{
+	payload := obj.HTTPError{
 		HTTPCore: obj.HTTPCore{
 			Status:    http.StatusBadRequest,
 			Path:      r.RequestURI,
@@ -133,14 +112,10 @@ func badRequest(message string, w http.ResponseWriter, r *http.Request) {
 		Message: message,
 	}
 
-	payload, err := json.Marshal(e)
-	if err != nil {
-		log.Println(err)
-	}
 	w.Header().Add("Content-Type", "application/json")
 	w.WriteHeader(http.StatusBadRequest)
-	_, err = w.Write(payload)
+	e := json.NewEncoder(w)
-	if err != nil {
+	if err := e.Encode(payload); err != nil {
-		log.Println(err)
+		slog.Error(err.Error())
 	}
 }

cmd/server/data/data.go

@@ -1,60 +0,0 @@
-package data
-
-import (
-	"cloudsave/pkg/game"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-func Write(gameID, documentRoot string, r io.Reader) error {
-	dataFolderPath := filepath.Join(documentRoot, "data", gameID)
-	partPath := filepath.Join(dataFolderPath, "data.tar.gz.part")
-	finalFilePath := filepath.Join(dataFolderPath, "data.tar.gz")
-
-	if err := makeDataFolder(gameID, documentRoot); err != nil {
-		return err
-	}
-
-	f, err := os.OpenFile(partPath, os.O_CREATE|os.O_WRONLY, 0740)
-	if err != nil {
-		return err
-	}
-
-	if _, err := io.Copy(f, r); err != nil {
-		f.Close()
-		if err := os.Remove(partPath); err != nil {
-			return fmt.Errorf("failed to write the file and cannot clean the folder: %w", err)
-		}
-		return fmt.Errorf("failed to write the file: %w", err)
-	}
-	f.Close()
-
-	if err := os.Rename(partPath, finalFilePath); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func UpdateMetadata(gameID, documentRoot string, m game.Metadata) error {
-	if err := makeDataFolder(gameID, documentRoot); err != nil {
-		return err
-	}
-	path := filepath.Join(documentRoot, "data", gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0740)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	return e.Encode(m)
-}
-
-func makeDataFolder(gameID, documentRoot string) error {
-	return os.MkdirAll(filepath.Join(documentRoot, "data", gameID), 0740)
-}

cmd/server/runner.go

@@ -4,8 +4,11 @@ import (
 	"cloudsave/cmd/server/api"
 	"cloudsave/cmd/server/security/htpasswd"
 	"cloudsave/pkg/constants"
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/repository"
 	"flag"
 	"fmt"
+	"log/slog"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -16,18 +19,49 @@ func run() {
 
 	var documentRoot string
 	var port int
+	var noCache, verbose bool
 	flag.StringVar(&documentRoot, "document-root", defaultDocumentRoot, "Define the path to the document root")
 	flag.IntVar(&port, "port", 8080, "Define the port of the server")
+	flag.BoolVar(&noCache, "no-cache", false, "Disable the cache")
+	flag.BoolVar(&verbose, "verbose", false, "Show more logs")
 	flag.Parse()
 
+	if verbose {
+		slog.SetLogLoggerLevel(slog.LevelDebug)
+	}
+
+	slog.Info("loading .htpasswd")
 	h, err := htpasswd.Open(filepath.Join(documentRoot, ".htpasswd"))
 	if err != nil {
 		fatal("failed to load .htpasswd: "+err.Error(), 1)
 	}
+	slog.Info("users loaded: " + strconv.Itoa(len(h.Content())) + " user(s) loaded")
 
-	server := api.NewServer(documentRoot, h.Content(), port)
+	var repo repository.Repository
+	if !noCache {
+		slog.Info("loading eager repository...")
+		r, err := repository.NewEagerRepository(filepath.Join(documentRoot, "data"))
+		if err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+		if err := r.Preload(); err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+		repo = r
+	} else {
+		slog.Info("loading lazy repository...")
+		repo, err = repository.NewLazyRepository(filepath.Join(documentRoot, "data"))
+		if err != nil {
+			fatal("failed to load datastore: "+err.Error(), 1)
+		}
+	}
 
-	fmt.Println("starting server at :" + strconv.Itoa(port))
+	slog.Info("repository loaded")
+	s := data.NewService(repo)
+
+	server := api.NewServer(documentRoot, s, h.Content(), port)
+
+	fmt.Println("server started at :" + strconv.Itoa(port))
 	if err := server.Server.ListenAndServe(); err != nil {
 		fatal("failed to start server: "+err.Error(), 1)
 	}

cmd/web/config.template.json

@@ -0,0 +1,8 @@
+{
+    "server": {
+        "port": 8181
+    },
+    "remote": {
+        "url": "http://localhost:8080"
+    }
+}

cmd/web/server/config/config.go

@@ -0,0 +1,40 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type (
+	Configuration struct {
+		Server ServerConfiguration `json:"server"`
+		Remote RemoteConfiguration `json:"remote"`
+	}
+
+	ServerConfiguration struct {
+		Port int `json:"port"`
+	}
+
+	RemoteConfiguration struct {
+		URL string `json:"url"`
+	}
+)
+
+func Load(path string) (Configuration, error) {
+	f, err := os.OpenFile(path, os.O_RDONLY, 0)
+	if err != nil {
+		return Configuration{}, fmt.Errorf("failed to open configuration file: %w", err)
+	}
+	defer f.Close()
+
+	d := json.NewDecoder(f)
+
+	var c Configuration
+	err = d.Decode(&c)
+	if err != nil {
+		return Configuration{}, fmt.Errorf("failed to parse configuration file (%s): %w", path, err)
+	}
+
+	return c, nil
+}

cmd/web/server/middlewares.go

@@ -0,0 +1,63 @@
+package server
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+func recoverMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			err := recover()
+			if err != nil {
+				internalServerError(w, r)
+			}
+		}()
+		next.ServeHTTP(w, r)
+	})
+}
+
+// BasicAuth implements a simple middleware handler for adding basic http auth to a route.
+func BasicAuth(realm string, creds map[string]string) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			user, pass, ok := r.BasicAuth()
+			if !ok {
+				basicAuthFailed(w, r, realm)
+				return
+			}
+
+			credPass := creds[user]
+			if err := bcrypt.CompareHashAndPassword([]byte(credPass), []byte(pass)); err != nil {
+				basicAuthFailed(w, r, realm)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+func basicAuthFailed(w http.ResponseWriter, r *http.Request, realm string) {
+	unauthorized(realm, w, r)
+}
+
+func unauthorized(realm string, w http.ResponseWriter, r *http.Request) {
+	w.Header().Add("WWW-Authenticate", fmt.Sprintf(`Basic realm="%s"`, realm))
+	w.WriteHeader(http.StatusUnauthorized)
+	_, err := w.Write([]byte(UnauthorizedErrorHTMLPage))
+	if err != nil {
+		log.Println(err)
+	}
+}
+
+func internalServerError(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusInternalServerError)
+	_, err := w.Write([]byte(InternalServerErrorHTMLPage))
+	if err != nil {
+		log.Println(err)
+	}
+}

cmd/web/server/server.go

@@ -0,0 +1,262 @@
+package server
+
+import (
+	"cloudsave/cmd/web/server/config"
+	"cloudsave/pkg/constants"
+	"cloudsave/pkg/remote/client"
+	"cloudsave/pkg/repository"
+	"errors"
+	"fmt"
+	"html/template"
+	"log/slog"
+	"net/http"
+	"runtime"
+	"slices"
+	"sync"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+
+	_ "embed"
+)
+
+type (
+	HTTPServer struct {
+		Server    *http.Server
+		Config    config.Configuration
+		Templates Templates
+	}
+
+	Templates struct {
+		Dashboard *template.Template
+		Detailled *template.Template
+		System    *template.Template
+	}
+)
+
+type (
+	DetaillePayload struct {
+		Version        string
+		Save           repository.Metadata
+		BackupMetadata []repository.Backup
+		Hash           string
+	}
+
+	DashboardPayload struct {
+		Version string
+		Saves   []repository.Metadata
+	}
+
+	SystemPayload struct {
+		Version string
+		Client  client.Information
+		Server  client.Information
+	}
+)
+
+var (
+	//go:embed templates/500.html
+	InternalServerErrorHTMLPage string
+
+	//go:embed templates/401.html
+	UnauthorizedErrorHTMLPage string
+
+	//go:embed templates/dashboard.html
+	DashboardHTMLPage string
+
+	//go:embed templates/detailled.html
+	DetailledHTMLPage string
+
+	//go:embed templates/information.html
+	SystemHTMLPage string
+)
+
+// NewServer start the http server
+func NewServer(c config.Configuration) *HTTPServer {
+	dashboardTemplate := template.New("dashboard")
+	dashboardTemplate.Parse(DashboardHTMLPage)
+
+	detailledTemplate := template.New("detailled")
+	detailledTemplate.Parse(DetailledHTMLPage)
+
+	systemTemplate := template.New("system")
+	systemTemplate.Parse(SystemHTMLPage)
+
+	s := &HTTPServer{
+		Config: c,
+		Templates: Templates{
+			Dashboard: dashboardTemplate,
+			Detailled: detailledTemplate,
+			System:    systemTemplate,
+		},
+	}
+	router := chi.NewRouter()
+	router.Use(middleware.Logger)
+	router.Use(recoverMiddleware)
+	router.Route("/web", func(routerAPI chi.Router) {
+		routerAPI.Get("/", s.dashboard)
+		routerAPI.Get("/{id}", s.detailled)
+		routerAPI.Get("/system", s.system)
+	})
+	s.Server = &http.Server{
+		Addr:    fmt.Sprintf(":%d", c.Server.Port),
+		Handler: router,
+	}
+	return s
+}
+
+func (s *HTTPServer) dashboard(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	saves, err := cli.All()
+	if err != nil {
+		if errors.Is(err, client.ErrUnauthorized) {
+			unauthorized("Unable to access resources", w, r)
+			return
+		}
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	slices.SortFunc(saves, func(a, b repository.Metadata) int {
+		return a.Date.Compare(b.Date)
+	})
+
+	slices.Reverse(saves)
+
+	payload := DashboardPayload{
+		Version: constants.Version,
+		Saves:   saves,
+	}
+
+	if err := s.Templates.Dashboard.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}
+
+func (s *HTTPServer) detailled(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+
+	id := chi.URLParam(r, "id")
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	var wg sync.WaitGroup
+	var err1, err2 error
+	var save repository.Metadata
+	var ids []string
+
+	wg.Add(1)
+	go func() {
+		save, err1 = cli.Metadata(id)
+		wg.Done()
+	}()
+
+	wg.Add(1)
+	go func() {
+		ids, err2 = cli.ListArchives(id)
+		wg.Done()
+	}()
+
+	wg.Wait()
+
+	if err1 != nil || err2 != nil {
+		if errors.Is(err1, client.ErrUnauthorized) {
+			unauthorized("Unable to access resources", w, r)
+			return
+		}
+		slog.Error("failed to get metadata: unable to connect to the remote", "err", err1)
+		return
+	}
+
+	wg = sync.WaitGroup{}
+
+	var bm []repository.Backup
+	for _, i := range ids {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			b, err := cli.ArchiveInfo(id, i)
+			if err != nil {
+				slog.Error("failed to get backup: unable to connect to the remote", "err", err)
+				return
+			}
+			bm = append(bm, b)
+		}()
+	}
+
+	wg.Wait()
+
+	payload := DetaillePayload{
+		Save:           save,
+		BackupMetadata: bm,
+		Version:        constants.Version,
+	}
+
+	if err := s.Templates.Detailled.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}
+
+func (s *HTTPServer) system(w http.ResponseWriter, r *http.Request) {
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		basicAuthFailed(w, r, "realm")
+		return
+	}
+	cli := client.New(s.Config.Remote.URL, user, pass)
+
+	if err := cli.Ping(); err != nil {
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	clientInfo := client.Information{
+		Version:        constants.Version,
+		APIVersion:     constants.ApiVersion,
+		GoVersion:      runtime.Version(),
+		OSName:         runtime.GOOS,
+		OSArchitecture: runtime.GOARCH,
+	}
+	serverInfo, err := cli.Version()
+	if err != nil {
+		if errors.Is(err, client.ErrUnauthorized) {
+			unauthorized("Unable to access resources", w, r)
+			return
+		}
+		slog.Error("unable to connect to the remote", "err", err)
+		return
+	}
+
+	payload := SystemPayload{
+		Version: constants.Version,
+		Client:  clientInfo,
+		Server:  serverInfo,
+	}
+
+	if err := s.Templates.System.Execute(w, payload); err != nil {
+		slog.Error("failed to render the html pages", "err", err)
+		return
+	}
+}

cmd/web/server/templates/401.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>You are not allowed</title>
+    </head>
+    <body>
+        <h1>401 Unauthorized</h1>
+    </body>
+</html>

cmd/web/server/templates/500.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>An error occured</title>
+    </head>
+    <body>
+        <h1>500 Internal Server Error</h1>
+    </body>
+</html>

cmd/web/server/templates/dashboard.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Dashboard</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <a class="muted" href="/web/system">v{{.Version}}</a>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <div class="list-group">
+            {{range .Saves}}
+            <a href="/web/{{.ID}}" class="list-group-item list-group-item-action">
+                <div class="d-flex w-100 justify-content-between">
+                    <h5 class="mb-1">{{.Name}}</h5>
+                    <small>{{.Date}}</small>
+                </div>
+                <p class="mb-1">Version: {{.Version}}</p>
+                <small>{{.ID}}</small>
+            </a>
+            {{end}}
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/server/templates/detailled.html

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{.Save.Name}}</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <a class="muted" href="/web/system">v{{.Version}}</a>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <nav aria-label="breadcrumb">
+            <ol class="breadcrumb">
+                <li class="breadcrumb-item"><a href="/web">Home</a></li>
+                <li class="breadcrumb-item active" aria-current="page">{{.Save.ID}}</li>
+            </ol>
+        </nav>
+        <div class="list-group">
+            <h1>{{.Save.Name}} <span class="badge text-bg-success">Version {{.Save.Version}}</span></h1>
+            <hr />
+            <h3>Details</h3>
+            <ul class="list-group list-group-flush">
+                <li class="list-group-item">UUID: {{.Save.ID}}</li>
+                <li class="list-group-item">Last Upload: {{.Save.Date}}</li>
+                <li class="list-group-item">Hash (MD5): {{.Save.MD5}}</li>
+            </ul>
+
+            <hr />
+            <h3>Backup</h3>
+            {{ range .BackupMetadata}}
+            <div class="card" style="margin-top: 1rem;">
+                <div class="card-body">
+                    <h5 class="card-title">{{.CreatedAt}}</h5>
+                    <h6 class="card-subtitle mb-2 text-body-secondary">{{.UUID}}</h6>
+                    <p class="card-text">MD5: {{.MD5}}</p>
+                </div>
+            </div>
+            {{end}}
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/server/templates/information.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>System Information</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-LN+7fdVzj6u52u30Kp6M/trliBMCMKTyK833zpbD+pXdCLuTusPj697FH4R/5mcr" crossorigin="anonymous">
+</head>
+
+<body>
+    <nav class="navbar bg-body-tertiary">
+        <div class="container-fluid">
+            <span class="navbar-brand mb-0 h1">CloudSave</span>
+            <span class="muted">v{{.Version}}</span>
+        </div>
+    </nav>
+    <div class="container" style="margin-top: 1rem;">
+        <nav aria-label="breadcrumb">
+            <ol class="breadcrumb">
+                <li class="breadcrumb-item"><a href="/web">Home</a></li>
+                <li class="breadcrumb-item active" aria-current="page">System</li>
+            </ol>
+        </nav>
+        <div class="list-group">
+            <h3>Client</h3>
+            <hr />
+            <ul class="list-group list-group-flush">
+                <li class="list-group-item">Version: {{.Client.Version}}</li>
+                <li class="list-group-item">API Version: {{.Client.APIVersion}}</li>
+                <li class="list-group-item">Go Version: {{.Client.GoVersion}}</li>
+                <li class="list-group-item">OS: {{.Client.OSName}}/{{.Client.OSArchitecture}}</li>
+            </ul>
+
+            <hr />
+            <h3>Server</h3>
+            <hr />
+            <ul class="list-group list-group-flush">
+                <li class="list-group-item">Version: {{.Server.Version}}</li>
+                <li class="list-group-item">API Version: {{.Server.APIVersion}}</li>
+                <li class="list-group-item">Go Version: {{.Server.GoVersion}}</li>
+                <li class="list-group-item">OS: {{.Server.OSName}}/{{.Server.OSArchitecture}}</li>
+            </ul>
+        </div>
+    </div>
+</body>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.7/dist/js/bootstrap.bundle.min.js"
+    integrity="sha384-ndDqU0Gzau9qJ1lfW4pNLlhNTkCfHzAVBReH9diLvGRem5+R9g2FzA8ZGN954O5Q"
+    crossorigin="anonymous"></script>
+
+</html>

cmd/web/web.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"cloudsave/cmd/web/server"
+	"cloudsave/cmd/web/server/config"
+	"cloudsave/pkg/constants"
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+)
+
+func main() {
+	fmt.Printf("CloudSave web -- v%s.%s.%s\n\n", constants.Version, runtime.GOOS, runtime.GOARCH)
+
+	var configPath string
+	flag.StringVar(&configPath, "config", "/var/lib/cloudsave/config.json", "Define the path to the configuration file")
+	flag.Parse()
+
+	c, err := config.Load(configPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "failed to load configuration:", err)
+		os.Exit(1)
+	}
+
+	s := server.NewServer(c)
+
+	fmt.Println("starting server at :" + strconv.Itoa(c.Server.Port))
+	if err := s.Server.ListenAndServe(); err != nil {
+		fmt.Fprintln(os.Stderr, "failed to start web server:", err)
+		os.Exit(1)
+	}
+}

go.mod

@@ -5,6 +5,7 @@ go 1.24
 require (
 	github.com/go-chi/chi/v5 v5.2.1
 	github.com/google/subcommands v1.2.0
+	github.com/google/uuid v1.6.0
 	github.com/schollz/progressbar/v3 v3.18.0
 	golang.org/x/crypto v0.38.0
 	golang.org/x/term v0.32.0

go.sum

@@ -6,6 +6,8 @@ github.com/go-chi/chi/v5 v5.2.1 h1:KOIHODQj58PmL80G2Eak4WdvUzjSJSm0vG72crDCqb8=
 github.com/go-chi/chi/v5 v5.2.1/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=

pkg/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
-const Version = "0.0.1"
+const Version = "0.0.4b"
 
 const ApiVersion = 1

pkg/data/data.go

@@ -0,0 +1,400 @@
+package data
+
+import (
+	"cloudsave/pkg/remote/client"
+	"cloudsave/pkg/repository"
+	"cloudsave/pkg/tools/archive"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type (
+	Service struct {
+		repo repository.Repository
+	}
+)
+
+func NewService(repo repository.Repository) *Service {
+	return &Service{
+		repo: repo,
+	}
+}
+
+func (s *Service) Add(name, path, remote string) (string, error) {
+	gameID := repository.NewGameIdentifier(uuid.NewString())
+
+	if err := s.repo.Mkdir(gameID); err != nil {
+		return "", fmt.Errorf("failed to add game reference: %w", err)
+	}
+
+	m := repository.Metadata{
+		ID:      gameID.Key(),
+		Name:    name,
+		Path:    path,
+		Version: 0,
+		Date:    time.Now(),
+	}
+
+	if err := s.repo.WriteMetadata(gameID, m); err != nil {
+		return "", fmt.Errorf("failed to add game reference: %w", err)
+	}
+
+	return gameID.Key(), nil
+}
+
+func (s *Service) One(gameID string) (repository.Metadata, error) {
+	id := repository.NewGameIdentifier(gameID)
+
+	m, err := s.repo.Metadata(id)
+	if err != nil {
+		return repository.Metadata{}, fmt.Errorf("failed to get metadata: %w", err)
+	}
+
+	return m, nil
+}
+
+func (s *Service) Backup(gameID, backupID string) (repository.Backup, error) {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return repository.Backup{}, fmt.Errorf("failed to make game dir: %w", err)
+	}
+
+	return s.repo.Backup(id)
+}
+
+func (s *Service) UpdateMetadata(gameID string, m repository.Metadata) error {
+	id := repository.NewGameIdentifier(gameID)
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return fmt.Errorf("failed to make game dir: %w", err)
+	}
+
+	if err := s.repo.WriteMetadata(id, m); err != nil {
+		return fmt.Errorf("failed to write metadate: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) Scan(gameID string) (bool, error) {
+	id := repository.NewGameIdentifier(gameID)
+
+	lastRun, err := s.repo.LastScan(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get last scan time: %w", err)
+	}
+
+	m, err := s.repo.Metadata(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get game metadata: %w", err)
+	}
+
+	if !IsDirectoryChanged(m.Path, lastRun) {
+		return false, nil
+	}
+
+	if err := s.MakeBackup(gameID); err != nil {
+		return false, fmt.Errorf("failed to make the backup: %w", err)
+	}
+
+	f, err := s.repo.WriteBlob(id)
+	if err != nil {
+		return false, fmt.Errorf("failed to get datastore stream: %w", err)
+	}
+	if v, ok := f.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if err := archive.Tar(f, m.Path); err != nil {
+		return false, fmt.Errorf("failed to make archive: %w", err)
+	}
+
+	if err := s.repo.ResetLastScan(id); err != nil {
+		return false, fmt.Errorf("failed to reset scan date: %w", err)
+	}
+
+	m.Date = time.Now()
+	m.Version += 1
+
+	if err := s.repo.WriteMetadata(id, m); err != nil {
+		return false, fmt.Errorf("failed to update metadata: %w", err)
+	}
+
+	return true, nil
+}
+
+func (s *Service) MakeBackup(gameID string) error {
+	var id repository.Identifier = repository.NewGameIdentifier(gameID)
+
+	src, err := s.repo.ReadBlob(id)
+	if err != nil {
+		return err
+	}
+	if v, ok := src.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	id = repository.NewBackupIdentifier(gameID, uuid.NewString())
+
+	if err := s.repo.Mkdir(id); err != nil {
+		return err
+	}
+
+	dst, err := s.repo.WriteBlob(id)
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Service) AllGames() ([]repository.Metadata, error) {
+	ids, err := s.repo.All()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the list of ids: %w", err)
+	}
+
+	var ms []repository.Metadata
+	for _, id := range ids {
+		m, err := s.repo.Metadata(repository.NewGameIdentifier(id))
+		if err != nil {
+			return nil, fmt.Errorf("failed to open metadata: %w", err)
+		}
+		ms = append(ms, m)
+	}
+
+	return ms, nil
+}
+
+func (s *Service) AllBackups(gameID string) ([]repository.Backup, error) {
+	ids, err := s.repo.AllHist(repository.NewGameIdentifier(gameID))
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the list of ids: %w", err)
+	}
+
+	var bs []repository.Backup
+	for _, id := range ids {
+		b, err := s.repo.Backup(repository.NewBackupIdentifier(gameID, id))
+		if err != nil {
+			return nil, fmt.Errorf("failed to open metadata: %w", err)
+		}
+		bs = append(bs, b)
+	}
+
+	return bs, nil
+}
+
+func (l Service) PullArchive(gameID, backupID string, cli *client.Client) error {
+	if len(backupID) > 0 {
+		path := l.repo.DataPath(repository.NewBackupIdentifier(gameID, backupID))
+		return cli.PullBackup(gameID, backupID, filepath.Join(path, "data.tar.gz"))
+	}
+
+	path := l.repo.DataPath(repository.NewGameIdentifier(gameID))
+	return cli.Pull(gameID, filepath.Join(path, "data.tar.gz"))
+}
+
+func (l Service) PushArchive(gameID, backupID string, cli *client.Client) error {
+	m, err := l.repo.Metadata(repository.NewGameIdentifier(gameID))
+	if err != nil {
+		return err
+	}
+
+	if len(backupID) > 0 {
+		path := l.repo.DataPath(repository.NewBackupIdentifier(gameID, backupID))
+		return cli.PushSave(filepath.Join(path, "data.taz.gz"), m)
+	}
+
+	path := l.repo.DataPath(repository.NewGameIdentifier(gameID))
+	return cli.PushSave(filepath.Join(path, "data.tar.gz"), m)
+}
+
+func (l Service) PullCurrent(id, path string, cli *client.Client) error {
+	gameID := repository.NewGameIdentifier(id)
+	if err := l.repo.Mkdir(gameID); err != nil {
+		return err
+	}
+
+	m, err := cli.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("failed to get metadata from the server: %w", err)
+	}
+
+	if err := l.repo.WriteMetadata(gameID, m); err != nil {
+		return fmt.Errorf("failed to write metadata: %w", err)
+	}
+
+	archivePath := filepath.Join(l.repo.DataPath(gameID), "data.tar.gz")
+
+	if err := cli.Pull(id, archivePath); err != nil {
+		return fmt.Errorf("failed to pull from the server: %w", err)
+	}
+
+	f, err := l.repo.ReadBlob(gameID)
+	if err != nil {
+		return fmt.Errorf("failed to open blob from local repository: %w", err)
+	}
+
+	if err := os.MkdirAll(path, 0740); err != nil {
+		return fmt.Errorf("failed to create destination directory: %w", err)
+	}
+
+	if err := archive.Untar(f, path); err != nil {
+		return fmt.Errorf("failed to untar archive: %w", err)
+	}
+
+	if err := l.repo.ResetLastScan(gameID); err != nil {
+		return fmt.Errorf("failed to create .last_run file: %w", err)
+	}
+
+	return nil
+}
+
+func (l Service) PullBackup(gameID, backupID string, cli *client.Client) error {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	archivePath := filepath.Join(l.repo.DataPath(id), "data.tar.gz")
+
+	if err := cli.PullBackup(gameID, backupID, archivePath); err != nil {
+		return fmt.Errorf("failed to pull backup: %w", err)
+	}
+
+	return nil
+}
+
+func (l Service) RemoveGame(gameID string) error {
+	return l.repo.Remove(repository.NewGameIdentifier(gameID))
+}
+
+func (l Service) SetVersion(gameID string, value int) error {
+	id := repository.NewGameIdentifier(gameID)
+
+	m, err := l.repo.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("failed to get metadata from the server: %w", err)
+	}
+
+	m.Version = value
+
+	if err := l.repo.WriteMetadata(id, m); err != nil {
+		return fmt.Errorf("failed to write metadata: %w", err)
+	}
+
+	return nil
+}
+
+func IsDirectoryChanged(path string, lastRun time.Time) bool {
+	changed := false
+	_ = filepath.Walk(path, func(path string, info os.FileInfo, walkErr error) error {
+		if walkErr != nil {
+			return nil
+		}
+		if info.ModTime().After(lastRun) {
+			changed = true
+			return io.EOF // early exit
+		}
+		return nil
+	})
+	return changed
+}
+
+func (l Service) Copy(id string, src io.Reader) error {
+	dst, err := l.repo.WriteBlob(repository.NewGameIdentifier(id))
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (l Service) CopyBackup(gameID, backupID string, src io.Reader) error {
+	id := repository.NewBackupIdentifier(gameID, backupID)
+
+	if err := l.repo.Mkdir(id); err != nil {
+		return err
+	}
+
+	dst, err := l.repo.WriteBlob(id)
+	if err != nil {
+		return err
+	}
+	if v, ok := dst.(io.Closer); ok {
+		defer v.Close()
+	}
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (l Service) ApplyCurrent(gameID string) error {
+	id := repository.NewGameIdentifier(gameID)
+	path := l.repo.DataPath(id)
+
+	g, err := l.repo.Metadata(id)
+	if err != nil {
+		return err
+	}
+
+	return l.apply(filepath.Join(path, "data.tar.gz"), g.Path)
+}
+
+func (l Service) ApplyBackup(gameID, backupID string) error {
+	id := repository.NewGameIdentifier(gameID)
+	fullID := repository.NewBackupIdentifier(gameID, backupID)
+	path := l.repo.DataPath(fullID)
+
+	g, err := l.repo.Metadata(id)
+	if err != nil {
+		return err
+	}
+
+	return l.apply(filepath.Join(path, "data.tar.gz"), g.Path)
+}
+
+func (l Service) Repository() repository.Repository {
+	return l.repo
+}
+
+func (l Service) ReloadCache(gameID string) error {
+	if er, ok := l.repo.(*repository.EagerRepository); ok {
+		return er.ReloadMetadata(repository.NewGameIdentifier(gameID))
+	}
+	return nil
+}
+
+func (l Service) apply(src, dst string) error {
+	if err := os.RemoveAll(dst); err != nil {
+		return fmt.Errorf("failed to remove old save: %w", err)
+	}
+
+	f, err := os.OpenFile(src, os.O_RDONLY, 0)
+	if err != nil {
+		return fmt.Errorf("failed to open archive: %w", err)
+	}
+	defer f.Close()
+
+	return archive.Untar(f, dst)
+}

pkg/game/game.go

@@ -1,254 +0,0 @@
-package game
-
-import (
-	"cloudsave/pkg/tools/id"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"time"
-)
-
-type (
-	Metadata struct {
-		ID      string    `json:"id"`
-		Name    string    `json:"name"`
-		Path    string    `json:"path"`
-		Version int       `json:"version"`
-		Date    time.Time `json:"date"`
-	}
-)
-
-var (
-	roaming       string
-	datastorepath string
-)
-
-func init() {
-	var err error
-	roaming, err = os.UserConfigDir()
-	if err != nil {
-		panic("failed to get user config path: " + err.Error())
-	}
-
-	datastorepath = filepath.Join(roaming, "cloudsave", "data")
-	err = os.MkdirAll(datastorepath, 0740)
-	if err != nil {
-		panic("cannot make the datastore:" + err.Error())
-	}
-}
-
-func Add(name, path string) (Metadata, error) {
-	m := Metadata{
-		ID:   id.New(),
-		Name: name,
-		Path: path,
-	}
-
-	err := os.MkdirAll(filepath.Join(datastorepath, m.ID), 0740)
-	if err != nil {
-		panic("cannot make directory for the game:" + err.Error())
-	}
-
-	f, err := os.OpenFile(filepath.Join(datastorepath, m.ID, "metadata.json"), os.O_CREATE|os.O_WRONLY, 0740)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot open the metadata file in the datastore: %w", err)
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(m)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot write into the metadata file in the datastore: %w", err)
-	}
-
-	return m, nil
-}
-
-func Register(m Metadata, path string) error {
-	m.Path = path
-
-	err := os.MkdirAll(filepath.Join(datastorepath, m.ID), 0740)
-	if err != nil {
-		panic("cannot make directory for the game:" + err.Error())
-	}
-
-	f, err := os.OpenFile(filepath.Join(datastorepath, m.ID, "metadata.json"), os.O_CREATE|os.O_WRONLY, 0740)
-	if err != nil {
-		return fmt.Errorf("cannot open the metadata file in the datastore: %w", err)
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(m)
-	if err != nil {
-		return fmt.Errorf("cannot write into the metadata file in the datastore: %w", err)
-	}
-
-	return nil
-}
-
-func All() ([]Metadata, error) {
-	ds, err := os.ReadDir(datastorepath)
-	if err != nil {
-		return nil, fmt.Errorf("cannot open the datastore: %w", err)
-	}
-
-	var datastore []Metadata
-	for _, d := range ds {
-		content, err := os.ReadFile(filepath.Join(datastorepath, d.Name(), "metadata.json"))
-		if err != nil {
-			continue
-		}
-
-		var m Metadata
-		err = json.Unmarshal(content, &m)
-		if err != nil {
-			return nil, fmt.Errorf("corrupted datastore: failed to parse %s/metadata.json: %w", d.Name(), err)
-		}
-
-		datastore = append(datastore, m)
-	}
-	return datastore, nil
-}
-
-func One(gameID string) (Metadata, error) {
-	_, err := os.ReadDir(datastorepath)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("cannot open the datastore: %w", err)
-	}
-
-	content, err := os.ReadFile(filepath.Join(datastorepath, gameID, "metadata.json"))
-	if err != nil {
-		return Metadata{}, fmt.Errorf("game not found: %w", err)
-	}
-
-	var m Metadata
-	err = json.Unmarshal(content, &m)
-	if err != nil {
-		return Metadata{}, fmt.Errorf("corrupted datastore: failed to parse %s/metadata.json: %w", gameID, err)
-	}
-
-	return m, nil
-}
-
-func DatastorePath() string {
-	return datastorepath
-}
-
-func Remove(gameID string) error {
-	err := os.RemoveAll(filepath.Join(datastorepath, gameID))
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func Hash(gameID string) (string, error) {
-	path := filepath.Join(datastorepath, gameID, "data.tar.gz")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	hasher := md5.New()
-	if _, err := io.Copy(hasher, f); err != nil {
-		return "", err
-	}
-	sum := hasher.Sum(nil)
-	return hex.EncodeToString(sum), nil
-}
-
-func Version(gameID string) (int, error) {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return 0, err
-	}
-	defer f.Close()
-
-	var metadata Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		return 0, err
-	}
-
-	return metadata.Version, nil
-}
-
-func SetVersion(gameID string, version int) error {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return err
-	}
-
-	var metadata Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		f.Close()
-		return err
-	}
-
-	f.Close()
-
-	metadata.Version = version
-
-	f, err = os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0740)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(metadata)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func SetDate(gameID string, dt time.Time) error {
-	path := filepath.Join(datastorepath, gameID, "metadata.json")
-
-	f, err := os.OpenFile(path, os.O_RDONLY, 0)
-	if err != nil {
-		return err
-	}
-
-	var metadata Metadata
-	d := json.NewDecoder(f)
-	err = d.Decode(&metadata)
-	if err != nil {
-		f.Close()
-		return err
-	}
-
-	f.Close()
-
-	metadata.Date = dt
-
-	f, err = os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0740)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	e := json.NewEncoder(f)
-	err = e.Encode(metadata)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/remote/client/client.go

@@ -2,8 +2,8 @@ package client
 
 import (
 	"bytes"
-	"cloudsave/pkg/game"
 	"cloudsave/pkg/remote/obj"
+	"cloudsave/pkg/repository"
 	customtime "cloudsave/pkg/tools/time"
 	"encoding/json"
 	"errors"
@@ -35,6 +35,11 @@ type (
 	}
 )
 
+var (
+	ErrNotFound     error = errors.New("not found")
+	ErrUnauthorized error = errors.New("unauthorized (HTTP Error 401)")
+)
+
 func New(baseURL, username, password string) *Client {
 	return &Client{
 		baseURL:  baseURL,
@@ -44,7 +49,7 @@ func New(baseURL, username, password string) *Client {
 }
 
 func (c *Client) Exists(gameID string) (bool, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "metadata")
 	if err != nil {
 		return false, err
 	}
@@ -99,101 +104,105 @@ func (c *Client) Version() (Information, error) {
 	return Information{}, errors.New("invalid payload sent by the server")
 }
 
+// Deprecated: use c.Metadata instead
 func (c *Client) Hash(gameID string) (string, error) {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hash")
+	m, err := c.Metadata(gameID)
 	if err != nil {
 		return "", err
 	}
-
+	return m.MD5, nil
-	o, err := c.get(u)
-	if err != nil {
-		return "", err
 }
 
-	if h, ok := (o.Data).(string); ok {
+func (c *Client) Metadata(gameID string) (repository.Metadata, error) {
-		return h, nil
-	}
-
-	return "", errors.New("invalid payload sent by the server")
-}
-
-func (c *Client) Metadata(gameID string) (game.Metadata, error) {
 	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "metadata")
 	if err != nil {
-		return game.Metadata{}, err
+		return repository.Metadata{}, err
 	}
 
 	o, err := c.get(u)
 	if err != nil {
-		return game.Metadata{}, err
+		return repository.Metadata{}, err
 	}
 
 	if m, ok := (o.Data).(map[string]any); ok {
-		gm := game.Metadata{
+		gm := repository.Metadata{
 			ID:      m["id"].(string),
 			Name:    m["name"].(string),
 			Version: int(m["version"].(float64)),
 			Date:    customtime.MustParse(time.RFC3339, m["date"].(string)),
+			MD5:     m["md5"].(string),
 		}
 		return gm, nil
 	}
 
-	return game.Metadata{}, errors.New("invalid payload sent by the server")
+	return repository.Metadata{}, errors.New("invalid payload sent by the server")
 }
 
-func (c *Client) Push(gameID, archivePath string, m game.Metadata) error {
+func (c *Client) PushSave(archivePath string, m repository.Metadata) error {
-	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "data")
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", m.ID, "data")
 	if err != nil {
 		return err
 	}
 
-	f, err := os.OpenFile(archivePath, os.O_RDONLY, 0)
+	return c.push(u, archivePath, m)
-	if err != nil {
-		return fmt.Errorf("failed to open file: %w", err)
 }
-	defer f.Close()
 
-	buf := new(bytes.Buffer)
+func (c *Client) PushBackup(archiveMetadata repository.Backup, m repository.Metadata) error {
-	writer := multipart.NewWriter(buf)
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", m.ID, "hist", archiveMetadata.UUID, "data")
-
-	part, err := writer.CreateFormFile("payload", "data.tar.gz")
 	if err != nil {
 		return err
 	}
 
-	if _, err := io.Copy(part, f); err != nil {
+	return c.push(u, archiveMetadata.ArchivePath, m)
-		return fmt.Errorf("failed to copy data: %w", err)
 }
 
-	writer.WriteField("name", m.Name)
+func (c *Client) ListArchives(gameID string) ([]string, error) {
-	writer.WriteField("version", strconv.Itoa(m.Version))
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hist")
-	writer.WriteField("date", m.Date.Format(time.RFC3339))
-
-	if err := writer.Close(); err != nil {
-		return err
-	}
-
-	cli := http.Client{}
-
-	req, err := http.NewRequest("POST", u, buf)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	req.SetBasicAuth(c.username, c.password)
+	o, err := c.get(u)
-	req.Header.Set("Content-Type", writer.FormDataContentType())
-
-	res, err := cli.Do(req)
 	if err != nil {
-		return err
+		return nil, err
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode != 201 {
-		return fmt.Errorf("server returns an unexpected status code: %s (expected 201)", res.Status)
 	}
 
-	return nil
+	if o.Data == nil {
+		return nil, nil
+	}
+
+	if m, ok := (o.Data).([]any); ok {
+		var res []string
+		for _, uuid := range m {
+			res = append(res, uuid.(string))
+		}
+		return res, nil
+	}
+
+	return nil, errors.New("invalid payload sent by the server")
+}
+
+func (c *Client) ArchiveInfo(gameID, uuid string) (repository.Backup, error) {
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hist", uuid, "info")
+	if err != nil {
+		return repository.Backup{}, err
+	}
+
+	o, err := c.get(u)
+	if err != nil {
+		return repository.Backup{}, err
+	}
+
+	if m, ok := (o.Data).(map[string]any); ok {
+		b := repository.Backup{
+			UUID:      m["uuid"].(string),
+			CreatedAt: customtime.MustParse(time.RFC3339, m["created_at"].(string)),
+			MD5:       m["md5"].(string),
+		}
+		return b, nil
+	}
+
+	return repository.Backup{}, errors.New("invalid payload sent by the server")
 }
 
 func (c *Client) Pull(gameID, archivePath string) error {
@@ -244,6 +253,57 @@ func (c *Client) Pull(gameID, archivePath string) error {
 	return nil
 }
 
+func (c *Client) PullBackup(gameID, uuid, archivePath string) error {
+	u, err := url.JoinPath(c.baseURL, "api", "v1", "games", gameID, "hist", uuid, "data")
+	if err != nil {
+		return err
+	}
+
+	cli := http.Client{}
+
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return err
+	}
+
+	req.SetBasicAuth(c.username, c.password)
+
+	f, err := os.OpenFile(archivePath+".part", os.O_CREATE|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+
+	res, err := cli.Do(req)
+	if err != nil {
+		f.Close()
+		return fmt.Errorf("cannot connect to remote: %w", err)
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		f.Close()
+		return fmt.Errorf("cannot connect to remote: server return code: %s", res.Status)
+	}
+
+	bar := progressbar.DefaultBytes(
+		res.ContentLength,
+		"Pulling...",
+	)
+	defer bar.Close()
+
+	if _, err := io.Copy(io.MultiWriter(f, bar), res.Body); err != nil {
+		f.Close()
+		return fmt.Errorf("an error occured while copying the file from the remote: %w", err)
+	}
+	f.Close()
+
+	if err := os.Rename(archivePath+".part", archivePath); err != nil {
+		return fmt.Errorf("failed to move temporary data: %w", err)
+	}
+
+	return nil
+}
+
 func (c *Client) Ping() error {
 	cli := http.Client{}
 
@@ -271,7 +331,7 @@ func (c *Client) Ping() error {
 	return nil
 }
 
-func (c *Client) All() ([]game.Metadata, error) {
+func (c *Client) All() ([]repository.Metadata, error) {
 	u, err := url.JoinPath(c.baseURL, "api", "v1", "games")
 	if err != nil {
 		return nil, err
@@ -282,15 +342,20 @@ func (c *Client) All() ([]game.Metadata, error) {
 		return nil, err
 	}
 
+	if o.Data == nil {
+		return nil, nil
+	}
+
 	if games, ok := (o.Data).([]any); ok {
-		var res []game.Metadata
+		var res []repository.Metadata
 		for _, g := range games {
 			if v, ok := g.(map[string]any); ok {
-				gm := game.Metadata{
+				gm := repository.Metadata{
 					ID:      v["id"].(string),
 					Name:    v["name"].(string),
 					Version: int(v["version"].(float64)),
 					Date:    customtime.MustParse(time.RFC3339, v["date"].(string)),
+					MD5:     v["md5"].(string),
 				}
 				res = append(res, gm)
 			}
@@ -318,6 +383,14 @@ func (c *Client) get(url string) (obj.HTTPObject, error) {
 	}
 	defer res.Body.Close()
 
+	if res.StatusCode == 404 {
+		return obj.HTTPObject{}, ErrNotFound
+	}
+
+	if res.StatusCode == 401 {
+		return obj.HTTPObject{}, ErrUnauthorized
+	}
+
 	if res.StatusCode != 200 {
 		return obj.HTTPObject{}, fmt.Errorf("server returns an unexpected status code: %d %s (expected 200)", res.StatusCode, res.Status)
 	}
@@ -331,3 +404,53 @@ func (c *Client) get(url string) (obj.HTTPObject, error) {
 
 	return httpObject, nil
 }
+
+func (c *Client) push(u, archivePath string, m repository.Metadata) error {
+	f, err := os.OpenFile(archivePath, os.O_RDONLY, 0)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer f.Close()
+
+	buf := new(bytes.Buffer)
+	writer := multipart.NewWriter(buf)
+
+	part, err := writer.CreateFormFile("payload", "data.tar.gz")
+	if err != nil {
+		return err
+	}
+
+	if _, err := io.Copy(part, f); err != nil {
+		return fmt.Errorf("failed to copy data: %w", err)
+	}
+
+	writer.WriteField("name", m.Name)
+	writer.WriteField("version", strconv.Itoa(m.Version))
+	writer.WriteField("date", m.Date.Format(time.RFC3339))
+
+	if err := writer.Close(); err != nil {
+		return err
+	}
+
+	cli := http.Client{}
+
+	req, err := http.NewRequest("POST", u, buf)
+	if err != nil {
+		return err
+	}
+
+	req.SetBasicAuth(c.username, c.password)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	res, err := cli.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 201 {
+		return fmt.Errorf("server returns an unexpected status code: %s (expected 201)", res.Status)
+	}
+
+	return nil
+}

pkg/repository/repository.go

@@ -0,0 +1,571 @@
+package repository
+
+import (
+	"cloudsave/pkg/tools/hash"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+type (
+	Metadata struct {
+		ID      string    `json:"id"`
+		Name    string    `json:"name"`
+		Path    string    `json:"path"`
+		Version int       `json:"version"`
+		Date    time.Time `json:"date"`
+		MD5     string    `json:"md5,omitempty"`
+	}
+
+	Remote struct {
+		URL    string `json:"url"`
+		GameID string `json:"-"`
+	}
+
+	Backup struct {
+		CreatedAt   time.Time `json:"created_at"`
+		MD5         string    `json:"md5"`
+		UUID        string    `json:"uuid"`
+		ArchivePath string    `json:"-"`
+	}
+
+	Data struct {
+		Metadata Metadata
+		Remote   *Remote
+		DataPath string
+		Backup   map[string]Backup
+	}
+
+	GameIdentifier struct {
+		gameID string
+	}
+
+	BackupIdentifier struct {
+		gameID   string
+		backupID string
+	}
+
+	Identifier interface {
+		Key() string
+	}
+
+	LazyRepository struct {
+		dataRoot string
+	}
+
+	EagerRepository struct {
+		Repository
+
+		mu   sync.RWMutex
+		data map[string]Data
+	}
+
+	Repository interface {
+		Mkdir(id Identifier) error
+
+		All() ([]string, error)
+		AllHist(gameID GameIdentifier) ([]string, error)
+
+		WriteBlob(ID Identifier) (io.Writer, error)
+		WriteMetadata(gameID GameIdentifier, m Metadata) error
+
+		Metadata(gameID GameIdentifier) (Metadata, error)
+		LastScan(gameID GameIdentifier) (time.Time, error)
+		ReadBlob(gameID Identifier) (io.ReadSeekCloser, error)
+		Backup(id BackupIdentifier) (Backup, error)
+		Remote(id GameIdentifier) (*Remote, error)
+
+		SetRemote(gameID GameIdentifier, url string) error
+		ResetLastScan(id GameIdentifier) error
+
+		DataPath(id Identifier) string
+
+		Remove(gameID GameIdentifier) error
+	}
+)
+
+var (
+	ErrNotFound error = errors.New("not found")
+)
+
+func NewGameIdentifier(gameID string) GameIdentifier {
+	return GameIdentifier{
+		gameID: gameID,
+	}
+}
+func (bi GameIdentifier) Key() string {
+	return bi.gameID
+}
+
+func NewBackupIdentifier(gameID, backupID string) BackupIdentifier {
+	return BackupIdentifier{
+		gameID:   gameID,
+		backupID: backupID,
+	}
+}
+
+func (bi BackupIdentifier) Key() string {
+	return bi.gameID + ":" + bi.backupID
+}
+
+func NewLazyRepository(dataRootPath string) (*LazyRepository, error) {
+	if m, err := os.Stat(dataRootPath); err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			if err := os.MkdirAll(dataRootPath, 0740); err != nil {
+				return nil, fmt.Errorf("failed to make the directory: %w", err)
+			}
+		} else {
+			return nil, fmt.Errorf("failed to open datastore: %w", err)
+		}
+	} else {
+		if !m.IsDir() {
+			return nil, fmt.Errorf("failed to open datastore: not a directory")
+		}
+	}
+
+	return &LazyRepository{
+		dataRoot: dataRootPath,
+	}, nil
+}
+
+func (l *LazyRepository) Mkdir(id Identifier) error {
+	path := l.DataPath(id)
+	if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
+		slog.Debug("making directory", "path", path, "id", id, "perm", "0740")
+		return os.MkdirAll(path, 0740)
+	}
+	return nil
+}
+
+func (l *LazyRepository) All() ([]string, error) {
+	slog.Debug("loading all current data...")
+	dir, err := os.ReadDir(l.dataRoot)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open directory: %w", err)
+	}
+
+	var res []string
+	for _, d := range dir {
+		res = append(res, d.Name())
+	}
+
+	return res, nil
+}
+
+func (l *LazyRepository) AllHist(id GameIdentifier) ([]string, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading hist data...", "id", id)
+	dir, err := os.ReadDir(filepath.Join(path, "hist"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to open directory: %w", err)
+	}
+
+	var res []string
+	for _, d := range dir {
+		res = append(res, d.Name())
+	}
+
+	return res, nil
+}
+
+func (l *LazyRepository) WriteBlob(ID Identifier) (io.Writer, error) {
+	path := l.DataPath(ID)
+
+	slog.Debug("loading write buffer...", "id", ID)
+	dst, err := os.OpenFile(filepath.Join(path, "data.tar.gz"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open destination file: %w", err)
+	}
+
+	return dst, nil
+}
+
+func (l *LazyRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
+	m.MD5 = ""
+	path := l.DataPath(id)
+
+	slog.Debug("writing metadata", "id", id, "metadata", m)
+	dst, err := os.OpenFile(filepath.Join(path, "metadata.json"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open destination file: %w", err)
+	}
+	defer dst.Close()
+
+	e := json.NewEncoder(dst)
+	if err := e.Encode(m); err != nil {
+		return fmt.Errorf("failed to encode data: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LazyRepository) Metadata(id GameIdentifier) (Metadata, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading metadata", "id", id)
+	src, err := os.OpenFile(filepath.Join(path, "metadata.json"), os.O_RDONLY, 0)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return Metadata{}, ErrNotFound
+		}
+		return Metadata{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
+	}
+
+	var m Metadata
+	d := json.NewDecoder(src)
+	if err := d.Decode(&m); err != nil {
+		return Metadata{}, fmt.Errorf("corrupted datastore: failed to parse metadata: %w", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(path, "data.tar.gz")); err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return m, nil
+		}
+		return Metadata{}, fmt.Errorf("failed to open archive: %w", err)
+	}
+
+	slog.Debug("loading md5 hash", "id", id)
+	m.MD5, err = hash.FileMD5(filepath.Join(path, "data.tar.gz"))
+	if err != nil {
+		return Metadata{}, fmt.Errorf("failed to calculate md5: %w", err)
+	}
+
+	return m, nil
+}
+
+func (l *LazyRepository) Backup(id BackupIdentifier) (Backup, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading hist metadata", "id", id)
+	fs, err := os.Stat(filepath.Join(path, "data.tar.gz"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return Backup{}, ErrNotFound
+		}
+		return Backup{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
+	}
+
+	slog.Debug("loading md5 hash", "id", id)
+	h, err := hash.FileMD5(filepath.Join(path, "data.tar.gz"))
+	if err != nil {
+		return Backup{}, fmt.Errorf("corrupted datastore: failed to open metadata: %w", err)
+	}
+
+	return Backup{
+		CreatedAt:   fs.ModTime(),
+		MD5:         h,
+		UUID:        id.backupID,
+		ArchivePath: filepath.Join(path, "data.tar.gz"),
+	}, nil
+}
+
+func (l *LazyRepository) LastScan(id GameIdentifier) (time.Time, error) {
+	path := l.DataPath(id)
+
+	data, err := os.ReadFile(filepath.Join(path, ".last_run"))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return time.Time{}, nil
+		}
+		return time.Time{}, fmt.Errorf("failed to reading state file: %w", err)
+	}
+
+	lastRun, err := time.Parse(time.RFC3339, string(data))
+	if err != nil {
+		return time.Time{}, fmt.Errorf("parsing state file timestamp: %w", err)
+	}
+
+	return lastRun, nil
+}
+
+func (l *LazyRepository) ResetLastScan(id GameIdentifier) error {
+	path := l.DataPath(id)
+
+	slog.Debug("resetting last scan datetime for", "id", id)
+	f, err := os.OpenFile(filepath.Join(path, ".last_run"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer f.Close()
+
+	data := time.Now().Format(time.RFC3339)
+
+	if _, err := f.WriteString(data); err != nil {
+		return fmt.Errorf("failed to write file: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LazyRepository) ReadBlob(id Identifier) (io.ReadSeekCloser, error) {
+	path := l.DataPath(id)
+
+	slog.Debug("loading read buffer...", "id", id)
+	dst, err := os.OpenFile(filepath.Join(path, "data.tar.gz"), os.O_RDONLY, 0)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open blob: %w", err)
+	}
+
+	return dst, nil
+}
+
+func (l *LazyRepository) SetRemote(id GameIdentifier, url string) error {
+	path := l.DataPath(id)
+
+	src, err := os.OpenFile(filepath.Join(path, "remote.json"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0740)
+	if err != nil {
+		return fmt.Errorf("failed to open remote description: %w", err)
+	}
+	defer src.Close()
+
+	var r Remote
+	r.URL = url
+
+	e := json.NewEncoder(src)
+	if err := e.Encode(r); err != nil {
+		return fmt.Errorf("failed to marshall remote description: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LazyRepository) Remote(id GameIdentifier) (*Remote, error) {
+	path := l.DataPath(id)
+
+	src, err := os.OpenFile(filepath.Join(path, "remote.json"), os.O_RDONLY, 0)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to open remote description: %w", err)
+	}
+	defer src.Close()
+
+	var r Remote
+	e := json.NewDecoder(src)
+	if err := e.Decode(&r); err != nil {
+		return nil, fmt.Errorf("failed to marshall remote description: %w", err)
+	}
+
+	return &r, nil
+}
+
+func (l *LazyRepository) Remove(id GameIdentifier) error {
+	path := l.DataPath(id)
+
+	slog.Debug("removing data", "id", id)
+	if err := os.RemoveAll(path); err != nil {
+		return fmt.Errorf("failed to remove game folder from the datastore: %w", err)
+	}
+
+	return nil
+}
+
+func (r *LazyRepository) DataPath(id Identifier) string {
+	switch identifier := id.(type) {
+	case GameIdentifier:
+		return filepath.Join(r.dataRoot, identifier.gameID)
+	case BackupIdentifier:
+		return filepath.Join(r.dataRoot, identifier.gameID, "hist", identifier.backupID)
+	}
+
+	panic("identifier type not supported")
+}
+
+func NewEagerRepository(dataRootPath string) (*EagerRepository, error) {
+	r, err := NewLazyRepository(dataRootPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return &EagerRepository{
+		Repository: r,
+		data:       make(map[string]Data),
+	}, nil
+}
+
+func (r *EagerRepository) Preload() error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	games, err := r.Repository.All()
+	if err != nil {
+		return fmt.Errorf("failed to load all data: %w", err)
+	}
+
+	for _, g := range games {
+		backup, err := r.Repository.AllHist(NewGameIdentifier(g))
+		if err != nil {
+			return fmt.Errorf("[%s] failed to load hist data: %w", g, err)
+		}
+
+		remote, err := r.Repository.Remote(NewGameIdentifier(g))
+		if err != nil {
+			return fmt.Errorf("[%s] failed to load remote metadata: %w", g, err)
+		}
+
+		m, err := r.Repository.Metadata(NewGameIdentifier(g))
+		if err != nil {
+			return fmt.Errorf("[%s] failed to load metadata: %w", g, err)
+		}
+
+		backups := make(map[string]Backup)
+		for _, b := range backup {
+			info, err := r.Repository.Backup(NewBackupIdentifier(g, b))
+			if err != nil {
+				return fmt.Errorf("[%s] failed to get backup information: %w", g, err)
+			}
+
+			backups[b] = info
+		}
+
+		r.data[g] = Data{
+			Metadata: m,
+			Remote:   remote,
+			DataPath: r.DataPath(NewGameIdentifier(g)),
+			Backup:   backups,
+		}
+	}
+
+	return nil
+}
+
+func (r *EagerRepository) All() ([]string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var res []string
+	for _, g := range r.data {
+		res = append(res, g.Metadata.ID)
+	}
+
+	return res, nil
+}
+
+func (r *EagerRepository) AllHist(id GameIdentifier) ([]string, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var res []string
+	if d, ok := r.data[id.gameID]; ok {
+		for _, b := range d.Backup {
+			res = append(res, b.UUID)
+		}
+	}
+	return res, nil
+}
+
+func (r *EagerRepository) WriteMetadata(id GameIdentifier, m Metadata) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	err := r.Repository.WriteMetadata(id, m)
+	if err != nil {
+		return err
+	}
+
+	d := r.data[id.gameID]
+	d.Metadata = m
+	r.data[id.gameID] = d
+
+	return nil
+}
+
+func (r *EagerRepository) Metadata(id GameIdentifier) (Metadata, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if d, ok := r.data[id.gameID]; ok {
+		return d.Metadata, nil
+	}
+	return Metadata{}, ErrNotFound
+}
+
+func (r *EagerRepository) Backup(id BackupIdentifier) (Backup, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	if d, ok := r.data[id.gameID]; ok {
+		if b, ok := d.Backup[id.backupID]; ok {
+			return b, nil
+		}
+	}
+	return Backup{}, ErrNotFound
+}
+
+func (r *EagerRepository) SetRemote(id GameIdentifier, url string) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	err := r.Repository.SetRemote(id, url)
+	if err != nil {
+		return err
+	}
+
+	d := r.data[id.gameID]
+	d.Remote = &Remote{
+		URL:    url,
+		GameID: d.Metadata.ID,
+	}
+	r.data[id.gameID] = d
+
+	return nil
+}
+
+func (r *EagerRepository) Remove(id GameIdentifier) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if err := r.Repository.Remove(id); err != nil {
+		return err
+	}
+
+	delete(r.data, id.gameID)
+	return nil
+}
+
+func (r *EagerRepository) ReloadMetadata(id GameIdentifier) error {
+	backup, err := r.Repository.AllHist(id)
+	if err != nil {
+		return fmt.Errorf("[%s] failed to load hist data: %w", id, err)
+	}
+
+	remote, err := r.Repository.Remote(id)
+	if err != nil {
+		return fmt.Errorf("[%s] failed to load remote metadata: %w", id, err)
+	}
+
+	m, err := r.Repository.Metadata(id)
+	if err != nil {
+		return fmt.Errorf("[%s] failed to load metadata: %w", id, err)
+	}
+
+	backups := make(map[string]Backup)
+	for _, b := range backup {
+		info, err := r.Repository.Backup(NewBackupIdentifier(id.gameID, b))
+		if err != nil {
+			return fmt.Errorf("[%s] failed to get backup information: %w", id, err)
+		}
+
+		backups[b] = info
+	}
+
+	r.data[id.gameID] = Data{
+		Metadata: m,
+		Remote:   remote,
+		DataPath: r.DataPath(id),
+		Backup:   backups,
+	}
+
+	return nil
+}

pkg/tools/archive/archive.go

@@ -3,6 +3,7 @@ package archive
 import (
 	"archive/tar"
 	"compress/gzip"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -71,3 +72,53 @@ func Untar(file io.Reader, path string) error {
 		}
 	}
 }
+
+func Tar(file io.Writer, root string) error {
+	gw := gzip.NewWriter(file)
+	defer gw.Close()
+
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	// Walk again to add files
+	err := filepath.Walk(root, func(path string, info os.FileInfo, walkErr error) error {
+		if walkErr != nil {
+			return fmt.Errorf("failed to walk through the directory: %w", walkErr)
+		}
+
+		relpath, err := filepath.Rel(root, path)
+		if err != nil {
+			return fmt.Errorf("failed to make relative path: %w", err)
+		}
+
+		// Create tar header
+		header, err := tar.FileInfoHeader(info, path)
+		if err != nil {
+			return fmt.Errorf("failed to make file info header: %w", err)
+		}
+		header.Name = relpath
+
+		if err := tw.WriteHeader(header); err != nil {
+			return fmt.Errorf("failed to write header: %w", err)
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		file, err := os.Open(path)
+		if err != nil {
+			return fmt.Errorf("failed to open file: %w", err)
+		}
+		defer file.Close()
+		if _, err := io.Copy(tw, file); err != nil {
+			return fmt.Errorf("failed to copy file: %w", err)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("writing tar entries: %w", err)
+	}
+
+	return nil
+}

pkg/tools/hash/hash.go

@@ -0,0 +1,23 @@
+package hash
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"io"
+	"os"
+)
+
+func FileMD5(fp string) (string, error) {
+	f, err := os.OpenFile(fp, os.O_RDONLY, 0)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	hasher := md5.New()
+	if _, err := io.Copy(hasher, f); err != nil {
+		return "", err
+	}
+	sum := hasher.Sum(nil)
+	return hex.EncodeToString(sum), nil
+}