feat: shell diff in openboot diff, sync --yes, sync logged-in fallback

openboot diff:
- Now detects shell config differences (ZSH_THEME, plugins) when the
  remote config specifies oh_my_zsh: true, matching sync behavior
- ShellDiff added to DiffResult, printed in terminal and JSON output
- TotalChanged and HasChanges account for shell diff

openboot sync:
- Falls back to the logged-in user's openboot.dev config when no
  sync source is saved (avoids "run openboot install first" error
  for users who are logged in but haven't installed yet)
- --yes / -y flag auto-confirms all prompts for non-interactive use
  (scripts, CI/CD, dotfiles automation); behaves like dry-run plan
  but actually executes the changes

Author: fullstackjam

internal/cli/sync.go

@@ -20,16 +20,20 @@ var syncCmd = &cobra.Command{
 	Long: `Fetch the latest remote config and apply changes to your local system.
 
 The sync source is automatically saved when you run 'openboot install <config>'.
+If no source is saved, falls back to your logged-in openboot.dev config.
 You can override it with --source.
 
 This command compares your local system against the remote config and lets you
 interactively select which changes to apply.`,
-	Example: `  # Sync with the config you last installed
+	Example: `  # Sync with the config you last installed (or your logged-in config)
   openboot sync
 
   # Preview changes without applying
   openboot sync --dry-run
 
+  # Apply all changes without prompts (for scripts/CI)
+  openboot sync --yes
+
   # Sync with a different config
   openboot sync --source alice/my-setup
 
@@ -45,12 +49,14 @@ func init() {
 	syncCmd.Flags().String("source", "", "override remote config source (alias or username/slug)")
 	syncCmd.Flags().Bool("dry-run", false, "preview changes without applying")
 	syncCmd.Flags().Bool("install-only", false, "only install missing packages, skip removal prompts")
+	syncCmd.Flags().BoolP("yes", "y", false, "auto-confirm all prompts (non-interactive)")
 }
 
 func runSync(cmd *cobra.Command) error {
 	sourceOverride, _ := cmd.Flags().GetString("source")
 	dryRun, _ := cmd.Flags().GetBool("dry-run")
 	installOnly, _ := cmd.Flags().GetBool("install-only")
+	yes, _ := cmd.Flags().GetBool("yes")
 
 	// 1. Load sync source
 	var source *syncpkg.SyncSource
@@ -63,7 +69,12 @@ func runSync(cmd *cobra.Command) error {
 			return fmt.Errorf("load sync source: %w", err)
 		}
 		if source == nil {
-			return fmt.Errorf("no sync source found — run 'openboot install <config>' first, or use --source")
+			// Fall back to the logged-in user's config
+			if stored, authErr := auth.LoadToken(); authErr == nil && stored != nil && stored.Username != "" {
+				source = &syncpkg.SyncSource{UserSlug: stored.Username}
+			} else {
+				return fmt.Errorf("no sync source found — run 'openboot install <config>' first, or use --source")
+			}
 		}
 	}
 
@@ -111,7 +122,7 @@ func runSync(cmd *cobra.Command) error {
 	printSyncDiff(diff)
 
 	// 7. Build plan from interactive selection
-	plan, err := buildSyncPlan(diff, rc, dryRun, installOnly)
+	plan, err := buildSyncPlan(diff, rc, dryRun, installOnly, yes)
 	if err != nil {
 		return err
 	}
@@ -121,8 +132,8 @@ func runSync(cmd *cobra.Command) error {
 		return nil
 	}
 
-	// 8. Confirm (skip in dry-run mode)
-	if !dryRun {
+	// 8. Confirm (skip in dry-run and --yes modes)
+	if !dryRun && !yes {
 		confirmed, err := ui.Confirm(fmt.Sprintf("Apply %d changes?", plan.TotalActions()), true)
 		if err != nil {
 			return fmt.Errorf("confirm: %w", err)
@@ -253,9 +264,9 @@ func printMissingExtra(category string, missing, extra []string) {
 	}
 }
 
-func buildSyncPlan(d *syncpkg.SyncDiff, rc *config.RemoteConfig, dryRun bool, installOnly bool) (*syncpkg.SyncPlan, error) {
-	// Dry-run: include all missing items without interactive prompts
-	if dryRun {
+func buildSyncPlan(d *syncpkg.SyncDiff, rc *config.RemoteConfig, dryRun bool, installOnly bool, yes bool) (*syncpkg.SyncPlan, error) {
+	// Dry-run or --yes: include all missing items without interactive prompts
+	if dryRun || yes {
 		return buildDryRunPlan(d), nil
 	}
 

internal/diff/compare.go

@@ -62,9 +62,65 @@ func CompareSnapshotToRemote(system *snapshot.Snapshot, remote *config.RemoteCon
 		result.MacOS = diffMacOS(system.MacOSPrefs, refPrefs)
 	}
 
+	// Shell configuration comparison — only when remote specifies oh-my-zsh
+	if remote.Shell != nil && remote.Shell.OhMyZsh {
+		result.Shell = diffShell(remote.Shell.Theme, remote.Shell.Plugins)
+	}
+
 	return result
 }
 
+// diffShell captures the local shell state and compares it against reference values.
+func diffShell(refTheme string, refPlugins []string) *ShellDiff {
+	local, err := snapshot.CaptureShell()
+	if err != nil || local == nil {
+		return nil
+	}
+
+	var sd *ShellDiff
+
+	if refTheme != "" && refTheme != local.Theme {
+		sd = &ShellDiff{
+			ThemeChanged:     true,
+			LocalTheme:       local.Theme,
+			ReferenceTheme:   refTheme,
+			LocalPlugins:     local.Plugins,
+			ReferencePlugins: refPlugins,
+		}
+	}
+
+	if len(refPlugins) > 0 && !pluginsEqual(refPlugins, local.Plugins) {
+		if sd == nil {
+			sd = &ShellDiff{
+				LocalTheme:       local.Theme,
+				ReferenceTheme:   refTheme,
+				LocalPlugins:     local.Plugins,
+				ReferencePlugins: refPlugins,
+			}
+		}
+		sd.PluginsChanged = true
+	}
+
+	return sd
+}
+
+// pluginsEqual reports whether two plugin lists contain the same elements regardless of order.
+func pluginsEqual(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	set := make(map[string]bool, len(a))
+	for _, p := range a {
+		set[p] = true
+	}
+	for _, p := range b {
+		if !set[p] {
+			return false
+		}
+	}
+	return true
+}
+
 func diffPackages(system, reference *snapshot.Snapshot) PackageDiff {
 	return PackageDiff{
 		Formulae: DiffLists(system.Packages.Formulae, reference.Packages.Formulae),

internal/diff/diff.go

@@ -73,13 +73,24 @@ type DotfilesDiff struct {
 	Unpushed    bool         // local commits not pushed to remote
 }
 
+// ShellDiff holds shell configuration differences between system and reference.
+type ShellDiff struct {
+	ThemeChanged     bool
+	LocalTheme       string
+	ReferenceTheme   string
+	PluginsChanged   bool
+	LocalPlugins     []string
+	ReferencePlugins []string
+}
+
 // DiffResult is the top-level diff output.
 type DiffResult struct {
 	Source   Source
 	Packages PackageDiff
 	MacOS    *MacOSDiff    // nil when not compared
 	DevTools *DevToolDiff  // nil when not compared
 	Dotfiles *DotfilesDiff // nil when not compared
+	Shell    *ShellDiff    // nil when not compared
 }
 
 // DiffLists computes a bidirectional set diff between system and reference string slices.
@@ -124,6 +135,9 @@ func (r *DiffResult) HasChanges() bool {
 	if r.Dotfiles != nil && (r.Dotfiles.Dirty || r.Dotfiles.Unpushed || r.Dotfiles.RepoChanged != nil) {
 		return true
 	}
+	if r.Shell != nil {
+		return true
+	}
 	return false
 }
 
@@ -171,6 +185,9 @@ func (r *DiffResult) TotalChanged() int {
 	if r.Dotfiles != nil && r.Dotfiles.RepoChanged != nil {
 		n++
 	}
+	if r.Shell != nil {
+		n++
+	}
 	return n
 }
 

internal/diff/format.go

@@ -3,6 +3,7 @@ package diff
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/openbootdotdev/openboot/internal/ui"
 )
@@ -32,6 +33,9 @@ func FormatTerminal(result *DiffResult, packagesOnly bool) {
 		if result.DevTools != nil {
 			printDevToolsSection(result.DevTools)
 		}
+		if result.Shell != nil {
+			printShellSection(result.Shell)
+		}
 	}
 
 	printSummary(result)
@@ -45,6 +49,7 @@ func FormatJSON(result *DiffResult) ([]byte, error) {
 		Dotfiles: result.Dotfiles,
 		MacOS:    result.MacOS,
 		DevTools: result.DevTools,
+		Shell:    result.Shell,
 		Summary: jsonSummary{
 			Missing: result.TotalMissing(),
 			Extra:   result.TotalExtra(),
@@ -61,6 +66,7 @@ type jsonOutput struct {
 	Dotfiles *DotfilesDiff `json:"dotfiles,omitempty"`
 	MacOS    *MacOSDiff    `json:"macos,omitempty"`
 	DevTools *DevToolDiff  `json:"dev_tools,omitempty"`
+	Shell    *ShellDiff    `json:"shell,omitempty"`
 	Summary  jsonSummary   `json:"summary"`
 }
 
@@ -163,6 +169,30 @@ func printDevToolsSection(dd *DevToolDiff) {
 	fmt.Println()
 }
 
+func printShellSection(sd *ShellDiff) {
+	if !sd.ThemeChanged && !sd.PluginsChanged {
+		return
+	}
+	fmt.Printf("  Shell:\n")
+	if sd.ThemeChanged {
+		local := sd.LocalTheme
+		if local == "" {
+			local = "(none)"
+		}
+		fmt.Printf("    %s theme: %s %s %s\n",
+			ui.Yellow("~"), local, ui.Yellow("\u2192"), sd.ReferenceTheme)
+	}
+	if sd.PluginsChanged {
+		local := strings.Join(sd.LocalPlugins, ", ")
+		if local == "" {
+			local = "(none)"
+		}
+		fmt.Printf("    %s plugins: %s %s %s\n",
+			ui.Yellow("~"), local, ui.Yellow("\u2192"), strings.Join(sd.ReferencePlugins, ", "))
+	}
+	fmt.Println()
+}
+
 func printSummary(result *DiffResult) {
 	missing := result.TotalMissing()
 	extra := result.TotalExtra()