fix(dotfiles): warn on stale backup removal failure after successful stow

os.Remove on the .zshrc backup was silently dropping its error. Now emits ui.Warn if the removal fails, consistent with the existing restoreFile warning on the failure path.

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: fullstackjam

internal/dotfiles/dotfiles.go

@@ -1,13 +1,15 @@
 package dotfiles
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 
 	"github.com/openbootdotdev/openboot/internal/system"
+	"github.com/openbootdotdev/openboot/internal/ui"
 )
 
 const defaultDotfilesDir = ".dotfiles"
@@ -77,6 +79,26 @@ func hasStowPackages(dotfilesPath string) bool {
 	return false
 }
 
+func backupFile(src, dst string) error {
+	data, err := os.ReadFile(src)
+	if err != nil {
+		return fmt.Errorf("failed to read %s for backup: %w", src, err)
+	}
+	if err := os.WriteFile(dst, data, 0644); err != nil {
+		return fmt.Errorf("failed to write backup %s: %w", dst, err)
+	}
+	return nil
+}
+
+func restoreFile(backup, original string) {
+	if _, err := os.Stat(backup); os.IsNotExist(err) {
+		return
+	}
+	if err := os.Rename(backup, original); err != nil {
+		fmt.Printf("Warning: failed to restore %s from backup: %v\n", original, err)
+	}
+}
+
 func linkWithStow(dotfilesPath string, dryRun bool) error {
 	entries, err := os.ReadDir(dotfilesPath)
 	if err != nil {
@@ -88,6 +110,8 @@ func linkWithStow(dotfilesPath string, dryRun bool) error {
 		return err
 	}
 
+	var errs []error
+
 	for _, entry := range entries {
 		if !entry.IsDir() || strings.HasPrefix(entry.Name(), ".") {
 			continue
@@ -99,23 +123,45 @@ func linkWithStow(dotfilesPath string, dryRun bool) error {
 			continue
 		}
 
+		// For the zsh package: back up .zshrc before removing it so we can
+		// restore it if stow fails, preventing an unrecoverable loss of shell config.
+		var zshrcBackedUp bool
+		var zshrcPath, zshrcBackupPath string
 		if pkg == "zsh" {
-			zshrc := filepath.Join(home, ".zshrc")
-			zshrcBackup := filepath.Join(home, ".zshrc.pre-oh-my-zsh")
-			os.Remove(zshrc)
-			os.Remove(zshrcBackup)
+			zshrcPath = filepath.Join(home, ".zshrc")
+			zshrcBackupPath = zshrcPath + ".openboot.bak"
+			if _, statErr := os.Stat(zshrcPath); statErr == nil {
+				if err := backupFile(zshrcPath, zshrcBackupPath); err != nil {
+					errs = append(errs, fmt.Errorf("stow %s: %w", pkg, err))
+					continue
+				}
+				zshrcBackedUp = true
+			}
+			os.Remove(zshrcPath)
+			os.Remove(filepath.Join(home, ".zshrc.pre-oh-my-zsh"))
 		}
 
 		cmd := exec.Command("stow", "-v", "-t", home, pkg)
 		cmd.Dir = dotfilesPath
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		if err := cmd.Run(); err != nil {
-			fmt.Printf("Warning: failed to stow %s: %v\n", pkg, err)
+			// Restore .zshrc backup so the user isn't left without a shell config.
+			if zshrcBackedUp {
+				restoreFile(zshrcBackupPath, zshrcPath)
+			}
+			errs = append(errs, fmt.Errorf("failed to stow %s: %w", pkg, err))
+			continue
+		}
+
+		if zshrcBackedUp {
+			if err := os.Remove(zshrcBackupPath); err != nil {
+				ui.Warn(fmt.Sprintf("could not remove .zshrc backup: %v", err))
+			}
 		}
 	}
 
-	return nil
+	return errors.Join(errs...)
 }
 
 func linkDirect(dotfilesPath string, dryRun bool) error {

internal/dotfiles/dotfiles_test.go

@@ -216,3 +216,67 @@ func TestLinkWithStow_SkipsFiles(t *testing.T) {
 	err = linkWithStow(dotfilesPath, true)
 	assert.NoError(t, err)
 }
+
+func TestBackupFile_CreatesBackup(t *testing.T) {
+	tmpDir := t.TempDir()
+	src := filepath.Join(tmpDir, "original")
+	dst := filepath.Join(tmpDir, "backup")
+
+	require.NoError(t, os.WriteFile(src, []byte("hello"), 0644))
+
+	require.NoError(t, backupFile(src, dst))
+
+	data, err := os.ReadFile(dst)
+	require.NoError(t, err)
+	assert.Equal(t, "hello", string(data))
+}
+
+func TestBackupFile_MissingSrcReturnsError(t *testing.T) {
+	tmpDir := t.TempDir()
+	err := backupFile(filepath.Join(tmpDir, "nonexistent"), filepath.Join(tmpDir, "backup"))
+	assert.Error(t, err)
+}
+
+func TestRestoreFile_MovesBackToOriginal(t *testing.T) {
+	tmpDir := t.TempDir()
+	backup := filepath.Join(tmpDir, "file.bak")
+	original := filepath.Join(tmpDir, "file")
+
+	require.NoError(t, os.WriteFile(backup, []byte("restored"), 0644))
+
+	restoreFile(backup, original)
+
+	data, err := os.ReadFile(original)
+	require.NoError(t, err)
+	assert.Equal(t, "restored", string(data))
+
+	_, err = os.Stat(backup)
+	assert.True(t, os.IsNotExist(err))
+}
+
+func TestRestoreFile_NoopWhenBackupMissing(t *testing.T) {
+	tmpDir := t.TempDir()
+	restoreFile(filepath.Join(tmpDir, "nonexistent.bak"), filepath.Join(tmpDir, "original"))
+}
+
+func TestLinkWithStow_ZshBackupRestoredOnFailure(t *testing.T) {
+	tmpHome := t.TempDir()
+	t.Setenv("HOME", tmpHome)
+
+	dotfilesPath := filepath.Join(tmpHome, defaultDotfilesDir)
+	zshPkg := filepath.Join(dotfilesPath, "zsh")
+	require.NoError(t, os.MkdirAll(zshPkg, 0755))
+	require.NoError(t, os.WriteFile(filepath.Join(zshPkg, ".zshrc"), []byte("zsh pkg zshrc"), 0644))
+
+	zshrcPath := filepath.Join(tmpHome, ".zshrc")
+	originalContent := "# original zshrc\n"
+	require.NoError(t, os.WriteFile(zshrcPath, []byte(originalContent), 0644))
+
+	err := linkWithStow(dotfilesPath, false)
+
+	if err != nil {
+		content, readErr := os.ReadFile(zshrcPath)
+		require.NoError(t, readErr)
+		assert.Equal(t, originalContent, string(content), ".zshrc should be restored after stow failure")
+	}
+}