+Check the [modding documentation](https://docs.ficsit.app/satisfactory-modding/latest/index.html#_for_users)
+for installation and usage instructions.
-### Usage
-
-Just choose a compatible mod and click install. SMM will take care of everything else!
-
-### Features
+## Features
* One-click install of any mod
* Automatically downloads the dependencies of any mod
@@ -20,22 +18,65 @@ Just choose a compatible mod and click install. SMM will take care of everything
* Mod profiles and sharing of them
* View the mod description in the app
-### Reporting issues
+## Reporting issues
+
+If you have any questions or run into issues, you can ask in the
+[Satisfactory Modding discord](https://discord.gg/TShj39G)
+for quicker responses than the GitHub issues.
+If there is any error message, please include it along with the generated debug info zip.
+
+## Troubleshooting
+
+Check the [modding documentation](https://docs.ficsit.app/satisfactory-modding/latest/ForUsers/SatisfactoryModManager.html)
+for common issues and their solutions.
+
+* Profile and installation records are located in `%APPDATA%\SatisfactoryModManager\`
+* Downloads are cached in `%LOCALAPPDATA%\SatisfactoryModManager\downloadCache\`
+
+## Development
+
+### Dependencies
+
+* [Go 1.21](https://go.dev/doc/install)
+* [pnpm](https://pnpm.io/installation)
+* [nodejs](https://nodejs.org/en/download/)
+* Wails (`go install github.com/wailsapp/wails/v2/cmd/wails@latest`)
+* IDE of Choice. Goland or VSCode suggested.
+
+### Configuration
-If you have any questions or run into issues, you can ask in the [Satisfactory Modding discord](https://discord.gg/TShj39G) for quicker responses than the GitHub issues. If there is any error message, please include it along with the generated debug info zip.
+If you want to point to the SMR staging API instead of production, edit:
-### Development
-``` bash
-# install dependencies
-yarn install
+* `main.go` to set `api-base` to the staging api (`https://api.ficsit.dev`)
+* `frontend\.graphqlrc` to set `schema` to the staging api (`https://api.ficsit.dev/v2/query`)
+* `frontend\codegen.yml` to set `schema` to the staging api (`https://api.ficsit.dev/v2/query`)
+
+### Development Server
+
+The development server will hot reload whenever you make changes to the Go or Typescript code.
+
+```bash
+wails dev
+```
+
+Upon successful launch of the development server, the application will open automatically.
+The command line output will also include a localhost URL you can visit in your browser if you wish to utilize browser developer tools for debugging.
+
+Make sure you don't already have a copy of the application running or the command will silently fail.
+
+### Building
+
+```bash
+wails build
+```
-# serve with hot reload at localhost:9080
-yarn dev
+### Linting
-# build electron application for production
-yarn dist
+Install `golangci-lint` via the directions [here](https://golangci-lint.run/usage/install/#local-installation),
+but make sure to install the version specified in `.github/workflows/push.yaml` instead of whatever it suggests.
-# lint all JS/Vue component files in `src/`
-yarn lint
+Then, to run it, use:
+```bash
+golangci-lint run --fix
```
diff --git a/backend/args.go b/backend/args.go
new file mode 100644
index 00000000..8d79e51b
--- /dev/null
+++ b/backend/args.go
@@ -0,0 +1,55 @@
+package backend
+
+import (
+ "log/slog"
+ "net/url"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/bindings"
+)
+
+func ProcessArguments(args []string) {
+ if len(args) < 1 {
+ return
+ }
+ if strings.HasPrefix(args[0], "smmanager://") {
+ uri := args[0]
+ err := handleURI(uri)
+ if err != nil {
+ slog.Error("failed to handle smmanager:// URI", slog.Any("error", err), slog.String("uri", uri))
+ }
+ } else {
+ err := handleFile(args[0])
+ if err != nil {
+ slog.Error("failed to handle file", slog.Any("error", err), slog.String("path", args[0]))
+ }
+ }
+ bindings.BindingsInstance.App.Show()
+}
+
+func handleURI(uri string) error {
+ u, err := url.Parse(uri)
+ if err != nil {
+ return errors.Wrap(err, "failed to parse URI")
+ }
+ switch u.Host {
+ case "install":
+ modID := u.Query().Get("modID")
+ version := u.Query().Get("version")
+ bindings.BindingsInstance.App.ExternalInstallMod(modID, version)
+ return nil
+ default:
+ return errors.New("unknown URI action " + u.Host)
+ }
+}
+
+func handleFile(path string) error {
+ if strings.HasSuffix(path, ".smmprofile") {
+ println(path)
+ bindings.BindingsInstance.App.ExternalImportProfile(path)
+ return nil
+ }
+ return errors.New("unknown file type " + path)
+}
diff --git a/backend/autoupdate/autoupdate.go b/backend/autoupdate/autoupdate.go
new file mode 100644
index 00000000..14f35623
--- /dev/null
+++ b/backend/autoupdate/autoupdate.go
@@ -0,0 +1,62 @@
+package autoupdate
+
+import (
+ "log/slog"
+ "time"
+
+ "github.com/spf13/viper"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/apply"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/source/github"
+)
+
+var (
+ Updater *updater.Updater
+ updateApply apply.Apply
+ releaseFile string
+)
+
+func Init(config Config) {
+ releaseFile, updateApply = getInstallType()
+ Updater = updater.MakeUpdater(updater.Config{
+ Source: github.MakeGithubProvider(viper.GetString("github-release-repo"), releaseFile),
+ Apply: updateApply,
+ CurrentVersion: viper.GetString("version"),
+ UpdateFoundCallback: config.UpdateFoundCallback,
+ DownloadProgressCallback: config.DownloadProgressCallback,
+ UpdateReadyCallback: config.UpdateReadyCallback,
+ })
+}
+
+var checkStarted bool
+
+func CheckInterval(interval time.Duration) {
+ if checkStarted {
+ return
+ }
+ checkStarted = true
+ updateCheckTicker := time.NewTicker(interval)
+ go func() {
+ err := Updater.CheckForUpdate()
+ if err != nil {
+ slog.Error("failed to check for update", slog.Any("error", err))
+ }
+ for range updateCheckTicker.C {
+ err := Updater.CheckForUpdate()
+ if err != nil {
+ slog.Error("failed to check for update", slog.Any("error", err))
+ }
+ }
+ }()
+}
+
+func OnExit(restart bool) error {
+ return updateApply.OnExit(restart)
+}
+
+type Config struct {
+ UpdateFoundCallback func(latestVersion string, changelogs map[string]string)
+ DownloadProgressCallback func(bytesDownloaded, totalBytes int64)
+ UpdateReadyCallback func()
+}
diff --git a/backend/autoupdate/installtype_linux.go b/backend/autoupdate/installtype_linux.go
new file mode 100644
index 00000000..f4bb46c4
--- /dev/null
+++ b/backend/autoupdate/installtype_linux.go
@@ -0,0 +1,9 @@
+package autoupdate
+
+import (
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/apply"
+)
+
+func getInstallType() (string, apply.Apply) {
+ return "Satisfactory Mod Manager", apply.MakeSingleFileApply()
+}
diff --git a/backend/autoupdate/installtype_windows.go b/backend/autoupdate/installtype_windows.go
new file mode 100644
index 00000000..59f262fd
--- /dev/null
+++ b/backend/autoupdate/installtype_windows.go
@@ -0,0 +1,35 @@
+package autoupdate
+
+import (
+ "path/filepath"
+
+ "github.com/spf13/viper"
+ "golang.org/x/sys/windows/registry"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/apply"
+)
+
+func getInstallType() (string, apply.Apply) {
+ nsis, elevation := isNsis()
+ if nsis {
+ return "Satisfactory-Mod-Manager-Setup.exe", apply.MakeNsisApply(apply.NsisApplyConfig{
+ InstallerDownloadPath: filepath.Join(viper.GetString("cache-dir"), "Satisfactory-Mod-Manager-Setup.exe"),
+ Elevation: elevation,
+ })
+ }
+ return "Satisfactory Mod Manager.exe", apply.MakeSingleFileApply()
+}
+
+func isNsis() (bool, bool) {
+ k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Satisfactory Mod Manager`, registry.READ)
+ if err == nil {
+ k.Close()
+ return true, true
+ }
+ k, err = registry.OpenKey(registry.CURRENT_USER, `SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Satisfactory Mod Manager`, registry.READ)
+ if err == nil {
+ k.Close()
+ return true, false
+ }
+ return false, false
+}
diff --git a/backend/autoupdate/updater/apply/apply.go b/backend/autoupdate/updater/apply/apply.go
new file mode 100644
index 00000000..dfb87013
--- /dev/null
+++ b/backend/autoupdate/updater/apply/apply.go
@@ -0,0 +1,8 @@
+package apply
+
+import "io"
+
+type Apply interface {
+ Apply(file io.Reader) error
+ OnExit(restart bool) error
+}
diff --git a/backend/autoupdate/updater/apply/nsis.go b/backend/autoupdate/updater/apply/nsis.go
new file mode 100644
index 00000000..d03e6276
--- /dev/null
+++ b/backend/autoupdate/updater/apply/nsis.go
@@ -0,0 +1,54 @@
+package apply
+
+import (
+ "io"
+ "os"
+ "os/exec"
+
+ "github.com/pkg/errors"
+)
+
+type NsisApply struct {
+ config NsisApplyConfig
+}
+
+type NsisApplyConfig struct {
+ InstallerDownloadPath string
+ Elevation bool
+}
+
+func MakeNsisApply(config NsisApplyConfig) *NsisApply {
+ return &NsisApply{
+ config: config,
+ }
+}
+
+func (a *NsisApply) Apply(file io.Reader) error {
+ fileContent, err := io.ReadAll(file)
+ if err != nil {
+ return errors.Wrap(err, "failed to read installer file")
+ }
+ err = os.WriteFile(a.config.InstallerDownloadPath, fileContent, 0o755)
+ if err != nil {
+ return errors.Wrap(err, "failed to write installer file")
+ }
+ return nil
+}
+
+func (a *NsisApply) OnExit(restart bool) error {
+ arguments := []string{"/S"}
+ if restart {
+ // TODO implement this in my installer
+ arguments = append(arguments, "--force-run")
+ }
+ cmd := exec.Command(a.config.InstallerDownloadPath, arguments...)
+ err := cmd.Start()
+ if err != nil {
+ return errors.Wrap(err, "failed to start nsis installer")
+ }
+ err = cmd.Process.Release()
+ if err != nil {
+ return errors.Wrap(err, "failed to release nsis installer process")
+ }
+ return nil
+}
diff --git a/backend/autoupdate/updater/apply/singlefile.go b/backend/autoupdate/updater/apply/singlefile.go
new file mode 100644
index 00000000..0efe89a2
--- /dev/null
+++ b/backend/autoupdate/updater/apply/singlefile.go
@@ -0,0 +1,50 @@
+package apply
+
+import (
+ "io"
+ "os"
+ "syscall"
+
+ "github.com/minio/selfupdate"
+ "github.com/pkg/errors"
+)
+
+type SingleFileApply struct{}
+
+func MakeSingleFileApply() *SingleFileApply {
+ return &SingleFileApply{}
+}
+
+func (a *SingleFileApply) Apply(file io.Reader) error {
+ err := selfupdate.Apply(file, selfupdate.Options{})
+ if err != nil {
+ return errors.Wrap(err, "failed to apply singlefile update")
+ }
+ return nil
+}
+
+func (a *SingleFileApply) OnExit(restart bool) error {
+ if restart {
+ wd, err := os.Getwd()
+ if err != nil {
+ return errors.Wrap(err, "failed to get working directory")
+ }
+
+ executable, err := os.Executable()
+ if err != nil {
+ return errors.Wrap(err, "failed to get executable path")
+ }
+
+ _, err = os.StartProcess(executable, os.Args, &os.ProcAttr{
+ Dir: wd,
+ Env: os.Environ(),
+ Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
+ Sys: &syscall.SysProcAttr{},
+ })
+
+ if err != nil {
+ return errors.Wrap(err, "failed to relaunch after update")
+ }
+ }
+ return nil
+}
diff --git a/backend/autoupdate/updater/check.go b/backend/autoupdate/updater/check.go
new file mode 100644
index 00000000..a5798b64
--- /dev/null
+++ b/backend/autoupdate/updater/check.go
@@ -0,0 +1,90 @@
+//go:build !bindings
+
+package updater
+
+import (
+ "github.com/Masterminds/semver/v3"
+ "github.com/pkg/errors"
+)
+
+func (u *Updater) CheckForUpdate() error {
+ if u.PendingUpdate != nil {
+ u.config.UpdateFoundCallback(u.PendingUpdate.Version, u.PendingUpdate.Changelogs)
+ if u.PendingUpdate.Ready {
+ u.config.UpdateReadyCallback()
+ }
+ }
+
+ u.lock.Lock()
+ defer u.lock.Unlock()
+
+ latestVersion, err := u.config.Source.GetLatestVersion()
+ if err != nil {
+ return errors.Wrap(err, "failed to get latest version")
+ }
+
+ latestSemver, err := semver.NewVersion(latestVersion)
+ if err != nil {
+ return errors.Wrapf(err, "failed to parse latest version %s", latestVersion)
+ }
+
+ var pendingSemver *semver.Version
+ if u.PendingUpdate != nil {
+ pendingSemver, err = semver.NewVersion(u.PendingUpdate.Version)
+ if err != nil {
+ return errors.Wrapf(err, "failed to parse pending version %s", u.PendingUpdate.Version)
+ }
+ }
+ currentSemver, err := semver.NewVersion(u.config.CurrentVersion)
+ if err != nil {
+ return errors.Wrapf(err, "failed to parse current version %s", u.config.CurrentVersion)
+ }
+
+ if pendingSemver != nil {
+ if !latestSemver.GreaterThan(pendingSemver) {
+ return nil
+ }
+ } else {
+ if !latestSemver.GreaterThan(currentSemver) {
+ return nil
+ }
+ }
+
+ changelogs, err := u.config.Source.GetChangelogs()
+ if err != nil {
+ return errors.Wrap(err, "failed to get changelogs")
+ }
+
+ newChangelogs := make(map[string]string)
+ for version, changelog := range changelogs {
+ semver, err := semver.NewVersion(version)
+ if err != nil {
+ return errors.Wrap(err, "failed to parse version")
+ }
+ if semver.GreaterThan(currentSemver) {
+ newChangelogs[version] = changelog
+ }
+ }
+
+ u.PendingUpdate = &PendingUpdate{
+ Version: latestVersion,
+ Changelogs: newChangelogs,
+ Ready: false,
+ }
+ u.config.UpdateFoundCallback(latestVersion, newChangelogs)
+
+ file, length, err := u.config.Source.GetFile()
+ if err != nil {
+ return errors.Wrap(err, "failed to get file")
+ }
+ defer file.Close()
+ p := &progressReader{Reader: file, progressCallback: u.config.DownloadProgressCallback, contentLength: length}
+
+ err = u.config.Apply.Apply(p)
+ if err != nil {
+ return errors.Wrap(err, "failed to apply update")
+ }
+ u.PendingUpdate.Ready = true
+ u.config.UpdateReadyCallback()
+ return nil
+}
diff --git a/backend/autoupdate/updater/check_noop.go b/backend/autoupdate/updater/check_noop.go
new file mode 100644
index 00000000..ca53ec95
--- /dev/null
+++ b/backend/autoupdate/updater/check_noop.go
@@ -0,0 +1,7 @@
+//go:build bindings
+
+package updater
+
+func (u *Updater) CheckForUpdate() error {
+ return nil
+}
diff --git a/backend/autoupdate/updater/progress.go b/backend/autoupdate/updater/progress.go
new file mode 100644
index 00000000..6443229c
--- /dev/null
+++ b/backend/autoupdate/updater/progress.go
@@ -0,0 +1,31 @@
+package updater
+
+import (
+ "io"
+
+ "github.com/pkg/errors"
+)
+
+type progressReader struct {
+ io.Reader
+ progressCallback func(int64, int64)
+ contentLength int64
+ downloaded int64
+}
+
+func (pr *progressReader) Read(p []byte) (int, error) {
+ n, err := pr.Reader.Read(p)
+ pr.downloaded += int64(n)
+
+ if err != io.EOF {
+ if pr.contentLength > 0 {
+ pr.progressCallback(pr.downloaded, pr.contentLength)
+ } else {
+ pr.progressCallback(pr.downloaded, 0)
+ }
+ } else {
+ pr.progressCallback(pr.downloaded, pr.downloaded)
+ }
+
+ return n, errors.Wrap(err, "failed to read from reader")
+}
diff --git a/backend/autoupdate/updater/source/github/github.go b/backend/autoupdate/updater/source/github/github.go
new file mode 100644
index 00000000..cea56fc8
--- /dev/null
+++ b/backend/autoupdate/updater/source/github/github.go
@@ -0,0 +1,91 @@
+package github
+
+import (
+ "encoding/json"
+ "io"
+ "net/http"
+
+ "github.com/pkg/errors"
+)
+
+type Provider struct {
+ repo string
+ releaseFilename string
+}
+
+func MakeGithubProvider(repo string, releaseFilename string) *Provider {
+ return &Provider{
+ repo: repo,
+ releaseFilename: releaseFilename,
+ }
+}
+
+func (g *Provider) GetLatestVersion() (string, error) {
+ release, err := g.getLatestReleaseData()
+ if err != nil {
+ return "", errors.Wrap(err, "failed to get latest release")
+ }
+ return release.TagName, nil
+}
+
+func (g *Provider) GetFile() (io.ReadCloser, int64, error) {
+ release, err := g.getLatestReleaseData()
+ if err != nil {
+ return nil, 0, errors.Wrap(err, "failed to get latest release")
+ }
+ var url string
+ for _, asset := range release.Assets {
+ if asset.Name == g.releaseFilename {
+ url = asset.BrowserDownloadURL
+ break
+ }
+ }
+ if url == "" {
+ return nil, 0, errors.Errorf("failed to find asset %s", g.releaseFilename)
+ }
+ response, err := http.Get(url)
+ if err != nil {
+ return nil, 0, errors.Wrapf(err, "failed to download asset %s", g.releaseFilename)
+ }
+ return response.Body, response.ContentLength, nil
+}
+
+func (g *Provider) GetChangelogs() (map[string]string, error) {
+ releases, err := g.getReleasesData()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get latest release")
+ }
+ changelogs := make(map[string]string)
+ for _, release := range releases {
+ changelogs[release.TagName] = release.Body
+ }
+ return changelogs, nil
+}
+
+func (g *Provider) getLatestReleaseData() (*Release, error) {
+ response, err := http.Get("https://api.github.com/repos/" + g.repo + "/releases/latest")
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get latest release")
+ }
+ defer response.Body.Close()
+ var release Release
+ err = json.NewDecoder(response.Body).Decode(&release)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to decode latest release")
+ }
+ return &release, nil
+}
+
+func (g *Provider) getReleasesData() ([]Release, error) {
+ response, err := http.Get("https://api.github.com/repos/" + g.repo + "/releases")
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get releases")
+ }
+ defer response.Body.Close()
+ var releases []Release
+ err = json.NewDecoder(response.Body).Decode(&releases)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to decode releases")
+ }
+ return releases, nil
+}
diff --git a/backend/autoupdate/updater/source/github/types.go b/backend/autoupdate/updater/source/github/types.go
new file mode 100644
index 00000000..607e2b58
--- /dev/null
+++ b/backend/autoupdate/updater/source/github/types.go
@@ -0,0 +1,59 @@
+package github
+
+import "time"
+
+type Release struct {
+ URL string `json:"url"`
+ AssetsURL string `json:"assets_url"`
+ UploadURL string `json:"upload_url"`
+ HTMLURL string `json:"html_url"`
+ ID int `json:"id"`
+ Author User `json:"author"`
+ NodeID string `json:"node_id"`
+ TagName string `json:"tag_name"`
+ TargetCommitish string `json:"target_commitish"`
+ Name string `json:"name"`
+ Draft bool `json:"draft"`
+ Prerelease bool `json:"prerelease"`
+ CreatedAt time.Time `json:"created_at"`
+ PublishedAt time.Time `json:"published_at"`
+ Assets []Assets `json:"assets"`
+ TarballURL string `json:"tarball_url"`
+ ZipballURL string `json:"zipball_url"`
+ Body string `json:"body"`
+}
+type User struct {
+ Login string `json:"login"`
+ ID int `json:"id"`
+ NodeID string `json:"node_id"`
+ AvatarURL string `json:"avatar_url"`
+ GravatarID string `json:"gravatar_id"`
+ URL string `json:"url"`
+ HTMLURL string `json:"html_url"`
+ FollowersURL string `json:"followers_url"`
+ FollowingURL string `json:"following_url"`
+ GistsURL string `json:"gists_url"`
+ StarredURL string `json:"starred_url"`
+ SubscriptionsURL string `json:"subscriptions_url"`
+ OrganizationsURL string `json:"organizations_url"`
+ ReposURL string `json:"repos_url"`
+ EventsURL string `json:"events_url"`
+ ReceivedEventsURL string `json:"received_events_url"`
+ Type string `json:"type"`
+ SiteAdmin bool `json:"site_admin"`
+}
+type Assets struct {
+ URL string `json:"url"`
+ ID int `json:"id"`
+ NodeID string `json:"node_id"`
+ Name string `json:"name"`
+ Label interface{} `json:"label"`
+ Uploader User `json:"uploader"`
+ ContentType string `json:"content_type"`
+ State string `json:"state"`
+ Size int `json:"size"`
+ DownloadCount int `json:"download_count"`
+ CreatedAt time.Time `json:"created_at"`
+ UpdatedAt time.Time `json:"updated_at"`
+ BrowserDownloadURL string `json:"browser_download_url"`
+}
diff --git a/backend/autoupdate/updater/source/source.go b/backend/autoupdate/updater/source/source.go
new file mode 100644
index 00000000..2c31f8c9
--- /dev/null
+++ b/backend/autoupdate/updater/source/source.go
@@ -0,0 +1,9 @@
+package source
+
+import "io"
+
+type Source interface {
+ GetLatestVersion() (string, error)
+ GetChangelogs() (map[string]string, error)
+ GetFile() (io.ReadCloser, int64, error)
+}
diff --git a/backend/autoupdate/updater/updater.go b/backend/autoupdate/updater/updater.go
new file mode 100644
index 00000000..6dce6b7f
--- /dev/null
+++ b/backend/autoupdate/updater/updater.go
@@ -0,0 +1,35 @@
+package updater
+
+import (
+ "sync"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/apply"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate/updater/source"
+)
+
+type Updater struct {
+ config Config
+ lock sync.Mutex
+ PendingUpdate *PendingUpdate
+}
+
+type PendingUpdate struct {
+ Version string
+ Changelogs map[string]string
+ Ready bool
+}
+
+type Config struct {
+ Source source.Source
+ Apply apply.Apply
+ CurrentVersion string
+ UpdateFoundCallback func(latestVersion string, changelogs map[string]string)
+ DownloadProgressCallback func(bytesDownloaded, totalBytes int64)
+ UpdateReadyCallback func()
+}
+
+func MakeUpdater(config Config) *Updater {
+ return &Updater{
+ config: config,
+ }
+}
diff --git a/backend/bindings/app.go b/backend/bindings/app.go
new file mode 100644
index 00000000..38e4fe50
--- /dev/null
+++ b/backend/bindings/app.go
@@ -0,0 +1,206 @@
+package bindings
+
+import (
+ "context"
+ "log/slog"
+ "strings"
+ "time"
+
+ "github.com/pkg/browser"
+ "github.com/pkg/errors"
+ "github.com/spf13/viper"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/projectfile"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/settings"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+// App struct
+type App struct {
+ ctx context.Context
+ isExpanded bool
+}
+
+func MakeApp() *App {
+ return &App{}
+}
+
+func (a *App) startup(ctx context.Context) {
+ a.ctx = ctx
+
+ windowStateTicker := time.NewTicker(100 * time.Millisecond)
+ go func() {
+ for range windowStateTicker.C {
+ if wailsRuntime.WindowIsMinimised(a.ctx) {
+ // When the window is minimized, the window position values are garbage
+ continue
+ }
+ w, h := wailsRuntime.WindowGetSize(a.ctx)
+ x, y := wailsRuntime.WindowGetPosition(a.ctx)
+ changed := false
+ if BindingsInstance.App.isExpanded {
+ if w != settings.Settings.ExpandedSize.Width {
+ settings.Settings.ExpandedSize.Width = w
+ changed = true
+ }
+ } else {
+ if w != settings.Settings.UnexpandedSize.Width {
+ settings.Settings.UnexpandedSize.Width = w
+ changed = true
+ }
+ }
+ if h != settings.Settings.ExpandedSize.Height {
+ settings.Settings.ExpandedSize.Height = h
+ changed = true
+ }
+ if h != settings.Settings.UnexpandedSize.Height {
+ settings.Settings.UnexpandedSize.Height = h
+ changed = true
+ }
+ if settings.Settings.WindowPosition == nil {
+ settings.Settings.WindowPosition = &utils.Position{
+ X: x,
+ Y: y,
+ }
+ changed = true
+ } else {
+ if x != settings.Settings.WindowPosition.X {
+ settings.Settings.WindowPosition.X = x
+ changed = true
+ }
+ if y != settings.Settings.WindowPosition.Y {
+ settings.Settings.WindowPosition.Y = y
+ changed = true
+ }
+ }
+ if changed {
+ err := settings.SaveSettings()
+ if err != nil {
+ slog.Error("failed to save settings", slog.Any("error", err))
+ }
+ }
+ }
+ }()
+
+ // Wails doesn't support setting the window position on init, so we do it here
+ if settings.Settings.WindowPosition != nil {
+ wailsRuntime.WindowSetPosition(ctx, settings.Settings.WindowPosition.X, settings.Settings.WindowPosition.Y)
+ }
+}
+
+func (a *App) ExpandMod() bool {
+ _, height := wailsRuntime.WindowGetSize(a.ctx)
+ wailsRuntime.WindowSetMinSize(a.ctx, utils.ExpandedMin.Width, utils.ExpandedMin.Height)
+ wailsRuntime.WindowSetMaxSize(a.ctx, utils.ExpandedMax.Width, utils.ExpandedMax.Height)
+ wailsRuntime.WindowSetSize(a.ctx, settings.Settings.ExpandedSize.Width, height)
+ a.isExpanded = true
+ return true
+}
+
+func (a *App) UnexpandMod() bool {
+ a.isExpanded = false
+ _, height := wailsRuntime.WindowGetSize(a.ctx)
+ wailsRuntime.WindowSetMinSize(a.ctx, utils.UnexpandedMin.Width, utils.UnexpandedMin.Height)
+ wailsRuntime.WindowSetMaxSize(a.ctx, utils.UnexpandedMax.Width, utils.UnexpandedMax.Height)
+ wailsRuntime.WindowSetSize(a.ctx, settings.Settings.UnexpandedSize.Width, height)
+ return true
+}
+
+func (a *App) GetVersion() string {
+ return projectfile.Version()
+}
+
+type FileFilter struct {
+ DisplayName string `json:"displayName"`
+ Pattern string `json:"pattern"`
+}
+
+type OpenDialogOptions struct {
+ DefaultDirectory string `json:"defaultDirectory,omitempty"`
+ DefaultFilename string `json:"defaultFilename,omitempty"`
+ Title string `json:"title,omitempty"`
+ Filters []FileFilter `json:"filters,omitempty"`
+ ShowHiddenFiles bool `json:"showHiddenFiles,omitempty"`
+ CanCreateDirectories bool `json:"canCreateDirectories,omitempty"`
+ ResolvesAliases bool `json:"resolvesAliases,omitempty"`
+ TreatPackagesAsDirectories bool `json:"treatPackagesAsDirectories,omitempty"`
+}
+
+func (a *App) OpenFileDialog(options OpenDialogOptions) (string, error) {
+ wailsFilters := make([]wailsRuntime.FileFilter, len(options.Filters))
+ for i, filter := range options.Filters {
+ wailsFilters[i] = wailsRuntime.FileFilter{
+ DisplayName: filter.DisplayName,
+ Pattern: filter.Pattern,
+ }
+ }
+ wailsOptions := wailsRuntime.OpenDialogOptions{
+ DefaultDirectory: options.DefaultDirectory,
+ DefaultFilename: options.DefaultFilename,
+ Title: options.Title,
+ Filters: wailsFilters,
+ ShowHiddenFiles: options.ShowHiddenFiles,
+ CanCreateDirectories: options.CanCreateDirectories,
+ ResolvesAliases: options.ResolvesAliases,
+ TreatPackagesAsDirectories: options.TreatPackagesAsDirectories,
+ }
+ file, err := wailsRuntime.OpenFileDialog(a.ctx, wailsOptions)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to open file dialog")
+ }
+ return file, nil
+}
+
+func (a *App) OpenDirectoryDialog(options OpenDialogOptions) (string, error) {
+ wailsFilters := make([]wailsRuntime.FileFilter, len(options.Filters))
+ for i, filter := range options.Filters {
+ wailsFilters[i] = wailsRuntime.FileFilter{
+ DisplayName: filter.DisplayName,
+ Pattern: filter.Pattern,
+ }
+ }
+ wailsOptions := wailsRuntime.OpenDialogOptions{
+ DefaultDirectory: options.DefaultDirectory,
+ DefaultFilename: options.DefaultFilename,
+ Title: options.Title,
+ Filters: wailsFilters,
+ ShowHiddenFiles: options.ShowHiddenFiles,
+ CanCreateDirectories: options.CanCreateDirectories,
+ ResolvesAliases: options.ResolvesAliases,
+ TreatPackagesAsDirectories: options.TreatPackagesAsDirectories,
+ }
+ file, err := wailsRuntime.OpenDirectoryDialog(a.ctx, wailsOptions)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to open directory dialog")
+ }
+ return file, nil
+}
+
+func (a *App) ExternalInstallMod(modID, version string) {
+ wailsRuntime.EventsEmit(a.ctx, "externalInstallMod", modID, version)
+}
+
+func (a *App) ExternalImportProfile(path string) {
+ wailsRuntime.EventsEmit(a.ctx, "externalImportProfile", path)
+}
+
+func (a *App) Show() {
+ wailsRuntime.WindowUnminimise(a.ctx)
+ wailsRuntime.Show(a.ctx)
+}
+
+func (a *App) OpenExternal(input string) {
+ err := browser.OpenFile(input)
+ if err != nil {
+ slog.Error("failed to open external", slog.Any("error", err), slog.String("path", input))
+ }
+}
+
+func (a *App) GetAPIEndpoint() string {
+ return viper.GetString("api-base") + viper.GetString("graphql-api")
+}
+
+func (a *App) GetSiteEndpoint() string {
+ return strings.Replace(viper.GetString("api-base"), "api.", "", 1)
+}
diff --git a/backend/bindings/bindings.go b/backend/bindings/bindings.go
new file mode 100644
index 00000000..1cd180eb
--- /dev/null
+++ b/backend/bindings/bindings.go
@@ -0,0 +1,56 @@
+package bindings
+
+import (
+ "context"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/bindings/ficsitcli"
+)
+
+type Bindings struct {
+ App *App
+ Update *Update
+ FicsitCLI *ficsitcli.FicsitCLI
+ settings *Settings
+ debugInfo *DebugInfo
+}
+
+var BindingsInstance *Bindings
+
+func MakeBindings() (*Bindings, error) {
+ if BindingsInstance != nil {
+ return BindingsInstance, nil
+ }
+
+ ficsitCLI, err := ficsitcli.MakeFicsitCLI()
+ if err != nil {
+ return nil, err
+ }
+
+ BindingsInstance = &Bindings{
+ App: MakeApp(),
+ Update: MakeUpdate(),
+ FicsitCLI: ficsitCLI,
+ settings: MakeSettings(),
+ debugInfo: MakeDebugInfo(),
+ }
+
+ return BindingsInstance, nil
+}
+
+func (b *Bindings) Startup(ctx context.Context) {
+ b.App.startup(ctx)
+ b.Update.startup(ctx)
+ b.FicsitCLI.Startup(ctx)
+ b.settings.startup(ctx)
+ b.debugInfo.startup(ctx)
+}
+
+func (b *Bindings) GetBindings() []interface{} {
+ return []interface{}{
+ b.App,
+ b.Update,
+ b.FicsitCLI,
+ b.settings,
+ b.debugInfo,
+ }
+}
diff --git a/backend/bindings/debug_info.go b/backend/bindings/debug_info.go
new file mode 100644
index 00000000..19f3d564
--- /dev/null
+++ b/backend/bindings/debug_info.go
@@ -0,0 +1,195 @@
+package bindings
+
+import (
+ "archive/zip"
+ "context"
+ "fmt"
+ "log/slog"
+ "os"
+ "path"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/pkg/errors"
+ ficsitCli "github.com/satisfactorymodding/ficsit-cli/cli"
+ "github.com/spf13/viper"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/projectfile"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+type DebugInfo struct {
+ ctx context.Context
+}
+
+func MakeDebugInfo() *DebugInfo {
+ return &DebugInfo{}
+}
+
+func (d *DebugInfo) startup(ctx context.Context) {
+ d.ctx = ctx
+}
+
+type MetadataInstallation struct {
+ *common.Installation
+ LaunchPath string `json:"launchPath"`
+ Name string `json:"name"`
+ Profile string `json:"profile"`
+}
+
+type Metadata struct {
+ Installations []*MetadataInstallation `json:"installations"`
+ SelectedInstallation *MetadataInstallation `json:"selectedInstallation"`
+ Profiles []*ficsitCli.Profile `json:"profiles"`
+ SelectedProfileName *string `json:"selectedProfile"`
+ InstalledMods map[string]string `json:"installedMods"`
+ SMLVersion *string `json:"smlVersion"`
+ SMMVersion string `json:"smmVersion"`
+ ModsEnabled bool `json:"modsEnabled"`
+}
+
+func addFactoryGameLog(writer *zip.Writer) error {
+ if runtime.GOOS == "windows" {
+ cacheDir, err := os.UserCacheDir()
+ if err != nil {
+ return errors.Wrap(err, "failed to get user cache dir")
+ }
+ err = utils.AddFileToZip(writer, path.Join(cacheDir, "FactoryGame", "Saved", "Logs", "FactoryGame.log"), "FactoryGame.log")
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return errors.Wrap(err, "failed to add file to zip")
+ }
+ }
+ }
+ return nil
+}
+
+func addMetadata(writer *zip.Writer) error {
+ ficsitCliInstalls := BindingsInstance.FicsitCLI.GetInstallations()
+ selectedFicsitCliInstall := BindingsInstance.FicsitCLI.GetSelectedInstall()
+ metadataInstalls := make([]*MetadataInstallation, 0)
+ var selectedMetadataInstall *MetadataInstallation
+ for _, install := range ficsitCliInstalls {
+ i := &MetadataInstallation{
+ Installation: install.Info,
+ Name: fmt.Sprintf("Satisfactory %s (%s)", install.Info.Branch, install.Info.Launcher),
+ Profile: install.Installation.Profile,
+ }
+ i.Path = utils.RedactPath(i.Path)
+ i.LaunchPath = strings.Join(i.Installation.LaunchPath, " ")
+
+ metadataInstalls = append(metadataInstalls, i)
+
+ if selectedFicsitCliInstall != nil && selectedFicsitCliInstall == install.Info {
+ selectedMetadataInstall = i
+ }
+ }
+
+ ficsitCliProfileNames := BindingsInstance.FicsitCLI.GetProfiles()
+ selectedMetadataProfileName := BindingsInstance.FicsitCLI.GetSelectedProfile()
+ metadataProfiles := make([]*ficsitCli.Profile, 0)
+ for _, profileName := range ficsitCliProfileNames {
+ p := BindingsInstance.FicsitCLI.GetProfile(profileName)
+
+ metadataProfiles = append(metadataProfiles, p)
+ }
+
+ lockfile, err := BindingsInstance.FicsitCLI.GetSelectedInstallLockfile()
+ if err != nil {
+ return errors.Wrap(err, "failed to get lockfile")
+ }
+
+ metadataInstalledMods := make(map[string]string)
+ var smlVersion *string
+ for name, data := range lockfile.Mods {
+ if name == "SML" {
+ smlVersion = &data.Version
+ } else {
+ metadataInstalledMods[name] = data.Version
+ }
+ }
+
+ metadata := Metadata{
+ SMMVersion: projectfile.Version(),
+ Installations: metadataInstalls,
+ SelectedInstallation: selectedMetadataInstall,
+ Profiles: metadataProfiles,
+ SelectedProfileName: selectedMetadataProfileName,
+ InstalledMods: metadataInstalledMods,
+ SMLVersion: smlVersion,
+ }
+
+ metadataBytes, err := utils.JSONMarshal(metadata, 2)
+ if err != nil {
+ return errors.Wrap(err, "failed to marshal metadata")
+ }
+
+ metadataFile, err := writer.Create("metadata.json")
+ if err != nil {
+ return errors.Wrap(err, "failed to create metadata file")
+ }
+
+ _, err = metadataFile.Write(metadataBytes)
+ if err != nil {
+ return errors.Wrap(err, "failed to write metadata")
+ }
+ return nil
+}
+
+func (d *DebugInfo) generateAndSaveDebugInfo(filename string) error {
+ file, err := os.Create(filename)
+ if err != nil {
+ return errors.Wrap(err, "failed to create file")
+ }
+ defer file.Close()
+ writer := zip.NewWriter(file)
+ defer writer.Close()
+
+ err = addFactoryGameLog(writer)
+ if err != nil {
+ return errors.Wrap(err, "failed to add FactoryGame.log to debuginfo zip")
+ }
+
+ err = addMetadata(writer)
+ if err != nil {
+ return errors.Wrap(err, "failed to add metadata to debuginfo zip")
+ }
+
+ err = utils.AddFileToZip(writer, viper.GetString("log-file"), "SatisfactoryModManager.log")
+ if err != nil {
+ return errors.Wrap(err, "failed to add SatisfactoryModManager.log to debuginfo zip")
+ }
+
+ return nil
+}
+
+func (d *DebugInfo) GenerateDebugInfo() bool {
+ defaultFileName := fmt.Sprintf("SMMDebug-%s.zip", time.Now().UTC().Format("2006-01-02-15-04-05"))
+ filename, err := wailsRuntime.SaveFileDialog(d.ctx, wailsRuntime.SaveDialogOptions{
+ DefaultFilename: defaultFileName,
+ Filters: []wailsRuntime.FileFilter{
+ {
+ Pattern: "*.zip",
+ DisplayName: "Zip Files (*.zip)",
+ },
+ },
+ })
+ if err != nil {
+ slog.Error("failed to open save dialog", slog.Any("error", err))
+ return false
+ }
+ if filename == "" {
+ return false
+ }
+
+ err = d.generateAndSaveDebugInfo(filename)
+ if err != nil {
+ slog.Error("failed to generate debug info", slog.Any("error", err))
+ return false
+ }
+
+ return true
+}
diff --git a/backend/bindings/ficsitcli/installs.go b/backend/bindings/ficsitcli/installs.go
new file mode 100644
index 00000000..ede33452
--- /dev/null
+++ b/backend/bindings/ficsitcli/installs.go
@@ -0,0 +1,281 @@
+package ficsitcli
+
+import (
+ "log/slog"
+ "net/url"
+ "os/exec"
+ "sort"
+
+ "github.com/pkg/errors"
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+ resolver "github.com/satisfactorymodding/ficsit-resolver"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+func (f *FicsitCLI) initInstallations() error {
+ err := f.initLocalInstallations()
+ if err != nil {
+ return errors.Wrap(err, "failed to initialize found installations")
+ }
+
+ err = f.initRemoteServerInstallations()
+ if err != nil {
+ return errors.Wrap(err, "failed to initialize remote server installations")
+ }
+
+ sort.Slice(f.installations, func(i, j int) bool {
+ if f.installations[i].Info.Launcher != f.installations[j].Info.Launcher {
+ return f.installations[i].Info.Launcher < f.installations[j].Info.Launcher
+ }
+ return f.installations[i].Info.Branch < f.installations[j].Info.Branch
+ })
+
+ if len(f.installations) > 0 {
+ f.selectedInstallation = f.installations[0]
+ }
+
+ if f.ficsitCli.Installations.SelectedInstallation != "" {
+ for _, install := range f.installations {
+ if install.Info.Path == f.ficsitCli.Installations.SelectedInstallation {
+ f.selectedInstallation = install
+ break
+ }
+ }
+ }
+
+ return nil
+}
+
+func (f *FicsitCLI) initLocalInstallations() error {
+ installs, findErrors := installfinders.FindInstallations()
+
+ f.installFindErrors = findErrors
+ f.installations = []*InstallationInfo{}
+
+ fallbackProfile := "Default"
+ if f.ficsitCli.Profiles.GetProfile(fallbackProfile) == nil {
+ // Pick first profile found
+ for name := range f.ficsitCli.Profiles.Profiles {
+ fallbackProfile = name
+ break
+ }
+ }
+
+ createdNewInstalls := false
+ for _, install := range installs {
+ ficsitCliInstall := f.ficsitCli.Installations.GetInstallation(install.Path)
+ if ficsitCliInstall == nil {
+ var err error
+ ficsitCliInstall, err = f.ficsitCli.Installations.AddInstallation(f.ficsitCli, install.Path, fallbackProfile)
+ if err != nil {
+ return errors.Wrap(err, "failed to add installation")
+ }
+ createdNewInstalls = true
+ }
+ f.installations = append(f.installations, &InstallationInfo{
+ Installation: ficsitCliInstall,
+ Info: install,
+ })
+ }
+
+ if createdNewInstalls {
+ err := f.ficsitCli.Installations.Save()
+ if err != nil {
+ return errors.Wrap(err, "failed to save installations")
+ }
+ }
+ return nil
+}
+
+func (f *FicsitCLI) initRemoteServerInstallations() error {
+ for _, installation := range f.ficsitCli.Installations.Installations {
+ err := f.checkAndAddExistingRemote(installation)
+ if err != nil {
+ slog.Warn("failed to check and add existing remote", slog.Any("error", err), utils.SlogPath("path", installation.Path))
+ }
+ }
+ return nil
+}
+
+func (f *FicsitCLI) checkAndAddExistingRemote(installation *cli.Installation) error {
+ slog.Debug("checking whether installation is remote", utils.SlogPath("path", installation.Path))
+ parsed, err := url.Parse(installation.Path)
+ if err != nil {
+ return errors.Wrap(err, "failed to parse installation path")
+ }
+ if parsed.Scheme == "ftp" || parsed.Scheme == "sftp" {
+ // It is not a local installation
+ if err := f.AddRemoteServer(installation.Path); err != nil {
+ return errors.Wrap(err, "failed to add remote server")
+ }
+ }
+ return nil
+}
+
+func (f *FicsitCLI) GetInstallations() []*InstallationInfo {
+ return f.installations
+}
+
+func (f *FicsitCLI) GetInstallationsInfo() []*common.Installation {
+ result := []*common.Installation{}
+ for _, install := range f.installations {
+ result = append(result, install.Info)
+ }
+ return result
+}
+
+func (f *FicsitCLI) GetInvalidInstalls() []string {
+ result := []string{}
+ for _, err := range f.installFindErrors {
+ var installFindErr common.InstallFindError
+ if errors.As(err, &installFindErr) {
+ result = append(result, installFindErr.Path)
+ }
+ }
+ return result
+}
+
+func (f *FicsitCLI) GetInstallation(path string) *InstallationInfo {
+ for _, install := range f.installations {
+ if install.Info.Path == path {
+ return install
+ }
+ }
+
+ return nil
+}
+
+func (f *FicsitCLI) SelectInstall(path string) error {
+ l := slog.With(slog.String("task", "selectInstall"), utils.SlogPath("path", path))
+ if f.selectedInstallation != nil && f.selectedInstallation.Info.Path == path {
+ return nil
+ }
+ installation := f.GetInstallation(path)
+ if installation == nil {
+ l.Error("failed to find installation")
+ return errors.Errorf("installation %s not found", path)
+ }
+ f.selectedInstallation = installation
+
+ f.ficsitCli.Installations.SelectedInstallation = path
+ _ = f.ficsitCli.Installations.Save()
+
+ f.EmitGlobals()
+
+ f.progress = &Progress{
+ Item: "__select_install__",
+ Message: "Validating install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, "__select_install__")
+
+ if installErr != nil {
+ l.Error("failed to validate install", slog.Any("error", installErr))
+ return installErr
+ }
+ return nil
+}
+
+func (f *FicsitCLI) GetSelectedInstall() *common.Installation {
+ if f.selectedInstallation == nil {
+ return nil
+ }
+ return f.selectedInstallation.Info
+}
+
+func (f *FicsitCLI) SetModsEnabled(enabled bool) error {
+ if f.selectedInstallation == nil {
+ slog.Error("no installation selected")
+ return errors.New("no installation selected")
+ }
+ l := slog.With(slog.String("task", "setModsEnabled"), slog.Bool("enabled", enabled), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ var message string
+ if enabled {
+ message = "Enabling mods"
+ } else {
+ message = "Disabling mods"
+ }
+
+ f.selectedInstallation.Installation.Vanilla = !enabled
+ _ = f.ficsitCli.Installations.Save()
+
+ f.EmitGlobals()
+
+ f.progress = &Progress{
+ Item: "__toggle_mods__",
+ Message: message,
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, "__toggle_mods__")
+
+ if installErr != nil {
+ l.Error("failed to validate install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ return nil
+}
+
+func (f *FicsitCLI) GetModsEnabled() bool {
+ return f.selectedInstallation == nil || !f.selectedInstallation.Installation.Vanilla
+}
+
+func (f *FicsitCLI) GetSelectedInstallProfileMods() map[string]cli.ProfileMod {
+ if f.selectedInstallation == nil {
+ return make(map[string]cli.ProfileMod)
+ }
+ profile := f.GetProfile(f.selectedInstallation.Installation.Profile)
+ return profile.Mods
+}
+
+func (f *FicsitCLI) GetSelectedInstallLockfileMods() (map[string]resolver.LockedMod, error) {
+ if f.selectedInstallation == nil {
+ return make(map[string]resolver.LockedMod), nil
+ }
+ lockfile, err := f.selectedInstallation.Installation.LockFile(f.ficsitCli)
+ if err != nil {
+ return nil, err //nolint:wrapcheck
+ }
+ if lockfile == nil {
+ return make(map[string]resolver.LockedMod), nil
+ }
+ return lockfile.Mods, nil
+}
+
+func (f *FicsitCLI) GetSelectedInstallLockfile() (*resolver.LockFile, error) {
+ if f.selectedInstallation == nil {
+ return nil, nil
+ }
+ lockfile, err := f.selectedInstallation.Installation.LockFile(f.ficsitCli)
+ if err != nil {
+ return nil, err //nolint:wrapcheck
+ }
+ return lockfile, nil
+}
+
+func (f *FicsitCLI) LaunchGame() {
+ if f.selectedInstallation == nil {
+ slog.Error("no installation selected")
+ return
+ }
+ cmd := exec.Command(f.selectedInstallation.Info.LaunchPath[0], f.selectedInstallation.Info.LaunchPath[1:]...)
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ slog.Error("failed to launch game", slog.Any("error", err), slog.String("cmd", cmd.String()), slog.String("output", string(out)))
+ return
+ }
+}
diff --git a/backend/bindings/ficsitcli/offline.go b/backend/bindings/ficsitcli/offline.go
new file mode 100644
index 00000000..96db726b
--- /dev/null
+++ b/backend/bindings/ficsitcli/offline.go
@@ -0,0 +1,152 @@
+package ficsitcli
+
+import (
+ "slices"
+ "strings"
+
+ "github.com/pkg/errors"
+ ficsitcache "github.com/satisfactorymodding/ficsit-cli/cli/cache"
+ "github.com/satisfactorymodding/ficsit-cli/cli/provider"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/settings"
+)
+
+func (f *FicsitCLI) GetOffline() bool {
+ return f.ficsitCli.Provider.IsOffline()
+}
+
+func (f *FicsitCLI) SetOffline(offline bool) {
+ f.ficsitCli.Provider.(*provider.MixedProvider).Offline = offline
+ settings.Settings.Offline = offline
+ _ = settings.SaveSettings()
+}
+
+type Mod struct {
+ ModReference string `json:"mod_reference"`
+ Name string `json:"name"`
+ Logo *string `json:"logo"` // Base64 encoded
+ Authors []string `json:"authors"`
+ Versions []ModVersion `json:"versions"`
+}
+
+type ModVersion struct {
+ Version string `json:"version"`
+ Size int64 `json:"size"`
+ Dependencies []ModVersionDependency `json:"dependencies"`
+}
+
+type ModVersionDependency struct {
+ ModReference string `json:"mod_id"`
+ Condition string `json:"condition"`
+ Optional bool `json:"optional"`
+}
+
+func (f *FicsitCLI) OfflineGetMods() ([]Mod, error) {
+ cache, err := ficsitcache.GetCache()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get cache")
+ }
+
+ mods := make([]Mod, 0)
+ cache.Range(func(modReference string, modFiles []ficsitcache.File) bool {
+ if modReference == "SML" {
+ return true
+ }
+ mods = append(mods, convertCacheFileToMod(modFiles))
+ return true
+ })
+ return mods, nil
+}
+
+func (f *FicsitCLI) OfflineGetModsByReferences(modReferences []string) ([]Mod, error) {
+ cache, err := ficsitcache.GetCache()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get cache")
+ }
+
+ mods := make([]Mod, 0)
+ cache.Range(func(modReference string, modFiles []ficsitcache.File) bool {
+ if modReference == "SML" {
+ return true
+ }
+ if !slices.Contains(modReferences, modReference) {
+ return true
+ }
+ mods = append(mods, convertCacheFileToMod(modFiles))
+ return true
+ })
+ return mods, nil
+}
+
+func (f *FicsitCLI) OfflineGetMod(modReference string) (Mod, error) {
+ modFiles, err := ficsitcache.GetCacheMod(modReference)
+ if err != nil {
+ return Mod{}, errors.Wrap(err, "failed to get cache")
+ }
+ if modFiles == nil {
+ return Mod{}, errors.New("mod not found")
+ }
+ return convertCacheFileToMod(modFiles), nil
+}
+
+type SMLVersion struct {
+ Version string `json:"version"`
+ SatisfactoryVersion int `json:"satisfactory_version"` // TODO
+}
+
+func (f *FicsitCLI) OfflineGetSMLVersions() ([]SMLVersion, error) {
+ smlFiles, err := ficsitcache.GetCacheMod("SML")
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get cache")
+ }
+ if smlFiles == nil {
+ return nil, errors.New("SML not found")
+ }
+
+ versions := make([]SMLVersion, 0)
+ for _, file := range smlFiles {
+ versions = append(versions, SMLVersion{
+ Version: file.Plugin.SemVersion,
+ SatisfactoryVersion: 0,
+ })
+ }
+ return versions, nil
+}
+
+func convertCacheFileToMod(files []ficsitcache.File) Mod {
+ authors := make([]string, 0)
+
+ for _, author := range strings.Split(files[0].Plugin.CreatedBy, ",") {
+ authors = append(authors, strings.TrimSpace(author))
+ }
+
+ versions := make([]ModVersion, 0)
+ for _, file := range files {
+ dependencies := make([]ModVersionDependency, 0)
+
+ for _, dependency := range file.Plugin.Plugins {
+ if dependency.BasePlugin {
+ continue
+ }
+ dependencies = append(dependencies, ModVersionDependency{
+ ModReference: dependency.Name,
+ Condition: dependency.SemVersion,
+ Optional: dependency.Optional,
+ })
+ }
+
+ versions = append(versions, ModVersion{
+ Version: file.Plugin.SemVersion,
+ Size: file.Size,
+ Dependencies: dependencies,
+ })
+ }
+
+ return Mod{
+ Name: files[0].Plugin.FriendlyName,
+ ModReference: files[0].ModReference,
+ Authors: authors,
+ Logo: files[0].Icon,
+ Versions: versions,
+ }
+}
diff --git a/backend/bindings/ficsitcli/process.go b/backend/bindings/ficsitcli/process.go
new file mode 100644
index 00000000..a2b2e372
--- /dev/null
+++ b/backend/bindings/ficsitcli/process.go
@@ -0,0 +1,397 @@
+package ficsitcli
+
+import (
+ "fmt"
+ "log/slog"
+ "time"
+
+ "github.com/dustin/go-humanize"
+ "github.com/pkg/errors"
+ "github.com/puzpuzpuz/xsync/v3"
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+ ficsitUtils "github.com/satisfactorymodding/ficsit-cli/utils"
+ resolver "github.com/satisfactorymodding/ficsit-resolver"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+func (f *FicsitCLI) validateInstall(installation *InstallationInfo, progressItem string) error {
+ f.EmitModsChange()
+ defer f.EmitModsChange()
+
+ installChannel := make(chan cli.InstallUpdate)
+
+ defer f.setProgress(f.progress)
+
+ type modProgress struct {
+ downloadProgress ficsitUtils.GenericProgress
+ extractProgress ficsitUtils.GenericProgress
+ downloading bool
+ complete bool
+ }
+ modProgresses := xsync.NewMapOf[string, modProgress]()
+
+ progressTicker := time.NewTicker(100 * time.Millisecond)
+ done := make(chan bool)
+ defer progressTicker.Stop()
+ defer close(done)
+
+ downloadProgressTracker := utils.NewProgressTracker(time.Second * 5)
+ extractProgressTracker := utils.NewProgressTracker(time.Second * 5)
+
+ go func() {
+ for {
+ select {
+ case <-done:
+ return
+ case <-progressTicker.C:
+ downloadBytesProgress := ficsitUtils.GenericProgress{}
+ extractBytesProgress := ficsitUtils.GenericProgress{}
+ downloadModsProgress := ficsitUtils.GenericProgress{}
+ extractModsProgress := ficsitUtils.GenericProgress{}
+
+ hasDownloading := false
+
+ modProgresses.Range(func(key string, value modProgress) bool {
+ if value.downloadProgress.Total != 0 {
+ downloadModsProgress.Total++
+ if value.complete || !value.downloading {
+ downloadModsProgress.Completed++
+ }
+ if !value.complete && value.downloading {
+ hasDownloading = true
+ }
+ }
+ // Extraction progress is not available while the mod is still being downloaded,
+ // but we should still count it as an extraction that has to execute.
+ if value.downloadProgress.Total != 0 || value.extractProgress.Total != 0 {
+ extractModsProgress.Total++
+ if value.complete {
+ extractModsProgress.Completed++
+ }
+ }
+
+ downloadBytesProgress.Completed += value.downloadProgress.Completed
+ downloadBytesProgress.Total += value.downloadProgress.Total
+ extractBytesProgress.Completed += value.extractProgress.Completed
+ extractBytesProgress.Total += value.extractProgress.Total
+
+ return true
+ })
+
+ downloadProgressTracker.Add(downloadBytesProgress.Completed)
+ downloadProgressTracker.Total = downloadBytesProgress.Total
+ extractProgressTracker.Add(extractBytesProgress.Completed)
+ extractProgressTracker.Total = extractBytesProgress.Total
+
+ if hasDownloading {
+ if downloadBytesProgress.Total != 0 {
+ eta := downloadProgressTracker.ETA().Round(time.Second)
+ etaText := eta.String()
+ if eta == 0 {
+ etaText = "soon™"
+ }
+ f.setProgress(&Progress{
+ Item: progressItem,
+ Message: fmt.Sprintf(
+ "Downloading %d/%d mods: %s/%s, %s/s, %s",
+ downloadModsProgress.Completed, downloadModsProgress.Total,
+ humanize.Bytes(uint64(downloadBytesProgress.Completed)), humanize.Bytes(uint64(downloadBytesProgress.Total)),
+ humanize.Bytes(uint64(downloadProgressTracker.Speed())),
+ etaText,
+ ),
+ Progress: downloadBytesProgress.Percentage(),
+ })
+ }
+ } else {
+ if extractBytesProgress.Total != 0 {
+ eta := extractProgressTracker.ETA().Round(time.Second)
+ etaText := eta.String()
+ if eta == 0 {
+ etaText = "soon™"
+ }
+ f.setProgress(&Progress{
+ Item: progressItem,
+ Message: fmt.Sprintf(
+ "Extracting %d/%d mods: %s/%s, %s/s, %s",
+ extractModsProgress.Completed, extractModsProgress.Total,
+ humanize.Bytes(uint64(extractBytesProgress.Completed)), humanize.Bytes(uint64(extractBytesProgress.Total)),
+ humanize.Bytes(uint64(extractProgressTracker.Speed())),
+ etaText,
+ ),
+ Progress: extractBytesProgress.Percentage(),
+ })
+ }
+ }
+ }
+ }
+ }()
+
+ go func() {
+ for update := range installChannel {
+ if update.Type == cli.InstallUpdateTypeOverall {
+ // Although this wouldn't cause any issues in the progress generation above, we can ignore this update.
+ continue
+ }
+ modProgresses.Compute(update.Item.Mod, func(oldValue modProgress, loaded bool) (modProgress, bool) {
+ if oldValue.complete {
+ // Sometimes extract updates are received after the mod is marked as complete.
+ return oldValue, false
+ }
+ oldValue.complete = update.Type == cli.InstallUpdateTypeModComplete
+ oldValue.downloading = update.Type == cli.InstallUpdateTypeModDownload
+
+ switch update.Type {
+ case cli.InstallUpdateTypeModDownload:
+ oldValue.downloadProgress = update.Progress
+ case cli.InstallUpdateTypeModExtract:
+ oldValue.extractProgress = update.Progress
+ }
+ return oldValue, false
+ })
+ }
+ }()
+
+ installErr := installation.Installation.Install(f.ficsitCli, installChannel)
+ if installErr != nil {
+ var solvingError resolver.DependencyResolverError
+ if errors.As(installErr, &solvingError) {
+ return solvingError
+ }
+ return installErr //nolint:wrapcheck
+ }
+ return nil
+}
+
+func (f *FicsitCLI) EmitModsChange() {
+ lockfileMods, err := f.GetSelectedInstallLockfileMods()
+ if err != nil {
+ slog.Error("failed to load lockfile", slog.Any("error", err))
+ return
+ }
+ wailsRuntime.EventsEmit(f.ctx, "lockfileMods", lockfileMods)
+ wailsRuntime.EventsEmit(f.ctx, "manifestMods", f.GetSelectedInstallProfileMods())
+}
+
+func (f *FicsitCLI) EmitGlobals() {
+ if f.ctx == nil {
+ // This function can be called from AddRemoteServer, which is used during initialization
+ // at which point the context is not set yet.
+ // We can safely ignore this call.
+ return
+ }
+ wailsRuntime.EventsEmit(f.ctx, "installations", f.GetInstallationsInfo())
+ wailsRuntime.EventsEmit(f.ctx, "remoteServers", f.GetRemoteInstallations())
+ profileNames := make([]string, 0, len(f.ficsitCli.Profiles.Profiles))
+ for k := range f.ficsitCli.Profiles.Profiles {
+ profileNames = append(profileNames, k)
+ }
+ wailsRuntime.EventsEmit(f.ctx, "profiles", profileNames)
+
+ if f.selectedInstallation == nil {
+ return
+ }
+
+ wailsRuntime.EventsEmit(f.ctx, "selectedInstallation", f.selectedInstallation.Installation.Path)
+ wailsRuntime.EventsEmit(f.ctx, "selectedProfile", f.selectedInstallation.Installation.Profile)
+ wailsRuntime.EventsEmit(f.ctx, "modsEnabled", !f.selectedInstallation.Installation.Vanilla)
+}
+
+func (f *FicsitCLI) InstallMod(mod string) error {
+ if f.progress != nil {
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ l := slog.With(slog.String("task", "installMod"), slog.String("mod", mod), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ profileName := f.selectedInstallation.Installation.Profile
+ profile := f.GetProfile(profileName)
+
+ profileErr := profile.AddMod(mod, ">=0.0.0")
+ if profileErr != nil {
+ l.Error("failed to add mod", slog.Any("error", profileErr))
+ return errors.Wrapf(profileErr, "failed to add mod: %s@latest", mod)
+ }
+
+ f.progress = &Progress{
+ Item: mod,
+ Message: "Finding the best version to install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, mod)
+
+ if installErr != nil {
+ l.Error("failed to install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
+
+func (f *FicsitCLI) InstallModVersion(mod string, version string) error {
+ if f.progress != nil {
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ l := slog.With(slog.String("task", "installModVersion"), slog.String("mod", mod), slog.String("version", version), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ profileName := f.selectedInstallation.Installation.Profile
+ profile := f.GetProfile(profileName)
+
+ profileErr := profile.AddMod(mod, version)
+ if profileErr != nil {
+ l.Error("failed to add mod", slog.Any("error", profileErr))
+ return errors.Wrapf(profileErr, "failed to add mod: %s@%s", mod, version)
+ }
+
+ f.progress = &Progress{
+ Item: mod,
+ Message: "Finding the best version to install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, mod)
+
+ if installErr != nil {
+ l.Error("failed to install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
+
+func (f *FicsitCLI) RemoveMod(mod string) error {
+ if f.progress != nil {
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ l := slog.With(slog.String("task", "removeMod"), slog.String("mod", mod), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ profileName := f.selectedInstallation.Installation.Profile
+ profile := f.GetProfile(profileName)
+
+ profile.RemoveMod(mod)
+
+ f.progress = &Progress{
+ Item: mod,
+ Message: "Checking for mods that are no longer needed",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, mod)
+
+ if installErr != nil {
+ l.Error("failed to install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
+
+func (f *FicsitCLI) EnableMod(mod string) error {
+ if f.progress != nil {
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ l := slog.With(slog.String("task", "enableMod"), slog.String("mod", mod), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ profileName := f.selectedInstallation.Installation.Profile
+ profile := f.GetProfile(profileName)
+
+ profile.SetModEnabled(mod, true)
+
+ f.progress = &Progress{
+ Item: mod,
+ Message: "Finding the best version to install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, mod)
+
+ if installErr != nil {
+ l.Error("failed to install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
+
+func (f *FicsitCLI) DisableMod(mod string) error {
+ if f.progress != nil {
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ l := slog.With(slog.String("task", "disableMod"), slog.String("mod", mod), utils.SlogPath("install", f.selectedInstallation.Info.Path))
+
+ profileName := f.selectedInstallation.Installation.Profile
+ profile := f.GetProfile(profileName)
+
+ profile.SetModEnabled(mod, false)
+
+ f.progress = &Progress{
+ Item: mod,
+ Message: "Checking for mods that are no longer needed",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, mod)
+
+ if installErr != nil {
+ l.Error("failed to install", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
diff --git a/backend/bindings/ficsitcli/profiles.go b/backend/bindings/ficsitcli/profiles.go
new file mode 100644
index 00000000..c37fa272
--- /dev/null
+++ b/backend/bindings/ficsitcli/profiles.go
@@ -0,0 +1,299 @@
+package ficsitcli
+
+import (
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "os"
+ "sort"
+ "time"
+
+ "github.com/pkg/errors"
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+ resolver "github.com/satisfactorymodding/ficsit-resolver"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+func (f *FicsitCLI) SetProfile(profile string) error {
+ l := slog.With(slog.String("task", "setProfile"), slog.String("profile", profile))
+
+ if f.selectedInstallation == nil {
+ l.Error("no installation selected")
+ return errors.New("no installation selected")
+ }
+ if f.selectedInstallation.Installation.Profile == profile {
+ return nil
+ }
+ err := f.selectedInstallation.Installation.SetProfile(f.ficsitCli, profile)
+ if err != nil {
+ l.Error("failed to set profile", slog.Any("error", err))
+ return errors.Wrap(err, "failed to set profile")
+ }
+ _ = f.ficsitCli.Installations.Save()
+
+ f.EmitGlobals()
+
+ f.progress = &Progress{
+ Item: "__select_profile__",
+ Message: "Validating install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, "__select_profile__")
+
+ if installErr != nil {
+ l.Error("failed to validate installation", slog.Any("error", installErr))
+ return installErr
+ }
+
+ return nil
+}
+
+func (f *FicsitCLI) GetSelectedProfile() *string {
+ if f.selectedInstallation == nil {
+ return nil
+ }
+ return &f.selectedInstallation.Installation.Profile
+}
+
+func (f *FicsitCLI) GetProfiles() []string {
+ profileNames := make([]string, 0, len(f.ficsitCli.Profiles.Profiles))
+ for k := range f.ficsitCli.Profiles.Profiles {
+ profileNames = append(profileNames, k)
+ }
+ sort.Strings(profileNames)
+ return profileNames
+}
+
+func (f *FicsitCLI) GetProfile(profile string) *cli.Profile {
+ return f.ficsitCli.Profiles.GetProfile(profile)
+}
+
+func (f *FicsitCLI) AddProfile(name string) error {
+ l := slog.With(slog.String("task", "addProfile"), slog.String("profile", name))
+
+ _, err := f.ficsitCli.Profiles.AddProfile(name)
+ if err != nil {
+ l.Error("failed to add profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to add profile: %s", name)
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ f.EmitGlobals()
+
+ return nil
+}
+
+func (f *FicsitCLI) RenameProfile(oldName string, newName string) error {
+ l := slog.With(slog.String("task", "renameProfile"), slog.String("oldName", oldName), slog.String("newName", newName))
+
+ err := f.ficsitCli.Profiles.RenameProfile(f.ficsitCli, oldName, newName)
+ if err != nil {
+ l.Error("failed to rename profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to rename profile: %s -> %s", oldName, newName)
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ f.EmitGlobals()
+
+ return nil
+}
+
+func (f *FicsitCLI) DeleteProfile(name string) error {
+ l := slog.With(slog.String("task", "deleteProfile"), slog.String("profile", name))
+
+ err := f.ficsitCli.Profiles.DeleteProfile(name)
+ if err != nil {
+ l.Error("failed to delete profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to delete profile: %s", name)
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ for _, install := range f.installations {
+ if install.Installation.Profile == name {
+ install.Installation.Profile = cli.DefaultProfileName
+ }
+ }
+
+ f.EmitGlobals()
+
+ return nil
+}
+
+type ExportedProfile struct {
+ Profile cli.Profile `json:"profile"`
+ LockFile resolver.LockFile `json:"lockfile"`
+ Metadata *ExportedProfileMetadata `json:"metadata"`
+}
+
+type ExportedProfileMetadata struct {
+ GameVersion int `json:"gameVersion"`
+}
+
+func (f *FicsitCLI) MakeCurrentExportedProfile() (*ExportedProfile, error) {
+ l := slog.With(slog.String("task", "makeCurrentExportedProfile"))
+
+ if f.selectedInstallation == nil {
+ l.Error("no installation selected")
+ return nil, errors.New("no installation selected")
+ }
+
+ profileName := f.GetSelectedProfile()
+ if profileName == nil {
+ l.Error("no profile selected")
+ return nil, errors.New("no profile selected")
+ }
+
+ profile := f.GetProfile(*profileName)
+ if profile == nil {
+ l.Error("profile not found", slog.String("profile", *profileName))
+ return nil, errors.New("profile not found")
+ }
+ lockfile, err := f.selectedInstallation.Installation.LockFile(f.ficsitCli)
+ if err != nil {
+ l.Error("failed to get lockfile", slog.Any("error", err))
+ return nil, errors.Wrap(err, "failed to get lockfile")
+ }
+ metadata := &ExportedProfileMetadata{
+ GameVersion: f.selectedInstallation.Info.Version,
+ }
+
+ if lockfile == nil {
+ lockfile = resolver.NewLockfile()
+ }
+
+ return &ExportedProfile{
+ Profile: *profile,
+ LockFile: *lockfile,
+ Metadata: metadata,
+ }, nil
+}
+
+func (f *FicsitCLI) ExportCurrentProfile() error {
+ l := slog.With(slog.String("task", "exportCurrentProfile"))
+
+ exportedProfile, err := f.MakeCurrentExportedProfile()
+ if err != nil {
+ l.Error("failed to make exported profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to export profile")
+ }
+
+ defaultFileName := fmt.Sprintf("%s-%s.smmprofile", exportedProfile.Profile.Name, time.Now().UTC().Format("2006-01-02-15-04-05"))
+ filename, err := wailsRuntime.SaveFileDialog(f.ctx, wailsRuntime.SaveDialogOptions{
+ DefaultFilename: defaultFileName,
+ Filters: []wailsRuntime.FileFilter{
+ {
+ Pattern: "*.smmprofile",
+ DisplayName: "SMM Profile (*.smmprofile)",
+ },
+ },
+ })
+ if err != nil {
+ l.Error("failed to open save dialog", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to open save dialog")
+ }
+
+ exportedProfileJSON, err := utils.JSONMarshal(exportedProfile, 2)
+ if err != nil {
+ l.Error("failed to marshal exported profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to marshal exported profile")
+ }
+ err = os.WriteFile(filename, exportedProfileJSON, 0o755)
+ if err != nil {
+ l.Error("failed to write exported profile", slog.Any("error", err))
+ return errors.Wrapf(err, "failed to write exported profile")
+ }
+
+ return nil
+}
+
+func (f *FicsitCLI) ReadExportedProfileMetadata(file string) (*ExportedProfileMetadata, error) {
+ l := slog.With(slog.String("task", "readExportedProfileMetadata"), slog.String("file", file))
+
+ fileBytes, err := os.ReadFile(file)
+ if err != nil {
+ l.Error("failed to read exported profile", slog.Any("error", err))
+ return nil, errors.Wrap(err, "failed to read exported profile")
+ }
+
+ var exportedProfile ExportedProfile
+ err = json.Unmarshal(fileBytes, &exportedProfile)
+ if err != nil {
+ l.Error("failed to unmarshal exported profile", slog.Any("error", err))
+ return nil, errors.Wrap(err, "failed to parse exported profile")
+ }
+
+ return exportedProfile.Metadata, nil
+}
+
+func (f *FicsitCLI) ImportProfile(name string, file string) error {
+ l := slog.With(slog.String("task", "importProfile"), slog.String("name", name), slog.String("file", file))
+
+ if f.selectedInstallation == nil {
+ l.Error("no installation selected")
+ return errors.New("no installation selected")
+ }
+
+ profileData, err := os.ReadFile(file)
+ if err != nil {
+ l.Error("failed to read exported profile", slog.Any("error", err))
+ return errors.Wrap(err, "failed to read profile file")
+ }
+
+ var exportedProfile ExportedProfile
+ err = json.Unmarshal(profileData, &exportedProfile)
+ if err != nil {
+ l.Error("failed to unmarshal exported profile", slog.Any("error", err))
+ return errors.Wrap(err, "failed to read profile file")
+ }
+
+ profile, err := f.ficsitCli.Profiles.AddProfile(name)
+ if err != nil {
+ l.Error("failed to add profile", slog.Any("error", err))
+ return errors.Wrap(err, "failed to add imported profile")
+ }
+
+ profile.Mods = exportedProfile.Profile.Mods
+
+ _ = f.selectedInstallation.Installation.SetProfile(f.ficsitCli, name)
+
+ err = f.selectedInstallation.Installation.WriteLockFile(f.ficsitCli, &exportedProfile.LockFile)
+ if err != nil {
+ _ = f.ficsitCli.Profiles.DeleteProfile(name)
+ l.Error("failed to write lockfile", slog.Any("error", err))
+ return errors.Wrap(err, "failed to write profile")
+ }
+
+ f.EmitGlobals()
+
+ f.progress = &Progress{
+ Item: "__import_profile__",
+ Message: "Validating install",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ installErr := f.validateInstall(f.selectedInstallation, "__import_profile__")
+
+ if installErr != nil {
+ _ = f.ficsitCli.Profiles.DeleteProfile(name)
+ l.Error("failed to validate installation", slog.Any("error", installErr))
+ return installErr
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
diff --git a/backend/bindings/ficsitcli/remote_servers.go b/backend/bindings/ficsitcli/remote_servers.go
new file mode 100644
index 00000000..1401e5e4
--- /dev/null
+++ b/backend/bindings/ficsitcli/remote_servers.go
@@ -0,0 +1,113 @@
+package ficsitcli
+
+import (
+ "strconv"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func (f *FicsitCLI) GetRemoteInstallations() []*common.Installation {
+ remoteInstallations := []*common.Installation{}
+ for _, install := range f.installations {
+ if install.Info.Location == common.LocationTypeRemote {
+ remoteInstallations = append(remoteInstallations, install.Info)
+ }
+ }
+ return remoteInstallations
+}
+
+func (f *FicsitCLI) AddRemoteServer(path string) error {
+ installation := f.ficsitCli.Installations.GetInstallation(path)
+ if installation == nil {
+ fallbackProfile := "Default"
+ if f.ficsitCli.Profiles.GetProfile(fallbackProfile) == nil {
+ // Pick first profile found
+ for name := range f.ficsitCli.Profiles.Profiles {
+ fallbackProfile = name
+ break
+ }
+ }
+
+ var err error
+ installation, err = f.ficsitCli.Installations.AddInstallation(f.ficsitCli, path, fallbackProfile)
+ if err != nil {
+ return errors.Wrap(err, "failed to add installation")
+ }
+ }
+ gameVersion, err := installation.GetGameVersion(f.ficsitCli)
+ if err != nil {
+ return errors.Wrap(err, "failed to get game version")
+ }
+
+ platform, err := installation.GetPlatform(f.ficsitCli)
+ if err != nil {
+ return errors.Wrap(err, "failed to get platform")
+ }
+ var installType common.InstallType
+ switch platform.TargetName {
+ case "Windows":
+ installType = common.InstallTypeWindowsClient
+ case "WindowsServer":
+ installType = common.InstallTypeWindowsServer
+ case "LinuxServer":
+ installType = common.InstallTypeLinuxServer
+ }
+
+ branch := common.BranchEarlyAccess // TODO: Do we have a way to detect this for remote installs?
+
+ f.installations = append(f.installations, &InstallationInfo{
+ Installation: installation,
+ Info: &common.Installation{
+ Path: installation.Path,
+ Type: installType,
+ Location: common.LocationTypeRemote,
+ Branch: branch,
+ Version: gameVersion,
+ Launcher: f.getNextRemoteLauncherName(),
+ },
+ })
+
+ f.EmitGlobals()
+
+ return nil
+}
+
+func (f *FicsitCLI) getNextRemoteLauncherName() string {
+ existingNumbers := make(map[int]bool)
+ for _, install := range f.GetRemoteInstallations() {
+ if strings.HasPrefix(install.Launcher, "Remote ") {
+ num, err := strconv.Atoi(strings.TrimPrefix(install.Launcher, "Remote "))
+ if err == nil {
+ existingNumbers[num] = true
+ }
+ }
+ }
+ for i := 1; ; i++ {
+ if !existingNumbers[i] {
+ return "Remote " + strconv.Itoa(i)
+ }
+ }
+}
+
+func (f *FicsitCLI) RemoveRemoteServer(path string) error {
+ for _, install := range f.installations {
+ if install.Info.Path == path && install.Info.Location != common.LocationTypeRemote {
+ return errors.New("installation is not remote")
+ }
+ }
+ err := f.ficsitCli.Installations.DeleteInstallation(path)
+ if err != nil {
+ return errors.Wrap(err, "failed to delete installation")
+ }
+ for i, install := range f.installations {
+ if install.Info.Path == path {
+ f.installations = append(f.installations[:i], f.installations[i+1:]...)
+ break
+ }
+ }
+ f.EmitGlobals()
+ return nil
+}
diff --git a/backend/bindings/ficsitcli/types.go b/backend/bindings/ficsitcli/types.go
new file mode 100644
index 00000000..f03aedf0
--- /dev/null
+++ b/backend/bindings/ficsitcli/types.go
@@ -0,0 +1,18 @@
+package ficsitcli
+
+import (
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+type InstallationInfo struct {
+ Installation *cli.Installation `json:"installation"`
+ Info *common.Installation `json:"info"`
+}
+
+type Progress struct {
+ Item string `json:"item"`
+ Message string `json:"message"`
+ Progress float64 `json:"progress"`
+}
diff --git a/backend/bindings/ficsitcli/update.go b/backend/bindings/ficsitcli/update.go
new file mode 100644
index 00000000..53c32146
--- /dev/null
+++ b/backend/bindings/ficsitcli/update.go
@@ -0,0 +1,139 @@
+package ficsitcli
+
+import (
+ "log/slog"
+
+ "github.com/pkg/errors"
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+ resolver "github.com/satisfactorymodding/ficsit-resolver"
+ "github.com/spf13/viper"
+)
+
+type Update struct {
+ Item string `json:"item"`
+ CurrentVersion string `json:"currentVersion"`
+ NewVersion string `json:"newVersion"`
+}
+
+func (f *FicsitCLI) CheckForUpdates() ([]Update, error) {
+ if f.selectedInstallation == nil {
+ return []Update{}, nil
+ }
+ l := slog.With(slog.String("task", "checkForUpdates"))
+
+ currentLockfile, err := f.selectedInstallation.Installation.LockFile(f.ficsitCli)
+ if err != nil {
+ l.Error("failed to get current lockfile", slog.Any("error", err))
+ return nil, errors.Wrap(err, "failed to get current lockfile")
+ }
+
+ if currentLockfile == nil {
+ return nil, nil
+ }
+
+ profile := f.GetProfile(f.selectedInstallation.Installation.Profile)
+
+ res := resolver.NewDependencyResolver(f.ficsitCli.Provider, viper.GetString("api-base"))
+
+ gameVersion, err := f.selectedInstallation.Installation.GetGameVersion(f.ficsitCli)
+ if err != nil {
+ l.Error("failed to get game version", slog.Any("error", err))
+ return nil, errors.Wrap(err, "failed to get game version")
+ }
+
+ updateProfile := &cli.Profile{
+ Name: "Update temp",
+ Mods: make(map[string]cli.ProfileMod),
+ }
+ for modReference, modData := range profile.Mods {
+ updateProfile.Mods[modReference] = cli.ProfileMod{
+ Enabled: modData.Enabled,
+ Version: ">=0.0.0",
+ }
+ }
+ newLockfile, err := updateProfile.Resolve(res, nil, gameVersion)
+ if err != nil {
+ l.Error("failed to resolve dependencies", slog.Any("error", err))
+ var solvingError resolver.DependencyResolverError
+ if errors.As(err, &solvingError) {
+ return nil, solvingError
+ }
+ return nil, err //nolint:wrapcheck
+ }
+
+ updates := []Update{}
+
+ for modReference, newLockedMod := range newLockfile.Mods {
+ if prevLockedMod, ok := currentLockfile.Mods[modReference]; ok {
+ if newLockedMod.Version != prevLockedMod.Version {
+ updates = append(updates, Update{
+ Item: modReference,
+ CurrentVersion: prevLockedMod.Version,
+ NewVersion: newLockedMod.Version,
+ })
+ }
+ }
+ }
+
+ return updates, nil
+}
+
+func (f *FicsitCLI) UpdateMods(mods []string) error {
+ l := slog.With(slog.String("task", "updateMods"))
+
+ if f.progress != nil {
+ l.Error("another operation in progress")
+ return errors.New("another operation in progress")
+ }
+
+ if f.selectedInstallation == nil {
+ return errors.New("no installation selected")
+ }
+
+ profile := f.GetProfile(f.selectedInstallation.Installation.Profile)
+ for _, modReference := range mods {
+ if _, ok := profile.Mods[modReference]; !ok {
+ l.Warn("mod not found in profile", slog.String("mod", modReference))
+ continue
+ }
+ profile.Mods[modReference] = cli.ProfileMod{
+ Enabled: profile.Mods[modReference].Enabled,
+ Version: ">=0.0.0",
+ }
+ }
+
+ err := f.selectedInstallation.Installation.UpdateMods(f.ficsitCli, mods)
+ if err != nil {
+ l.Error("failed to update mods", slog.Any("error", err))
+ var solvingError resolver.DependencyResolverError
+ if errors.As(err, &solvingError) {
+ return solvingError
+ }
+ return err //nolint:wrapcheck
+ }
+
+ f.progress = &Progress{
+ Item: "__update__",
+ Message: "Updating...",
+ Progress: -1,
+ }
+
+ f.setProgress(f.progress)
+
+ defer f.setProgress(nil)
+
+ err = f.validateInstall(f.selectedInstallation, "__update__")
+
+ if err != nil {
+ l.Error("failed to validate installation", slog.Any("error", err))
+ var solvingError resolver.DependencyResolverError
+ if errors.As(err, &solvingError) {
+ return solvingError
+ }
+ return err
+ }
+
+ _ = f.ficsitCli.Profiles.Save()
+
+ return nil
+}
diff --git a/backend/bindings/ficsitcli/wrapper.go b/backend/bindings/ficsitcli/wrapper.go
new file mode 100644
index 00000000..d292ff27
--- /dev/null
+++ b/backend/bindings/ficsitcli/wrapper.go
@@ -0,0 +1,158 @@
+package ficsitcli
+
+import (
+ "context"
+ "log/slog"
+ "os"
+ "time"
+
+ "github.com/mitchellh/go-ps"
+ "github.com/pkg/errors"
+ "github.com/satisfactorymodding/ficsit-cli/cli"
+ "github.com/satisfactorymodding/ficsit-cli/cli/provider"
+ "github.com/spf13/viper"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/settings"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+type FicsitCLI struct {
+ ctx context.Context
+ ficsitCli *cli.GlobalContext
+ installations []*InstallationInfo
+ installFindErrors []error
+ selectedInstallation *InstallationInfo
+ progress *Progress
+ isGameRunning bool
+}
+
+func MakeFicsitCLI() (*FicsitCLI, error) {
+ f := &FicsitCLI{}
+ err := f.Init()
+ if err != nil {
+ return nil, err
+ }
+ return f, nil
+}
+
+func (f *FicsitCLI) Startup(ctx context.Context) {
+ f.ctx = ctx
+}
+
+func (f *FicsitCLI) Init() error {
+ if f.ficsitCli != nil {
+ return errors.New("FicsitCLIWrapper already initialized")
+ }
+ var err error
+ f.ficsitCli, err = cli.InitCLI(false)
+ if err != nil {
+ return errors.Wrap(err, "failed to initialize ficsit-cli")
+ }
+ f.ficsitCli.Provider.(*provider.MixedProvider).Offline = settings.Settings.Offline
+ err = f.initInstallations()
+ if err != nil {
+ return errors.Wrap(err, "failed to initialize installations")
+ }
+ gameRunningTicker := time.NewTicker(5 * time.Second)
+ go func() {
+ for range gameRunningTicker.C {
+ processes, err := ps.Processes()
+ if err != nil {
+ slog.Error("failed to get processes", slog.Any("error", err))
+ continue
+ }
+ f.isGameRunning = false
+ for _, process := range processes {
+ if process.Executable() == "FactoryGame-Win64-Shipping.exe" || process.Executable() == "FactoryGame-Win64-Shipping" {
+ f.isGameRunning = true
+ break
+ }
+ }
+ wailsRuntime.EventsEmit(f.ctx, "isGameRunning", f.isGameRunning)
+ }
+ }()
+ return nil
+}
+
+func (f *FicsitCLI) setProgress(p *Progress) {
+ f.progress = p
+ wailsRuntime.EventsEmit(f.ctx, "progress", p)
+}
+
+func ValidateCacheDir(dir string) error {
+ stat, err := os.Stat(dir)
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return errors.Wrapf(err, "failed to stat %s", dir)
+ }
+ } else {
+ if !stat.IsDir() {
+ return errors.Errorf("%s is not a directory", dir)
+ }
+ }
+ return nil
+}
+
+func MoveCacheDir(newDir string) error {
+ if newDir == viper.GetString("cache-dir") {
+ return nil
+ }
+
+ err := ValidateCacheDir(newDir)
+ if err != nil {
+ return err
+ }
+
+ err = os.MkdirAll(newDir, 0o755)
+ if err != nil {
+ if !os.IsExist(err) {
+ return errors.Wrapf(err, "failed to create %s", newDir)
+ }
+ }
+
+ items, err := os.ReadDir(newDir)
+ if err != nil {
+ return errors.Wrapf(err, "failed to check if directory %s is empty", newDir)
+ }
+ if len(items) > 0 {
+ return errors.Errorf("directory %s is not empty", newDir)
+ }
+
+ oldCacheDir := viper.GetString("cache-dir")
+ // Move contents of oldCacheDir to dir
+ if oldCacheDir != "" && oldCacheDir != newDir {
+ err := moveCacheData(oldCacheDir, newDir)
+ if err != nil {
+ return err
+ }
+ }
+
+ viper.Set("cache-dir", newDir)
+ return nil
+}
+
+func moveCacheData(oldCacheDir, newDir string) error {
+ oldStat, err := os.Stat(oldCacheDir)
+ if err != nil {
+ if os.IsNotExist(err) {
+ // Nothing to move
+ return nil
+ }
+ return errors.Wrapf(err, "failed to stat %s", oldCacheDir)
+ }
+ if !oldStat.IsDir() {
+ return errors.Errorf("%s is not a directory", oldCacheDir)
+ }
+
+ // Perform the move atomically
+ copySuccess, err := utils.MoveRecursive(oldCacheDir, newDir)
+ if err != nil {
+ if !copySuccess {
+ return err
+ }
+ slog.Error("failed to move cache dir", slog.Any("error", err))
+ }
+
+ return nil
+}
diff --git a/backend/bindings/settings.go b/backend/bindings/settings.go
new file mode 100644
index 00000000..28a922de
--- /dev/null
+++ b/backend/bindings/settings.go
@@ -0,0 +1,199 @@
+package bindings
+
+import (
+ "context"
+ "log/slog"
+
+ "github.com/spf13/viper"
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/bindings/ficsitcli"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/settings"
+)
+
+type Settings struct {
+ ctx context.Context
+}
+
+func MakeSettings() *Settings {
+ s := &Settings{}
+ return s
+}
+
+func (s *Settings) startup(ctx context.Context) {
+ s.ctx = ctx
+}
+
+func (s *Settings) FavoriteMod(modReference string) (bool, error) {
+ idx := -1
+ for i, mod := range settings.Settings.FavoriteMods {
+ if mod == modReference {
+ idx = i
+ break
+ }
+ }
+ if idx != -1 {
+ return false, nil
+ }
+ settings.Settings.FavoriteMods = append(settings.Settings.FavoriteMods, modReference)
+ err := settings.SaveSettings()
+ if err != nil {
+ return false, err
+ }
+ s.emitFavoriteMods()
+ return true, nil
+}
+
+func (s *Settings) UnFavoriteMod(modReference string) bool {
+ idx := -1
+ for i, mod := range settings.Settings.FavoriteMods {
+ if mod == modReference {
+ idx = i
+ break
+ }
+ }
+ if idx == -1 {
+ return false
+ }
+ settings.Settings.FavoriteMods = append(settings.Settings.FavoriteMods[:idx], settings.Settings.FavoriteMods[idx+1:]...)
+ _ = settings.SaveSettings()
+ s.emitFavoriteMods()
+ return true
+}
+
+func (s *Settings) GetFavoriteMods() []string {
+ return settings.Settings.FavoriteMods
+}
+
+func (s *Settings) GetModFiltersOrder() string {
+ return settings.Settings.ModFilters.Order
+}
+
+func (s *Settings) GetModFiltersFilter() string {
+ return settings.Settings.ModFilters.Filter
+}
+
+func (s *Settings) SetModFiltersOrder(order string) {
+ settings.Settings.ModFilters.Order = order
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) SetModFiltersFilter(filter string) {
+ settings.Settings.ModFilters.Filter = filter
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) emitFavoriteMods() {
+ wailsRuntime.EventsEmit(s.ctx, "favoriteMods", settings.Settings.FavoriteMods)
+}
+
+func (s *Settings) GetStartView() settings.View {
+ return settings.Settings.StartView
+}
+
+func (s *Settings) SetStartView(view settings.View) {
+ settings.Settings.StartView = view
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) GetKonami() bool {
+ return settings.Settings.Konami
+}
+
+func (s *Settings) SetKonami(value bool) {
+ settings.Settings.Konami = value
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) GetLaunchButton() string {
+ return settings.Settings.LaunchButton
+}
+
+func (s *Settings) SetLaunchButton(value string) {
+ settings.Settings.LaunchButton = value
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) GetQueueAutoStart() bool {
+ return settings.Settings.QueueAutoStart
+}
+
+func (s *Settings) SetQueueAutoStart(value bool) {
+ settings.Settings.QueueAutoStart = value
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) GetIgnoredUpdates() map[string][]string {
+ return settings.Settings.IgnoredUpdates
+}
+
+func (s *Settings) SetUpdateIgnore(modReference string, version string) {
+ settings.Settings.IgnoredUpdates[modReference] = append(settings.Settings.IgnoredUpdates[modReference], version)
+ _ = settings.SaveSettings()
+ wailsRuntime.EventsEmit(s.ctx, "ignoredUpdates", settings.Settings.IgnoredUpdates)
+}
+
+func (s *Settings) SetUpdateUnignore(modReference string, version string) {
+ versions := settings.Settings.IgnoredUpdates[modReference]
+ idx := -1
+ for i, v := range versions {
+ if v == version {
+ idx = i
+ break
+ }
+ }
+ if idx == -1 {
+ return
+ }
+ settings.Settings.IgnoredUpdates[modReference] = append(versions[:idx], versions[idx+1:]...)
+ _ = settings.SaveSettings()
+ wailsRuntime.EventsEmit(s.ctx, "ignoredUpdates", settings.Settings.IgnoredUpdates)
+}
+
+func (s *Settings) GetUpdateCheckMode() settings.UpdateCheckMode {
+ return settings.Settings.UpdateCheckMode
+}
+
+func (s *Settings) SetUpdateCheckMode(value settings.UpdateCheckMode) {
+ settings.Settings.UpdateCheckMode = value
+ _ = settings.SaveSettings()
+}
+
+func (s *Settings) GetViewedAnnouncements() []string {
+ return settings.Settings.ViewedAnnouncements
+}
+
+func (s *Settings) SetAnnouncementViewed(announcement string) {
+ found := false
+ for _, viewed := range settings.Settings.ViewedAnnouncements {
+ if viewed == announcement {
+ found = true
+ break
+ }
+ }
+ if found {
+ return
+ }
+ settings.Settings.ViewedAnnouncements = append(settings.Settings.ViewedAnnouncements, announcement)
+ _ = settings.SaveSettings()
+ wailsRuntime.EventsEmit(s.ctx, "viewedAnnouncements", settings.Settings.ViewedAnnouncements)
+}
+
+func (s *Settings) SetCacheDir(dir string) error {
+ if dir == "" {
+ dir = viper.GetString("default-cache-dir")
+ }
+ err := ficsitcli.MoveCacheDir(dir)
+ if err != nil {
+ slog.Error("failed to set cache dir", slog.Any("error", err))
+ return err
+ }
+ settings.Settings.CacheDir = dir
+ _ = settings.SaveSettings()
+ wailsRuntime.EventsEmit(s.ctx, "cacheDir", dir)
+ return nil
+}
+
+func (s *Settings) GetCacheDir() string {
+ return viper.GetString("cache-dir")
+}
diff --git a/backend/bindings/update.go b/backend/bindings/update.go
new file mode 100644
index 00000000..5624d23f
--- /dev/null
+++ b/backend/bindings/update.go
@@ -0,0 +1,43 @@
+package bindings
+
+import (
+ "context"
+
+ wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/autoupdate"
+)
+
+type Update struct {
+ ctx context.Context
+ Restart bool
+}
+
+func MakeUpdate() *Update {
+ return &Update{}
+}
+
+func (u *Update) startup(ctx context.Context) {
+ u.ctx = ctx
+}
+
+func (u *Update) CheckForUpdates() {
+ _ = autoupdate.Updater.CheckForUpdate()
+}
+
+func (u *Update) UpdateAndRestart() {
+ u.Restart = true
+ wailsRuntime.Quit(u.ctx)
+}
+
+func (u *Update) UpdateAvailable(latestVersion string, changelogs map[string]string) {
+ wailsRuntime.EventsEmit(u.ctx, "updateAvailable", latestVersion, changelogs)
+}
+
+func (u *Update) UpdateDownloadProgress(downloaded, total int64) {
+ wailsRuntime.EventsEmit(u.ctx, "updateDownloadProgress", downloaded, total)
+}
+
+func (u *Update) UpdateReady() {
+ wailsRuntime.EventsEmit(u.ctx, "updateReady")
+}
diff --git a/backend/installfinders/common/helpers.go b/backend/installfinders/common/helpers.go
new file mode 100644
index 00000000..096d5c9c
--- /dev/null
+++ b/backend/installfinders/common/helpers.go
@@ -0,0 +1,38 @@
+package common
+
+import (
+ "path/filepath"
+ "runtime"
+ "strings"
+)
+
+func OsPathEqual(path1, path2 string) bool {
+ path1 = filepath.Clean(path1)
+ path2 = filepath.Clean(path2)
+ if runtime.GOOS == "windows" {
+ return strings.EqualFold(path1, path2)
+ }
+ return path1 == path2
+}
+
+func FindAll(finders ...InstallFinderFunc) ([]*Installation, []error) {
+ installs := make([]*Installation, 0)
+ var errors []error
+ for _, finder := range finders {
+ foundInstalls, foundErrors := finder()
+ for _, install := range foundInstalls {
+ existing := false
+ for i := range installs {
+ if OsPathEqual(installs[i].Path, install.Path) {
+ existing = true
+ break
+ }
+ }
+ if !existing {
+ installs = append(installs, install)
+ }
+ }
+ errors = append(errors, foundErrors...)
+ }
+ return installs, errors
+}
diff --git a/backend/installfinders/common/types.go b/backend/installfinders/common/types.go
new file mode 100644
index 00000000..b346c54d
--- /dev/null
+++ b/backend/installfinders/common/types.go
@@ -0,0 +1,48 @@
+package common
+
+type GameBranch string
+
+var (
+ BranchEarlyAccess GameBranch = "Early Access"
+ BranchExperimental GameBranch = "Experimental"
+)
+
+type InstallType string
+
+var (
+ InstallTypeWindowsClient InstallType = "WindowsClient"
+ InstallTypeWindowsServer InstallType = "WindowsServer"
+ InstallTypeLinuxServer InstallType = "LinuxServer"
+)
+
+type LocationType string
+
+var (
+ LocationTypeLocal LocationType = "Local"
+ LocationTypeRemote LocationType = "Remote"
+)
+
+type Installation struct {
+ Path string `json:"path"`
+ Version int `json:"version"`
+ Type InstallType `json:"type"`
+ Location LocationType `json:"location"`
+ Branch GameBranch `json:"branch"`
+ Launcher string `json:"launcher"`
+ LaunchPath []string `json:"launchPath"`
+}
+
+type InstallFindError struct {
+ Inner error `json:"cause"`
+ Path string `json:"path"`
+}
+
+func (e InstallFindError) Error() string {
+ return e.Path + ": " + e.Inner.Error()
+}
+
+func (e InstallFindError) Cause() error {
+ return e.Inner
+}
+
+type InstallFinderFunc func() ([]*Installation, []error)
diff --git a/backend/installfinders/findinstalls.go b/backend/installfinders/findinstalls.go
new file mode 100644
index 00000000..eb1ed656
--- /dev/null
+++ b/backend/installfinders/findinstalls.go
@@ -0,0 +1,12 @@
+//go:build !bindings
+
+package installfinders
+
+import (
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return common.FindAll(launchers.GetInstallFinders()...)
+}
diff --git a/backend/installfinders/findinstalls_noop.go b/backend/installfinders/findinstalls_noop.go
new file mode 100644
index 00000000..86141a43
--- /dev/null
+++ b/backend/installfinders/findinstalls_noop.go
@@ -0,0 +1,9 @@
+//go:build bindings
+
+package installfinders
+
+import "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return nil, nil
+}
diff --git a/backend/installfinders/launchers/all_linux.go b/backend/installfinders/launchers/all_linux.go
new file mode 100644
index 00000000..6f21b51b
--- /dev/null
+++ b/backend/installfinders/launchers/all_linux.go
@@ -0,0 +1,18 @@
+package launchers
+
+import (
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/heroic"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/legendary"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/lutris"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/steam"
+)
+
+func GetInstallFinders() []common.InstallFinderFunc {
+ return []common.InstallFinderFunc{
+ heroic.FindInstallations,
+ legendary.FindInstallations,
+ lutris.FindInstallations,
+ steam.FindInstallations,
+ }
+}
diff --git a/backend/installfinders/launchers/all_windows.go b/backend/installfinders/launchers/all_windows.go
new file mode 100644
index 00000000..878db9cb
--- /dev/null
+++ b/backend/installfinders/launchers/all_windows.go
@@ -0,0 +1,18 @@
+package launchers
+
+import (
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/epic"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/heroic"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/legendary"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/steam"
+)
+
+func GetInstallFinders() []common.InstallFinderFunc {
+ return []common.InstallFinderFunc{
+ epic.FindInstallations,
+ heroic.FindInstallations,
+ legendary.FindInstallations,
+ steam.FindInstallations,
+ }
+}
diff --git a/backend/installfinders/launchers/epic/epic.go b/backend/installfinders/launchers/epic/epic.go
new file mode 100644
index 00000000..c5948197
--- /dev/null
+++ b/backend/installfinders/launchers/epic/epic.go
@@ -0,0 +1,183 @@
+package epic
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+type GameVersionFile struct {
+ MajorVersion int `json:"MajorVersion"`
+ MinorVersion int `json:"MinorVersion"`
+ PatchVersion int `json:"PatchVersion"`
+ Changelist int `json:"Changelist"`
+ CompatibleChangelist int `json:"CompatibleChangelist"`
+ IsLicenseeVersion int `json:"IsLicenseeVersion"`
+ IsPromotedBuild int `json:"IsPromotedBuild"`
+ BranchName string `json:"BranchName"`
+ BuildID string `json:"BuildId"`
+}
+
+type Manifest struct {
+ CatalogNamespace string `json:"CatalogNamespace"`
+ CatalogItemID string `json:"CatalogItemID"`
+ ManifestLocation string `json:"ManifestLocation"`
+ InstallationGUID string `json:"InstallationGUID"`
+ MainGameAppName string `json:"MainGameAppName"`
+ AppVersionString string `json:"AppVersionString"`
+ InstallLocation string `json:"InstallLocation"`
+}
+
+type GameManifest struct {
+ AppName string `json:"AppName"`
+ CatalogNamespace string `json:"CatalogNamespace"`
+ CatalogItemID string `json:"CatalogItemID"`
+}
+
+var (
+ EarlyAccessAppName = "CrabEA"
+ ExperimentalAppName = "CrabTest"
+)
+
+func GetEpicBranch(appName string) (common.GameBranch, error) {
+ switch appName {
+ case EarlyAccessAppName:
+ return common.BranchEarlyAccess, nil
+ case ExperimentalAppName:
+ return common.BranchExperimental, nil
+ default:
+ return "", errors.New("unknown branch for " + appName)
+ }
+}
+
+func findInstallationsEpic(epicManifestsPath string, launcher string, launchPath func(appName string) []string, processPath func(path string) string) ([]*common.Installation, []error) {
+ if launchPath == nil {
+ launchPath = func(appName string) []string { return nil }
+ }
+
+ if processPath == nil {
+ processPath = func(path string) string { return path }
+ }
+
+ if _, err := os.Stat(epicManifestsPath); os.IsNotExist(err) {
+ return nil, []error{errors.New("Epic is not installed")}
+ }
+
+ manifests, err := os.ReadDir(epicManifestsPath)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to list Epic manifests")}
+ }
+
+ installs := make([]*common.Installation, 0)
+ var findErrors []error
+
+ for _, manifest := range manifests {
+ manifestName := manifest.Name()
+ manifestPath := filepath.Join(epicManifestsPath, manifestName)
+
+ if fileInfo, err := os.Stat(manifestPath); os.IsNotExist(err) || fileInfo.IsDir() {
+ continue
+ }
+
+ manifestData, err := os.ReadFile(manifestPath)
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to read Epic manifest %s", manifestName))
+ continue
+ }
+
+ var epicManifest Manifest
+ if err := json.Unmarshal(manifestData, &epicManifest); err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to parse Epic manifest %s", manifestName))
+ continue
+ }
+
+ if epicManifest.CatalogNamespace != "crab" {
+ continue
+ }
+
+ installLocation := processPath(epicManifest.InstallLocation)
+
+ gameManifestName := fmt.Sprintf("%s.mancpn", epicManifest.InstallationGUID)
+ gameManifestPath := processPath(filepath.Join(epicManifest.ManifestLocation, gameManifestName))
+ gameManifestData, err := os.ReadFile(gameManifestPath)
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to read Epic game manifest %s", gameManifestName))
+ continue
+ }
+
+ var epicGameManifest GameManifest
+ if err := json.Unmarshal(gameManifestData, &epicGameManifest); err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to parse Epic game manifest %s", gameManifestName))
+ continue
+ }
+
+ if epicGameManifest.CatalogNamespace != epicManifest.CatalogNamespace ||
+ epicGameManifest.CatalogItemID != epicManifest.CatalogItemID ||
+ epicGameManifest.AppName != epicManifest.MainGameAppName {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: installLocation,
+ Inner: errors.New("mismatching manifest data"),
+ })
+ continue
+ }
+
+ existingIdx := -1
+ for i := range installs {
+ if installs[i].Path == installLocation {
+ existingIdx = i
+ break
+ }
+ }
+
+ if existingIdx != -1 {
+ continue
+ }
+
+ versionFilePath := filepath.Join(installLocation, "Engine", "Binaries", "Win64", "FactoryGame-Win64-Shipping.version")
+ if _, err := os.Stat(versionFilePath); os.IsNotExist(err) {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: installLocation,
+ Inner: errors.Wrap(err, "failed to read game version"),
+ })
+ continue
+ }
+
+ versionFile, err := os.ReadFile(versionFilePath)
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to read version file %s", versionFilePath))
+ continue
+ }
+
+ var versionData GameVersionFile
+ if err := json.Unmarshal(versionFile, &versionData); err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to parse version file %s", versionFilePath))
+ continue
+ }
+
+ branch, err := GetEpicBranch(epicManifest.MainGameAppName)
+ if err != nil {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: installLocation,
+ Inner: err,
+ })
+ continue
+ }
+
+ installs = append(installs, &common.Installation{
+ Path: filepath.Clean(installLocation),
+ Version: versionData.Changelist,
+ Type: common.InstallTypeWindowsClient,
+ Location: common.LocationTypeLocal,
+ Branch: branch,
+ Launcher: launcher,
+ LaunchPath: launchPath(epicManifest.MainGameAppName),
+ })
+ }
+
+ return installs, findErrors
+}
diff --git a/backend/installfinders/launchers/epic/epic_windows.go b/backend/installfinders/launchers/epic/epic_windows.go
new file mode 100644
index 00000000..5b27b9d9
--- /dev/null
+++ b/backend/installfinders/launchers/epic/epic_windows.go
@@ -0,0 +1,24 @@
+package epic
+
+import (
+ "os"
+ "path/filepath"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+var epicManifestsFolder = filepath.Join(os.Getenv("PROGRAMDATA"), "Epic", "EpicGamesLauncher", "Data", "Manifests")
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return findInstallationsEpic(epicManifestsFolder, "Epic Games", func(appName string) []string {
+ return []string{
+ "cmd",
+ "/C",
+ `start`,
+ ``,
+ // The extra space at the end is required for exec to escape the argument with double quotes
+ // Otherwise, the & is interpreted as a command sequence
+ `com.epicgames.launcher://apps/` + appName + `?action=launch&silent=true `,
+ }
+ }, nil)
+}
diff --git a/backend/installfinders/launchers/epic/epic_wine_linux.go b/backend/installfinders/launchers/epic/epic_wine_linux.go
new file mode 100644
index 00000000..b519657e
--- /dev/null
+++ b/backend/installfinders/launchers/epic/epic_wine_linux.go
@@ -0,0 +1,26 @@
+package epic
+
+import (
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+var epicWineManifestPath = filepath.Join("c:", "ProgramData", "Epic", "EpicGamesLauncher", "Data", "Manifests")
+
+func FindInstallationsWine(winePrefix string, launcher string, launchPath []string) ([]*common.Installation, []error) {
+ wineWindowsRoot := filepath.Join(winePrefix, "dosdevices")
+ epicManifestsPath := filepath.Join(wineWindowsRoot, epicWineManifestPath)
+
+ if _, err := os.Stat(epicManifestsPath); os.IsNotExist(err) {
+ return nil, []error{errors.New("Epic is not installed in " + winePrefix)}
+ }
+
+ return findInstallationsEpic(epicManifestsPath, launcher, func(appName string) []string { return launchPath }, func(path string) string {
+ return filepath.Join(wineWindowsRoot, strings.ToLower(path[0:1])+strings.ReplaceAll(path[1:], "\\", "/"))
+ })
+}
diff --git a/backend/installfinders/launchers/heroic/heroic.go b/backend/installfinders/launchers/heroic/heroic.go
new file mode 100644
index 00000000..cd93c47c
--- /dev/null
+++ b/backend/installfinders/launchers/heroic/heroic.go
@@ -0,0 +1,45 @@
+package heroic
+
+import (
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/legendary"
+)
+
+func findInstallationsHeroic(snap bool, xdgConfigHomeEnv string, launcher string) ([]*common.Installation, []error) {
+ legendaryDataPath, err := getHeroicLegendaryConfigPath(snap, xdgConfigHomeEnv)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get heroic legendary config paths")}
+ }
+
+ return legendary.FindInstallationsIn(legendaryDataPath, launcher)
+}
+
+func getHeroicLegendaryConfigPath(snap bool, xdgConfigHomeEnv string) (string, error) {
+ // Allow passing xdgConfigHomeEnv for flatpak and snap support
+
+ // Should be kept in sync with
+ // https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher/blob/main/src/backend/constants.ts#L56
+
+ if snap {
+ if xdgConfigHomeEnv == "" {
+ return "", errors.New("creating path for heroic snap but XDG_CONFIG_HOME not set")
+ }
+ return filepath.Join(xdgConfigHomeEnv, "legendary"), nil
+ }
+
+ configPath := xdgConfigHomeEnv
+ if configPath == "" {
+ var err error
+ configPath, err = os.UserConfigDir()
+ if err != nil {
+ return "", errors.Wrap(err, "failed to get user config dir")
+ }
+ }
+
+ return filepath.Join(configPath, "heroic", "legendaryConfig", "legendary"), nil
+}
diff --git a/backend/installfinders/launchers/heroic/heroic_linux.go b/backend/installfinders/launchers/heroic/heroic_linux.go
new file mode 100644
index 00000000..105e602a
--- /dev/null
+++ b/backend/installfinders/launchers/heroic/heroic_linux.go
@@ -0,0 +1,68 @@
+package heroic
+
+import (
+ "os"
+ "path/filepath"
+ "strconv"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return common.FindAll(findInstallationsNative, findInstallationsFlatpak, findInstallationsSnap)
+}
+
+func findInstallationsNative() ([]*common.Installation, []error) {
+ return findInstallationsHeroic(false, "", "Heroic")
+}
+
+func findInstallationsFlatpak() ([]*common.Installation, []error) {
+ homeDir, err := os.UserHomeDir()
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get user home dir")}
+ }
+ flatpakXdgConfigHome := filepath.Join(homeDir, ".var", "app", "com.heroicgameslauncher.hgl", "config")
+ return findInstallationsHeroic(false, flatpakXdgConfigHome, "Heroic")
+}
+
+func findInstallationsSnap() ([]*common.Installation, []error) {
+ homeDir, err := os.UserHomeDir()
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get user home dir")}
+ }
+ snapAppDir := filepath.Join(homeDir, "snap", "heroic")
+ var latestSnapRevision int
+ var latestSnapDirName string
+ items, err := os.ReadDir(snapAppDir)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to read heroic snap dir")}
+ }
+ for _, item := range items {
+ if item.IsDir() {
+ folderName := item.Name()
+ var revision int
+ if folderName[0] == 'x' {
+ revision, err = strconv.Atoi(folderName[1:])
+ if err != nil {
+ continue
+ }
+ } else {
+ revision, err = strconv.Atoi(folderName)
+ if err != nil {
+ continue
+ }
+ }
+ if latestSnapDirName == "" || revision > latestSnapRevision {
+ latestSnapRevision = revision
+ latestSnapDirName = folderName
+ }
+ }
+ }
+ if latestSnapDirName == "" {
+ return nil, []error{errors.New("no heroic snap folders found")}
+ }
+
+ return findInstallationsHeroic(true, filepath.Join(snapAppDir, latestSnapDirName, ".config"), "Heroic")
+}
diff --git a/backend/installfinders/launchers/heroic/heroic_windows.go b/backend/installfinders/launchers/heroic/heroic_windows.go
new file mode 100644
index 00000000..a7cfcfc2
--- /dev/null
+++ b/backend/installfinders/launchers/heroic/heroic_windows.go
@@ -0,0 +1,9 @@
+package heroic
+
+import (
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return findInstallationsHeroic(false, "", "Heroic")
+}
diff --git a/backend/installfinders/launchers/legendary/legendary.go b/backend/installfinders/launchers/legendary/legendary.go
new file mode 100644
index 00000000..acef043c
--- /dev/null
+++ b/backend/installfinders/launchers/legendary/legendary.go
@@ -0,0 +1,107 @@
+package legendary
+
+import (
+ "encoding/json"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strconv"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/epic"
+)
+
+type Game struct {
+ AppName string `json:"app_name"`
+ BaseURLs []string `json:"base_urls"`
+ CanRunOffline bool `json:"can_run_offline"`
+ EGLGUID string `json:"egl_guid"`
+ Executable string `json:"executable"`
+ InstallPath string `json:"install_path"`
+ InstallSize int `json:"install_size"`
+ IsDLC bool `json:"is_dlc"`
+ LaunchParameters string `json:"launch_parameters"`
+ ManifestPath string `json:"manifest_path"`
+ NeedsVerification bool `json:"needs_verification"`
+ RequiresOT bool `json:"requires_ot"`
+ SavePath string `json:"save_path"`
+ Title string `json:"title"`
+ Version string `json:"version"`
+}
+
+type Data = map[string]Game
+
+func FindInstallationsIn(legendaryDataPath string, launcher string) ([]*common.Installation, []error) {
+ legendaryInstalledPath := filepath.Join(legendaryDataPath, "installed.json")
+ if _, err := os.Stat(legendaryInstalledPath); os.IsNotExist(err) {
+ return nil, []error{errors.Errorf("%s not installed", launcher)}
+ }
+ var legendaryData Data
+ legendaryDataFile, err := os.ReadFile(legendaryInstalledPath)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to read legendary installed.json")}
+ }
+ err = json.Unmarshal(legendaryDataFile, &legendaryData)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to parse legendary installed.json output")}
+ }
+
+ _, err = exec.LookPath("legendary")
+ canLaunchLegendary := err == nil
+
+ installs := make([]*common.Installation, 0)
+ var findErrors []error
+
+ for _, legendaryGame := range legendaryData {
+ branch, err := epic.GetEpicBranch(legendaryGame.AppName)
+ if err != nil {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: legendaryGame.InstallPath,
+ Inner: err,
+ })
+ continue
+ }
+
+ version, err := strconv.Atoi(legendaryGame.Version)
+ if err != nil {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: legendaryGame.InstallPath,
+ Inner: errors.Wrap(err, "failed to parse version for "+legendaryGame.AppName),
+ })
+ continue
+ }
+ var launchPath []string
+ if canLaunchLegendary {
+ launchPath = []string{"legendary", "launch", legendaryGame.AppName}
+ }
+ installs = append(installs, &common.Installation{
+ Path: filepath.Clean(legendaryGame.InstallPath),
+ Version: version,
+ Type: common.InstallTypeWindowsClient,
+ Location: common.LocationTypeLocal,
+ Branch: branch,
+ Launcher: launcher,
+ LaunchPath: launchPath,
+ })
+ }
+ return installs, findErrors
+}
+
+func getGlobalLegendaryDataPath(xdgConfigHomeEnv string) (string, error) {
+ // Should be kept in sync with
+ // https://github.com/derrod/legendary/blob/master/legendary/lfs/lgndry.py#L29-L34
+
+ if legendaryConfigPathEnv, found := os.LookupEnv("LEGENDARY_CONFIG_PATH"); found {
+ return legendaryConfigPathEnv, nil
+ }
+ if xdgConfigHomeEnv != "" {
+ return filepath.Join(xdgConfigHomeEnv, "legendary"), nil
+ }
+ homeDir, err := os.UserHomeDir()
+ if err != nil {
+ return "", errors.Wrap(err, "failed to get user home dir")
+ }
+ return filepath.Join(homeDir, ".config", "legendary"), nil
+}
diff --git a/backend/installfinders/launchers/legendary/legendary_linux.go b/backend/installfinders/launchers/legendary/legendary_linux.go
new file mode 100644
index 00000000..e5d21390
--- /dev/null
+++ b/backend/installfinders/launchers/legendary/legendary_linux.go
@@ -0,0 +1,15 @@
+package legendary
+
+import (
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ legendaryDataPath, err := getGlobalLegendaryDataPath("")
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get legendary config path")}
+ }
+ return FindInstallationsIn(legendaryDataPath, "Legendary")
+}
diff --git a/backend/installfinders/launchers/legendary/legendary_windows.go b/backend/installfinders/launchers/legendary/legendary_windows.go
new file mode 100644
index 00000000..e5d21390
--- /dev/null
+++ b/backend/installfinders/launchers/legendary/legendary_windows.go
@@ -0,0 +1,15 @@
+package legendary
+
+import (
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ legendaryDataPath, err := getGlobalLegendaryDataPath("")
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get legendary config path")}
+ }
+ return FindInstallationsIn(legendaryDataPath, "Legendary")
+}
diff --git a/backend/installfinders/launchers/lutris/lutris_linux.go b/backend/installfinders/launchers/lutris/lutris_linux.go
new file mode 100644
index 00000000..dbf50825
--- /dev/null
+++ b/backend/installfinders/launchers/lutris/lutris_linux.go
@@ -0,0 +1,64 @@
+package lutris
+
+import (
+ "encoding/json"
+ "os/exec"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/epic"
+)
+
+type Game struct {
+ ID int `json:"id"`
+ Slug string `json:"slug"`
+ Name string `json:"name"`
+ Runner string `json:"runner"`
+ Directory string `json:"directory"`
+}
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return common.FindAll(findInstallationsNative, findInstallationsFlatpak)
+}
+
+func findInstallationsNative() ([]*common.Installation, []error) {
+ return findInstallations([]string{"lutris"}, "Lutris")
+}
+
+func findInstallationsFlatpak() ([]*common.Installation, []error) {
+ return findInstallations([]string{"flatpak", "run", "net.lutris.Lutris"}, "Lutris")
+}
+
+func findInstallations(lutrisCmd []string, launcher string) ([]*common.Installation, []error) {
+ lutrisLjCmd := makeLutrisCmd(lutrisCmd, "-lj")
+ lutrisLj := exec.Command(lutrisLjCmd[0], lutrisLjCmd[1:]...)
+ outputBytes, err := lutrisLj.Output()
+ if err != nil {
+ return nil, []error{
+ errors.Wrap(err, "failed to run lutris -lj"),
+ }
+ }
+ var lutrisGames []Game
+ err = json.Unmarshal(outputBytes, &lutrisGames)
+ if err != nil {
+ return nil, []error{
+ errors.Wrap(err, "failed to parse lutris -lj output"),
+ }
+ }
+
+ installs := []*common.Installation{}
+ findErrors := []error{}
+ for _, lutrisGame := range lutrisGames {
+ currentInstalls, errs := epic.FindInstallationsWine(lutrisGame.Directory, launcher+" - "+lutrisGame.Name, makeLutrisCmd(lutrisCmd, "lutris:rungame/"+lutrisGame.Slug))
+ installs = append(installs, currentInstalls...)
+ if errs != nil {
+ findErrors = append(findErrors, errs...)
+ }
+ }
+ return installs, findErrors
+}
+
+func makeLutrisCmd(lutrisCmd []string, args ...string) []string {
+ return append(lutrisCmd, args...)
+}
diff --git a/backend/installfinders/launchers/steam/steam.go b/backend/installfinders/launchers/steam/steam.go
new file mode 100644
index 00000000..2060d057
--- /dev/null
+++ b/backend/installfinders/launchers/steam/steam.go
@@ -0,0 +1,154 @@
+package steam
+
+import (
+ "encoding/json"
+ "os"
+ "path"
+ "path/filepath"
+ "strconv"
+
+ "github.com/andygrunwald/vdf"
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/launchers/epic"
+)
+
+func findInstallationsSteam(steamPath string, launcher string, executable []string) ([]*common.Installation, []error) {
+ steamAppsPath := filepath.Join(steamPath, "steamapps")
+ libraryFoldersManifestPath := filepath.Join(steamAppsPath, "libraryfolders.vdf")
+
+ libraryFoldersF, err := os.Open(libraryFoldersManifestPath)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to open library folders manifest")}
+ }
+
+ parser := vdf.NewParser(libraryFoldersF)
+ libraryFoldersManifest, err := parser.Parse()
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to parse library folders manifest")}
+ }
+
+ var libraryFoldersList map[string]interface{}
+
+ if _, ok := libraryFoldersManifest["LibraryFolders"]; ok {
+ libraryFoldersList = libraryFoldersManifest["LibraryFolders"].(map[string]interface{})
+ } else if _, ok := libraryFoldersManifest["libraryfolders"]; ok {
+ libraryFoldersList = libraryFoldersManifest["libraryfolders"].(map[string]interface{})
+ } else {
+ return nil, []error{errors.New("failed to find library folders in manifest")}
+ }
+
+ libraryFolders := []string{
+ path.Clean(steamPath),
+ }
+
+ for key, val := range libraryFoldersList {
+ if _, err := strconv.Atoi(key); err != nil {
+ continue
+ }
+
+ libraryFolderData := val.(map[string]interface{})
+ libraryFolder := libraryFolderData["path"].(string)
+
+ found := false
+ for _, existingLibraryFolder := range libraryFolders {
+ if common.OsPathEqual(existingLibraryFolder, libraryFolder) {
+ found = true
+ break
+ }
+ }
+ if !found {
+ libraryFolders = append(libraryFolders, libraryFolder)
+ }
+ }
+
+ installs := make([]*common.Installation, 0)
+ var findErrors []error
+
+ for _, libraryFolder := range libraryFolders {
+ manifestPath := filepath.Join(libraryFolder, "steamapps", "appmanifest_526870.acf")
+
+ if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
+ continue
+ }
+
+ manifestF, err := os.Open(manifestPath)
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to open manifest file %s", manifestPath))
+ continue
+ }
+
+ parser := vdf.NewParser(manifestF)
+ manifest, err := parser.Parse()
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to parse manifest file %s", manifestPath))
+ continue
+ }
+
+ if _, ok := manifest["AppState"]; !ok {
+ findErrors = append(findErrors, errors.Errorf("Failed to find AppState in manifest %s", manifestPath))
+ continue
+ }
+
+ fullInstallationPath := filepath.Join(libraryFolder, "steamapps", "common", manifest["AppState"].(map[string]interface{})["installdir"].(string))
+
+ gameExe := filepath.Join(fullInstallationPath, "FactoryGame.exe")
+ if _, err := os.Stat(gameExe); os.IsNotExist(err) {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: fullInstallationPath,
+ Inner: errors.Wrap(err, "missing game executable"),
+ })
+ continue
+ }
+
+ versionFilePath := filepath.Join(fullInstallationPath, "Engine", "Binaries", "Win64", "FactoryGame-Win64-Shipping.version")
+ if _, err := os.Stat(versionFilePath); os.IsNotExist(err) {
+ findErrors = append(findErrors, common.InstallFindError{
+ Path: fullInstallationPath,
+ Inner: errors.Wrap(err, "missing game version file"),
+ })
+ continue
+ }
+
+ versionFile, err := os.ReadFile(versionFilePath)
+ if err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to read version file %s", versionFilePath))
+ continue
+ }
+
+ var versionData epic.GameVersionFile
+ if err := json.Unmarshal(versionFile, &versionData); err != nil {
+ findErrors = append(findErrors, errors.Wrapf(err, "failed to parse version file %s", versionFilePath))
+ continue
+ }
+
+ var branch common.GameBranch
+ userConfig := manifest["AppState"].(map[string]interface{})["UserConfig"].(map[string]interface{})
+ betakey, ok := userConfig["betakey"]
+ if !ok {
+ branch = common.BranchEarlyAccess
+ } else {
+ if betakey == "experimental" {
+ branch = common.BranchExperimental
+ } else {
+ findErrors = append(findErrors, errors.Errorf("Unknown beta key %s", betakey))
+ }
+ }
+
+ installs = append(installs, &common.Installation{
+ Path: filepath.Clean(fullInstallationPath),
+ Version: versionData.Changelist,
+ Type: common.InstallTypeWindowsClient,
+ Location: common.LocationTypeLocal,
+ Branch: branch,
+ Launcher: launcher,
+ LaunchPath: append(
+ executable,
+ `steam://rungameid/526870`,
+ ),
+ })
+ }
+
+ return installs, findErrors
+}
diff --git a/backend/installfinders/launchers/steam/steam_linux.go b/backend/installfinders/launchers/steam/steam_linux.go
new file mode 100644
index 00000000..a9264ad1
--- /dev/null
+++ b/backend/installfinders/launchers/steam/steam_linux.go
@@ -0,0 +1,53 @@
+package steam
+
+import (
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ return common.FindAll(findInstallationsNative, findInstallationsFlatpak)
+}
+
+func findInstallationsNative() ([]*common.Installation, []error) {
+ homeDir, err := os.UserHomeDir()
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get user home dir")}
+ }
+ steamPath := filepath.Join(homeDir, ".steam", "steam")
+ if _, err := os.Stat(steamPath); os.IsNotExist(err) {
+ return nil, []error{errors.New("steam not installed")}
+ }
+ return findInstallationsSteam(
+ steamPath,
+ "Steam",
+ []string{
+ "steam",
+ },
+ )
+}
+
+func findInstallationsFlatpak() ([]*common.Installation, []error) {
+ homeDir, err := os.UserHomeDir()
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to get user home dir")}
+ }
+
+ steamPath := filepath.Join(homeDir, ".var", "app", "com.valvesoftware.Steam", ".steam", "steam")
+ if _, err := os.Stat(steamPath); os.IsNotExist(err) {
+ return nil, []error{errors.New("steam-flatpak not installed")}
+ }
+ return findInstallationsSteam(
+ steamPath,
+ "Steam",
+ []string{
+ "flatpak",
+ "run",
+ "com.valvesoftware.Steam",
+ },
+ )
+}
diff --git a/backend/installfinders/launchers/steam/steam_windows.go b/backend/installfinders/launchers/steam/steam_windows.go
new file mode 100644
index 00000000..45367576
--- /dev/null
+++ b/backend/installfinders/launchers/steam/steam_windows.go
@@ -0,0 +1,35 @@
+package steam
+
+import (
+ "path/filepath"
+
+ "github.com/pkg/errors"
+ "golang.org/x/sys/windows/registry"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/installfinders/common"
+)
+
+func FindInstallations() ([]*common.Installation, []error) {
+ key, err := registry.OpenKey(registry.CURRENT_USER, `Software\Valve\Steam`, registry.QUERY_VALUE)
+ if err != nil {
+ return nil, []error{errors.Wrap(err, "failed to open Steam registry key")}
+ }
+ defer key.Close()
+
+ steamExePath, _, err := key.GetStringValue("SteamExe")
+ if err != nil {
+ steamExePath = `C:\Program Files (x86)\Steam\steam.exe`
+ }
+
+ steamPath := filepath.Dir(steamExePath)
+ return findInstallationsSteam(
+ steamPath,
+ "Steam",
+ []string{
+ "cmd",
+ "/C",
+ "start",
+ "",
+ },
+ )
+}
diff --git a/backend/projectfile/project_file.go b/backend/projectfile/project_file.go
new file mode 100644
index 00000000..46c87bf8
--- /dev/null
+++ b/backend/projectfile/project_file.go
@@ -0,0 +1,20 @@
+package projectfile
+
+type Info struct {
+ CompanyName string `json:"companyName"`
+ ProductName string `json:"productName"`
+ ProductVersion string `json:"productVersion"`
+ Copyright *string `json:"copyright"`
+ Comments *string `json:"comments"`
+}
+
+type Project struct {
+ Name string `json:"name"`
+ Info Info `json:"info"`
+}
+
+var ProjectFile Project
+
+func Version() string {
+ return ProjectFile.Info.ProductVersion
+}
diff --git a/backend/settings/settings.go b/backend/settings/settings.go
new file mode 100644
index 00000000..21955c64
--- /dev/null
+++ b/backend/settings/settings.go
@@ -0,0 +1,129 @@
+package settings
+
+import (
+ "encoding/json"
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+ "github.com/spf13/viper"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+type SavedModFilters struct {
+ Order string `json:"order"`
+ Filter string `json:"filter"`
+}
+
+type View string
+
+var (
+ ViewCompact View = "compact"
+ ViewExpanded View = "expanded"
+)
+
+type UpdateCheckMode string
+
+var (
+ UpdateOnLaunch UpdateCheckMode = "launch"
+ UpdateOnExit UpdateCheckMode = "exit"
+ UpdateAsk UpdateCheckMode = "ask"
+)
+
+type settings struct {
+ WindowPosition *utils.Position `json:"windowPosition,omitempty"`
+ Maximized bool `json:"maximized,omitempty"`
+
+ UnexpandedSize utils.Size `json:"unexpandedSize,omitempty"`
+ ExpandedSize utils.Size `json:"expandedSize,omitempty"`
+
+ StartView View `json:"startView,omitempty"`
+
+ FavoriteMods []string `json:"favoriteMods,omitempty"`
+ ModFilters SavedModFilters `json:"modFilters,omitempty"`
+
+ QueueAutoStart bool `json:"queueAutoStart,omitempty"`
+ IgnoredUpdates map[string][]string `json:"ignoredUpdates,omitempty"`
+ UpdateCheckMode UpdateCheckMode `json:"updateCheckMode,omitempty"`
+ ViewedAnnouncements []string `json:"viewedAnnouncements,omitempty"`
+
+ Offline bool `json:"offline,omitempty"`
+
+ Konami bool `json:"konami,omitempty"`
+ LaunchButton string `json:"launchButton,omitempty"`
+
+ CacheDir string `json:"cacheDir,omitempty"`
+}
+
+var Settings = settings{
+ WindowPosition: nil,
+ Maximized: false,
+
+ UnexpandedSize: utils.UnexpandedDefault,
+ ExpandedSize: utils.ExpandedDefault,
+
+ StartView: ViewCompact,
+
+ FavoriteMods: []string{},
+ ModFilters: SavedModFilters{
+ Order: "Last updated",
+ Filter: "Compatible",
+ },
+
+ QueueAutoStart: true,
+ IgnoredUpdates: map[string][]string{},
+ UpdateCheckMode: UpdateOnLaunch,
+ ViewedAnnouncements: []string{},
+
+ Offline: false,
+
+ Konami: false,
+ LaunchButton: "normal",
+}
+
+var settingsFileName = "settings.json"
+
+func LoadSettings() error {
+ settingsFilePath := filepath.Join(viper.GetString("smm-local-dir"), settingsFileName)
+
+ _, err := os.Stat(settingsFilePath)
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return errors.Wrap(err, "failed to stat settings file")
+ }
+
+ err = SaveSettings()
+ if err != nil {
+ return errors.Wrap(err, "failed to save default settings")
+ }
+ }
+
+ settingsFile, err := os.ReadFile(filepath.Join(viper.GetString("smm-local-dir"), settingsFileName))
+ if err != nil {
+ return errors.Wrap(err, "failed to read settings")
+ }
+
+ if err := json.Unmarshal(settingsFile, &Settings); err != nil {
+ // Settings file might be SMM2 settings, try to load those
+ err = readSMM2Settings(settingsFile)
+ if err != nil {
+ return errors.Wrap(err, "failed to unmarshal settings")
+ }
+ }
+
+ return nil
+}
+
+func SaveSettings() error {
+ settingsFile, err := utils.JSONMarshal(Settings, 2)
+ if err != nil {
+ return errors.Wrap(err, "failed to marshal settings")
+ }
+ err = os.WriteFile(filepath.Join(viper.GetString("smm-local-dir"), settingsFileName), settingsFile, 0o755)
+ if err != nil {
+ return errors.Wrap(err, "failed to write settings")
+ }
+
+ return nil
+}
diff --git a/backend/settings/smm2settings.go b/backend/settings/smm2settings.go
new file mode 100644
index 00000000..6d561cc6
--- /dev/null
+++ b/backend/settings/smm2settings.go
@@ -0,0 +1,125 @@
+package settings
+
+import (
+ "encoding/json"
+ "maps"
+
+ "github.com/pkg/errors"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/utils"
+)
+
+type smm2Settings struct {
+ WindowLocation *struct {
+ X int `json:"x"`
+ Y int `json:"y"`
+ } `json:"windowLocation"`
+ NormalSize *struct {
+ Width int `json:"width"`
+ Height int `json:"height"`
+ } `json:"normalSize"`
+ ExpandedSize *struct {
+ Width int `json:"width"`
+ Height int `json:"height"`
+ } `json:"expandedSize"`
+ FavoriteMods *[]string `json:"favoriteMods"`
+ Filters *struct {
+ ModFilters string `json:"modFilters"`
+ SortBy string `json:"sortBy"`
+ } `json:"filters"`
+ IgnoredUpdates *map[string][]string `json:"ignoredUpdates"`
+ Maximized *bool `json:"maximized"`
+ SelectedInstall *string `json:"selectedInstall"`
+ DebugMode *bool `json:"debugMode"`
+ SelectedProfile *map[string]string `json:"selectedProfile"`
+ UpdateCheckMode *UpdateCheckMode `json:"updateCheckMode"`
+ ModsEnabled *map[string]bool `json:"modsEnabled"`
+ Konami *bool `json:"konami"`
+ LaunchButton *bool `json:"launchButton"`
+ ExpandModInfoOnStart *bool `json:"expandModInfoOnStart"`
+ LaunchCat *bool `json:"launchCat"`
+ ViewedAnnouncements *[]string `json:"viewedAnnouncements"`
+ DisableDownloadTimeout *bool `json:"disableDownloadTimeout"`
+}
+
+func readSMM2Settings(data []byte) error {
+ s := smm2Settings{}
+ err := json.Unmarshal(data, &s)
+ if err != nil {
+ return errors.Wrap(err, "failed to unmarshal SMM2 settings")
+ }
+
+ if s.WindowLocation != nil {
+ Settings.WindowPosition = &utils.Position{
+ X: s.WindowLocation.X,
+ Y: s.WindowLocation.Y,
+ }
+ }
+
+ if s.NormalSize != nil {
+ Settings.UnexpandedSize.Width = s.NormalSize.Width
+ Settings.UnexpandedSize.Height = s.NormalSize.Height
+ }
+
+ if s.ExpandedSize != nil {
+ Settings.ExpandedSize.Width = s.ExpandedSize.Width
+ Settings.ExpandedSize.Height = s.ExpandedSize.Height
+ }
+
+ if s.FavoriteMods != nil {
+ Settings.FavoriteMods = *s.FavoriteMods
+ }
+
+ if s.Filters != nil {
+ Settings.ModFilters.Filter = s.Filters.ModFilters
+ Settings.ModFilters.Order = s.Filters.SortBy
+ }
+
+ if s.IgnoredUpdates != nil {
+ Settings.IgnoredUpdates = maps.Clone(*s.IgnoredUpdates)
+ }
+
+ if s.Maximized != nil {
+ Settings.Maximized = *s.Maximized
+ }
+
+ // Ignore selected install, profile, and mods enabled
+ // They are stored in ficsit-cli, but that gets initialized later
+ // They are not critical anyway
+
+ // Ignore DebugMode, it's not used anymore
+
+ if s.UpdateCheckMode != nil {
+ Settings.UpdateCheckMode = *s.UpdateCheckMode
+ }
+
+ if s.Konami != nil {
+ Settings.Konami = *s.Konami
+ }
+
+ if s.LaunchButton != nil {
+ if *s.LaunchButton {
+ Settings.LaunchButton = "button"
+ }
+ }
+
+ if s.LaunchCat != nil {
+ if *s.LaunchCat {
+ Settings.LaunchButton = "cat"
+ }
+ }
+
+ if s.ExpandModInfoOnStart != nil {
+ if *s.ExpandModInfoOnStart {
+ Settings.StartView = ViewExpanded
+ }
+ }
+
+ if s.ViewedAnnouncements != nil {
+ Settings.ViewedAnnouncements = *s.ViewedAnnouncements
+ }
+
+ // Ignore DisableDownloadTimeout, it's not used anymore
+
+ return nil
+}
diff --git a/backend/utils/json.go b/backend/utils/json.go
new file mode 100644
index 00000000..cd4cee71
--- /dev/null
+++ b/backend/utils/json.go
@@ -0,0 +1,19 @@
+package utils
+
+import (
+ "bytes"
+ "encoding/json"
+ "strings"
+)
+
+func JSONMarshal(v any, indentSize int) ([]byte, error) {
+ buf := new(bytes.Buffer)
+ enc := json.NewEncoder(buf)
+ enc.SetEscapeHTML(false)
+ enc.SetIndent("", strings.Repeat(" ", indentSize))
+ err := enc.Encode(v)
+ if err != nil {
+ return nil, err // nolint:wrapcheck
+ }
+ return buf.Bytes(), nil
+}
diff --git a/backend/utils/os.go b/backend/utils/os.go
new file mode 100644
index 00000000..4d367e0e
--- /dev/null
+++ b/backend/utils/os.go
@@ -0,0 +1,86 @@
+package utils
+
+import (
+ "io"
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+)
+
+func IsIn(dir, path string) bool {
+ rel, err := filepath.Rel(dir, path)
+ if err != nil {
+ return false
+ }
+ return filepath.IsLocal(rel)
+}
+
+func CopyRecursive(from, to string) error {
+ return filepath.Walk(from, func(path string, info os.FileInfo, err error) error { //nolint:wrapcheck
+ if err != nil {
+ return err
+ }
+ if IsIn(to, path) {
+ return nil
+ }
+ relPath, err := filepath.Rel(from, path)
+ if err != nil {
+ return err //nolint:wrapcheck
+ }
+ newPath := filepath.Join(to, relPath)
+ if info.IsDir() {
+ err := os.Mkdir(newPath, 0o755)
+ if err != nil && !os.IsExist(err) {
+ return err //nolint:wrapcheck
+ }
+ return nil
+ }
+ f, err := os.Open(path)
+ if err != nil {
+ return err //nolint:wrapcheck
+ }
+ defer f.Close()
+ f2, err := os.Create(newPath)
+ if err != nil {
+ return err //nolint:wrapcheck
+ }
+ defer f2.Close()
+ _, err = io.Copy(f2, f)
+ return err //nolint:wrapcheck
+ })
+}
+
+func MoveRecursive(from, to string) (bool, error) {
+ err := CopyRecursive(from, to)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to copy %s to %s", from, to)
+ }
+ err = filepath.Walk(from, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return err
+ }
+ return nil
+ }
+ if IsIn(path, to) {
+ // Skip parent directories of destination
+ return nil
+ }
+ if IsIn(to, path) {
+ // Skip contents of destination
+ return nil
+ }
+ err = os.RemoveAll(path)
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return err //nolint:wrapcheck
+ }
+ }
+ return nil
+ })
+ if err != nil {
+ return true, errors.Wrapf(err, "failed to remove %s", from)
+ }
+ return true, nil
+}
diff --git a/backend/utils/paths.go b/backend/utils/paths.go
new file mode 100644
index 00000000..3df98a3a
--- /dev/null
+++ b/backend/utils/paths.go
@@ -0,0 +1,44 @@
+package utils
+
+import (
+ "log/slog"
+ "net/url"
+ "os"
+
+ "github.com/pkg/errors"
+)
+
+func EnsureDirExists(path string) error {
+ _, err := os.Stat(path)
+ if err != nil {
+ if !os.IsNotExist(err) {
+ return errors.Wrapf(err, "failed to stat path %s", path)
+ }
+
+ err = os.MkdirAll(path, 0o755)
+ if err != nil {
+ return errors.Wrapf(err, "failed to create directory %s", path)
+ }
+ }
+ return nil
+}
+
+func RedactPath(path string) string {
+ parsed, err := url.Parse(path)
+ if err != nil {
+ return "***INVALID PATH FOR REDACTION***"
+ }
+ // For remote servers, they might contain a username, password, and host, all of which should be redacted when logging
+ if parsed.User != nil {
+ // "*" would be encoded to %2A in usernames and passwords
+ parsed.User = url.UserPassword("user", "pass")
+ }
+ if parsed.Host != "" {
+ parsed.Host = "******"
+ }
+ return parsed.String()
+}
+
+func SlogPath(key string, path string) slog.Attr {
+ return slog.String(key, RedactPath(path))
+}
diff --git a/backend/utils/progress.go b/backend/utils/progress.go
new file mode 100644
index 00000000..17edf913
--- /dev/null
+++ b/backend/utils/progress.go
@@ -0,0 +1,62 @@
+package utils
+
+import (
+ "maps"
+ "time"
+)
+
+type ProgressTracker struct {
+ windowSize time.Duration
+ data map[time.Time]int64
+ Total int64
+}
+
+func NewProgressTracker(windowSize time.Duration) *ProgressTracker {
+ return &ProgressTracker{
+ windowSize: windowSize,
+ data: make(map[time.Time]int64),
+ }
+}
+
+func (pt *ProgressTracker) Add(value int64) {
+ pt.Total += value
+ pt.data[time.Now()] = value
+ pt.evict()
+}
+
+func (pt *ProgressTracker) Speed() float64 {
+ pt.evict()
+ var first, last time.Time
+ for t := range pt.data {
+ if first.IsZero() || t.Before(first) {
+ first = t
+ }
+ if last.IsZero() || t.After(last) {
+ last = t
+ }
+ }
+ firstData := pt.data[first]
+ lastData := pt.data[last]
+ return float64(lastData-firstData) / pt.windowSize.Seconds()
+}
+
+func (pt *ProgressTracker) ETA() time.Duration {
+ speed := pt.Speed()
+ if speed == 0 {
+ return 0
+ }
+ var latest time.Time
+ for t := range pt.data {
+ if latest.IsZero() || t.After(latest) {
+ latest = t
+ }
+ }
+ latestData := pt.data[latest]
+ return time.Duration(float64(pt.Total-latestData)/speed) * time.Second
+}
+
+func (pt *ProgressTracker) evict() {
+ maps.DeleteFunc(pt.data, func(t time.Time, _ int64) bool {
+ return time.Since(t) > pt.windowSize
+ })
+}
diff --git a/backend/utils/sizes.go b/backend/utils/sizes.go
new file mode 100644
index 00000000..ff0094b8
--- /dev/null
+++ b/backend/utils/sizes.go
@@ -0,0 +1,20 @@
+package utils
+
+type Size struct {
+ Width int `json:"width"`
+ Height int `json:"height"`
+}
+
+type Position struct {
+ X int `json:"x"`
+ Y int `json:"y"`
+}
+
+var (
+ UnexpandedMin = Size{Width: 850, Height: 750}
+ UnexpandedMax = Size{Width: 0, Height: 0}
+ UnexpandedDefault = Size{Width: 950, Height: 950}
+ ExpandedMin = Size{Width: 1255, Height: 750}
+ ExpandedMax = Size{Width: 0, Height: 0}
+ ExpandedDefault = Size{Width: 1300, Height: 950}
+)
diff --git a/backend/utils/zip.go b/backend/utils/zip.go
new file mode 100644
index 00000000..9966d018
--- /dev/null
+++ b/backend/utils/zip.go
@@ -0,0 +1,42 @@
+package utils
+
+import (
+ "archive/zip"
+ "io"
+ "os"
+
+ "github.com/pkg/errors"
+)
+
+func AddFileToZip(writer *zip.Writer, path string, zipPath string) error {
+ file, err := os.Open(path)
+ if err != nil {
+ return errors.Wrap(err, "failed to open file")
+ }
+ defer file.Close()
+
+ fileInfo, err := file.Stat()
+ if err != nil {
+ return errors.Wrap(err, "failed to get file info")
+ }
+
+ if fileInfo.IsDir() {
+ return errors.New("file is a directory")
+ }
+
+ header, err := zip.FileInfoHeader(fileInfo)
+ if err != nil {
+ return errors.Wrap(err, "failed to create header")
+ }
+
+ header.Method = zip.Deflate
+ header.Name = zipPath
+
+ fileWriter, err := writer.CreateHeader(header)
+ if err != nil {
+ return errors.Wrap(err, "failed to create file writer")
+ }
+
+ _, err = io.Copy(fileWriter, file)
+ return errors.Wrap(err, "failed to copy file")
+}
diff --git a/backend/wails_logger.go b/backend/wails_logger.go
new file mode 100644
index 00000000..daba0a55
--- /dev/null
+++ b/backend/wails_logger.go
@@ -0,0 +1,37 @@
+package backend
+
+import (
+ "log/slog"
+ "os"
+)
+
+type WailsZeroLogLogger struct{}
+
+func (l WailsZeroLogLogger) Print(message string) {
+ slog.Debug(message)
+}
+
+func (l WailsZeroLogLogger) Trace(message string) {
+ slog.Debug(message)
+}
+
+func (l WailsZeroLogLogger) Debug(message string) {
+ slog.Debug(message)
+}
+
+func (l WailsZeroLogLogger) Info(message string) {
+ slog.Info(message)
+}
+
+func (l WailsZeroLogLogger) Warning(message string) {
+ slog.Warn(message)
+}
+
+func (l WailsZeroLogLogger) Error(message string) {
+ slog.Error(message)
+}
+
+func (l WailsZeroLogLogger) Fatal(message string) {
+ slog.Error(message)
+ os.Exit(1)
+}
diff --git a/backend/websocket/websocket.go b/backend/websocket/websocket.go
new file mode 100644
index 00000000..eead4e64
--- /dev/null
+++ b/backend/websocket/websocket.go
@@ -0,0 +1,45 @@
+//go:build !bindings
+
+package websocket
+
+import (
+ "log/slog"
+
+ "github.com/spf13/viper"
+ engineio_types "github.com/zishang520/engine.io/types"
+ "github.com/zishang520/socket.io/socket"
+
+ "github.com/satisfactorymodding/SatisfactoryModManager/backend/bindings"
+)
+
+func ListenAndServeWebsocket() {
+ httpServer := engineio_types.CreateServer(nil)
+ options := &socket.ServerOptions{}
+ options.SetCors(&engineio_types.Cors{
+ Origin: true, // Allow any origin
+ })
+ io := socket.NewServer(nil, options)
+ httpServer.Handle("/socket.io", io.ServeHandler(nil))
+
+ _ = io.On("connection", func(data ...any) {
+ client := data[0].(*socket.Socket)
+ _ = client.On("installedMods", func(datas ...any) {
+ lockfile, err := bindings.BindingsInstance.FicsitCLI.GetSelectedInstallLockfile()
+ if err != nil {
+ slog.Error("failed to get lockfile", slog.Any("error", err))
+ return
+ }
+ if lockfile == nil {
+ slog.Error("no lockfile found for websocket call", slog.Any("error", err))
+ return
+ }
+ installedMods := make(map[string]string)
+ for modReference, info := range lockfile.Mods {
+ installedMods[modReference] = info.Version
+ }
+ _ = client.Emit("installedMods", installedMods)
+ })
+ })
+
+ httpServer.Listen("localhost:"+viper.GetString("websocket-port"), nil)
+}
diff --git a/backend/websocket/websocket_noop.go b/backend/websocket/websocket_noop.go
new file mode 100644
index 00000000..4fc94073
--- /dev/null
+++ b/backend/websocket/websocket_noop.go
@@ -0,0 +1,6 @@
+//go:build bindings
+
+package websocket
+
+func ListenAndServeWebsocket() {
+}
diff --git a/build/README.md b/build/README.md
new file mode 100644
index 00000000..c01ea3cb
--- /dev/null
+++ b/build/README.md
@@ -0,0 +1,61 @@
+# Build Directory
+
+The build directory is used to house all the build files and assets for your application.
+
+The structure is:
+
+ * bin - Output directory
+ * dialog - Icons for dialogs
+ * tray - Icons for the system tray
+ * mac - MacOS specific files
+ * linux - Linux specific files
+ * windows - Windows specific files
+
+## Dialog Icons
+
+Place any PNG file in this directory to be able to use them in message dialogs.
+The files should have names in the following format: `name[-(light|dark)][2x].png`
+
+Examples:
+
+* `mypic.png` - Standard definition icon with ID `mypic`
+* `mypic-light.png` - Standard definition icon with ID `mypic`, used when system theme is light
+* `mypic-dark.png` - Standard definition icon with ID `mypic`, used when system theme is dark
+* `mypic2x.png` - High definition icon with ID `mypic`
+* `mypic-light2x.png` - High definition icon with ID `mypic`, used when system theme is light
+* `mypic-dark2x.png` - High definition icon with ID `mypic`, used when system theme is dark
+
+### Order of preference
+
+Icons are selected with the following order of preference:
+
+For High Definition displays:
+* name-(theme)2x.png
+* name2x.png
+* name-(theme).png
+* name.png
+
+For Standard Definition displays:
+* name-(theme).png
+* name.png
+
+## Tray
+
+Place any PNG file in this directory to be able to use them as tray icons.
+The name of the filename will be the ID to reference the image.
+
+Example:
+
+* `mypic.png` - May be referenced using `runtime.Tray.SetIcon("mypic")`
+
+## Mac
+
+The `darwin` directory holds files specific to Mac builds, such as `Info.plist`.
+These may be customised and used as part of the build. To return these files to the default state, simply delete them and
+build with the `-package` flag.
+
+## Windows
+
+The `windows` directory contains the manifest and rc files used when building with the `-package` flag.
+These may be customised for your application. To return these files to the default state, simply delete them and
+build with the `-package` flag.
\ No newline at end of file
diff --git a/build/appicon.png b/build/appicon.png
new file mode 100644
index 00000000..67a31f3a
Binary files /dev/null and b/build/appicon.png differ
diff --git a/build/darwin/Info.plist b/build/darwin/Info.plist
new file mode 100644
index 00000000..303145e3
--- /dev/null
+++ b/build/darwin/Info.plist
@@ -0,0 +1,14 @@
+
+
+ {#if frameless}
+
+
+
+
+
+
+ {#if $expandedMod}
+
+
+
+ {/if}
+
+
+
+
+
+
+
diff --git a/frontend/src/lib/components/announcements/Announcement.svelte b/frontend/src/lib/components/announcements/Announcement.svelte
new file mode 100644
index 00000000..d788b347
--- /dev/null
+++ b/frontend/src/lib/components/announcements/Announcement.svelte
@@ -0,0 +1,80 @@
+
+
+
+ 
+
+
+
+
+
+
+
+ Satisfactory Mod Manager v{version}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/frontend/src/lib/components/announcements/AnnouncementsBar.svelte b/frontend/src/lib/components/announcements/AnnouncementsBar.svelte
new file mode 100644
index 00000000..c647174c
--- /dev/null
+++ b/frontend/src/lib/components/announcements/AnnouncementsBar.svelte
@@ -0,0 +1,153 @@
+
+
+{#if $offline}
+
+
+
+
+ {announcement.message}
+
+
+
+
+
+
+{:else if announcements.length > 0}
+
+ {offlineAnnouncement.message}
+ Go Online
+
+ hovered = true} on:mouseleave={() => hovered = false} role="alert">
+ 1}
+ dots={false}
+ arrows={false}
+ swiping={false}
+ on:pageChange={pageChange}
+ >
+ {#each announcements as announcement}
+
+
+{/if}
diff --git a/frontend/src/lib/components/left-bar/LaunchButton.svelte b/frontend/src/lib/components/left-bar/LaunchButton.svelte
new file mode 100644
index 00000000..580e0bdf
--- /dev/null
+++ b/frontend/src/lib/components/left-bar/LaunchButton.svelte
@@ -0,0 +1,241 @@
+
+
+
+ {#if CUSTOM_ANNOUNCEMENT_REGEX.test(announcement.id)}
+
+ {#if announcement.id === '__healthcheck__'}
+
+ {:else}
+
+
+ {announcement.message}
+
+
+ {/if}
+
+ {/each}
+
+ {announcement.message}
+ Go Offline
+
+ {:else}
+ {announcement.message}
+ {/if}
+ catPressed = false}
+ on:mousemove={catMouseMove}
+ >
+ 
+
+ {:else if $launchButton === 'button' }
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+ {/if}
+
+
+
+
+ launchButtonState = 'over'}
+ on:mousedown={() => launchButtonState = 'press'}
+ on:mouseenter={() => launchButtonState = 'over'}
+ on:mouseleave={() => launchButtonState = 'normal'}
+ >
+ 
+
+
+ -
+ {#if versionIncompatible.length > 0}
+
- + { versionIncompatible.length } incompatible mod{ versionIncompatible.length > 1 ? 's' : '' } which will either not load or crash your game + + {/if} + {#if reportedIncompatible.length > 0} +
- + { reportedIncompatible.length } mod{ reportedIncompatible.length > 1 ? 's' : '' } that { reportedIncompatible.length > 1 ? 'are' : 'is' } reported as Broken on this game version. + Read the mod{ reportedIncompatible.length > 1 ? 's\'' : '\'s' } description or compatibility notes for more information. + + {/if} + {#if versionPossiblyCompatible.length > 0} +
- + { versionPossiblyCompatible.length } mod{ versionPossiblyCompatible.length > 1 ? 's' : '' } + that { versionPossiblyCompatible.length > 1 ? 'are' : 'is' } likely incompatible with your game + + {/if} + {#if reportedPossiblyCompatible.length > 0} +
- + { reportedPossiblyCompatible.length } mod{ reportedPossiblyCompatible.length > 1 ? 's' : '' } + that { reportedPossiblyCompatible.length > 1 ? 'are' : 'is' } reported as Damaged on this game version. + Read the mod{ reportedPossiblyCompatible.length > 1 ? 's\'' : '\'s' } description or compatibility notes for more information. + + {/if} +
(You're in Queue "Start manually" mode) +
Note: The Mod Manager has already finished installing the mod files for you. You could launch the game using your usual game launcher and mods would still be loaded. +
+
+
+
+
+
+
+
diff --git a/frontend/src/lib/components/mods-list/ModsList.svelte b/frontend/src/lib/components/mods-list/ModsList.svelte
new file mode 100644
index 00000000..3e3daf73
--- /dev/null
+++ b/frontend/src/lib/components/mods-list/ModsList.svelte
@@ -0,0 +1,164 @@
+
+
+
+ 
+ {mod?.name ?? 'Loading...'}
+ A mod by:
+ {author ?? 'Loading...'}
+
+
+ authorsMenu.setOpen(true)} on:mouseleave={() => authorsMenu.setOpen(false)} role="listbox" tabindex="0">
+
+
+
+
+
+ Mod info:
+ Size: {size ?? 'Loading...'}
+ {#if (!mod || !('offline' in mod)) && !$offline} + Created: {mod ? new Date(mod.created_at).toLocaleDateString() : 'Loading...'}
+ Updated: {mod ? new Date(mod.last_version_date).toLocaleString() : 'Loading...'}
+ Total downloads: {mod?.downloads.toLocaleString() ?? 'Loading...'}
+ Views: {mod?.views.toLocaleString() ?? 'Loading...'}
+
+
+ + Size: {size ?? 'Loading...'}
+ {#if (!mod || !('offline' in mod)) && !$offline} + Created: {mod ? new Date(mod.created_at).toLocaleDateString() : 'Loading...'}
+ Updated: {mod ? new Date(mod.last_version_date).toLocaleString() : 'Loading...'}
+ Total downloads: {mod?.downloads.toLocaleString() ?? 'Loading...'}
+ Views: {mod?.views.toLocaleString() ?? 'Loading...'}
+
+ Compatibility:
+ {#if mod?.compatibility}
+
+ Unknown
+
+ No compatibility information has been reported for this mod yet. Try it out and contact us on the Discord so it can be updated!
+
+
+ {/if}
+
+ {/if}
+
+
+
+ This mod has been reported as {mod.compatibility.EA.state} on Early Access.
+ {#if mod.compatibility.EA.note}
+
+ {@html markdown(mod.compatibility.EA.note)}
+ {:else}
+ (No further notes provided)
+ {/if}
+
+
+
+
+ This mod has been reported as {mod.compatibility.EXP.state} on Experimental.
+ {#if mod.compatibility.EXP.note}
+
+ {@html markdown(mod.compatibility.EXP.note)}
+ {:else}
+ (No further notes provided)
+ {/if}
+
+
+
+ {:else}
+
+ Latest version: { latestVersion ?? 'Loading...' }
+ Installed version: { installedVersion ?? 'Loading...' }
+
+
+
+
+
+ + Installed version: { installedVersion ?? 'Loading...' }
+
+
+
+
+ {#if (!mod || !('offline' in mod)) && !$offline}
+
+
+
+
+ {/if}
+
+
+
+
+ {#if $offline}
+
+Offline mode is enabled. Changelogs and descriptions are not available.
+ {:else if descriptionRendered}
+
+
+ + + {@html descriptionRendered} +
+ {:else} +Loading...
+ {/if} +
+
diff --git a/frontend/src/lib/components/mods-list/ModsListFilters.svelte b/frontend/src/lib/components/mods-list/ModsListFilters.svelte
new file mode 100644
index 00000000..41ab3633
--- /dev/null
+++ b/frontend/src/lib/components/mods-list/ModsListFilters.svelte
@@ -0,0 +1,95 @@
+
+
+
+
+
+
+
+
+ {
+ $expandedMod = mod.mod_reference;
+ dispatch('expandedMod', mod.mod_reference);
+ }}
+ selected={$expandedMod == mod.mod_reference}
+ />
+
+
+
+
+
+
diff --git a/frontend/src/lib/components/mods-list/ModsListItem.svelte b/frontend/src/lib/components/mods-list/ModsListItem.svelte
new file mode 100644
index 00000000..a9563b03
--- /dev/null
+++ b/frontend/src/lib/components/mods-list/ModsListItem.svelte
@@ -0,0 +1,354 @@
+
+
+
+
+
+
+
+
+
+
+
+
+ {#if inProgress}
+
+
+
diff --git a/frontend/src/lib/components/mods-list/VirtualModList.svelte b/frontend/src/lib/components/mods-list/VirtualModList.svelte
new file mode 100644
index 00000000..1303b003
--- /dev/null
+++ b/frontend/src/lib/components/mods-list/VirtualModList.svelte
@@ -0,0 +1,84 @@
+
+
+
+
+ {/if}
+
+
+
+
+
+
+ This mod is Disabled. Click the pause icon to Enable it.
+
+ {:else if compatibility.state !== CompatibilityState.Works}
+
+
+ { @html compatibility.note }
+
+ {/if}
+
+
+
+
+
+
+
+ {#if isInstalled && !isEnabled}
+
+ {mod.name}
+
+
+
+ {#if !inProgress}
+
+
+
+ {:else}
+ { $progress?.message }
+ {/if}
+ {'short_description' in mod ? mod.short_description : ''}
+
+
+ {#if !('offline' in mod) && !('missing' in mod)}
+
+
+
+
+
+ {mod.views.toLocaleString()}
+
+
+ {/if}
+
+
+ {mod.downloads.toLocaleString()}
+ { /* empty */ }} on:keypress|stopPropagation={() => { /* empty */ }}>
+
+
+
\ No newline at end of file
diff --git a/frontend/src/lib/core/graphql.ts b/frontend/src/lib/core/graphql.ts
new file mode 100644
index 00000000..0defcb55
--- /dev/null
+++ b/frontend/src/lib/core/graphql.ts
@@ -0,0 +1,41 @@
+import type { Client } from '@urql/svelte';
+import { createClient, fetchExchange } from '@urql/svelte';
+import { cacheExchange } from '@urql/exchange-graphcache';
+import { persistedExchange } from '@urql/exchange-persisted';
+
+import schema from '$lib/generated/graphql.schema.urql.json';
+
+export function initializeGraphQLClient(apiEndpointURL: string): Client {
+ return createClient({
+ url: apiEndpointURL,
+ exchanges: [
+ cacheExchange({
+ schema,
+ keys: {
+ GetMods: () => null,
+ GetSMLVersions: () => null,
+ LatestVersions: () => null,
+ UserMod: () => null,
+ GetGuides: () => null,
+ OAuthOptions: () => null,
+ UserRoles: () => null,
+ Compatibility: () => null,
+ CompatibilityInfo: () => null,
+ VersionDependency: () => null,
+ Mod: (data) => data.mod_reference as string,
+ },
+ resolvers: {
+ Query: {
+ getModByReference: (_parent, args) => {
+ return { __typename: 'Mod', mod_reference: args.modReference };
+ },
+ },
+ },
+ }),
+ persistedExchange({
+ preferGetForPersistedQueries: true,
+ }),
+ fetchExchange,
+ ],
+ });
+}
diff --git a/frontend/src/lib/core/index.ts b/frontend/src/lib/core/index.ts
new file mode 100644
index 00000000..acae838c
--- /dev/null
+++ b/frontend/src/lib/core/index.ts
@@ -0,0 +1 @@
+export * from './graphql';
diff --git a/frontend/src/lib/generated/.gitignore b/frontend/src/lib/generated/.gitignore
new file mode 100644
index 00000000..4623421c
--- /dev/null
+++ b/frontend/src/lib/generated/.gitignore
@@ -0,0 +1,2 @@
+graphql.schema.urql.json
+graphql.ts
\ No newline at end of file
diff --git a/frontend/src/lib/generated/index.ts b/frontend/src/lib/generated/index.ts
new file mode 100644
index 00000000..acae838c
--- /dev/null
+++ b/frontend/src/lib/generated/index.ts
@@ -0,0 +1 @@
+export * from './graphql';
diff --git a/frontend/src/lib/store/actionQueue.ts b/frontend/src/lib/store/actionQueue.ts
new file mode 100644
index 00000000..2cec4167
--- /dev/null
+++ b/frontend/src/lib/store/actionQueue.ts
@@ -0,0 +1,59 @@
+import { queue } from 'async';
+import { derived, get, writable } from 'svelte/store';
+
+import { queueAutoStart } from './settingsStore';
+
+interface QueuedAction
+ {#each visibleItems as item (item.index)}
+
+
+ Missing template
+
+ {/each}
+