fixes

.gitignore

@@ -1,6 +1,7 @@
 /cli
 /server
 /web
+/gui
 /env/
 /build/
 *.exe

cmd/cli/commands/login/login.go

@@ -32,7 +32,8 @@ func (p *LoginCmd) SetFlags(f *flag.FlagSet) {
 
 func (p *LoginCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
 	if f.NArg() != 1 {
-		fmt.Fprintf(os.Stderr, "error: this command take 1 argument")
+		fmt.Fprintln(os.Stderr, "error: this command take 1 argument")
+		
 		return subcommands.ExitUsageError
 	}
 
@@ -46,12 +47,12 @@ func (p *LoginCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 
 	cli := client.New(server, username, password)
 	if _, err := cli.Version(); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to login: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to login: %s\n", err)
 		return subcommands.ExitFailure
 	}
 
 	if err := credentials.Login(username, password, server); err != nil {
-		fmt.Fprintf(os.Stderr, "error: failed to save login: %s", err)
+		fmt.Fprintf(os.Stderr, "error: failed to save login: %s\n", err)
 		return subcommands.ExitFailure
 	}
 

cmd/cli/commands/remote/remote.go

@@ -27,9 +27,11 @@ func (*RemoteCmd) Usage() string {
 
 The -list argument lists all remotes for each registered game.
 This command performs a connection test.
+Usage: cloudsave remote -list
 
 The -set argument allow you to set (create or update) 
 the URL to the remote for a game
+Usage: cloudsave remote -set GAME_ID REMOTE_URL
 
 Options
 `

cmd/cli/commands/sync/sync.go

@@ -7,11 +7,10 @@ import (
 	"cloudsave/pkg/remote"
 	"cloudsave/pkg/remote/client"
 	"cloudsave/pkg/repository"
+	"cloudsave/pkg/sync"
 	"context"
-	"errors"
 	"flag"
 	"fmt"
-	"log/slog"
 	"os"
 	"time"
 
@@ -38,247 +37,92 @@ func (p *SyncCmd) SetFlags(f *flag.FlagSet) {
 }
 
 func (p *SyncCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	games, err := p.Service.AllGames()
+
+	remoteCred := make(map[string]map[string]string)
+	rs, err := remote.All()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "error: failed to load datastore:", err)
+		fmt.Fprintln(os.Stderr, "error: failed to connect to the remote:", err)
 		return subcommands.ExitFailure
 	}
 
-	remoteCred := make(map[string]map[string]string)
+	done := make(map[string]struct{})
-	for _, g := range games {
+	for _, r := range rs {
-		r, err := remote.One(g.ID)
+		if _, ok := done[r.URL]; ok {
-		if err != nil {
+			continue
-			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)
+		fmt.Println()
+
+		done[r.URL] = struct{}{}
+		syncer := sync.NewSyncer(cli, p.Service)
+
+		var pg *progressbar.ProgressBar
 		destroyPg := func() {
-			if err := pg.Finish(); err != nil {
+			pg.Finish()
-				slog.Error("failed to finish progressbar", "err", err)
+			pg.Clear()
-			}
+			pg.Close()
-			if err := pg.Clear(); err != nil {
-				slog.Error("failed to clear progressbar", "err", err)
-			}
-			if err := pg.Close(); err != nil {
-				slog.Error("failed to close progressbar", "err", err)
-			}
 		}
 
-		pg.Describe(fmt.Sprintf("[%s] Checking status...", g.Name))
+		syncer.SetStateCallback(func(s sync.State, g repository.Metadata) {
-		exists, err := cli.Exists(r.GameID)
+			switch s {
-		if err != nil {
+			case sync.FetchingMetdata:
-			slog.Error(err.Error())
+				pg = progressbar.New(-1)
-			continue
+				pg.Describe(fmt.Sprintf("%s: fetching metadata from repository", g.Name))
-		}
+			case sync.Pushing:
-
+				pg.Describe(fmt.Sprintf("%s: pushing data to the server", g.Name))
-		if !exists {
+			case sync.Pulling:
-			pg.Describe(fmt.Sprintf("[%s] Pushing data...", g.Name))
+				pg.Describe(fmt.Sprintf("%s: pull data from the server", g.Name))
-			if err := p.push(g, cli); err != nil {
+			case sync.UpToDate:
 				destroyPg()
-				fmt.Fprintln(os.Stderr, "failed to push:", err)
+				fmt.Println("🆗", g.Name+": already up-to-date")
-				return subcommands.ExitFailure
+			case sync.Pushed:
-			}
-			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)
+				fmt.Println("⬆️", g.Name+": pushed")
-			}
+			case sync.Pulled:
-			destroyPg()
-			fmt.Println("⬆️", g.Name+": pushed")
-			continue
-		}
-
-		pg.Describe(fmt.Sprintf("[%s] Fetching metadata...", g.Name))
-
-		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
-		}
-
-		pg.Describe(fmt.Sprintf("[%s] Pulling backup...", g.Name))
-		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 := p.Service.SetVersion(r.GameID, remoteMetadata.Version); err != nil {
-					fmt.Fprintln(os.Stderr, "error: failed to synchronize version number:", err)
-					continue
-				}
-			}
-			fmt.Println("🆗", g.Name+": already up-to-date")
-			continue
-		}
-
-		if g.Version > remoteMetadata.Version {
-			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)
+				fmt.Println("⬇️", g.Name+": pulled")
-				return subcommands.ExitFailure
 			}
+		})
+
+		syncer.SetErrorCallback(func(err error, g repository.Metadata) {
 			destroyPg()
-			fmt.Println("⬆️", g.Name+": pushed")
+			fmt.Println("❌", g.Name+": "+err.Error())
-			continue
+		})
-		}
 
-		if g.Version < remoteMetadata.Version {
+		syncer.SetConflictCallback(func(a, b repository.Metadata) sync.ConflictResolution {
-			destroyPg()
+			fmt.Println()
-			if err := p.pull(g, cli); err != nil {
+			fmt.Println("--- ⚠️ CONFLICT ---")
-				destroyPg()
+			fmt.Println(a.Name, "(", a.Path, ")")
-				fmt.Fprintln(os.Stderr, "failed to push:", err)
+			fmt.Println("----")
-				return subcommands.ExitFailure
+			fmt.Println("Your version:", a.Date.Format(time.RFC1123))
+			fmt.Println("Their version:", b.Date.Format(time.RFC1123))
+			fmt.Println()
+
+			res := prompt.Conflict()
+
+			switch res {
+			case prompt.Their:
+				return sync.Their
+			case prompt.My:
+				return sync.Mine
 			}
 
-			g.Version = remoteMetadata.Version
+			return sync.None
-			g.Date = remoteMetadata.Date
+		})
 
-			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
+		syncer.Sync()
-				destroyPg()
-				fmt.Fprintln(os.Stderr, "failed to push:", err)
-				return subcommands.ExitFailure
-			}
-			fmt.Println("⬇️", g.Name+": pulled")
-			continue
-		}
-
-		destroyPg()
-
-		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
-			}
-			continue
-		}
 	}
 
 	fmt.Println("done.")
 	return subcommands.ExitSuccess
 }
 
-func (p *SyncCmd) conflict(gameID string, m, remoteMetadata repository.Metadata, cli *client.Client) error {
-	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)
-		return nil
-	}
-	fmt.Println()
-	fmt.Println("--- ⚠️ CONFLICT ---")
-	fmt.Println(g.Name, "(", g.Path, ")")
-	fmt.Println("----")
-	fmt.Println("Your version:", g.Date.Format(time.RFC1123))
-	fmt.Println("Their version:", remoteMetadata.Date.Format(time.RFC1123))
-	fmt.Println()
-
-	res := prompt.Conflict()
-
-	switch res {
-	case prompt.My:
-		{
-			if err := p.push(m, cli); err != nil {
-				return fmt.Errorf("failed to push: %w", err)
-			}
-		}
-
-	case prompt.Their:
-		{
-			if err := p.pull(g, cli); err != nil {
-				return fmt.Errorf("failed to push: %w", err)
-			}
-			g.Version = remoteMetadata.Version
-			g.Date = remoteMetadata.Date
-
-			if err := p.Service.UpdateMetadata(g.ID, g); err != nil {
-				return fmt.Errorf("failed to push: %w", err)
-			}
-		}
-	}
-	return nil
-}
-
-func (p *SyncCmd) push(m repository.Metadata, cli *client.Client) error {
-	return p.Service.PushArchive(m.ID, "", cli)
-}
-
-func (p *SyncCmd) pushBackup(m repository.Metadata, cli *client.Client) error {
-	bs, err := p.Service.AllBackups(m.ID)
-	if err != nil {
-		return err
-	}
-
-	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(g repository.Metadata, cli *client.Client) error {
-	if err := p.Service.PullArchive(g.ID, "", cli); err != nil {
-		return err
-	}
-	return p.Service.ApplyCurrent(g.ID)
-}
-
 func connect(remoteCred map[string]map[string]string, r remote.Remote) (*client.Client, error) {
 	var cli *client.Client
 

cmd/cli/main.go

@@ -44,7 +44,6 @@ func main() {
 
 	subcommands.Register(subcommands.HelpCommand(), "help")
 	subcommands.Register(subcommands.FlagsCommand(), "help")
-	subcommands.Register(subcommands.CommandsCommand(), "help")
 	subcommands.Register(&version.VersionCmd{}, "help")
 
 	subcommands.Register(&add.AddCmd{Service: s}, "management")

cmd/cli/tools/prompt/credentials/credentials.go

@@ -35,6 +35,17 @@ func init() {
 	datastorePath = filepath.Join(roaming, "cloudsave")
 }
 
+func Get(server string) (string, string, error) {
+	var err error
+	store, err := load()
+	if err == nil {
+		if c, ok := store[server]; ok {
+			return c.Username, c.Password, nil
+		}
+	}
+	return "","",fmt.Errorf("not found")
+}
+
 func Read(server string) (string, string, error) {
 	var err error
 	store, err := load()

cmd/server/runner.go

@@ -30,6 +30,14 @@ func run(updateChan <-chan struct{}) {
 		slog.SetLogLoggerLevel(slog.LevelDebug)
 	}
 
+	if !filepath.IsAbs(documentRoot) {
+		if v, err := filepath.Abs(documentRoot); err == nil {
+			documentRoot = v
+		} else {
+			fatal("failed to get absolute path from document-root flag: "+err.Error(), 2)
+		}
+	}
+
 	slog.Info("loading .htpasswd")
 	h, err := htpasswd.Open(filepath.Join(documentRoot, ".htpasswd"))
 	if err != nil {

pkg/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
-const Version = "0.0.4e"
+const Version = "0.0.5"
 
 const ApiVersion = 1

pkg/remote/client/client.go

@@ -384,6 +384,10 @@ func (c *Client) All() ([]repository.Metadata, error) {
 	return nil, errors.New("invalid payload sent by the server")
 }
 
+func (c *Client) BaseURL() string {
+	return c.baseURL
+}
+
 func (c *Client) get(url string) (obj.HTTPObject, error) {
 	cli := http.Client{}
 

pkg/remote/remote.go

@@ -57,6 +57,28 @@ func One(gameID string) (Remote, error) {
 	return r, nil
 }
 
+func All() ([]Remote, error) {
+	d, err := os.ReadDir(filepath.Clean(datastorepath))
+	if err != nil {
+		return nil, fmt.Errorf("failed to load datastore: %w", err)
+	}
+
+	var res []Remote
+	for _, g := range d {
+		r, err := One(g.Name())
+		if err != nil {
+			if errors.Is(err, ErrNoRemote) {
+				continue
+			}
+			return nil, fmt.Errorf("failed to load remote: %w", err)
+		}
+
+		res = append(res, r)
+	}
+
+	return res, nil
+}
+
 func Set(gameID, url string) error {
 	r := Remote{
 		URL: url,

pkg/sync/sync.go

@@ -0,0 +1,237 @@
+package sync
+
+import (
+	"cloudsave/pkg/data"
+	"cloudsave/pkg/remote"
+	"cloudsave/pkg/remote/client"
+	"cloudsave/pkg/repository"
+	"errors"
+	"fmt"
+)
+
+type (
+	ConflictResolution int
+	State              int
+	decision           int
+
+	Syncer struct {
+		cli     *client.Client
+		service *data.Service
+
+		stateCallback    func(s State, g repository.Metadata)
+		errorCallback    func(err error, g repository.Metadata)
+		conflictCallback func(a, b repository.Metadata) ConflictResolution
+	}
+)
+
+const (
+	Their ConflictResolution = iota
+	Mine
+	None
+)
+
+const (
+	ignore decision = iota
+	push
+	pull
+)
+
+const (
+	FetchingMetdata State = iota
+	Pushing
+	Pulling
+	Pushed
+	Pulled
+	UpToDate
+	Done
+)
+
+var (
+	ErrFetching  error = errors.New("failed to fetch the metadata")
+	ErrPushing   error = errors.New("failed to push data")
+	ErrPulling   error = errors.New("failed to pull data")
+	ErrDatastore error = errors.New("failed to get data from local datastore")
+)
+
+func NewSyncer(cli *client.Client, service *data.Service) *Syncer {
+	return &Syncer{
+		cli:     cli,
+		service: service,
+	}
+}
+
+func (s *Syncer) SetStateCallback(fn func(s State, g repository.Metadata)) {
+	s.stateCallback = fn
+}
+
+func (s *Syncer) SetErrorCallback(fn func(err error, g repository.Metadata)) {
+	s.errorCallback = fn
+}
+
+func (s *Syncer) SetConflictCallback(fn func(a, b repository.Metadata) ConflictResolution) {
+	s.conflictCallback = fn
+}
+
+func (s *Syncer) Sync() {
+	games, err := s.service.AllGames()
+	if err != nil {
+		s.errorCallback(fmt.Errorf("failed to get all games: %w", err), repository.Metadata{})
+		return
+	}
+
+	for _, g := range games {
+		r, err := remote.One(g.ID)
+		if err != nil {
+			continue
+		}
+		if r.URL != s.cli.BaseURL() {
+			continue
+		}
+		if err := s.sync(g); err != nil {
+			s.errorCallback(err, g)
+		}
+	}
+	s.stateCallback(Done, repository.Metadata{})
+}
+
+func (s *Syncer) sync(g repository.Metadata) error {
+	s.stateCallback(FetchingMetdata, g)
+
+	remoteMetadata, err := s.cli.Metadata(g.ID)
+	if err != nil {
+		if errors.Is(err, client.ErrNotFound) {
+			s.stateCallback(Pushing, g)
+			if err := s.push(g); err != nil {
+				return fmt.Errorf("%w: %s", ErrPushing, err)
+			}
+			s.stateCallback(Pushed, g)
+			return nil
+		}
+		return fmt.Errorf("%w: %s", ErrFetching, err)
+	}
+
+	if g.MD5 == remoteMetadata.MD5 {
+		s.stateCallback(UpToDate, g)
+		return nil
+	}
+
+	d := ignore
+
+	if g.Version > remoteMetadata.Version {
+		d = push
+	}
+
+	if g.Version < remoteMetadata.Version {
+		d = pull
+	}
+
+	if g.Version == remoteMetadata.Version {
+		r := s.conflictCallback(g, remoteMetadata)
+		switch r {
+		case Mine:
+			{
+				d = push
+			}
+		case Their:
+			{
+				d = pull
+			}
+		}
+		return nil
+	}
+
+	switch d {
+	case push:
+		{
+			s.stateCallback(Pushing, g)
+			if err := s.push(g); err != nil {
+				return fmt.Errorf("%w: %s", ErrPushing, err)
+			}
+			s.stateCallback(Pushed, g)
+			return nil
+		}
+	case pull:
+		{
+			s.stateCallback(Pulling, g)
+			if err := s.pull(g, remoteMetadata); err != nil {
+				return fmt.Errorf("%w: %s", ErrPulling, err)
+			}
+			s.stateCallback(Pulled, g)
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (s *Syncer) push(g repository.Metadata) error {
+	if err := s.service.PushArchive(g.ID, "", s.cli); err != nil {
+		return err
+	}
+
+	// manage backup
+	bs, err := s.service.AllBackups(g.ID)
+	if err != nil {
+		return err
+	}
+
+	for _, b := range bs {
+		binfo, err := s.cli.ArchiveInfo(g.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 := s.cli.PushBackup(b, g); err != nil {
+				return fmt.Errorf("failed to push backup: %w", err)
+			}
+		}
+
+	}
+	return nil
+}
+
+func (s *Syncer) pull(g, r repository.Metadata) error {
+	g.Version = r.Version
+	g.Date = r.Date
+
+	if err := s.service.UpdateMetadata(g.ID, g); err != nil {
+		return err
+	}
+
+	if err := s.service.PullArchive(g.ID, "", s.cli); err != nil {
+		return err
+	}
+
+	if err := s.service.ApplyCurrent(g.ID); err != nil {
+		return err
+	}
+
+	// manage backup
+	bs, err := s.cli.ListArchives(g.ID)
+	if err != nil {
+		return err
+	}
+
+	for _, uuid := range bs {
+		rinfo, err := s.cli.ArchiveInfo(g.ID, uuid)
+		if err != nil {
+			return err
+		}
+
+		linfo, err := s.service.Backup(g.ID, uuid)
+		if err != nil {
+			return err
+		}
+
+		if linfo.MD5 != rinfo.MD5 {
+			if err := s.service.PullBackup(g.ID, uuid, s.cli); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

pkg/tools/iterator/iterator.go

@@ -0,0 +1,40 @@
+package iterator
+
+type (
+	Iterator[T any] struct {
+		index  int
+		values []T
+	}
+)
+
+func New[T any](values []T) *Iterator[T] {
+	return &Iterator[T]{
+		values: values,
+	}
+}
+
+func (it *Iterator[T]) Next() bool {
+	if len(it.values) == it.index {
+		return false
+	}
+	it.index += 1
+	return true
+}
+
+func (it *Iterator[T]) Value() T {
+	if len(it.values) == 0 {
+		var zero T
+		return zero
+	}
+
+	if len(it.values) == it.index {
+		var zero T
+		return zero
+	}
+
+	return it.values[it.index]
+}
+
+func (it *Iterator[T]) IsEmpty() bool {
+	return len(it.values) == 0
+}