fix(linux): warn once when passthrough_unbounded_keys is set on the X11 backend (#1625)

Author: y3owk1n

cmd/neru/main.go

@@ -55,6 +55,13 @@ func LaunchDaemon(configPath string) {
 		zap.NewNop(),
 		newAlertProvider(systemPort),
 	)
+
+	// The display backend is a limit the platform column cannot say, so the
+	// root that knows the backend hands the loader the words it cannot honor.
+	if platform.CurrentProfile().DisplayServer == platform.DisplayServerX11 {
+		service = service.WithBackendInert(config.X11InertWords)
+	}
+
 	configResult := service.LoadWithValidation(configPath)
 
 	// If there's a validation error, show alert and exit
@@ -72,6 +79,7 @@ func LaunchDaemon(configPath string) {
 		app.WithConfig(configResult.Config),
 		app.WithWrittenConfig(configResult.Written),
 		app.WithConfigPath(configResult.ConfigPath),
+		app.WithConfigWarnings(configResult.Warnings),
 	)
 	if appErr != nil {
 		fmt.Fprintf(os.Stderr, "Error creating app: %v\n", appErr)

docs/CROSS_PLATFORM.md

@@ -618,7 +618,11 @@ is physically holding, and each stays the compositor's until released
 (`evdevSession.handlePress` and `evdevProxy.forwardWithheld`). It is **not**
 available on X11 (an `XGrabKeyboard` routes Neru's own XTest events back to
 itself, and `XSendEvent` is ignored by most apps) nor on the rare wl-keyboard
-fallback, which has no injection path. Windows needs no re-injection: a
+fallback, which has no injection path. The platform column cannot say "Linux,
+except X11", so a configuration that turns passthrough on under X11 warns once
+at load, in the same voice as the parity warning, and `neru doctor` lists the
+option and its two dependents in its `platform_support` row
+(`config.X11InertWords`). Windows needs no re-injection: a
 `WH_KEYBOARD_LL` hook forwards or blocks each event on its own
 (`eventtap/windows/tap.go`, `handleKey`). Classification (blacklist,
 mode-intercepted keys, the mode's own hotkeys, and the global chords it falls

internal/app/app.go

@@ -47,8 +47,11 @@ type App struct {
 	// handed to the config service so a later `neru config set` derives from
 	// what the user wrote rather than from what was derived for them.
 	writtenConfig *config.Config
-	ConfigPath    string
-	logger        *zap.Logger
+	// configWarnings are what the launch-time load found wrong but loadable,
+	// logged once the logger exists (WithConfigWarnings).
+	configWarnings []string
+	ConfigPath     string
+	logger         *zap.Logger
 
 	systemPort    ports.SystemPort
 	accessibility ports.AccessibilityPort

internal/app/config.go

@@ -5,6 +5,7 @@ import (
 
 	"go.uber.org/zap"
 
+	"github.com/y3owk1n/neru/internal/adapter/platform"
 	"github.com/y3owk1n/neru/internal/config"
 	"github.com/y3owk1n/neru/internal/config/loader"
 	"github.com/y3owk1n/neru/internal/derrors"
@@ -15,9 +16,18 @@ import (
 // app was constructed with: the configuration to run on, and the one it was
 // derived from. Passing only the first leaves the service deriving from its own
 // output, which cannot re-infer — so the two travel together from here on.
+//
+// The backend limit is wired the same way main.go wires it for the first load,
+// so a hot reload warns about the same words the launch did.
 func (a *App) newConfigService(logger *zap.Logger) *loader.Service {
-	return loader.NewService(a.config, a.ConfigPath, logger, a.systemPort).
+	svc := loader.NewService(a.config, a.ConfigPath, logger, a.systemPort).
 		WithWritten(a.writtenConfig)
+
+	if platform.CurrentProfile().DisplayServer == platform.DisplayServerX11 {
+		svc = svc.WithBackendInert(config.X11InertWords)
+	}
+
+	return svc
 }
 
 // SetConfigField applies a single runtime config field change with full

internal/app/new.go

@@ -37,6 +37,12 @@ func New(opts ...Option) (*App, error) {
 		app.logger = logger
 	}
 
+	// Under the same name and message the config service logs a reload's, so
+	// the two reads of the same file are one line to search for.
+	for _, warning := range app.configWarnings {
+		app.logger.Named("config").Warn("Configuration warning", zap.String("warning", warning))
+	}
+
 	// Initialize the rest of the application
 	return initializeApp(app)
 }

internal/app/options.go

@@ -36,6 +36,18 @@ func WithWrittenConfig(cfg *config.Config) Option {
 	}
 }
 
+// WithConfigWarnings carries the warnings the launch-time load found, for the
+// app to log once its logger exists. The load runs before there is a logger to
+// hand it, and a warning nobody prints is a warning nobody can act on (ADR
+// 0002); a hot reload logs its own through the config service.
+func WithConfigWarnings(warnings []string) Option {
+	return func(a *App) error {
+		a.configWarnings = warnings
+
+		return nil
+	}
+}
+
 // WithConfigPath sets the configuration file path.
 func WithConfigPath(path string) Option {
 	return func(a *App) error {

internal/cli/config_loader.go

@@ -0,0 +1,24 @@
+package cli
+
+import (
+	"github.com/y3owk1n/neru/internal/adapter/platform"
+	"github.com/y3owk1n/neru/internal/config"
+	"github.com/y3owk1n/neru/internal/config/loader"
+)
+
+// clientConfigLoader builds the loader a client-side command reads the
+// configuration with: defaults, no daemon, no logger, no alert dialog. The
+// commands that judge a file (`config validate`, `doctor`, `roles explain`)
+// share it so they read the same file the same way.
+//
+// The backend limit is wired here as it is in the daemon's two roots, so
+// `config validate` and `doctor` warn about the same words the daemon does.
+func clientConfigLoader() *loader.Service {
+	svc := loader.NewService(config.DefaultConfig(), "", nil, nil)
+
+	if platform.CurrentProfile().DisplayServer == platform.DisplayServerX11 {
+		svc = svc.WithBackendInert(config.X11InertWords)
+	}
+
+	return svc
+}

internal/cli/config_validate.go

@@ -4,9 +4,6 @@ import (
 	"errors"
 
 	"github.com/spf13/cobra"
-
-	"github.com/y3owk1n/neru/internal/config"
-	"github.com/y3owk1n/neru/internal/config/loader"
 )
 
 // errConfigValidationFailed is returned when config validation fails.
@@ -34,7 +31,7 @@ func init() {
 }
 
 func runConfigValidate(cmd *cobra.Command) error {
-	svc := loader.NewService(config.DefaultConfig(), "", nil, nil)
+	svc := clientConfigLoader()
 
 	path := configPath
 	if path == "" {

internal/cli/doctor_platform_support.go

@@ -6,7 +6,6 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/y3owk1n/neru/internal/config"
-	"github.com/y3owk1n/neru/internal/config/loader"
 	"github.com/y3owk1n/neru/internal/domain/parity"
 )
 
@@ -23,7 +22,7 @@ const platformSupportRow = "platform_support"
 // One load for all of them: two would be two chances to disagree about which
 // file is even being judged, and the load is what discovers that file.
 func doctorConfigLoad() *config.LoadResult {
-	svc := loader.NewService(config.DefaultConfig(), "", nil, nil)
+	svc := clientConfigLoader()
 
 	path := configPath
 	if path == "" {
@@ -34,7 +33,8 @@ func doctorConfigLoad() *config.LoadResult {
 }
 
 // printPlatformSupportCheck reports the options, actions and mode flags this
-// configuration writes that do nothing on this platform.
+// configuration writes that do nothing on this platform or on the display
+// backend it is running.
 //
 // It never fails the doctor. An inert word is not a broken configuration — the
 // same file is meant to work on every platform, which is why writing one is a
@@ -62,7 +62,11 @@ func printPlatformSupportCheck(cmd *cobra.Command, loadResult *config.LoadResult
 		return
 	}
 
-	cmd.Printf("  ⚠️  %-24s %d %s nothing on %s (written and ignored; the daemon runs)\n",
+	// "This session" rather than the platform: the list carries the words the
+	// display backend cannot honor beside the ones the platform cannot, and
+	// passthrough on X11 does nothing here without doing nothing on Linux.
+	cmd.Printf(
+		"  ⚠️  %-24s %d %s nothing on this %s session (written and ignored; the daemon runs)\n",
 		platformSupportRow,
 		len(loadResult.Inert),
 		pluralSettingsDo(len(loadResult.Inert)),

internal/cli/roles.go

@@ -8,7 +8,6 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/y3owk1n/neru/internal/config"
-	"github.com/y3owk1n/neru/internal/config/loader"
 	"github.com/y3owk1n/neru/internal/domain/element"
 )
 
@@ -102,7 +101,7 @@ func runRolesList(cmd *cobra.Command) {
 
 // runRolesExplain resolves the loaded configuration and reports each entry.
 func runRolesExplain(cmd *cobra.Command) error {
-	svc := loader.NewService(config.DefaultConfig(), "", nil, nil)
+	svc := clientConfigLoader()
 
 	path := configPath
 	if path == "" {