Route aether:// silent=true through the CLI apply path

silent=true now applies directly inside the URL-handler process via
writer.ApplyTheme, matching aether --import-colors-toml semantics. No
GUI launch, no IPC, no staged pending file. Wallpaper-only silent links
preserve the current palette by reading the applied colors.toml on disk.

Author: bjarneo

cli/cli.go

@@ -33,7 +33,7 @@ func Run(args []string, templatesFS embed.FS) int {
 	case "--import-colors-toml":
 		return runImportColorsToml(args[1:], templatesFS)
 	case "--handle-url":
-		return runHandleURL(args[1:])
+		return runHandleURL(args[1:], templatesFS)
 
 	// --- Color utilities ---
 	case "--color-convert":

cli/url_handler.go

@@ -1,14 +1,20 @@
 package cli
 
 import (
+	"embed"
 	"fmt"
 	"net/url"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"time"
 
+	"aether/internal/blueprint"
+	"aether/internal/omarchy"
 	"aether/internal/pending"
+	"aether/internal/platform"
+	"aether/internal/theme"
 	"aether/internal/wallpaper"
 	"aether/ipc"
 )
@@ -23,7 +29,7 @@ import (
 //	aether://apply?colors=https://…/colors.toml
 //	aether://apply?wallpaper=https://…/wp.jpg
 //	aether://apply?colors=…&wallpaper=…
-func runHandleURL(args []string) int {
+func runHandleURL(args []string, templatesFS embed.FS) int {
 	if len(args) == 0 {
 		fmt.Fprintln(os.Stderr, "Usage: aether --handle-url <aether://...>")
 		return 1
@@ -92,6 +98,13 @@ func runHandleURL(args []string) int {
 		return 1
 	}
 
+	// Silent mode: apply directly in this process, no GUI, no dialog.
+	// Matches `aether --import-colors-toml` semantics — first-party flows
+	// only, since any web page can construct silent URLs.
+	if imp.Silent {
+		return runSilentApply(&imp, templatesFS)
+	}
+
 	if err := pending.Write(&imp); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return 1
@@ -129,3 +142,78 @@ func runHandleURL(args []string) int {
 	fmt.Println("Launching Aether.")
 	return 0
 }
+
+// runSilentApply runs the equivalent of `--import-colors-toml URL` directly
+// inside the URL-handler process: parse the downloaded palette source, build
+// a ThemeState, and call writer.ApplyTheme. When only a wallpaper was given,
+// the current colors.toml on disk is reused so the existing palette is kept
+// instead of clobbered. Never touches the GUI or IPC.
+func runSilentApply(imp *pending.Import, templatesFS embed.FS) int {
+	var palette [16]string
+	var bp *blueprint.Blueprint
+	var err error
+
+	switch {
+	case imp.ExternalTheme != "":
+		bp, err = blueprint.ImportJSON(imp.ExternalTheme)
+	case imp.ColorsToml != "":
+		bp, err = blueprint.ImportColorsToml(imp.ColorsToml)
+	}
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: parse: %v\n", err)
+		return 1
+	}
+
+	extended := map[string]string{}
+	if bp != nil {
+		for i := 0; i < 16 && i < len(bp.Palette.Colors); i++ {
+			palette[i] = bp.Palette.Colors[i]
+		}
+		for k, v := range bp.Palette.ExtendedColors {
+			extended[k] = v
+		}
+	} else {
+		// Wallpaper-only silent apply: preserve current palette by reading
+		// the existing applied colors.toml. Falls back to a default-ish
+		// state when nothing has been applied yet.
+		existing := filepath.Join(platform.ThemeDir(), "colors.toml")
+		if data, err := os.ReadFile(existing); err == nil {
+			current, bg, fg := omarchy.ParseColorsToml(string(data))
+			palette = current
+			if bg != "" {
+				extended["background"] = bg
+			}
+			if fg != "" {
+				extended["foreground"] = fg
+			}
+		} else {
+			fmt.Fprintln(os.Stderr, "Warning: no existing colors.toml to preserve; palette will be empty")
+		}
+	}
+
+	// mode= is the only signal we have for light/dark in the silent CLI
+	// path. Omit → false (matches existing --import-colors-toml default).
+	lightMode := imp.Mode == "light"
+
+	colorRoles := MapColorsToRoles(palette)
+	writer := theme.NewWriter(templatesFS, "templates")
+	state := &theme.ThemeState{
+		Palette:        palette,
+		WallpaperPath:  imp.Wallpaper,
+		LightMode:      lightMode,
+		ColorRoles:     colorRoles,
+		ExtendedColors: extended,
+	}
+
+	fmt.Println("Applying theme silently...")
+	result, err := writer.ApplyTheme(state, theme.Settings{})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: apply: %v\n", err)
+		return 1
+	}
+	if result.Success {
+		fmt.Println("Theme applied successfully")
+	}
+	_ = pending.Clear() // best-effort cleanup of any prior staged file
+	return 0
+}

docs/web-handler.md

@@ -77,7 +77,11 @@ If Aether is closed when the link is clicked, the launch is automatic and the di
 
 ### `silent=true` — apply without confirming
 
-`silent=true` makes the click apply immediately, no dialog. Useful for in-app links where the user has already chosen the theme on the web side and doesn't need a second confirmation. The trade-off is real, though: any web page can produce a silent-apply link. Only mark links silent inside flows where the user has already opted in to the theme they're about to install (your own theme gallery, an in-app catalog), and prefer the default interactive flow for third-party content.
+`silent=true` makes the click apply immediately, no dialog. The URL handler runs the apply *itself*, in the same process — same code path as `aether --import-colors-toml URL`. No GUI is launched and no IPC happens; this works identically whether or not the Aether GUI is running. The downloaded files still land in `~/.cache/aether/web-imports/`, but the staging file and confirmation step are skipped.
+
+Wallpaper-only silent links preserve the current palette by reading the existing `colors.toml` on disk. Light/dark mode is controlled by `mode=light|dark`; omit it to default to dark, matching the existing CLI behavior.
+
+The trade-off is real, though: any web page can produce a silent-apply link. Only mark links silent inside flows where the user has already opted in to the theme they're about to install (your own theme gallery, an in-app catalog), and prefer the default interactive flow for third-party content.
 
 ## What's not supported
 

external_import.go

@@ -35,11 +35,11 @@ type ExternalImportPreview struct {
 	Mode             string   `json:"mode,omitempty"` // "light" | "dark" | ""
 }
 
-// loadPendingImport reads the staged file, stores it in memory, and either
-// emits "external-import-requested" (interactive — the dialog will pick it
-// up) or applies it immediately when imp.Silent is set. Safe to call from
-// startup and from the IPC handler — repeated calls just refresh the
-// in-memory snapshot.
+// loadPendingImport reads the staged file, stores it in memory, and emits
+// "external-import-requested" to the frontend. Safe to call from startup
+// and from the IPC handler — repeated calls just refresh the in-memory
+// snapshot and re-emit. Silent imports never reach the GUI (the CLI URL
+// handler applies them directly), so no branching is needed here.
 func (a *App) loadPendingImport() {
 	imp, err := pending.Read()
 	if err != nil {
@@ -54,17 +54,6 @@ func (a *App) loadPendingImport() {
 	a.pending.curr = imp
 	a.pending.mu.Unlock()
 
-	if imp.Silent {
-		// Off the IPC/startup goroutine so the caller returns promptly;
-		// writer.ApplyTheme can take a moment when many target files exist.
-		go func() {
-			if err := a.ConfirmExternalImport(); err != nil {
-				log.Printf("pending-import: silent apply failed: %v", err)
-			}
-		}()
-		return
-	}
-
 	if a.ctx != nil {
 		preview := a.buildPreview(imp)
 		wailsrt.EventsEmit(a.ctx, "external-import-requested", preview)