From 8eedf14e1af08d66ff5a4dc83d2fc7cd0c99f026 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 15 Nov 2026 06:32:46 +0000 Subject: [PATCH] Release 2.1.3: no more silent waiting without an Nvidia card Without an NVIDIA driver the converter asks "Continue on the processor?" and waits 15 seconds. The window starts one converter per file and never showed that question, so every file waited. When nvidia-smi is missing altogether the window now passes -cpu itself (encoderForRun) and says so once in the log. Any unclear answer leaves the decision to the converter. Downloads: the window's own update and the converter download compare the SHA-256 digest GitHub lists for the asset, not only its size. Files: profiles, the savings balance and the window state are written next to the target and put in place with one rename (writeFileAtomic). Writes to the INI and the phrase list are serialised (fileWriteMu), so two changes in quick succession cannot overwrite each other. Version 2.1.3 in main.go and wails.json, and the release text. Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01GvUq7F6HRPWfTUBjDkD1bR --- .github/release-notes/v2.1.3.md | 12 +++++++++ app.go | 28 +++++++++++++++++++- configfile.go | 10 +++++++ converter.go | 8 ++++++ datadir.go | 33 +++++++++++++++++++++++ datadir_test.go | 36 ++++++++++++++++++++++++++ frontend/wailsjs/go/models.ts | 2 ++ gpu.go | 34 +++++++++++++++++++++++- main.go | 2 +- profiles.go | 2 +- runargs_test.go | 28 ++++++++++++++++++++ savings.go | 2 +- selfupdate.go | 46 +++++++++++++++++++++++++++++++++ selfupdate_test.go | 38 +++++++++++++++++++++++++++ srtcleaner.go | 3 +++ wails.json | 2 +- windowstate.go | 2 +- 17 files changed, 281 insertions(+), 7 deletions(-) create mode 100644 .github/release-notes/v2.1.3.md diff --git a/.github/release-notes/v2.1.3.md b/.github/release-notes/v2.1.3.md new file mode 100644 index 0000000..d725be6 --- /dev/null +++ b/.github/release-notes/v2.1.3.md @@ -0,0 +1,12 @@ +## NVENCForgeGUI 2.1.3: no more silent waiting without an Nvidia card + +Small fixes and safeguards from a full read-through of the code. + +- **A PC without an Nvidia driver no longer waits 15 seconds before every file.** The converter asks "Continue on the processor?" and waits for an answer, but the window started one converter per file and never showed the question. When there is no Nvidia driver on the PC at all, the window now tells the converter straight away to use the processor, and says so once in the log. With a card present nothing changes. +- **Updates are checked against GitHub's checksum.** Both the window's own update and the converter download now compare the SHA-256 checksum GitHub lists for the file, not only its size. A download that does not match is discarded and nothing is replaced. +- **Profiles, the savings balance and the window position survive a crash while saving.** They are written next to the old file first and put in place in one step. +- **Two settings changed in quick succession can no longer overwrite each other.** Writes to `NVENCForge_Config.ini` and the subtitle phrase list now happen one at a time. + +Best together with NVENCForge 2.2.4, which fixes old WMV files being encoded at 1000 fps and answers to track questions getting lost: use the converter's update button. + +Update: About page > *Check for updates*, or replace `NVENCForgeGUI.exe` with the new one. Your converter, settings and profiles in `tools` stay. diff --git a/app.go b/app.go index ae5a874..2e70e86 100644 --- a/app.go +++ b/app.go @@ -16,6 +16,7 @@ import ( "os" "path/filepath" "strings" + "sync" "time" "github.com/wailsapp/wails/v2/pkg/options" @@ -44,6 +45,13 @@ type App struct { // profiles sind die gespeicherten Optionssätze der Konvertieren-Seite. profiles *profileStore + // gpuInfo ist die einmal abgefragte Grafikkarte (gpu). noteProcessorOnce + // sorgt dafür, dass der Hinweis "es wird auf dem Prozessor gerechnet" nur + // einmal im Protokoll steht und nicht vor jeder Datei. + gpuOnce sync.Once + gpuInfo GPUInfo + noteProcessorOnce sync.Once + // shutdown hält den Wunsch "PC ausschalten, wenn alles fertig ist" und // führt ihn aus, sobald wirklich nichts mehr zu tun ist (shutdown.go). shutdown *shutdownGuard @@ -336,7 +344,7 @@ type StartupInfo struct { func (a *App) GetStartupInfo() StartupInfo { return StartupInfo{ GUIVersion: guiVersion, - GPU: queryGPU(), + GPU: a.gpu(), Converter: converterStatus(), Config: readConfigView(), } @@ -679,6 +687,14 @@ func (a *App) DropPendingFile(area, path string) bool { return a.dispatcher.DropPending(areaOf(area), path) } +// gpu fragt die Grafikkarte einmal ab und merkt sich die Antwort. Die Abfrage +// startet ein Hilfsprogramm; vor jedem einzelnen Lauf wäre das unnötig — und +// eine Karte kommt im laufenden Betrieb nicht dazu. +func (a *App) gpu() GPUInfo { + a.gpuOnce.Do(func() { a.gpuInfo = queryGPU() }) + return a.gpuInfo +} + // StartRun reiht die Arbeit ein und startet, was auf die freien Plätze passt. func (a *App) StartRun(request RunRequest) error { status := converterStatus() @@ -707,6 +723,16 @@ func (a *App) StartRun(request RunRequest) error { if request.Crop == "" && status.AutoCrop { request.Crop = cropOff } + // Nur das Umwandeln rechnet überhaupt; die Werkzeug-Modi kopieren. + if request.Mode == "" { + if encoder, switched := encoderForRun(request.Encoder, a.gpu()); switched { + request.Encoder = encoder + a.noteProcessorOnce.Do(func() { + a.note("No NVIDIA driver on this PC (nvidia-smi is missing): encoding on the processor. " + + "That works everywhere, but takes considerably longer than a graphics card.") + }) + } + } jobs, err := buildJobs(request, status.EventChannel) if err != nil { diff --git a/configfile.go b/configfile.go index 1bd257f..9a6d181 100644 --- a/configfile.go +++ b/configfile.go @@ -180,6 +180,13 @@ func settingsByKey(settings []SettingEntry) map[string]string { // eine Nebendatei schreiben, dann umbenennen. Bricht irgendetwas ab, ist die // alte INI entweder unversehrt oder als .bak vorhanden — halb geschriebene // Einstellungen kann es nicht geben. +// fileWriteMu lässt immer nur EINEN Schreibvorgang an die Dateien des +// Konverters (INI, Phrasenliste). Jeder liest die Datei, ändert Zeilen und +// setzt sie neu ein — zwei gleichzeitig, und der zweite hätte die Änderung des +// ersten nie gesehen und überschriebe sie. Die Oberfläche ruft für jedes +// geänderte Feld einzeln, und jeder Aufruf läuft in seinem eigenen Ablauf. +var fileWriteMu sync.Mutex + func writeSettings(values map[string]string) (SaveResult, error) { if len(values) == 0 { return SaveResult{Note: "nothing to save"}, nil @@ -197,6 +204,9 @@ func writeSettings(values map[string]string) (SaveResult, error) { // können: Ein Test, der die echte Einstellungsdatei des Nutzers beschreibt, // wäre selbst dann ein Fehler, wenn er funktioniert. func writeSettingsTo(path string, values map[string]string) (SaveResult, error) { + fileWriteMu.Lock() + defer fileWriteMu.Unlock() + original, err := os.ReadFile(path) if err != nil { return SaveResult{}, fmt.Errorf("configfile.go: writeSettings (read): %w", err) diff --git a/converter.go b/converter.go index 1e95ce4..96702c4 100644 --- a/converter.go +++ b/converter.go @@ -256,6 +256,10 @@ type releaseAsset struct { Name string `json:"name"` Size int64 `json:"size"` URL string `json:"browser_download_url"` + // Digest ist die Prüfsumme, die GitHub zu einer Datei mitliefert + // ("sha256:…"). Ältere Veröffentlichungen haben keine; dann bleibt das + // Feld leer (siehe verifyDownloadedDigest). + Digest string `json:"digest"` } type releaseInfo struct { @@ -447,6 +451,10 @@ func downloadConverter(ctx context.Context, force bool, report func(done, total if err := downloadToFile(ctx, asset, partPath, report); err != nil { return result, err } + if err := verifyDownloadedDigest(partPath, asset.Digest); err != nil { + _ = os.Remove(partPath) + return result, err + } if !force && wouldLoseEventChannel(before, partPath) { _ = os.Remove(partPath) diff --git a/datadir.go b/datadir.go index daec504..b2150fa 100644 --- a/datadir.go +++ b/datadir.go @@ -69,3 +69,36 @@ func dataFilePathIn(home, fileName string) string { } return inside } + +// writeFileAtomic schreibt data erst in eine Datei NEBEN dem Ziel und setzt +// sie dann mit einem einzigen Umbenennen ein. +// +// Für alles, was dieses Fenster sich merkt (Profile, Sparbuch, Fensterplatz). +// Bis 2.1.2 wurde direkt ins Ziel geschrieben: Ging dabei etwas schief — +// Rechner aus, Platte voll —, blieb eine halbe Datei zurück, und beim +// nächsten Start waren die Profile weg, weil sie sich nicht mehr lesen ließ. +// Jetzt steht am Ziel entweder die alte Fassung oder die neue. +func writeFileAtomic(path string, data []byte, perm os.FileMode) error { + temp, err := os.CreateTemp(filepath.Dir(path), filepath.Base(path)+".*.tmp") + if err != nil { + return fmt.Errorf("datadir.go: writeFileAtomic (temp file): %w", err) + } + tempPath := temp.Name() + _, writeErr := temp.Write(data) + if writeErr == nil { + writeErr = temp.Sync() + } + if closeErr := temp.Close(); writeErr == nil { + writeErr = closeErr + } + if writeErr != nil { + _ = os.Remove(tempPath) + return fmt.Errorf("datadir.go: writeFileAtomic (write): %w", writeErr) + } + _ = os.Chmod(tempPath, perm) + if err := os.Rename(tempPath, path); err != nil { + _ = os.Remove(tempPath) + return fmt.Errorf("datadir.go: writeFileAtomic (replace): %w", err) + } + return nil +} diff --git a/datadir_test.go b/datadir_test.go index 9b4d7ef..7214f29 100644 --- a/datadir_test.go +++ b/datadir_test.go @@ -101,3 +101,39 @@ func TestUnwritableHomeFallsBackNextToTheExe(t *testing.T) { t.Errorf("Ausweichort %q, erwartet neben der exe in %q", path, home) } } + +// TestWriteFileAtomicReplacesInOneStep: Am Ziel steht danach die neue Fassung, +// und es bleibt keine Nebendatei liegen — die würde sich sonst mit jedem +// Speichern im tools-Ordner ansammeln. +func TestWriteFileAtomicReplacesInOneStep(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "NVENCForgeGUI.profiles") + if err := os.WriteFile(path, []byte("alt"), 0o644); err != nil { + t.Fatalf("Ausgangsdatei: %v", err) + } + + if err := writeFileAtomic(path, []byte("neu"), 0o644); err != nil { + t.Fatalf("writeFileAtomic: %v", err) + } + + raw, err := os.ReadFile(path) + if err != nil || string(raw) != "neu" { + t.Errorf("am Ziel steht %q (Fehler: %v), erwartet \"neu\"", raw, err) + } + entries, err := os.ReadDir(dir) + if err != nil { + t.Fatalf("Ordner lesen: %v", err) + } + if len(entries) != 1 { + t.Errorf("im Ordner liegen %d Dateien, erwartet nur das Ziel", len(entries)) + } +} + +// TestWriteFileAtomicKeepsTheOldFileOnFailure: Lässt sich nicht schreiben, +// bleibt die alte Fassung unversehrt. Genau dafür gibt es den Umweg. +func TestWriteFileAtomicKeepsTheOldFileOnFailure(t *testing.T) { + missing := filepath.Join(t.TempDir(), "gibt-es-nicht", "NVENCForgeGUI.profiles") + if err := writeFileAtomic(missing, []byte("neu"), 0o644); err == nil { + t.Error("ein Ziel in einem fehlenden Ordner muss einen Fehler melden") + } +} diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts index d6558b0..8eb56f3 100644 --- a/frontend/wailsjs/go/models.ts +++ b/frontend/wailsjs/go/models.ts @@ -122,6 +122,7 @@ export namespace main { driver: string; memoryMB: number; note: string; + driverMissing: boolean; static createFrom(source: any = {}) { return new GPUInfo(source); @@ -134,6 +135,7 @@ export namespace main { this.driver = source["driver"]; this.memoryMB = source["memoryMB"]; this.note = source["note"]; + this.driverMissing = source["driverMissing"]; } } export class JoinFile { diff --git a/gpu.go b/gpu.go index 697896f..6893938 100644 --- a/gpu.go +++ b/gpu.go @@ -12,6 +12,7 @@ package main import ( "context" + "errors" "os/exec" "strconv" "strings" @@ -35,6 +36,12 @@ type GPUInfo struct { Driver string `json:"driver"` MemoryMB int `json:"memoryMB"` Note string `json:"note"` + // DriverMissing heißt: nvidia-smi gibt es auf diesem Rechner gar nicht. + // Das ist mehr als "keine Karte erkannt" — eine Abfrage, die nur zu lange + // brauchte oder mit einem Fehler endete, setzt es NICHT. Nur auf diese + // eindeutige Auskunft hin wählt das Fenster von sich aus den Prozessor + // (encoderForRun). + DriverMissing bool `json:"driverMissing"` } // queryGPU fragt nvidia-smi nach Name, Treiber und Speicher der ersten Karte. @@ -54,11 +61,36 @@ func queryGPU() GPUInfo { out, err := cmd.Output() if err != nil { - return GPUInfo{Note: "No NVIDIA GPU detected (nvidia-smi not available)."} + return GPUInfo{ + Note: "No NVIDIA GPU detected (nvidia-smi not available).", + DriverMissing: errors.Is(err, exec.ErrNotFound), + } } return parseGPUQuery(string(out)) } +// encoderForRun entscheidet, womit ein Umwandel-Lauf rechnet. Zurück kommt +// der Encoder für die Befehlszeile und ob das Fenster ihn gerade selbst +// umgestellt hat. +// +// Ohne NVIDIA-Treiber kann der Konverter nur auf dem Prozessor rechnen. Er +// findet das selbst heraus und fragt dann "Continue on the processor?" — mit +// 15 Sekunden Bedenkzeit, weil er auf der Konsole niemanden übergehen will. +// Dieses Fenster startet aber je Datei einen eigenen Konverter: Jede einzelne +// Datei wartete diese 15 Sekunden ab, ohne dass irgendwo eine Frage zu sehen +// war. Weiß das Fenster sicher, dass kein Treiber da ist, sagt es dem +// Konverter deshalb gleich "-cpu". +// +// Bewusst eng: nur wenn nvidia-smi wirklich fehlt. Bei jeder unklaren Auskunft +// bleibt die Entscheidung beim Konverter, der die Karte selbst ausprobiert — +// ein Fenster, das eine vorhandene Karte übergeht, wäre der schlimmere Fehler. +func encoderForRun(requested string, gpu GPUInfo) (encoder string, switched bool) { + if requested == encoderCPU || !gpu.DriverMissing { + return requested, false + } + return encoderCPU, true +} + // parseGPUQuery liest die erste Zeile der nvidia-smi-Ausgabe. // // Eigene Funktion, damit sie ohne Grafikkarte testbar ist. Bei mehreren Karten diff --git a/main.go b/main.go index 8de8674..01e780d 100644 --- a/main.go +++ b/main.go @@ -25,7 +25,7 @@ var assets embed.FS // guiVersion ist die einzige Stelle, an der die Version dieses Fensters // steht. Angezeigt wird sie im Fensterkopf (Titelleiste) und in der // Kopfzeile der Oberfläche selbst (siehe StartupInfo in app.go). -const guiVersion = "2.1.2" +const guiVersion = "2.1.3" // singleInstanceID hält die Startsperre. Der Name muss auf dem Rechner // einmalig sein und darf sich nie ändern — sonst erkennt eine neue Ausgabe die diff --git a/profiles.go b/profiles.go index 263df64..63274e2 100644 --- a/profiles.go +++ b/profiles.go @@ -268,7 +268,7 @@ func (s *profileStore) write() error { if err != nil { return fmt.Errorf("profiles.go: write (Marshal): %w", err) } - if err := os.WriteFile(s.path, raw, 0o644); err != nil { + if err := writeFileAtomic(s.path, raw, 0o644); err != nil { return fmt.Errorf("profiles.go: write (WriteFile): %w", err) } return nil diff --git a/runargs_test.go b/runargs_test.go index 0897bac..d57a55d 100644 --- a/runargs_test.go +++ b/runargs_test.go @@ -361,3 +361,31 @@ func TestCropCheckReachesEveryFile(t *testing.T) { } } } + +// TestEncoderForRun: Das Fenster wählt den Prozessor nur dann von sich aus, +// wenn sicher kein NVIDIA-Treiber da ist. Der dritte Fall ist der wichtige — +// eine Abfrage, die bloß gescheitert ist, darf eine vorhandene Karte nicht +// übergehen. +func TestEncoderForRun(t *testing.T) { + cases := []struct { + name string + requested string + gpu GPUInfo + wantEncoder string + wantSwitched bool + }{ + {"card present, nothing chosen", "", GPUInfo{Detected: true}, "", false}, + {"card present, card chosen", encoderNvidia, GPUInfo{Detected: true}, encoderNvidia, false}, + {"query failed, driver may be there", encoderNvidia, GPUInfo{}, encoderNvidia, false}, + {"no driver at all", encoderNvidia, GPUInfo{DriverMissing: true}, encoderCPU, true}, + {"no driver, nothing chosen", "", GPUInfo{DriverMissing: true}, encoderCPU, true}, + {"no driver, processor already chosen", encoderCPU, GPUInfo{DriverMissing: true}, encoderCPU, false}, + } + for _, c := range cases { + encoder, switched := encoderForRun(c.requested, c.gpu) + if encoder != c.wantEncoder || switched != c.wantSwitched { + t.Errorf("%s: encoderForRun = %q, %v — erwartet %q, %v", + c.name, encoder, switched, c.wantEncoder, c.wantSwitched) + } + } +} diff --git a/savings.go b/savings.go index eb3bbda..c97351a 100644 --- a/savings.go +++ b/savings.go @@ -170,7 +170,7 @@ func (l *savingsLedger) write() { return } if raw, err := json.Marshal(l.book); err == nil { - _ = os.WriteFile(l.path, raw, 0o644) + _ = writeFileAtomic(l.path, raw, 0o644) } } diff --git a/selfupdate.go b/selfupdate.go index 3d90946..3ed598f 100644 --- a/selfupdate.go +++ b/selfupdate.go @@ -28,7 +28,10 @@ package main import ( "context" + "crypto/sha256" + "encoding/hex" "fmt" + "io" "os" "os/exec" "path/filepath" @@ -222,6 +225,10 @@ func installUpdate(ctx context.Context, report func(done, total int64)) (UpdateR _ = os.Remove(partPath) return result, err } + if err := verifyDownloadedDigest(partPath, asset.Digest); err != nil { + _ = os.Remove(partPath) + return result, err + } backupPath := backupPathFor(self, guiVersion) if err := swapInNewExe(self, partPath, backupPath); err != nil { @@ -254,6 +261,45 @@ func verifyDownloadedSize(path string, expected int64) error { return nil } +// sha256DigestPrefix steht vor der Prüfsumme, wie GitHub sie meldet. +const sha256DigestPrefix = "sha256:" + +// verifyDownloadedDigest vergleicht die geladene Datei mit der Prüfsumme, die +// GitHub für sie nennt. +// +// Die Größe allein (verifyDownloadedSize) fängt einen abgebrochenen Download, +// aber keine Datei, die unterwegs verändert wurde und zufällig gleich lang +// ist. Eine Programmdatei, die sich selbst ersetzt, soll das unterscheiden +// können. +// +// Nennt GitHub keine Prüfsumme (ältere Veröffentlichungen) oder eine in einem +// Verfahren, das dieses Fenster nicht kennt, wird nichts geprüft und nichts +// abgelehnt: Das Update soll an einer fehlenden Angabe nicht scheitern. +func verifyDownloadedDigest(path, digest string) error { + digest = strings.TrimSpace(digest) + if !strings.HasPrefix(strings.ToLower(digest), sha256DigestPrefix) { + return nil + } + expected := strings.ToLower(digest[len(sha256DigestPrefix):]) + + file, err := os.Open(path) + if err != nil { + return fmt.Errorf("selfupdate.go: verifyDownloadedDigest (Open): %w", err) + } + defer file.Close() + + hash := sha256.New() + if _, err := io.Copy(hash, file); err != nil { + return fmt.Errorf("selfupdate.go: verifyDownloadedDigest (read): %w", err) + } + if actual := hex.EncodeToString(hash.Sum(nil)); actual != expected { + return fmt.Errorf( + "selfupdate.go: verifyDownloadedDigest: the download does not match the checksum " + + "GitHub lists for it — nothing was replaced, please try again") + } + return nil +} + // canWriteInto stellt fest, ob in einem Ordner geschrieben werden darf. // // Der Weg über eine echte Testdatei ist der einzige verlässliche: Über Rechte, diff --git a/selfupdate_test.go b/selfupdate_test.go index 021eaa0..8fcfd9c 100644 --- a/selfupdate_test.go +++ b/selfupdate_test.go @@ -11,6 +11,8 @@ package main import ( + "crypto/sha256" + "encoding/hex" "os" "path/filepath" "strings" @@ -224,3 +226,39 @@ func readProbeFile(t *testing.T, path string) string { } return string(raw) } + +// TestVerifyDownloadedDigest prüft den Vergleich mit der Prüfsumme von GitHub. +// Entscheidend ist der dritte Fall: gleiche Länge, anderer Inhalt — genau das +// lässt die Größenprüfung allein durch. +func TestVerifyDownloadedDigest(t *testing.T) { + path := filepath.Join(t.TempDir(), "NVENCForgeGUI.exe.part") + writeProbeFile(t, path, "neue Ausgabe") + actual := sha256Hex(t, "neue Ausgabe") + + if err := verifyDownloadedDigest(path, "sha256:"+actual); err != nil { + t.Errorf("die passende Prüfsumme wurde abgelehnt: %v", err) + } + if err := verifyDownloadedDigest(path, "SHA256:"+strings.ToUpper(actual)); err != nil { + t.Errorf("Großschreibung darf keinen Unterschied machen: %v", err) + } + writeProbeFile(t, path, "neue Ausgabf") // gleich lang, anderer Inhalt + if err := verifyDownloadedDigest(path, "sha256:"+actual); err == nil { + t.Error("eine veränderte Datei gleicher Länge wurde angenommen") + } + // Keine oder eine unbekannte Angabe: nichts prüfen, nichts ablehnen. + // Die letzte Angabe ist eine Prüfsumme OHNE das Kennzeichen des Verfahrens: + // was sie bedeutet, ist dann nicht gesagt. + for _, digest := range []string{"", " ", "md5:abc", actual} { + if err := verifyDownloadedDigest(path, digest); err != nil { + t.Errorf("Angabe %q darf das Update nicht aufhalten: %v", digest, err) + } + } +} + +// sha256Hex rechnet die Prüfsumme eines Textes aus, unabhängig vom geprüften +// Code — sonst prüfte die Funktion nur sich selbst. +func sha256Hex(t *testing.T, text string) string { + t.Helper() + sum := sha256.Sum256([]byte(text)) + return hex.EncodeToString(sum[:]) +} diff --git a/srtcleaner.go b/srtcleaner.go index 771c78d..212ce48 100644 --- a/srtcleaner.go +++ b/srtcleaner.go @@ -205,6 +205,9 @@ func writeSRTCleaner(phrases []SRTPhrase) (SaveResult, error) { // Nebendatei, dann umbenennen. Bricht etwas ab, ist die alte Liste entweder // unversehrt oder als .bak vorhanden. func writeSRTCleanerTo(path string, phrases []SRTPhrase) (SaveResult, error) { + fileWriteMu.Lock() + defer fileWriteMu.Unlock() + original, err := os.ReadFile(path) if err != nil { return SaveResult{}, fmt.Errorf("srtcleaner.go: writeSRTCleaner (read): %w", err) diff --git a/wails.json b/wails.json index 4e372c1..7ec558c 100644 --- a/wails.json +++ b/wails.json @@ -8,7 +8,7 @@ "info": { "companyName": "burnersen", "productName": "NVENCForgeGUI", - "productVersion": "2.1.2", + "productVersion": "2.1.3", "copyright": "Copyright 2026 burnersen", "comments": "A window for NVENCForge" } diff --git a/windowstate.go b/windowstate.go index a8093db..4a4ec64 100644 --- a/windowstate.go +++ b/windowstate.go @@ -132,7 +132,7 @@ func saveWindowState(state windowState) error { if err != nil { return fmt.Errorf("windowstate.go: saveWindowState (Marshal): %w", err) } - if err := os.WriteFile(path, raw, 0o644); err != nil { + if err := writeFileAtomic(path, raw, 0o644); err != nil { return fmt.Errorf("windowstate.go: saveWindowState (WriteFile): %w", err) } return nil