doctor: use console.warn for quickshell feature logs

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,65 @@
+---
+name: Bug Report
+about: Crashes or unexpected behaviors
+title: ""
+labels: "bug"
+assignees: ""
+---
+
+<!-- If your issue is related to ICONS
+- Purple and black checkerboards are QT's way of signalling an icon doesn't exist
+  - FIX: Configure a QT6 or Icon Pack in DMS Settings that has the icon you want
+  - Follow the [THEMING](https://danklinux.com/docs/dankmaterialshell/icon-theming) section to ensure your QT environment variable is configured correctly for themes.
+  - Once done, configure an icon theme - either however you normally do with gtk3 or qt6ct, or through the built-in settings modal. -->
+
+## Compositor
+
+- [ ] niri
+- [ ] Hyprland
+- [ ] dwl (MangoWC)
+- [ ] sway
+- [ ] Other (specify)
+
+## Distribution
+
+<!-- Arch, Fedora, Debian, etc. -->
+
+## dms version
+
+<!-- Output of dms version command -->
+
+## Description
+
+<!-- Brief description of the issue -->
+
+## Expected Behavior
+
+<!-- Describe what you expected to happen -->
+
+## Steps to Reproduce
+
+<!-- Please provide detailed steps to reproduce the issue -->
+
+1.
+2.
+3.
+
+## Error Messages/Logs
+
+<!-- Please include any error messages, stack traces, or relevant logs -->
+<!-- you can get a log file with the following steps:
+dms kill
+mkdir ~/dms_logs
+nohup dms run > ~/dms_logs/dms-$(date +%s).txt 2>&1 &
+
+Then trigger your issue, and share the contents of ~/dms_logs/dms-<timestamp>.txt
+
+-->
+
+```
+Paste error messages or logs here
+```
+
+## Screenshots/Recordings
+
+<!-- If applicable, add screenshots or screen recordings -->

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,96 +0,0 @@
-name: Bug Report
-description: Crashes or unexpected behaviors
-labels:
-  - bug
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## DankMaterialShell Bug Report
-        Limit your report to one issue per submission unless closely related
-  - type: checkboxes
-    id: compositor
-    attributes:
-      label: Compositor
-      options:
-        - label: Niri
-        - label: Hyprland
-        - label: MangoWC (dwl)
-        - label: Sway
-    validations:
-      required: true
-  - type: checkboxes
-    id: distribution
-    attributes:
-      label: Distribution
-      options:
-        - label: Arch Linux
-        - label: CachyOS
-        - label: Fedora
-        - label: NixOS
-        - label: Debian
-        - label: Ubuntu
-        - label: Gentoo
-        - label: OpenSUSE
-        - label: Other (specify below)
-    validations:
-      required: true
-  - type: input
-    id: distribution_other
-    attributes:
-      label: If Other, please specify
-      placeholder: e.g., PikaOS, Void Linux, etc.
-    validations:
-      required: false
-  - type: input
-    id: dms_version
-    attributes:
-      label: dms version
-      description: Output of dms version command
-      placeholder: e.g., 1.2.3
-    validations:
-      required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Brief description of the issue
-      placeholder: What happened?
-    validations:
-      required: true
-  - type: textarea
-    id: expected_behavior
-    attributes:
-      label: Expected Behavior
-      description: What did you expect to happen?
-      placeholder: Describe the expected behavior
-    validations:
-      required: false
-  - type: textarea
-    id: steps_to_reproduce
-    attributes:
-      label: Steps to Reproduce & Installation Method
-      description: Please provide detailed steps to reproduce the issue
-      placeholder: |
-        1. ...
-        2. ...
-        3. ...
-    validations:
-      required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Error Messages/Logs
-      description: Please include any error messages, stack traces, or relevant logs
-      placeholder: |
-        Paste error messages or logs here
-    validations:
-      required: false
-  - type: textarea
-    id: screenshots
-    attributes:
-      label: Screenshots/Recordings
-      description: If applicable, add screenshots or screen recordings
-      placeholder: Attach images or videos here
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,33 @@
+---
+name: Request a Feature
+about: New widgets, new widget behavior, etc.
+title: ""
+labels: "enhancement"
+assignees: ""
+---
+
+## Feature Description
+
+<!-- Brief description of the feature requested -->
+
+## Use Case
+
+<!-- Explain the purpose of this feature/why it'd be useful to you -->
+
+## Compositor
+
+Is this feature specific to one compositor?
+
+- [ ] All compositors
+- [ ] niri
+- [ ] Hyprland
+- [ ] dwl (MangoWC)
+- [ ] sway
+
+## Proposed Solution
+
+<!-- If you have any ideas for how to implement this, please share! -->
+
+## Alternatives/Existing Solutions
+
+<!-- Include any similar/pre-existing products that solve this problem -->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,55 +0,0 @@
-name: Feature Request
-description: Suggest a new feature or improvement for DMS
-labels:
-  - enhancement
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## DankMaterialShell Feature Request
-  - type: textarea
-    id: feature_description
-    attributes:
-      label: Feature Description
-      description: Brief description of the feature requested
-      placeholder: What feature would you like to see?
-    validations:
-      required: true
-  - type: textarea
-    id: use_case
-    attributes:
-      label: Use Case
-      description: Explain the purpose of this feature/why it'd be useful to you
-      placeholder: Why is this feature important?
-    validations:
-      required: false
-  - type: checkboxes
-    id: compositor
-    attributes:
-      label: Compositor(s)
-      description: Is this feature specific to one or more compositors?
-      options:
-        - label: All compositors
-        - label: Niri
-        - label: Hyprland
-        - label: MangoWC (dwl)
-        - label: Sway
-        - label: Other (specify below)
-    validations:
-      required: false
-  - type: textarea
-    id: proposed_solution
-    attributes:
-      label: Proposed Solution
-      description: If you have any ideas for how to implement this, please share!
-      placeholder: Suggest a solution or approach
-    validations:
-      required: false
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives/Existing Solutions
-      description: Include any similar/pre-existing products that solve this problem
-      placeholder: List alternatives or existing solutions
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/support_request.md

@@ -0,0 +1,40 @@
+---
+name: Request Assistance or Support
+about: Help with installation, usage, or general questions.
+title: ""
+labels: "support"
+assignees: ""
+---
+
+## Compositor
+
+- [ ] niri
+- [ ] Hyprland
+- [ ] dwl (MangoWC)
+- [ ] sway
+- [ ] other
+
+## Distribution
+
+<!-- Arch, Fedora, Debian, etc. -->
+
+## dms version
+
+<!-- Output of dms version command -->
+
+## Description
+
+<!-- Brief description of the support needed -->
+
+## Solutions Tried
+
+<!-- Describe what you've tried so far -->
+<!-- Outlining what you've tried so far helps us make improvements to the user experience and documentation to avoid recurrent issues -->
+
+## Configuration Details
+
+<!-- Include any configuration if relevant -->
+
+## Screenshots/Recordings
+
+<!-- If applicable, add screenshots or screen recordings -->

.github/ISSUE_TEMPLATE/support_request.yml

@@ -1,69 +0,0 @@
-name: Support Request
-description: Help with installation, usage, or general questions about DankMaterialShell
-labels:
-  - support
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## DankMaterialShell Support Request
-  - type: checkboxes
-    id: compositor
-    attributes:
-      label: Compositor
-      options:
-        - label: Niri
-        - label: Hyprland
-        - label: MangoWC (dwl)
-        - label: Sway
-        - label: Other (specify below)
-    validations:
-      required: false
-  - type: input
-    id: distribution
-    attributes:
-      label: Distribution
-      description: Which Linux distribution are you using? (e.g., Arch, Fedora, Debian, etc.)
-      placeholder: Your Linux distribution
-    validations:
-      required: false
-  - type: input
-    id: dms_version
-    attributes:
-      label: dms version
-      description: Output of dms version command
-      placeholder: e.g., 1.2.3
-    validations:
-      required: false
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Brief description of the support needed
-      placeholder: What do you need help with?
-    validations:
-      required: true
-  - type: textarea
-    id: solutions_tried
-    attributes:
-      label: Solutions Tried
-      description: Describe what you've tried so far (commands, documentation, etc.)
-      placeholder: List steps or resources you've already tried
-    validations:
-      required: false
-  - type: textarea
-    id: configuration
-    attributes:
-      label: Configuration Details
-      description: Include any relevant configuration if relevant
-      placeholder: Add configuration or environment info
-    validations:
-      required: false
-  - type: textarea
-    id: screenshots
-    attributes:
-      label: Screenshots/Recordings
-      description: If applicable, add screenshots or screen recordings
-      placeholder: Attach images or videos here
-    validations:
-      required: false

.github/workflows/go-ci.yml

@@ -28,15 +28,6 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install flatpak
-        run: sudo apt update && sudo apt install -y flatpak
-
-      - name: Add flathub
-        run: sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
-
-      - name: Add a flatpak that mutagen could support
-        run: sudo flatpak install -y org.freedesktop.Platform/x86_64/24.08 app.zen_browser.zen
-
       - name: Set up Go
         uses: actions/setup-go@v5
         with:

.github/workflows/prek.yml

@@ -11,14 +11,5 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install flatpak
-        run: sudo apt update && sudo apt install -y flatpak
-
-      - name: Add flathub
-        run: sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
-
-      - name: Add a flatpak that mutagen could support
-        run: sudo flatpak install -y org.freedesktop.Platform/x86_64/24.08 app.zen_browser.zen
-
       - name: run pre-commit hooks
         uses: j178/prek-action@v1

.github/workflows/stable.yml

@@ -5,27 +5,15 @@ on:
     tags:
       - "v*"
 
-permissions:
-  contents: write
-
 jobs:
   update-stable:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
-      - name: Create GitHub App token
+      - uses: actions/checkout@v4
-        id: app_token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.APP_PRIVATE_KEY }}
-
-      - name: Checkout
-        uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ steps.app_token.outputs.token }}
 
       - name: Push to stable branch
-        env:
+        run: git push origin HEAD:refs/heads/stable --force
-          GH_TOKEN: ${{ steps.app_token.outputs.token }}
-        run: git push https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git HEAD:refs/heads/stable --force

.gitignore

@@ -108,5 +108,3 @@ bin/
 # direnv
 .envrc
 .direnv/
-quickshell/dms-plugins
-__pycache__

CHANGELOG.MD

@@ -15,9 +15,3 @@ This file is more of a quick reference so I know what to account for before next
   - new IPC targets
 - Initial RTL support/i18n
 - Theme registry
-- Notification persistence & history
-- **BREAKING** vscode theme needs re-installed
-- dms doctor cmd
-- niri/hypr/mango gaps/window/border overrides
-- settings search
-- notification display ops on lock screen

core/.mockery.yml

@@ -68,9 +68,3 @@ packages:
       outpkg: mocks_wlclient
     interfaces:
       WaylandDisplay:
-  github.com/AvengeMedia/DankMaterialShell/core/internal/utils:
-    config:
-      dir: "internal/mocks/utils"
-      outpkg: mocks_utils
-    interfaces:
-      AppChecker:

core/cmd/dms/commands_brightness.go

@@ -179,7 +179,7 @@ func runBrightnessList(cmd *cobra.Command, args []string) {
 	fmt.Printf("%-*s  %-12s  %-*s  %s\n", idPad, "Device", "Class", namePad, "Name", "Brightness")
 
 	sepLen := idPad + 2 + 12 + 2 + namePad + 2 + 15
-	for range sepLen {
+	for i := 0; i < sepLen; i++ {
 		fmt.Print("─")
 	}
 	fmt.Println()

core/cmd/dms/commands_clipboard.go

@@ -1,29 +1,17 @@
 package main
 
 import (
-	"bytes"
 	"context"
-	"encoding/base64"
-	"encoding/binary"
 	"encoding/json"
 	"fmt"
-	"image"
-	_ "image/gif"
-	_ "image/jpeg"
-	_ "image/png"
 	"io"
 	"os"
 	"os/exec"
 	"os/signal"
-	"path/filepath"
 	"strconv"
 	"syscall"
 	"time"
 
-	bolt "go.etcd.io/bbolt"
-	_ "golang.org/x/image/bmp"
-	_ "golang.org/x/image/tiff"
-
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
@@ -154,32 +142,10 @@ var (
 	clipConfigNoClearStartup bool
 	clipConfigDisabled       bool
 	clipConfigEnabled        bool
+	clipConfigDisableHistory bool
+	clipConfigEnableHistory  bool
 )
 
-var clipExportCmd = &cobra.Command{
-	Use:   "export [file]",
-	Short: "Export clipboard history to JSON",
-	Long:  "Export clipboard history to JSON file. If no file specified, writes to stdout.",
-	Run:   runClipExport,
-}
-
-var clipImportCmd = &cobra.Command{
-	Use:   "import <file>",
-	Short: "Import clipboard history from JSON",
-	Long:  "Import clipboard history from JSON file exported by 'dms cl export'.",
-	Args:  cobra.ExactArgs(1),
-	Run:   runClipImport,
-}
-
-var clipMigrateCmd = &cobra.Command{
-	Use:   "cliphist-migrate [db-path]",
-	Short: "Migrate from cliphist",
-	Long:  "Migrate clipboard history from cliphist. Uses default cliphist path if not specified.",
-	Run:   runClipMigrate,
-}
-
-var clipMigrateDelete bool
-
 func init() {
 	clipCopyCmd.Flags().BoolVarP(&clipCopyForeground, "foreground", "f", false, "Stay in foreground instead of forking")
 	clipCopyCmd.Flags().BoolVarP(&clipCopyPasteOnce, "paste-once", "o", false, "Exit after first paste")
@@ -201,15 +167,15 @@ func init() {
 	clipConfigSetCmd.Flags().IntVar(&clipConfigAutoClearDays, "auto-clear-days", -1, "Auto-clear entries older than N days (0 to disable)")
 	clipConfigSetCmd.Flags().BoolVar(&clipConfigClearAtStartup, "clear-at-startup", false, "Clear history on startup")
 	clipConfigSetCmd.Flags().BoolVar(&clipConfigNoClearStartup, "no-clear-at-startup", false, "Don't clear history on startup")
-	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisabled, "disable", false, "Disable clipboard tracking")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisabled, "disable", false, "Disable clipboard manager entirely")
-	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnabled, "enable", false, "Enable clipboard tracking")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnabled, "enable", false, "Enable clipboard manager")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisableHistory, "disable-history", false, "Disable clipboard history persistence")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnableHistory, "enable-history", false, "Enable clipboard history persistence")
 
 	clipWatchCmd.Flags().BoolVarP(&clipWatchStore, "store", "s", false, "Store clipboard changes to history (no server required)")
 
-	clipMigrateCmd.Flags().BoolVar(&clipMigrateDelete, "delete", false, "Delete cliphist db after successful migration")
-
 	clipConfigCmd.AddCommand(clipConfigGetCmd, clipConfigSetCmd)
-	clipboardCmd.AddCommand(clipCopyCmd, clipPasteCmd, clipWatchCmd, clipHistoryCmd, clipGetCmd, clipDeleteCmd, clipClearCmd, clipSearchCmd, clipConfigCmd, clipExportCmd, clipImportCmd, clipMigrateCmd)
+	clipboardCmd.AddCommand(clipCopyCmd, clipPasteCmd, clipWatchCmd, clipHistoryCmd, clipGetCmd, clipDeleteCmd, clipClearCmd, clipSearchCmd, clipConfigCmd)
 }
 
 func runClipCopy(cmd *cobra.Command, args []string) {
@@ -621,6 +587,12 @@ func runClipConfigSet(cmd *cobra.Command, args []string) {
 	if clipConfigEnabled {
 		params["disabled"] = false
 	}
+	if clipConfigDisableHistory {
+		params["disableHistory"] = true
+	}
+	if clipConfigEnableHistory {
+		params["disableHistory"] = false
+	}
 
 	if len(params) == 0 {
 		fmt.Println("No config options specified")
@@ -644,154 +616,3 @@ func runClipConfigSet(cmd *cobra.Command, args []string) {
 
 	fmt.Println("Config updated")
 }
-
-func runClipExport(cmd *cobra.Command, args []string) {
-	req := models.Request{
-		ID:     1,
-		Method: "clipboard.getHistory",
-	}
-
-	resp, err := sendServerRequest(req)
-	if err != nil {
-		log.Fatalf("Failed to get clipboard history: %v", err)
-	}
-	if resp.Error != "" {
-		log.Fatalf("Error: %s", resp.Error)
-	}
-	if resp.Result == nil {
-		log.Fatal("No clipboard history")
-	}
-
-	out, err := json.MarshalIndent(resp.Result, "", "  ")
-	if err != nil {
-		log.Fatalf("Failed to marshal: %v", err)
-	}
-
-	if len(args) == 0 {
-		fmt.Println(string(out))
-		return
-	}
-
-	if err := os.WriteFile(args[0], out, 0644); err != nil {
-		log.Fatalf("Failed to write file: %v", err)
-	}
-	fmt.Printf("Exported to %s\n", args[0])
-}
-
-func runClipImport(cmd *cobra.Command, args []string) {
-	data, err := os.ReadFile(args[0])
-	if err != nil {
-		log.Fatalf("Failed to read file: %v", err)
-	}
-
-	var entries []map[string]any
-	if err := json.Unmarshal(data, &entries); err != nil {
-		log.Fatalf("Failed to parse JSON: %v", err)
-	}
-
-	var imported int
-	for _, entry := range entries {
-		dataStr, ok := entry["data"].(string)
-		if !ok {
-			continue
-		}
-		mimeType, _ := entry["mimeType"].(string)
-		if mimeType == "" {
-			mimeType = "text/plain"
-		}
-
-		var entryData []byte
-		if decoded, err := base64.StdEncoding.DecodeString(dataStr); err == nil {
-			entryData = decoded
-		} else {
-			entryData = []byte(dataStr)
-		}
-
-		if err := clipboard.Store(entryData, mimeType); err != nil {
-			log.Errorf("Failed to store entry: %v", err)
-			continue
-		}
-		imported++
-	}
-
-	fmt.Printf("Imported %d entries\n", imported)
-}
-
-func runClipMigrate(cmd *cobra.Command, args []string) {
-	dbPath := getCliphistPath()
-	if len(args) > 0 {
-		dbPath = args[0]
-	}
-
-	if _, err := os.Stat(dbPath); err != nil {
-		log.Fatalf("Cliphist db not found: %s", dbPath)
-	}
-
-	db, err := bolt.Open(dbPath, 0644, &bolt.Options{
-		ReadOnly: true,
-		Timeout:  1 * time.Second,
-	})
-	if err != nil {
-		log.Fatalf("Failed to open cliphist db: %v", err)
-	}
-	defer db.Close()
-
-	var migrated int
-	err = db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("b"))
-		if b == nil {
-			return fmt.Errorf("cliphist bucket not found")
-		}
-
-		c := b.Cursor()
-		for k, v := c.First(); k != nil; k, v = c.Next() {
-			if len(v) == 0 {
-				continue
-			}
-
-			mimeType := detectMimeType(v)
-			if err := clipboard.Store(v, mimeType); err != nil {
-				log.Errorf("Failed to store entry %d: %v", btoi(k), err)
-				continue
-			}
-			migrated++
-		}
-		return nil
-	})
-	if err != nil {
-		log.Fatalf("Migration failed: %v", err)
-	}
-
-	fmt.Printf("Migrated %d entries from cliphist\n", migrated)
-
-	if !clipMigrateDelete {
-		return
-	}
-
-	db.Close()
-	if err := os.Remove(dbPath); err != nil {
-		log.Errorf("Failed to delete cliphist db: %v", err)
-		return
-	}
-	os.Remove(filepath.Dir(dbPath))
-	fmt.Println("Deleted cliphist db")
-}
-
-func getCliphistPath() string {
-	cacheDir, err := os.UserCacheDir()
-	if err != nil {
-		return filepath.Join(os.Getenv("HOME"), ".cache", "cliphist", "db")
-	}
-	return filepath.Join(cacheDir, "cliphist", "db")
-}
-
-func detectMimeType(data []byte) string {
-	if _, _, err := image.DecodeConfig(bytes.NewReader(data)); err == nil {
-		return "image/png"
-	}
-	return "text/plain"
-}
-
-func btoi(v []byte) uint64 {
-	return binary.BigEndian.Uint64(v)
-}

core/cmd/dms/commands_common.go

@@ -514,6 +514,5 @@ func getCommonCommands() []*cobra.Command {
 		matugenCmd,
 		clipboardCmd,
 		doctorCmd,
-		configCmd,
 	}
 }

core/cmd/dms/commands_config.go

@@ -1,318 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"github.com/spf13/cobra"
-)
-
-var configCmd = &cobra.Command{
-	Use:   "config",
-	Short: "Configuration utilities",
-}
-
-var resolveIncludeCmd = &cobra.Command{
-	Use:   "resolve-include <compositor> <filename>",
-	Short: "Check if a file is included in compositor config",
-	Long:  "Recursively check if a file is included/sourced in compositor configuration. Returns JSON with exists and included status.",
-	Args:  cobra.ExactArgs(2),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		switch len(args) {
-		case 0:
-			return []string{"hyprland", "niri", "mangowc"}, cobra.ShellCompDirectiveNoFileComp
-		case 1:
-			return []string{"cursor.kdl", "cursor.conf", "outputs.kdl", "outputs.conf", "binds.kdl", "binds.conf"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runResolveInclude,
-}
-
-func init() {
-	configCmd.AddCommand(resolveIncludeCmd)
-}
-
-type IncludeResult struct {
-	Exists   bool `json:"exists"`
-	Included bool `json:"included"`
-}
-
-func runResolveInclude(cmd *cobra.Command, args []string) {
-	compositor := strings.ToLower(args[0])
-	filename := args[1]
-
-	var result IncludeResult
-	var err error
-
-	switch compositor {
-	case "hyprland":
-		result, err = checkHyprlandInclude(filename)
-	case "niri":
-		result, err = checkNiriInclude(filename)
-	case "mangowc", "dwl", "mango":
-		result, err = checkMangoWCInclude(filename)
-	default:
-		log.Fatalf("Unknown compositor: %s", compositor)
-	}
-
-	if err != nil {
-		log.Fatalf("Error checking include: %v", err)
-	}
-
-	output, _ := json.Marshal(result)
-	fmt.Fprintln(os.Stdout, string(output))
-}
-
-func checkHyprlandInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-	if err != nil {
-		return IncludeResult{}, err
-	}
-
-	targetPath := filepath.Join(configDir, "dms", filename)
-	result := IncludeResult{}
-
-	if _, err := os.Stat(targetPath); err == nil {
-		result.Exists = true
-	}
-
-	mainConfig := filepath.Join(configDir, "hyprland.conf")
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		return result, nil
-	}
-
-	processed := make(map[string]bool)
-	result.Included = hyprlandFindInclude(mainConfig, "dms/"+filename, processed)
-	return result, nil
-}
-
-func hyprlandFindInclude(filePath, target string, processed map[string]bool) bool {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return false
-	}
-
-	if processed[absPath] {
-		return false
-	}
-	processed[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return false
-	}
-
-	baseDir := filepath.Dir(absPath)
-	lines := strings.Split(string(data), "\n")
-
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "#") || trimmed == "" {
-			continue
-		}
-
-		if !strings.HasPrefix(trimmed, "source") {
-			continue
-		}
-
-		parts := strings.SplitN(trimmed, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-
-		sourcePath := strings.TrimSpace(parts[1])
-		if matchesTarget(sourcePath, target) {
-			return true
-		}
-
-		fullPath := sourcePath
-		if !filepath.IsAbs(sourcePath) {
-			fullPath = filepath.Join(baseDir, sourcePath)
-		}
-
-		expanded, err := utils.ExpandPath(fullPath)
-		if err != nil {
-			continue
-		}
-
-		if hyprlandFindInclude(expanded, target, processed) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func checkNiriInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/niri")
-	if err != nil {
-		return IncludeResult{}, err
-	}
-
-	targetPath := filepath.Join(configDir, "dms", filename)
-	result := IncludeResult{}
-
-	if _, err := os.Stat(targetPath); err == nil {
-		result.Exists = true
-	}
-
-	mainConfig := filepath.Join(configDir, "config.kdl")
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		return result, nil
-	}
-
-	processed := make(map[string]bool)
-	result.Included = niriFindInclude(mainConfig, "dms/"+filename, processed)
-	return result, nil
-}
-
-func niriFindInclude(filePath, target string, processed map[string]bool) bool {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return false
-	}
-
-	if processed[absPath] {
-		return false
-	}
-	processed[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return false
-	}
-
-	baseDir := filepath.Dir(absPath)
-	content := string(data)
-
-	for _, line := range strings.Split(content, "\n") {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "//") || trimmed == "" {
-			continue
-		}
-
-		if !strings.HasPrefix(trimmed, "include") {
-			continue
-		}
-
-		startQuote := strings.Index(trimmed, "\"")
-		if startQuote == -1 {
-			continue
-		}
-		endQuote := strings.LastIndex(trimmed, "\"")
-		if endQuote <= startQuote {
-			continue
-		}
-
-		includePath := trimmed[startQuote+1 : endQuote]
-		if matchesTarget(includePath, target) {
-			return true
-		}
-
-		fullPath := includePath
-		if !filepath.IsAbs(includePath) {
-			fullPath = filepath.Join(baseDir, includePath)
-		}
-
-		if niriFindInclude(fullPath, target, processed) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func checkMangoWCInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/mango")
-	if err != nil {
-		return IncludeResult{}, err
-	}
-
-	targetPath := filepath.Join(configDir, "dms", filename)
-	result := IncludeResult{}
-
-	if _, err := os.Stat(targetPath); err == nil {
-		result.Exists = true
-	}
-
-	mainConfig := filepath.Join(configDir, "config.conf")
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		mainConfig = filepath.Join(configDir, "mango.conf")
-	}
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		return result, nil
-	}
-
-	processed := make(map[string]bool)
-	result.Included = mangowcFindInclude(mainConfig, "dms/"+filename, processed)
-	return result, nil
-}
-
-func mangowcFindInclude(filePath, target string, processed map[string]bool) bool {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return false
-	}
-
-	if processed[absPath] {
-		return false
-	}
-	processed[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return false
-	}
-
-	baseDir := filepath.Dir(absPath)
-	lines := strings.Split(string(data), "\n")
-
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "#") || trimmed == "" {
-			continue
-		}
-
-		if !strings.HasPrefix(trimmed, "source") {
-			continue
-		}
-
-		parts := strings.SplitN(trimmed, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-
-		sourcePath := strings.TrimSpace(parts[1])
-		if matchesTarget(sourcePath, target) {
-			return true
-		}
-
-		fullPath := sourcePath
-		if !filepath.IsAbs(sourcePath) {
-			fullPath = filepath.Join(baseDir, sourcePath)
-		}
-
-		expanded, err := utils.ExpandPath(fullPath)
-		if err != nil {
-			continue
-		}
-
-		if mangowcFindInclude(expanded, target, processed) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func matchesTarget(path, target string) bool {
-	path = strings.TrimPrefix(path, "./")
-	target = strings.TrimPrefix(target, "./")
-	return path == target || strings.HasSuffix(path, "/"+target)
-}

core/cmd/dms/commands_doctor.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
@@ -13,84 +12,12 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/brightness"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/network"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/tui"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
-	"github.com/charmbracelet/lipgloss"
 	"github.com/spf13/cobra"
 )
 
-type status string
-
-const (
-	statusOK    status = "ok"
-	statusWarn  status = "warn"
-	statusError status = "error"
-	statusInfo  status = "info"
-)
-
-func (s status) IconStyle(styles tui.Styles) (string, lipgloss.Style) {
-	switch s {
-	case statusOK:
-		return "●", styles.Success
-	case statusWarn:
-		return "●", styles.Warning
-	case statusError:
-		return "●", styles.Error
-	default:
-		return "○", styles.Subtle
-	}
-}
-
-type DoctorStatus struct {
-	Errors   []checkResult
-	Warnings []checkResult
-	OK       []checkResult
-	Info     []checkResult
-}
-
-func (ds *DoctorStatus) Add(r checkResult) {
-	switch r.status {
-	case statusError:
-		ds.Errors = append(ds.Errors, r)
-	case statusWarn:
-		ds.Warnings = append(ds.Warnings, r)
-	case statusOK:
-		ds.OK = append(ds.OK, r)
-	case statusInfo:
-		ds.Info = append(ds.Info, r)
-	}
-}
-
-func (ds *DoctorStatus) HasIssues() bool {
-	return len(ds.Errors) > 0 || len(ds.Warnings) > 0
-}
-
-func (ds *DoctorStatus) ErrorCount() int {
-	return len(ds.Errors)
-}
-
-func (ds *DoctorStatus) WarningCount() int {
-	return len(ds.Warnings)
-}
-
-func (ds *DoctorStatus) OKCount() int {
-	return len(ds.OK)
-}
-
-var (
-	quickshellVersionRegex = regexp.MustCompile(`quickshell (\d+\.\d+\.\d+)`)
-	hyprlandVersionRegex   = regexp.MustCompile(`v?(\d+\.\d+\.\d+)`)
-	niriVersionRegex       = regexp.MustCompile(`niri (\d+\.\d+)`)
-	swayVersionRegex       = regexp.MustCompile(`sway version (\d+\.\d+)`)
-	riverVersionRegex      = regexp.MustCompile(`river (\d+\.\d+)`)
-	wayfireVersionRegex    = regexp.MustCompile(`wayfire (\d+\.\d+)`)
-	labwcVersionRegex      = regexp.MustCompile(`labwc (\d+\.\d+\.\d+)`)
-	mangowcVersionRegex    = regexp.MustCompile(`mango (\d+\.\d+\.\d+)`)
-)
-
 var doctorCmd = &cobra.Command{
 	Use:   "doctor",
 	Short: "Diagnose DMS installation and dependencies",
@@ -98,14 +25,10 @@ var doctorCmd = &cobra.Command{
 	Run:   runDoctor,
 }
 
-var (
+var doctorVerbose bool
-	doctorVerbose bool
-	doctorJSON    bool
-)
 
 func init() {
 	doctorCmd.Flags().BoolVarP(&doctorVerbose, "verbose", "v", false, "Show detailed output including paths and versions")
-	doctorCmd.Flags().BoolVarP(&doctorJSON, "json", "j", false, "Output results in JSON format")
 }
 
 type category int
@@ -119,82 +42,23 @@ const (
 	catOptionalFeatures
 	catConfigFiles
 	catServices
-	catEnvironment
 )
 
-func (c category) String() string {
+var categoryNames = []string{
-	switch c {
+	"System", "Versions", "Installation", "Compositor",
-	case catSystem:
+	"Quickshell Features", "Optional Features", "Config Files", "Services",
-		return "System"
-	case catVersions:
-		return "Versions"
-	case catInstallation:
-		return "Installation"
-	case catCompositor:
-		return "Compositor"
-	case catQuickshellFeatures:
-		return "Quickshell Features"
-	case catOptionalFeatures:
-		return "Optional Features"
-	case catConfigFiles:
-		return "Config Files"
-	case catServices:
-		return "Services"
-	case catEnvironment:
-		return "Environment"
-	default:
-		return "Unknown"
-	}
 }
 
-const (
-	checkNameMaxLength = 21
-	doctorDocsURL      = "https://danklinux.com/docs/dankmaterialshell/cli-doctor"
-)
-
 type checkResult struct {
 	category category
 	name     string
-	status   status
+	status   string
 	message  string
 	details  string
-	url      string
-}
-
-type checkResultJSON struct {
-	Category string `json:"category"`
-	Name     string `json:"name"`
-	Status   string `json:"status"`
-	Message  string `json:"message"`
-	Details  string `json:"details,omitempty"`
-	URL      string `json:"url,omitempty"`
-}
-
-type doctorOutputJSON struct {
-	Summary struct {
-		Errors   int `json:"errors"`
-		Warnings int `json:"warnings"`
-		OK       int `json:"ok"`
-		Info     int `json:"info"`
-	} `json:"summary"`
-	Results []checkResultJSON `json:"results"`
-}
-
-func (r checkResult) toJSON() checkResultJSON {
-	return checkResultJSON{
-		Category: r.category.String(),
-		Name:     r.name,
-		Status:   string(r.status),
-		Message:  r.message,
-		Details:  r.details,
-		URL:      r.url,
-	}
 }
 
 func runDoctor(cmd *cobra.Command, args []string) {
-	if !doctorJSON {
+	printDoctorHeader()
-		printDoctorHeader()
-	}
 
 	qsFeatures, qsMissingFeatures := checkQuickshellFeatures()
 
@@ -207,15 +71,10 @@ func runDoctor(cmd *cobra.Command, args []string) {
 		checkOptionalDependencies(),
 		checkConfigurationFiles(),
 		checkSystemdServices(),
-		checkEnvironmentVars(),
 	)
 
-	if doctorJSON {
+	printResults(results)
-		printResultsJSON(results)
+	printSummary(results, qsMissingFeatures)
-	} else {
-		printResults(results)
-		printSummary(results, qsMissingFeatures)
-	}
 }
 
 func printDoctorHeader() {
@@ -229,52 +88,50 @@ func printDoctorHeader() {
 }
 
 func checkSystemInfo() []checkResult {
-	var results []checkResult
+	results := []checkResult{}
 
 	osInfo, err := distros.GetOSInfo()
 	if err != nil {
-		status, message, details := statusWarn, fmt.Sprintf("Unknown (%v)", err), ""
+		status, message, details := "warn", fmt.Sprintf("Unknown (%v)", err), ""
 
 		if strings.Contains(err.Error(), "Unsupported distribution") {
 			osRelease := readOSRelease()
-			switch {
+			if osRelease["ID"] == "nixos" {
-			case osRelease["ID"] == "nixos":
+				status = "ok"
-				status = statusOK
 				message = osRelease["PRETTY_NAME"]
 				if message == "" {
 					message = fmt.Sprintf("NixOS %s", osRelease["VERSION_ID"])
 				}
 				details = "Supported for runtime (install via NixOS module or Flake)"
-			case osRelease["PRETTY_NAME"] != "":
+			} else if osRelease["PRETTY_NAME"] != "" {
 				message = fmt.Sprintf("%s (not supported by dms setup)", osRelease["PRETTY_NAME"])
 				details = "DMS may work but automatic installation is not available"
 			}
 		}
 
-		results = append(results, checkResult{catSystem, "Operating System", status, message, details, doctorDocsURL + "#operating-system"})
+		results = append(results, checkResult{catSystem, "Operating System", status, message, details})
 	} else {
-		status := statusOK
+		status := "ok"
 		message := osInfo.PrettyName
 		if message == "" {
 			message = fmt.Sprintf("%s %s", osInfo.Distribution.ID, osInfo.VersionID)
 		}
 		if distros.IsUnsupportedDistro(osInfo.Distribution.ID, osInfo.VersionID) {
-			status = statusWarn
+			status = "warn"
 			message += " (version may not be fully supported)"
 		}
 		results = append(results, checkResult{
 			catSystem, "Operating System", status, message,
 			fmt.Sprintf("ID: %s, Version: %s, Arch: %s", osInfo.Distribution.ID, osInfo.VersionID, osInfo.Architecture),
-			doctorDocsURL + "#operating-system",
 		})
 	}
 
 	arch := runtime.GOARCH
-	archStatus := statusOK
+	archStatus := "ok"
 	if arch != "amd64" && arch != "arm64" {
-		archStatus = statusError
+		archStatus = "error"
 	}
-	results = append(results, checkResult{catSystem, "Architecture", archStatus, arch, "", doctorDocsURL + "#architecture"})
+	results = append(results, checkResult{catSystem, "Architecture", archStatus, arch, ""})
 
 	waylandDisplay := os.Getenv("WAYLAND_DISPLAY")
 	xdgSessionType := os.Getenv("XDG_SESSION_TYPE")
@@ -282,41 +139,21 @@ func checkSystemInfo() []checkResult {
 	switch {
 	case waylandDisplay != "" || xdgSessionType == "wayland":
 		results = append(results, checkResult{
-			catSystem, "Display Server", statusOK, "Wayland",
+			catSystem, "Display Server", "ok", "Wayland",
 			fmt.Sprintf("WAYLAND_DISPLAY=%s", waylandDisplay),
-			doctorDocsURL + "#display-server",
 		})
 	case xdgSessionType == "x11":
-		results = append(results, checkResult{catSystem, "Display Server", statusError, "X11 (DMS requires Wayland)", "", doctorDocsURL + "#display-server"})
+		results = append(results, checkResult{catSystem, "Display Server", "error", "X11 (DMS requires Wayland)", ""})
 	default:
 		results = append(results, checkResult{
-			catSystem, "Display Server", statusWarn, "Unknown (ensure you're running Wayland)",
+			catSystem, "Display Server", "warn", "Unknown (ensure you're running Wayland)",
 			fmt.Sprintf("XDG_SESSION_TYPE=%s", xdgSessionType),
-			doctorDocsURL + "#display-server",
 		})
 	}
 
 	return results
 }
 
-func checkEnvironmentVars() []checkResult {
-	var results []checkResult
-	results = append(results, checkEnvVar("QT_QPA_PLATFORMTHEME")...)
-	results = append(results, checkEnvVar("QS_ICON_THEME")...)
-	return results
-}
-
-func checkEnvVar(name string) []checkResult {
-	value := os.Getenv(name)
-	if value != "" {
-		return []checkResult{{catEnvironment, name, statusInfo, value, "", doctorDocsURL + "#environment-variables"}}
-	}
-	if doctorVerbose {
-		return []checkResult{{catEnvironment, name, statusInfo, "Not set", "", doctorDocsURL + "#environment-variables"}}
-	}
-	return nil
-}
-
 func readOSRelease() map[string]string {
 	result := make(map[string]string)
 	data, err := os.ReadFile("/etc/os-release")
@@ -332,28 +169,18 @@ func readOSRelease() map[string]string {
 }
 
 func checkVersions(qsMissingFeatures bool) []checkResult {
-	dmsCliPath, _ := os.Executable()
-	dmsCliDetails := ""
-	if doctorVerbose {
-		dmsCliDetails = dmsCliPath
-	}
-
 	results := []checkResult{
-		{catVersions, "DMS CLI", statusOK, formatVersion(Version), dmsCliDetails, doctorDocsURL + "#dms-cli"},
+		{catVersions, "DMS CLI", "info", formatVersion(Version), ""},
 	}
 
-	qsVersion, qsStatus, qsPath := getQuickshellVersionInfo(qsMissingFeatures)
+	qsVersion, qsStatus := getQuickshellVersionInfo(qsMissingFeatures)
-	qsDetails := ""
+	results = append(results, checkResult{catVersions, "Quickshell", qsStatus, qsVersion, ""})
-	if doctorVerbose && qsPath != "" {
-		qsDetails = qsPath
-	}
-	results = append(results, checkResult{catVersions, "Quickshell", qsStatus, qsVersion, qsDetails, doctorDocsURL + "#quickshell"})
 
 	dmsVersion, dmsPath := getDMSShellVersion()
 	if dmsVersion != "" {
-		results = append(results, checkResult{catVersions, "DMS Shell", statusOK, dmsVersion, dmsPath, doctorDocsURL + "#dms-shell"})
+		results = append(results, checkResult{catVersions, "DMS Shell", "ok", dmsVersion, dmsPath})
 	} else {
-		results = append(results, checkResult{catVersions, "DMS Shell", statusError, "Not installed or not detected", "Run 'dms setup' to install", doctorDocsURL + "#dms-shell"})
+		results = append(results, checkResult{catVersions, "DMS Shell", "error", "Not installed or not detected", "Run 'dms setup' to install"})
 	}
 
 	return results
@@ -379,34 +206,32 @@ func getDMSShellVersion() (version, path string) {
 	return "", ""
 }
 
-func getQuickshellVersionInfo(missingFeatures bool) (string, status, string) {
+func getQuickshellVersionInfo(missingFeatures bool) (string, string) {
 	if !utils.CommandExists("qs") {
-		return "Not installed", statusError, ""
+		return "Not installed", "error"
 	}
 
-	qsPath, _ := exec.LookPath("qs")
-
 	output, err := exec.Command("qs", "--version").Output()
 	if err != nil {
-		return "Installed (version check failed)", statusWarn, qsPath
+		return "Installed (version check failed)", "warn"
 	}
 
 	fullVersion := strings.TrimSpace(string(output))
-	if matches := quickshellVersionRegex.FindStringSubmatch(fullVersion); len(matches) >= 2 {
+	if matches := regexp.MustCompile(`quickshell (\d+\.\d+\.\d+)`).FindStringSubmatch(fullVersion); len(matches) >= 2 {
 		if version.CompareVersions(matches[1], "0.2.0") < 0 {
-			return fmt.Sprintf("%s (needs >= 0.2.0)", fullVersion), statusError, qsPath
+			return fmt.Sprintf("%s (needs >= 0.2.0)", fullVersion), "error"
 		}
 		if missingFeatures {
-			return fullVersion, statusWarn, qsPath
+			return fullVersion, "warn"
 		}
-		return fullVersion, statusOK, qsPath
+		return fullVersion, "ok"
 	}
 
-	return fullVersion, statusWarn, qsPath
+	return fullVersion, "warn"
 }
 
 func checkDMSInstallation() []checkResult {
-	var results []checkResult
+	results := []checkResult{}
 
 	dmsPath := ""
 	if err := findConfig(nil, nil); err == nil && configPath != "" {
@@ -416,16 +241,16 @@ func checkDMSInstallation() []checkResult {
 	}
 
 	if dmsPath == "" {
-		return []checkResult{{catInstallation, "DMS Configuration", statusError, "Not found", "shell.qml not found in any config path", doctorDocsURL + "#dms-configuration"}}
+		return []checkResult{{catInstallation, "DMS Configuration", "error", "Not found", "shell.qml not found in any config path"}}
 	}
 
-	results = append(results, checkResult{catInstallation, "DMS Configuration", statusOK, "Found", dmsPath, doctorDocsURL + "#dms-configuration"})
+	results = append(results, checkResult{catInstallation, "DMS Configuration", "ok", "Found", dmsPath})
 
 	shellQml := filepath.Join(dmsPath, "shell.qml")
 	if _, err := os.Stat(shellQml); err != nil {
-		results = append(results, checkResult{catInstallation, "shell.qml", statusError, "Missing", shellQml, doctorDocsURL + "#dms-configuration"})
+		results = append(results, checkResult{catInstallation, "shell.qml", "error", "Missing", shellQml})
 	} else {
-		results = append(results, checkResult{catInstallation, "shell.qml", statusOK, "Present", shellQml, doctorDocsURL + "#dms-configuration"})
+		results = append(results, checkResult{catInstallation, "shell.qml", "ok", "Present", shellQml})
 	}
 
 	if doctorVerbose {
@@ -438,7 +263,7 @@ func checkDMSInstallation() []checkResult {
 		case strings.Contains(dmsPath, ".config"):
 			installType = "User config"
 		}
-		results = append(results, checkResult{catInstallation, "Install Type", statusInfo, installType, dmsPath, doctorDocsURL + "#dms-configuration"})
+		results = append(results, checkResult{catInstallation, "Install Type", "info", installType, dmsPath})
 	}
 
 	return results
@@ -446,69 +271,52 @@ func checkDMSInstallation() []checkResult {
 
 func checkWindowManagers() []checkResult {
 	compositors := []struct {
-		name, versionCmd, versionArg string
+		name, versionCmd, versionArg, versionRe string
-		versionRegex                 *regexp.Regexp
+		commands                                []string
-		commands                     []string
 	}{
-		{"Hyprland", "Hyprland", "--version", hyprlandVersionRegex, []string{"hyprland", "Hyprland"}},
+		{"Hyprland", "hyprctl", "version", `v?(\d+\.\d+\.\d+)`, []string{"hyprland", "Hyprland"}},
-		{"niri", "niri", "--version", niriVersionRegex, []string{"niri"}},
+		{"niri", "niri", "--version", `niri (\d+\.\d+)`, []string{"niri"}},
-		{"Sway", "sway", "--version", swayVersionRegex, []string{"sway"}},
+		{"Sway", "sway", "--version", `sway version (\d+\.\d+)`, []string{"sway"}},
-		{"River", "river", "-version", riverVersionRegex, []string{"river"}},
+		{"River", "river", "-version", `river (\d+\.\d+)`, []string{"river"}},
-		{"Wayfire", "wayfire", "--version", wayfireVersionRegex, []string{"wayfire"}},
+		{"Wayfire", "wayfire", "--version", `wayfire (\d+\.\d+)`, []string{"wayfire"}},
-		{"labwc", "labwc", "--version", labwcVersionRegex, []string{"labwc"}},
-		{"mangowc", "mango", "-v", mangowcVersionRegex, []string{"mango"}},
 	}
 
-	var results []checkResult
+	results := []checkResult{}
 	foundAny := false
 
 	for _, c := range compositors {
-		if !slices.ContainsFunc(c.commands, utils.CommandExists) {
+		if slices.ContainsFunc(c.commands, utils.CommandExists) {
-			continue
+			foundAny = true
+			results = append(results, checkResult{
+				catCompositor, c.name, "ok",
+				getVersionFromCommand(c.versionCmd, c.versionArg, c.versionRe), "",
+			})
 		}
-		foundAny = true
-		var compositorPath string
-		for _, cmd := range c.commands {
-			if path, err := exec.LookPath(cmd); err == nil {
-				compositorPath = path
-				break
-			}
-		}
-		details := ""
-		if doctorVerbose && compositorPath != "" {
-			details = compositorPath
-		}
-		results = append(results, checkResult{
-			catCompositor, c.name, statusOK,
-			getVersionFromCommand(c.versionCmd, c.versionArg, c.versionRegex), details,
-			doctorDocsURL + "#compositor-checks",
-		})
 	}
 
 	if !foundAny {
 		results = append(results, checkResult{
-			catCompositor, "Compositor", statusError,
+			catCompositor, "Compositor", "error",
 			"No supported Wayland compositor found",
 			"Install Hyprland, niri, Sway, River, or Wayfire",
-			doctorDocsURL + "#compositor-checks",
 		})
 	}
 
 	if wm := detectRunningWM(); wm != "" {
-		results = append(results, checkResult{catCompositor, "Active", statusInfo, wm, "", doctorDocsURL + "#compositor"})
+		results = append(results, checkResult{catCompositor, "Active", "info", wm, ""})
 	}
 
 	return results
 }
 
-func getVersionFromCommand(cmd, arg string, regex *regexp.Regexp) string {
+func getVersionFromCommand(cmd, arg, regex string) string {
-	output, err := exec.Command(cmd, arg).CombinedOutput()
+	output, err := exec.Command(cmd, arg).Output()
-	if err != nil && len(output) == 0 {
+	if err != nil {
 		return "installed"
 	}
 
 	outStr := string(output)
-	if matches := regex.FindStringSubmatch(outStr); len(matches) > 1 {
+	if matches := regexp.MustCompile(regex).FindStringSubmatch(outStr); len(matches) > 1 {
 		ver := matches[1]
 		if strings.Contains(outStr, "git") || strings.Contains(outStr, "dirty") {
 			return ver + " (git)"
@@ -607,122 +415,80 @@ ShellRoot {
 		{"ShortcutInhibitor", "Allow shortcut management (niri)"},
 	}
 
-	var results []checkResult
+	results := []checkResult{}
 	missingFeatures := false
 
 	for _, f := range features {
 		available := strings.Contains(outputStr, fmt.Sprintf("FEATURE:%s:OK", f.name))
-		status, message := statusOK, "Available"
+		status, message := "ok", "Available"
 		if !available {
-			status, message = statusInfo, "Not available"
+			status, message = "info", "Not available"
 			missingFeatures = true
 		}
-		results = append(results, checkResult{catQuickshellFeatures, f.name, status, message, f.desc, doctorDocsURL + "#quickshell-features"})
+		results = append(results, checkResult{catQuickshellFeatures, f.name, status, message, f.desc})
 	}
 
 	return results, missingFeatures
 }
 
-func checkI2CAvailability() checkResult {
-	ddc, err := brightness.NewDDCBackend()
-	if err != nil {
-		return checkResult{catOptionalFeatures, "I2C/DDC", statusInfo, "Not available", "External monitor brightness control", doctorDocsURL + "#optional-features"}
-	}
-	defer ddc.Close()
-
-	devices, err := ddc.GetDevices()
-	if err != nil || len(devices) == 0 {
-		return checkResult{catOptionalFeatures, "I2C/DDC", statusInfo, "No monitors detected", "External monitor brightness control", doctorDocsURL + "#optional-features"}
-	}
-
-	return checkResult{catOptionalFeatures, "I2C/DDC", statusOK, fmt.Sprintf("%d monitor(s) detected", len(devices)), "External monitor brightness control", doctorDocsURL + "#optional-features"}
-}
-
-func detectNetworkBackend(stackResult *network.DetectResult) string {
-	switch stackResult.Backend {
-	case network.BackendNetworkManager:
-		return "NetworkManager"
-	case network.BackendIwd:
-		return "iwd"
-	case network.BackendNetworkd:
-		if stackResult.HasIwd {
-			return "iwd + systemd-networkd"
-		}
-		return "systemd-networkd"
-	case network.BackendConnMan:
-		return "ConnMan"
-	default:
-		return ""
-	}
-}
-
-func getOptionalDBusStatus(busName string) (status, string) {
-	if utils.IsDBusServiceAvailable(busName) {
-		return statusOK, "Available"
-	} else {
-		return statusWarn, "Not available"
-	}
-}
-
 func checkOptionalDependencies() []checkResult {
-	var results []checkResult
+	results := []checkResult{}
 
-	optionalFeaturesURL := doctorDocsURL + "#optional-features"
+	if utils.IsServiceActive("accounts-daemon", false) {
-
+		results = append(results, checkResult{catOptionalFeatures, "accountsservice", "ok", "Running", "User accounts"})
-	accountsStatus, accountsMsg := getOptionalDBusStatus("org.freedesktop.Accounts")
+	} else {
-	results = append(results, checkResult{catOptionalFeatures, "accountsservice", accountsStatus, accountsMsg, "User accounts", optionalFeaturesURL})
+		results = append(results, checkResult{catOptionalFeatures, "accountsservice", "warn", "Not running", "User accounts"})
-
+	}
-	ppdStatus, ppdMsg := getOptionalDBusStatus("org.freedesktop.UPower.PowerProfiles")
-	results = append(results, checkResult{catOptionalFeatures, "power-profiles-daemon", ppdStatus, ppdMsg, "Power profile management", optionalFeaturesURL})
-
-	logindStatus, logindMsg := getOptionalDBusStatus("org.freedesktop.login1")
-	results = append(results, checkResult{catOptionalFeatures, "logind", logindStatus, logindMsg, "Session management", optionalFeaturesURL})
-
-	results = append(results, checkI2CAvailability())
 
 	terminals := []string{"ghostty", "kitty", "alacritty", "foot", "wezterm"}
-	if idx := slices.IndexFunc(terminals, utils.CommandExists); idx >= 0 {
+	terminalFound := ""
-		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusOK, terminals[idx], "", optionalFeaturesURL})
+	for _, term := range terminals {
-	} else {
+		if utils.CommandExists(term) {
-		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusWarn, "None found", "Install ghostty, kitty, or alacritty", optionalFeaturesURL})
+			terminalFound = term
-	}
+			break
-
-	networkResult, err := network.DetectNetworkStack()
-	networkStatus, networkMessage, networkDetails := statusOK, "Not available", "Network management"
-
-	if err == nil && networkResult.Backend != network.BackendNone {
-		networkMessage = detectNetworkBackend(networkResult)
-		if doctorVerbose {
-			networkDetails = networkResult.ChosenReason
 		}
-	} else {
-		networkStatus = statusInfo
 	}
-
+	if terminalFound != "" {
-	results = append(results, checkResult{catOptionalFeatures, "Network", networkStatus, networkMessage, networkDetails, optionalFeaturesURL})
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", "ok", terminalFound, ""})
+	} else {
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", "warn", "None found", "Install ghostty, kitty, or alacritty"})
+	}
 
 	deps := []struct {
-		name, cmd, desc string
+		name, cmd, altCmd, desc string
-		important       bool
+		important               bool
 	}{
-		{"matugen", "matugen", "Dynamic theming", true},
+		{"matugen", "matugen", "", "Dynamic theming", true},
-		{"dgop", "dgop", "System monitoring", true},
+		{"dgop", "dgop", "", "System monitoring", true},
-		{"cava", "cava", "Audio visualizer", true},
+		{"cava", "cava", "", "Audio waveform", false},
-		{"khal", "khal", "Calendar events", false},
+		{"khal", "khal", "", "Calendar events", false},
-		{"danksearch", "dsearch", "File search", false},
+		{"Network", "nmcli", "iwctl", "Network management", false},
-		{"fprintd", "fprintd-list", "Fingerprint auth", false},
+		{"danksearch", "dsearch", "", "File search", false},
+		{"loginctl", "loginctl", "", "Session management", false},
+		{"fprintd", "fprintd-list", "", "Fingerprint auth", false},
 	}
 
 	for _, d := range deps {
-		found := utils.CommandExists(d.cmd)
+		found, foundCmd := utils.CommandExists(d.cmd), d.cmd
+		if !found && d.altCmd != "" {
+			if utils.CommandExists(d.altCmd) {
+				found, foundCmd = true, d.altCmd
+			}
+		}
 
-		switch {
+		if found {
-		case found:
+			message := "Installed"
-			results = append(results, checkResult{catOptionalFeatures, d.name, statusOK, "Installed", d.desc, optionalFeaturesURL})
+			switch foundCmd {
-		case d.important:
+			case "nmcli":
-			results = append(results, checkResult{catOptionalFeatures, d.name, statusWarn, "Missing", d.desc, optionalFeaturesURL})
+				message = "NetworkManager"
-		default:
+			case "iwctl":
-			results = append(results, checkResult{catOptionalFeatures, d.name, statusInfo, "Not installed", d.desc, optionalFeaturesURL})
+				message = "iwd"
+			}
+			results = append(results, checkResult{catOptionalFeatures, d.name, "ok", message, d.desc})
+		} else if d.important {
+			results = append(results, checkResult{catOptionalFeatures, d.name, "warn", "Missing", d.desc})
+		} else {
+			results = append(results, checkResult{catOptionalFeatures, d.name, "info", "Not installed", d.desc})
 		}
 	}
 
@@ -730,33 +496,19 @@ func checkOptionalDependencies() []checkResult {
 }
 
 func checkConfigurationFiles() []checkResult {
-	configDir, _ := os.UserConfigDir()
-	cacheDir, _ := os.UserCacheDir()
-	dmsDir := "DankMaterialShell"
-
 	configFiles := []struct{ name, path string }{
-		{"settings.json", filepath.Join(configDir, dmsDir, "settings.json")},
+		{"Settings", filepath.Join(utils.XDGConfigHome(), "DankMaterialShell", "settings.json")},
-		{"clsettings.json", filepath.Join(configDir, dmsDir, "clsettings.json")},
+		{"Session", filepath.Join(utils.XDGStateHome(), "DankMaterialShell", "session.json")},
-		{"plugin_settings.json", filepath.Join(configDir, dmsDir, "plugin_settings.json")},
+		{"Colors", filepath.Join(utils.XDGCacheHome(), "DankMaterialShell", "dms-colors.json")},
-		{"session.json", filepath.Join(utils.XDGStateHome(), dmsDir, "session.json")},
-		{"dms-colors.json", filepath.Join(cacheDir, dmsDir, "dms-colors.json")},
 	}
 
-	var results []checkResult
+	results := []checkResult{}
 	for _, cf := range configFiles {
-		info, err := os.Stat(cf.path)
+		if _, err := os.Stat(cf.path); err == nil {
-		if err != nil {
+			results = append(results, checkResult{catConfigFiles, cf.name, "ok", "Present", cf.path})
-			results = append(results, checkResult{catConfigFiles, cf.name, statusInfo, "Not yet created", cf.path, doctorDocsURL + "#config-files"})
+		} else {
-			continue
+			results = append(results, checkResult{catConfigFiles, cf.name, "info", "Not yet created", cf.path})
 		}
-
-		status := statusOK
-		message := "Present"
-		if info.Mode().Perm()&0200 == 0 {
-			status = statusWarn
-			message += " (read-only)"
-		}
-		results = append(results, checkResult{catConfigFiles, cf.name, status, message, cf.path, doctorDocsURL + "#config-files"})
 	}
 	return results
 }
@@ -766,35 +518,31 @@ func checkSystemdServices() []checkResult {
 		return nil
 	}
 
-	var results []checkResult
+	results := []checkResult{}
 
 	dmsState := getServiceState("dms", true)
 	if !dmsState.exists {
-		results = append(results, checkResult{catServices, "dms.service", statusInfo, "Not installed", "Optional user service", doctorDocsURL + "#services"})
+		results = append(results, checkResult{catServices, "dms.service", "info", "Not installed", "Optional user service"})
 	} else {
-		status, message := statusOK, dmsState.enabled
+		status, message := "ok", dmsState.enabled
 		if dmsState.active != "" {
 			message = fmt.Sprintf("%s, %s", dmsState.enabled, dmsState.active)
 		}
-		switch {
+		if dmsState.enabled == "disabled" {
-		case dmsState.enabled == "disabled":
+			status, message = "warn", "Disabled"
-			status, message = statusWarn, "Disabled"
-		case dmsState.active == "failed" || dmsState.active == "inactive":
-			status = statusError
 		}
-		results = append(results, checkResult{catServices, "dms.service", status, message, "", doctorDocsURL + "#services"})
+		results = append(results, checkResult{catServices, "dms.service", status, message, ""})
 	}
 
 	greetdState := getServiceState("greetd", false)
-	switch {
+	if greetdState.exists {
-	case greetdState.exists:
+		status := "ok"
-		status := statusOK
 		if greetdState.enabled == "disabled" {
-			status = statusInfo
+			status = "info"
 		}
-		results = append(results, checkResult{catServices, "greetd", status, greetdState.enabled, "", doctorDocsURL + "#services"})
+		results = append(results, checkResult{catServices, "greetd", status, greetdState.enabled, ""})
-	case doctorVerbose:
+	} else if doctorVerbose {
-		results = append(results, checkResult{catServices, "greetd", statusInfo, "Not installed", "Optional greeter service", doctorDocsURL + "#services"})
+		results = append(results, checkResult{catServices, "greetd", "info", "Not installed", "Optional greeter service"})
 	}
 
 	return results
@@ -841,85 +589,67 @@ func printResults(results []checkResult) {
 			if currentCategory != -1 {
 				fmt.Println()
 			}
-			fmt.Printf("  %s\n", styles.Bold.Render(r.category.String()))
+			fmt.Printf("  %s\n", styles.Bold.Render(categoryNames[r.category]))
 			currentCategory = r.category
 		}
 		printResultLine(r, styles)
 	}
 }
 
-func printResultsJSON(results []checkResult) {
-	var ds DoctorStatus
-	for _, r := range results {
-		ds.Add(r)
-	}
-
-	output := doctorOutputJSON{}
-	output.Summary.Errors = ds.ErrorCount()
-	output.Summary.Warnings = ds.WarningCount()
-	output.Summary.OK = ds.OKCount()
-	output.Summary.Info = len(ds.Info)
-
-	output.Results = make([]checkResultJSON, 0, len(results))
-	for _, r := range results {
-		output.Results = append(output.Results, r.toJSON())
-	}
-
-	encoder := json.NewEncoder(os.Stdout)
-	encoder.SetIndent("", "  ")
-	if err := encoder.Encode(output); err != nil {
-		fmt.Fprintf(os.Stderr, "Error encoding JSON: %v\n", err)
-		os.Exit(1)
-	}
-}
-
 func printResultLine(r checkResult, styles tui.Styles) {
-	icon, style := r.status.IconStyle(styles)
+	icon, style := "○", styles.Subtle
+	switch r.status {
+	case "ok":
+		icon, style = "●", styles.Success
+	case "warn":
+		icon, style = "●", styles.Warning
+	case "error":
+		icon, style = "●", styles.Error
+	}
 
 	name := r.name
-	nameLen := len(name)
+	if len(name) > 18 {
-
+		name = name[:17] + "…"
-	if nameLen > checkNameMaxLength {
-		name = name[:checkNameMaxLength-1] + "…"
-		nameLen = checkNameMaxLength
 	}
-	dots := strings.Repeat("·", checkNameMaxLength-nameLen)
+	dots := strings.Repeat("·", 19-len(name))
 
 	fmt.Printf("    %s %s %s %s\n", style.Render(icon), name, styles.Subtle.Render(dots), r.message)
 
 	if doctorVerbose && r.details != "" {
 		fmt.Printf("      %s\n", styles.Subtle.Render("└─ "+r.details))
 	}
-
-	if (r.status == statusError || r.status == statusWarn) && r.url != "" {
-		fmt.Printf("      %s\n", styles.Subtle.Render("→ "+r.url))
-	}
 }
 
 func printSummary(results []checkResult, qsMissingFeatures bool) {
 	theme := tui.TerminalTheme()
 	styles := tui.NewStyles(theme)
 
-	var ds DoctorStatus
+	errors, warnings, ok := 0, 0, 0
 	for _, r := range results {
-		ds.Add(r)
+		switch r.status {
+		case "error":
+			errors++
+		case "warn":
+			warnings++
+		case "ok":
+			ok++
+		}
 	}
 
 	fmt.Println()
 	fmt.Printf("  %s\n", styles.Subtle.Render("──────────────────────────────────────"))
 
-	if !ds.HasIssues() {
+	if errors == 0 && warnings == 0 {
 		fmt.Printf("  %s\n", styles.Success.Render("✓ All checks passed!"))
 	} else {
-		var parts []string
+		parts := []string{}
-
+		if errors > 0 {
-		if ds.ErrorCount() > 0 {
+			parts = append(parts, styles.Error.Render(fmt.Sprintf("%d error(s)", errors)))
-			parts = append(parts, styles.Error.Render(fmt.Sprintf("%d error(s)", ds.ErrorCount())))
 		}
-		if ds.WarningCount() > 0 {
+		if warnings > 0 {
-			parts = append(parts, styles.Warning.Render(fmt.Sprintf("%d warning(s)", ds.WarningCount())))
+			parts = append(parts, styles.Warning.Render(fmt.Sprintf("%d warning(s)", warnings)))
 		}
-		parts = append(parts, styles.Success.Render(fmt.Sprintf("%d ok", ds.OKCount())))
+		parts = append(parts, styles.Success.Render(fmt.Sprintf("%d ok", ok)))
 		fmt.Printf("  %s\n", strings.Join(parts, ", "))
 
 		if qsMissingFeatures {

core/cmd/dms/commands_features.go

@@ -377,7 +377,7 @@ func updateDMSBinary() error {
 	}
 
 	version := ""
-	for line := range strings.SplitSeq(string(output), "\n") {
+	for _, line := range strings.Split(string(output), "\n") {
 		if strings.Contains(line, "\"tag_name\"") {
 			parts := strings.Split(line, "\"")
 			if len(parts) >= 4 {
@@ -443,7 +443,7 @@ func updateDMSBinary() error {
 
 	decompressedPath := filepath.Join(tempDir, "dms")
 
-	if err := os.Chmod(decompressedPath, 0o755); err != nil {
+	if err := os.Chmod(decompressedPath, 0755); err != nil {
 		return fmt.Errorf("failed to make binary executable: %w", err)
 	}
 

core/cmd/dms/commands_greeter.go

@@ -211,8 +211,8 @@ func checkGroupExists(groupName string) bool {
 		return false
 	}
 
-	lines := strings.SplitSeq(string(data), "\n")
+	lines := strings.Split(string(data), "\n")
-	for line := range lines {
+	for _, line := range lines {
 		if strings.HasPrefix(line, groupName+":") {
 			return true
 		}
@@ -521,7 +521,7 @@ func enableGreeter() error {
 	newConfig := strings.Join(finalLines, "\n")
 
 	tmpFile := "/tmp/greetd-config.toml"
-	if err := os.WriteFile(tmpFile, []byte(newConfig), 0o644); err != nil {
+	if err := os.WriteFile(tmpFile, []byte(newConfig), 0644); err != nil {
 		return fmt.Errorf("failed to write temp config: %w", err)
 	}
 
@@ -592,8 +592,8 @@ func checkGreeterStatus() error {
 	if data, err := os.ReadFile(configPath); err == nil {
 		configContent := string(data)
 		if strings.Contains(configContent, "dms-greeter") {
-			lines := strings.SplitSeq(configContent, "\n")
+			lines := strings.Split(configContent, "\n")
-			for line := range lines {
+			for _, line := range lines {
 				trimmed := strings.TrimSpace(line)
 				if strings.HasPrefix(trimmed, "command =") || strings.HasPrefix(trimmed, "command=") {
 					parts := strings.SplitN(trimmed, "=", 2)

core/cmd/dms/commands_keybinds.go

@@ -57,14 +57,12 @@ var keybindsRemoveCmd = &cobra.Command{
 }
 
 func init() {
-	keybindsListCmd.Flags().BoolP("json", "j", false, "Output as JSON")
 	keybindsShowCmd.Flags().String("path", "", "Override config path for the provider")
 	keybindsSetCmd.Flags().String("desc", "", "Description for hotkey overlay")
 	keybindsSetCmd.Flags().Bool("allow-when-locked", false, "Allow when screen is locked")
 	keybindsSetCmd.Flags().Int("cooldown-ms", 0, "Cooldown in milliseconds")
 	keybindsSetCmd.Flags().Bool("no-repeat", false, "Disable key repeat")
 	keybindsSetCmd.Flags().String("replace-key", "", "Original key to replace (removes old key)")
-	keybindsSetCmd.Flags().String("flags", "", "Hyprland bind flags (e.g., 'e' for repeat, 'l' for locked, 'r' for release)")
 
 	keybindsCmd.AddCommand(keybindsListCmd)
 	keybindsCmd.AddCommand(keybindsShowCmd)
@@ -112,21 +110,12 @@ func initializeProviders() {
 	}
 }
 
-func runKeybindsList(cmd *cobra.Command, _ []string) {
+func runKeybindsList(_ *cobra.Command, _ []string) {
 	providerList := keybinds.GetDefaultRegistry().List()
-	asJSON, _ := cmd.Flags().GetBool("json")
-
-	if asJSON {
-		output, _ := json.Marshal(providerList)
-		fmt.Fprintln(os.Stdout, string(output))
-		return
-	}
-
 	if len(providerList) == 0 {
 		fmt.Fprintln(os.Stdout, "No providers available")
 		return
 	}
-
 	fmt.Fprintln(os.Stdout, "Available providers:")
 	for _, name := range providerList {
 		fmt.Fprintf(os.Stdout, "  - %s\n", name)
@@ -212,9 +201,6 @@ func runKeybindsSet(cmd *cobra.Command, args []string) {
 	if v, _ := cmd.Flags().GetBool("no-repeat"); v {
 		options["repeat"] = false
 	}
-	if v, _ := cmd.Flags().GetString("flags"); v != "" {
-		options["flags"] = v
-	}
 
 	desc, _ := cmd.Flags().GetString("desc")
 	if err := writable.SetBind(key, action, desc, options); err != nil {

core/cmd/dms/commands_matugen.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 
@@ -30,16 +29,9 @@ var matugenQueueCmd = &cobra.Command{
 	Run:   runMatugenQueue,
 }
 
-var matugenCheckCmd = &cobra.Command{
-	Use:   "check",
-	Short: "Check which template apps are detected",
-	Run:   runMatugenCheck,
-}
-
 func init() {
 	matugenCmd.AddCommand(matugenGenerateCmd)
 	matugenCmd.AddCommand(matugenQueueCmd)
-	matugenCmd.AddCommand(matugenCheckCmd)
 
 	for _, cmd := range []*cobra.Command{matugenGenerateCmd, matugenQueueCmd} {
 		cmd.Flags().String("state-dir", "", "State directory for cache files")
@@ -82,7 +74,7 @@ func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
 		ConfigDir:           configDir,
 		Kind:                kind,
 		Value:               value,
-		Mode:                matugen.ColorMode(mode),
+		Mode:                mode,
 		IconTheme:           iconTheme,
 		MatugenType:         matugenType,
 		RunUserTemplates:    runUserTemplates,
@@ -170,12 +162,3 @@ func runMatugenQueue(cmd *cobra.Command, args []string) {
 		log.Fatalf("Timeout waiting for theme generation")
 	}
 }
-
-func runMatugenCheck(cmd *cobra.Command, args []string) {
-	checks := matugen.CheckTemplates(nil)
-	data, err := json.Marshal(checks)
-	if err != nil {
-		log.Fatalf("Failed to marshal check results: %v", err)
-	}
-	fmt.Println(string(data))
-}

core/cmd/dms/commands_root.go

@@ -50,18 +50,15 @@ func findConfig(cmd *cobra.Command, args []string) error {
 
 	configStateFile := filepath.Join(getRuntimeDir(), "danklinux.path")
 	if data, readErr := os.ReadFile(configStateFile); readErr == nil {
-		if len(getAllDMSPIDs()) == 0 {
+		statePath := strings.TrimSpace(string(data))
-			os.Remove(configStateFile)
+		shellPath := filepath.Join(statePath, "shell.qml")
-		} else {
-			statePath := strings.TrimSpace(string(data))
-			shellPath := filepath.Join(statePath, "shell.qml")
 
-			if info, statErr := os.Stat(shellPath); statErr == nil && !info.IsDir() {
+		if info, statErr := os.Stat(shellPath); statErr == nil && !info.IsDir() {
-				log.Debug("Using config from active session state file: %s", statePath)
+			log.Debug("Using config from active session state file: %s", statePath)
-				configPath = statePath
+			configPath = statePath
-				log.Debug("Using config from: %s", configPath)
+			log.Debug("Using config from: %s", configPath)
-				return nil
+			return nil // <-- Guard statement
-			}
+		} else {
 			os.Remove(configStateFile)
 		}
 	}

core/cmd/dms/dpms_client.go

@@ -87,14 +87,20 @@ func newDPMSClient() (*dpmsClient, error) {
 		switch e.Interface {
 		case wlr_output_power.ZwlrOutputPowerManagerV1InterfaceName:
 			powerMgr := wlr_output_power.NewZwlrOutputPowerManagerV1(c.ctx)
-			version := min(e.Version, 1)
+			version := e.Version
+			if version > 1 {
+				version = 1
+			}
 			if err := registry.Bind(e.Name, e.Interface, version, powerMgr); err == nil {
 				c.powerMgr = powerMgr
 			}
 
 		case "wl_output":
 			output := wlclient.NewOutput(c.ctx)
-			version := min(e.Version, 4)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
 			if err := registry.Bind(e.Name, e.Interface, version, output); err == nil {
 				outputID := fmt.Sprintf("output-%d", output.ID())
 				state := &outputState{

core/cmd/dms/shell.go

@@ -7,10 +7,8 @@ import (
 	"os/exec"
 	"os/signal"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"strings"
-	"sync"
 	"syscall"
 	"time"
 
@@ -186,10 +184,8 @@ func runShellInteractive(session bool) {
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
 	cmd.Env = append(os.Environ(), "DMS_SOCKET="+socketPath)
-	if os.Getenv("QT_LOGGING_RULES") == "" {
+	if qtRules := log.GetQtLoggingRules(); qtRules != "" {
-		if qtRules := log.GetQtLoggingRules(); qtRules != "" {
+		cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
-			cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
-		}
 	}
 
 	if isSessionManaged && hasSystemdRun() {
@@ -375,7 +371,13 @@ func killShell() {
 
 func runShellDaemon(session bool) {
 	isSessionManaged = session
-	isDaemonChild := slices.Contains(os.Args, "--daemon-child")
+	isDaemonChild := false
+	for _, arg := range os.Args {
+		if arg == "--daemon-child" {
+			isDaemonChild = true
+			break
+		}
+	}
 
 	if !isDaemonChild {
 		fmt.Fprintf(os.Stderr, "dms %s\n", Version)
@@ -426,10 +428,8 @@ func runShellDaemon(session bool) {
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
 	cmd.Env = append(os.Environ(), "DMS_SOCKET="+socketPath)
-	if os.Getenv("QT_LOGGING_RULES") == "" {
+	if qtRules := log.GetQtLoggingRules(); qtRules != "" {
-		if qtRules := log.GetQtLoggingRules(); qtRules != "" {
+		cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
-			cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
-		}
 	}
 
 	if isSessionManaged && hasSystemdRun() {
@@ -531,20 +531,12 @@ func runShellDaemon(session bool) {
 	}
 }
 
-var qsHasAnyDisplay = sync.OnceValue(func() bool {
-	out, err := exec.Command("qs", "ipc", "--help").Output()
-	if err != nil {
-		return false
-	}
-	return strings.Contains(string(out), "--any-display")
-})
-
 func parseTargetsFromIPCShowOutput(output string) ipcTargets {
 	targets := make(ipcTargets)
 	var currentTarget string
-	for line := range strings.SplitSeq(output, "\n") {
+	for _, line := range strings.Split(output, "\n") {
-		if after, ok := strings.CutPrefix(line, "target "); ok {
+		if strings.HasPrefix(line, "target ") {
-			currentTarget = strings.TrimSpace(after)
+			currentTarget = strings.TrimSpace(strings.TrimPrefix(line, "target "))
 			targets[currentTarget] = make(map[string][]string)
 		}
 		if strings.HasPrefix(line, "  function") && currentTarget != "" {
@@ -569,11 +561,7 @@ func parseTargetsFromIPCShowOutput(output string) ipcTargets {
 }
 
 func getShellIPCCompletions(args []string, _ string) []string {
-	cmdArgs := []string{"ipc"}
+	cmdArgs := []string{"-p", configPath, "ipc", "show"}
-	if qsHasAnyDisplay() {
-		cmdArgs = append(cmdArgs, "--any-display")
-	}
-	cmdArgs = append(cmdArgs, "-p", configPath, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 	var targets ipcTargets
 
@@ -627,12 +615,7 @@ func runShellIPCCommand(args []string) {
 		args = append([]string{"call"}, args...)
 	}
 
-	cmdArgs := []string{"ipc"}
+	cmdArgs := append([]string{"-p", configPath, "ipc"}, args...)
-	if qsHasAnyDisplay() {
-		cmdArgs = append(cmdArgs, "--any-display")
-	}
-	cmdArgs = append(cmdArgs, "-p", configPath)
-	cmdArgs = append(cmdArgs, args...)
 	cmd := exec.Command("qs", cmdArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout

core/cmd/dms/utils.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"os/exec"
-	"slices"
 	"strings"
 )
 
@@ -37,7 +36,13 @@ func checkSystemdServiceEnabled(serviceName string) (string, bool, error) {
 
 	if err != nil {
 		knownStates := []string{"disabled", "masked", "masked-runtime", "not-found", "enabled", "enabled-runtime", "static", "indirect", "alias"}
-		isKnownState := slices.Contains(knownStates, stateStr)
+		isKnownState := false
+		for _, known := range knownStates {
+			if stateStr == known {
+				isKnownState = true
+				break
+			}
+		}
 
 		if !isKnownState {
 			return stateStr, false, fmt.Errorf("systemctl is-enabled failed: %w (output: %s)", err, stateStr)

core/go.mod

@@ -9,28 +9,28 @@ require (
 	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/charmbracelet/log v0.4.2
 	github.com/fsnotify/fsnotify v1.9.0
-	github.com/godbus/dbus/v5 v5.2.2
+	github.com/godbus/dbus/v5 v5.2.0
 	github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83
 	github.com/pilebones/go-udev v0.9.1
-	github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3
+	github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a
-	github.com/spf13/cobra v1.10.2
+	github.com/spf13/cobra v1.10.1
 	github.com/stretchr/testify v1.11.1
 	go.etcd.io/bbolt v1.4.3
-	golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93
+	golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39
 	golang.org/x/image v0.34.0
 )
 
 require (
 	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/clipperhouse/displaywidth v0.6.2 // indirect
+	github.com/clipperhouse/displaywidth v0.6.0 // indirect
 	github.com/clipperhouse/stringish v0.1.1 // indirect
 	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
-	github.com/cloudflare/circl v1.6.2 // indirect
+	github.com/cloudflare/circl v1.6.1 // indirect
 	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/go-git/gcfg/v2 v2.0.2 // indirect
-	github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd // indirect
+	github.com/go-git/go-billy/v6 v6.0.0-20251126203821-7f9c95185ee0 // indirect
 	github.com/go-logfmt/logfmt v0.6.1 // indirect
 	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	github.com/kevinburke/ssh_config v1.4.0 // indirect
@@ -38,21 +38,21 @@ require (
 	github.com/pjbgf/sha1cd v0.5.0 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/stretchr/objx v0.5.3 // indirect
-	golang.org/x/crypto v0.46.0 // indirect
+	golang.org/x/crypto v0.45.0 // indirect
-	golang.org/x/net v0.48.0 // indirect
+	golang.org/x/net v0.47.0 // indirect
 )
 
 require (
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.4.1 // indirect
+	github.com/charmbracelet/colorprofile v0.3.3 // indirect
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.3 // indirect
+	github.com/charmbracelet/x/ansi v0.11.2 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19
+	github.com/go-git/go-git/v6 v6.0.0-20251128074608-48f817f57805
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -66,7 +66,7 @@ require (
 	github.com/spf13/afero v1.15.0
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/sys v0.39.0
+	golang.org/x/sys v0.38.0
 	golang.org/x/text v0.32.0
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

core/go.sum

@@ -18,8 +18,6 @@ github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlv
 github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
 github.com/charmbracelet/colorprofile v0.3.3 h1:DjJzJtLP6/NZ8p7Cgjno0CKGr7wwRJGxWUwh2IyhfAI=
 github.com/charmbracelet/colorprofile v0.3.3/go.mod h1:nB1FugsAbzq284eJcjfah2nhdSLppN2NqvfotkfRYP4=
-github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
-github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=
 github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
 github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
@@ -28,24 +26,18 @@ github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsy
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
 github.com/charmbracelet/x/ansi v0.11.2 h1:XAG3FSjiVtFvgEgGrNBkCNNYrsucAt8c6bfxHyROLLs=
 github.com/charmbracelet/x/ansi v0.11.2/go.mod h1:9tY2bzX5SiJCU0iWyskjBeI2BRQfvPqI+J760Mjf+Rg=
-github.com/charmbracelet/x/ansi v0.11.3 h1:6DcVaqWI82BBVM/atTyq6yBoRLZFBsnoDoX9GCu2YOI=
-github.com/charmbracelet/x/ansi v0.11.3/go.mod h1:yI7Zslym9tCJcedxz5+WBq+eUGMJT0bM06Fqy1/Y4dI=
 github.com/charmbracelet/x/cellbuf v0.0.14 h1:iUEMryGyFTelKW3THW4+FfPgi4fkmKnnaLOXuc+/Kj4=
 github.com/charmbracelet/x/cellbuf v0.0.14/go.mod h1:P447lJl49ywBbil/KjCk2HexGh4tEY9LH0/1QrZZ9rA=
 github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
 github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
 github.com/clipperhouse/displaywidth v0.6.0 h1:k32vueaksef9WIKCNcoqRNyKbyvkvkysNYnAWz2fN4s=
 github.com/clipperhouse/displaywidth v0.6.0/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
-github.com/clipperhouse/displaywidth v0.6.2 h1:ZDpTkFfpHOKte4RG5O/BOyf3ysnvFswpyYrV7z2uAKo=
-github.com/clipperhouse/displaywidth v0.6.2/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
 github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
 github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
 github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
 github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
 github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
-github.com/cloudflare/circl v1.6.2 h1:hL7VBpHHKzrV5WTfHCaBsgx/HGbBYlgrwvNXEVDYYsQ=
-github.com/cloudflare/circl v1.6.2/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/cyphar/filepath-securejoin v0.6.1 h1:5CeZ1jPXEiYt3+Z6zqprSAgSWiggmpVyciv8syjIpVE=
 github.com/cyphar/filepath-securejoin v0.6.1/go.mod h1:A8hd4EnAeyujCJRrICiOWqjS1AX0a9kM5XL+NwKoYSc=
@@ -66,22 +58,15 @@ github.com/go-git/gcfg/v2 v2.0.2 h1:MY5SIIfTGGEMhdA7d7JePuVVxtKL7Hp+ApGDJAJ7dpo=
 github.com/go-git/gcfg/v2 v2.0.2/go.mod h1:/lv2NsxvhepuMrldsFilrgct6pxzpGdSRC13ydTLSLs=
 github.com/go-git/go-billy/v6 v6.0.0-20251126203821-7f9c95185ee0 h1:eY5aB2GXiVdgTueBcqsBt53WuJTRZAuCdIS/86Pcq5c=
 github.com/go-git/go-billy/v6 v6.0.0-20251126203821-7f9c95185ee0/go.mod h1:0NjwVNrwtVFZBReAp5OoGklGJIgJFEbVyHneAr4lc8k=
-github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd h1:Gd/f9cGi/3h1JOPaa6er+CkKUGyGX2DBJdFbDKVO+R0=
-github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd/go.mod h1:d3XQcsHu1idnquxt48kAv+h+1MUiYKLH/e7LAzjP+pI=
 github.com/go-git/go-git-fixtures/v5 v5.1.1 h1:OH8i1ojV9bWfr0ZfasfpgtUXQHQyVS8HXik/V1C099w=
 github.com/go-git/go-git-fixtures/v5 v5.1.1/go.mod h1:Altk43lx3b1ks+dVoAG2300o5WWUnktvfY3VI6bcaXU=
-github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20251229094738-4b14af179146 h1:xYfxAopYyL44ot6dMBIb1Z1njFM0ZBQ99HdIB99KxLs=
 github.com/go-git/go-git/v6 v6.0.0-20251128074608-48f817f57805 h1:jxQ3BzYeErNRvlI/4+0mpwqMzvB4g97U+ksfgvrUEbY=
 github.com/go-git/go-git/v6 v6.0.0-20251128074608-48f817f57805/go.mod h1:dIwT3uWK1ooHInyVnK2JS5VfQ3peVGYaw2QPqX7uFvs=
-github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19 h1:0lz2eJScP8v5YZQsrEw+ggWC5jNySjg4bIZo5BIh6iI=
-github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19/go.mod h1:L+Evfcs7EdTqxwv854354cb6+++7TFL3hJn3Wy4g+3w=
 github.com/go-logfmt/logfmt v0.6.1 h1:4hvbpePJKnIzH1B+8OR/JPbTx37NktoI9LE2QZBBkvE=
 github.com/go-logfmt/logfmt v0.6.1/go.mod h1:EV2pOAQoZaT1ZXZbqDl5hrymndi4SY9ED9/z6CO0XAk=
 github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/godbus/dbus/v5 v5.2.0 h1:3WexO+U+yg9T70v9FdHr9kCxYlazaAXUhx2VMkbfax8=
 github.com/godbus/dbus/v5 v5.2.0/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
-github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
-github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
 github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
@@ -129,16 +114,12 @@ github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a h1:8ZZwZWIQKC0YVMyaCkbrdeI8faTjD1QBrRAAWc1TjMI=
 github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a/go.mod h1:b3oNGuAKOQzhsCKmuLc/urEOPzgHj6fB8vl8bwTBh28=
-github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3 h1:msKaIZrrNpvofLPDzNBW3152PJBsnPZsoNNosOCS+C0=
-github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3/go.mod h1:b3oNGuAKOQzhsCKmuLc/urEOPzgHj6fB8vl8bwTBh28=
 github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
 github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
 github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
 github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
-github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
-github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -152,32 +133,22 @@ github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavM
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
 go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
 golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
-golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
-golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
 golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 h1:DHNhtq3sNNzrvduZZIiFyXWOL9IWaDPHqTnLJp+rCBY=
 golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
-golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93 h1:fQsdNF2N+/YewlRZiricy4P1iimyPKZ/xwniHj8Q2a0=
-golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93/go.mod h1:EPRbTFwzwjXj9NpYyyrvenVh9Y+GFeEvMNh7Xuz7xgU=
 golang.org/x/image v0.34.0 h1:33gCkyw9hmwbZJeZkct8XyR11yH889EQt/QH4VmXMn8=
 golang.org/x/image v0.34.0/go.mod h1:2RNFBZRB+vnwwFil8GkMdRvrJOFd1AzdZI6vOY+eJVU=
 golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
 golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
-golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
-golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
 golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
-golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
 golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
-golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q=
 golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
 golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

core/internal/clipboard/store.go

@@ -55,7 +55,7 @@ func StoreWithConfig(data []byte, mimeType string, cfg StoreConfig) error {
 		return fmt.Errorf("data too large: %d > %d", len(data), cfg.MaxEntrySize)
 	}
 
-	dbPath, err := GetDBPath()
+	dbPath, err := getDBPath()
 	if err != nil {
 		return fmt.Errorf("get db path: %w", err)
 	}
@@ -111,7 +111,7 @@ func StoreWithConfig(data []byte, mimeType string, cfg StoreConfig) error {
 	})
 }
 
-func GetDBPath() (string, error) {
+func getDBPath() (string, error) {
 	cacheDir, err := os.UserCacheDir()
 	if err != nil {
 		homeDir, err := os.UserHomeDir()
@@ -121,31 +121,12 @@ func GetDBPath() (string, error) {
 		cacheDir = filepath.Join(homeDir, ".cache")
 	}
 
-	newDir := filepath.Join(cacheDir, "DankMaterialShell", "clipboard")
+	dbDir := filepath.Join(cacheDir, "dms-clipboard")
-	newPath := filepath.Join(newDir, "db")
+	if err := os.MkdirAll(dbDir, 0700); err != nil {
-
-	if _, err := os.Stat(newPath); err == nil {
-		return newPath, nil
-	}
-
-	oldDir := filepath.Join(cacheDir, "dms-clipboard")
-	oldPath := filepath.Join(oldDir, "db")
-
-	if _, err := os.Stat(oldPath); err == nil {
-		if err := os.MkdirAll(newDir, 0700); err != nil {
-			return "", err
-		}
-		if err := os.Rename(oldPath, newPath); err != nil {
-			return "", err
-		}
-		os.Remove(oldDir)
-		return newPath, nil
-	}
-
-	if err := os.MkdirAll(newDir, 0700); err != nil {
 		return "", err
 	}
-	return newPath, nil
+
+	return filepath.Join(dbDir, "db"), nil
 }
 
 func deduplicateInTx(b *bolt.Bucket, hash uint64) error {

core/internal/colorpicker/picker.go

@@ -221,7 +221,10 @@ func (p *Picker) handleGlobal(e client.RegistryGlobalEvent) {
 
 	case client.OutputInterfaceName:
 		output := client.NewOutput(p.ctx)
-		version := min(e.Version, 4)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
 		if err := p.registry.Bind(e.Name, e.Interface, version, output); err == nil {
 			p.outputsMu.Lock()
 			p.outputs[e.Name] = &Output{
@@ -236,14 +239,20 @@ func (p *Picker) handleGlobal(e client.RegistryGlobalEvent) {
 
 	case wlr_layer_shell.ZwlrLayerShellV1InterfaceName:
 		layerShell := wlr_layer_shell.NewZwlrLayerShellV1(p.ctx)
-		version := min(e.Version, 4)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
 		if err := p.registry.Bind(e.Name, e.Interface, version, layerShell); err == nil {
 			p.layerShell = layerShell
 		}
 
 	case wlr_screencopy.ZwlrScreencopyManagerV1InterfaceName:
 		screencopy := wlr_screencopy.NewZwlrScreencopyManagerV1(p.ctx)
-		version := min(e.Version, 3)
+		version := e.Version
+		if version > 3 {
+			version = 3
+		}
 		if err := p.registry.Bind(e.Name, e.Interface, version, screencopy); err == nil {
 			p.screencopy = screencopy
 		}

core/internal/colorpicker/state.go

@@ -1157,7 +1157,7 @@ func drawGlyph(data []byte, stride, width, height, x, y int, r rune, col Color,
 		rOff, bOff = 2, 0
 	}
 
-	for row := range fontH {
+	for row := 0; row < fontH; row++ {
 		yy := y + row
 		if yy < 0 || yy >= height {
 			continue
@@ -1165,7 +1165,7 @@ func drawGlyph(data []byte, stride, width, height, x, y int, r rune, col Color,
 		rowPattern := g[row]
 		dstRowOff := yy * stride
 
-		for colIdx := range fontW {
+		for colIdx := 0; colIdx < fontW; colIdx++ {
 			if (rowPattern & (1 << (fontW - 1 - colIdx))) == 0 {
 				continue
 			}

core/internal/colorpicker/state_test.go

@@ -14,11 +14,11 @@ func TestSurfaceState_ConcurrentPointerMotion(t *testing.T) {
 	const goroutines = 50
 	const iterations = 100
 
-	for i := range goroutines {
+	for i := 0; i < goroutines; i++ {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for j := range iterations {
+			for j := 0; j < iterations; j++ {
 				s.OnPointerMotion(float64(id*10+j), float64(id*10+j))
 			}
 		}(i)
@@ -34,21 +34,21 @@ func TestSurfaceState_ConcurrentScaleAccess(t *testing.T) {
 	const goroutines = 30
 	const iterations = 100
 
-	for i := range goroutines / 2 {
+	for i := 0; i < goroutines/2; i++ {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				s.SetScale(int32(id%3 + 1))
 			}
 		}(i)
 	}
 
-	for range goroutines / 2 {
+	for i := 0; i < goroutines/2; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				scale := s.Scale()
 				assert.GreaterOrEqual(t, scale, int32(1))
 			}
@@ -65,21 +65,21 @@ func TestSurfaceState_ConcurrentLogicalSize(t *testing.T) {
 	const goroutines = 20
 	const iterations = 100
 
-	for i := range goroutines / 2 {
+	for i := 0; i < goroutines/2; i++ {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for j := range iterations {
+			for j := 0; j < iterations; j++ {
 				_ = s.OnLayerConfigure(1920+id, 1080+j)
 			}
 		}(i)
 	}
 
-	for range goroutines / 2 {
+	for i := 0; i < goroutines/2; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				w, h := s.LogicalSize()
 				_ = w
 				_ = h
@@ -97,31 +97,31 @@ func TestSurfaceState_ConcurrentIsDone(t *testing.T) {
 	const goroutines = 30
 	const iterations = 100
 
-	for range goroutines / 3 {
+	for i := 0; i < goroutines/3; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				s.OnPointerButton(0x110, 1)
 			}
 		}()
 	}
 
-	for range goroutines / 3 {
+	for i := 0; i < goroutines/3; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				s.OnKey(1, 1)
 			}
 		}()
 	}
 
-	for range goroutines / 3 {
+	for i := 0; i < goroutines/3; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				picked, cancelled := s.IsDone()
 				_ = picked
 				_ = cancelled
@@ -139,11 +139,11 @@ func TestSurfaceState_ConcurrentIsReady(t *testing.T) {
 	const goroutines = 20
 	const iterations = 100
 
-	for range goroutines {
+	for i := 0; i < goroutines; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				_ = s.IsReady()
 			}
 		}()
@@ -159,11 +159,11 @@ func TestSurfaceState_ConcurrentSwapBuffers(t *testing.T) {
 	const goroutines = 20
 	const iterations = 100
 
-	for range goroutines {
+	for i := 0; i < goroutines; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for range iterations {
+			for j := 0; j < iterations; j++ {
 				s.SwapBuffers()
 			}
 		}()

core/internal/config/deployer.go

@@ -176,7 +176,7 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal, useSystemd bo
 	}
 
 	if existingConfig != "" {
-		mergedConfig, err := cd.mergeNiriOutputSections(newConfig, existingConfig, dmsDir)
+		mergedConfig, err := cd.mergeNiriOutputSections(newConfig, existingConfig)
 		if err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to merge output sections: %v", err))
 		} else {
@@ -209,8 +209,6 @@ func (cd *ConfigDeployer) deployNiriDmsConfigs(dmsDir, terminalCommand string) e
 		{"layout.kdl", NiriLayoutConfig},
 		{"alttab.kdl", NiriAlttabConfig},
 		{"binds.kdl", strings.ReplaceAll(NiriBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
-		{"outputs.kdl", ""},
-		{"cursor.kdl", ""},
 	}
 
 	for _, cfg := range configs {
@@ -423,31 +421,24 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 	return results, nil
 }
 
-func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig, dmsDir string) (string, error) {
+// mergeNiriOutputSections extracts output sections from existing config and merges them into the new config
+func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig string) (string, error) {
+	// Regular expression to match output sections (including commented ones)
 	outputRegex := regexp.MustCompile(`(?m)^(/-)?\s*output\s+"[^"]+"\s*\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}`)
+
+	// Find all output sections in the existing config
 	existingOutputs := outputRegex.FindAllString(existingConfig, -1)
 
 	if len(existingOutputs) == 0 {
+		// No output sections to merge
 		return newConfig, nil
 	}
 
-	outputsPath := filepath.Join(dmsDir, "outputs.kdl")
+	// Remove the example output section from the new config
-	if _, err := os.Stat(outputsPath); err != nil {
-		var outputsContent strings.Builder
-		for _, output := range existingOutputs {
-			outputsContent.WriteString(output)
-			outputsContent.WriteString("\n\n")
-		}
-		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0644); err != nil {
-			cd.log(fmt.Sprintf("Warning: Failed to migrate outputs to %s: %v", outputsPath, err))
-		} else {
-			cd.log("Migrated output sections to dms/outputs.kdl")
-		}
-	}
-
 	exampleOutputRegex := regexp.MustCompile(`(?m)^/-output "eDP-2" \{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}`)
 	mergedConfig := exampleOutputRegex.ReplaceAllString(newConfig, "")
 
+	// Find where to insert the output sections (after the input section)
 	inputEndRegex := regexp.MustCompile(`(?m)^}$`)
 	inputMatches := inputEndRegex.FindAllStringIndex(newConfig, -1)
 
@@ -455,6 +446,7 @@ func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig, dms
 		return "", fmt.Errorf("could not find insertion point for output sections")
 	}
 
+	// Insert after the first closing brace (end of input section)
 	insertPos := inputMatches[0][1]
 
 	var builder strings.Builder
@@ -484,12 +476,6 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		return result, result.Error
 	}
 
-	dmsDir := filepath.Join(configDir, "dms")
-	if err := os.MkdirAll(dmsDir, 0755); err != nil {
-		result.Error = fmt.Errorf("failed to create dms directory: %w", err)
-		return result, result.Error
-	}
-
 	var existingConfig string
 	if _, err := os.Stat(result.Path); err == nil {
 		cd.log("Found existing Hyprland configuration")
@@ -529,7 +515,7 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 	}
 
 	if existingConfig != "" {
-		mergedConfig, err := cd.mergeHyprlandMonitorSections(newConfig, existingConfig, dmsDir)
+		mergedConfig, err := cd.mergeHyprlandMonitorSections(newConfig, existingConfig)
 		if err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to merge monitor sections: %v", err))
 		} else {
@@ -543,44 +529,13 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		return result, result.Error
 	}
 
-	if err := cd.deployHyprlandDmsConfigs(dmsDir, terminalCommand); err != nil {
-		result.Error = fmt.Errorf("failed to deploy dms configs: %w", err)
-		return result, result.Error
-	}
-
 	result.Deployed = true
 	cd.log("Successfully deployed Hyprland configuration")
 	return result, nil
 }
 
-func (cd *ConfigDeployer) deployHyprlandDmsConfigs(dmsDir string, terminalCommand string) error {
+// mergeHyprlandMonitorSections extracts monitor sections from existing config and merges them into the new config
-	configs := []struct {
+func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig string) (string, error) {
-		name    string
-		content string
-	}{
-		{"colors.conf", HyprColorsConfig},
-		{"layout.conf", HyprLayoutConfig},
-		{"binds.conf", strings.ReplaceAll(HyprBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
-		{"outputs.conf", ""},
-		{"cursor.conf", ""},
-	}
-
-	for _, cfg := range configs {
-		path := filepath.Join(dmsDir, cfg.name)
-		if _, err := os.Stat(path); err == nil {
-			cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
-			continue
-		}
-		if err := os.WriteFile(path, []byte(cfg.content), 0644); err != nil {
-			return fmt.Errorf("failed to write %s: %w", cfg.name, err)
-		}
-		cd.log(fmt.Sprintf("Deployed %s", cfg.name))
-	}
-
-	return nil
-}
-
-func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig, dmsDir string) (string, error) {
 	monitorRegex := regexp.MustCompile(`(?m)^#?\s*monitor\s*=.*$`)
 	existingMonitors := monitorRegex.FindAllString(existingConfig, -1)
 
@@ -588,20 +543,6 @@ func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig
 		return newConfig, nil
 	}
 
-	outputsPath := filepath.Join(dmsDir, "outputs.conf")
-	if _, err := os.Stat(outputsPath); err != nil {
-		var outputsContent strings.Builder
-		for _, monitor := range existingMonitors {
-			outputsContent.WriteString(monitor)
-			outputsContent.WriteString("\n")
-		}
-		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0644); err != nil {
-			cd.log(fmt.Sprintf("Warning: Failed to migrate monitors to %s: %v", outputsPath, err))
-		} else {
-			cd.log("Migrated monitor sections to dms/outputs.conf")
-		}
-	}
-
 	exampleMonitorRegex := regexp.MustCompile(`(?m)^# monitor = eDP-2.*$`)
 	mergedConfig := exampleMonitorRegex.ReplaceAllString(newConfig, "")
 

core/internal/config/deployer_test.go

@@ -161,8 +161,7 @@ layout {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
+			result, err := cd.mergeNiriOutputSections(tt.newConfig, tt.existingConfig)
-			result, err := cd.mergeNiriOutputSections(tt.newConfig, tt.existingConfig, tmpDir)
 
 			if tt.wantError {
 				assert.Error(t, err)
@@ -363,8 +362,7 @@ input {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
+			result, err := cd.mergeHyprlandMonitorSections(tt.newConfig, tt.existingConfig)
-			result, err := cd.mergeHyprlandMonitorSections(tt.newConfig, tt.existingConfig, tmpDir)
 
 			if tt.wantError {
 				assert.Error(t, err)
@@ -408,7 +406,7 @@ func TestHyprlandConfigDeployment(t *testing.T) {
 		content, err := os.ReadFile(result.Path)
 		require.NoError(t, err)
 		assert.Contains(t, string(content), "# MONITOR CONFIG")
-		assert.Contains(t, string(content), "source = ./dms/binds.conf")
+		assert.Contains(t, string(content), "bind = $mod, T, exec, ghostty")
 		assert.Contains(t, string(content), "exec-once = ")
 	})
 
@@ -444,7 +442,7 @@ general {
 		require.NoError(t, err)
 		assert.Contains(t, string(newContent), "monitor = DP-1, 1920x1080@144")
 		assert.Contains(t, string(newContent), "monitor = HDMI-A-1, 3840x2160@60")
-		assert.Contains(t, string(newContent), "source = ./dms/binds.conf")
+		assert.Contains(t, string(newContent), "bind = $mod, T, exec, kitty")
 		assert.NotContains(t, string(newContent), "monitor = eDP-2")
 	})
 }
@@ -461,7 +459,10 @@ func TestHyprlandConfigStructure(t *testing.T) {
 	assert.Contains(t, HyprlandConfig, "# MONITOR CONFIG")
 	assert.Contains(t, HyprlandConfig, "# STARTUP APPS")
 	assert.Contains(t, HyprlandConfig, "# INPUT CONFIG")
-	assert.Contains(t, HyprlandConfig, "source = ./dms/binds.conf")
+	assert.Contains(t, HyprlandConfig, "# KEYBINDINGS")
+	assert.Contains(t, HyprlandConfig, "bind = $mod, T, exec, {{TERMINAL_COMMAND}}")
+	assert.Contains(t, HyprlandConfig, "bind = $mod, space, exec, dms ipc call spotlight toggle")
+	assert.Contains(t, HyprlandConfig, "windowrulev2 = noborder, class:^(com\\.mitchellh\\.ghostty)$")
 }
 
 func TestGhosttyConfigStructure(t *testing.T) {

core/internal/config/dms.go

@@ -21,7 +21,7 @@ func LocateDMSConfig() (string, error) {
 		dataDirs = "/usr/local/share:/usr/share"
 	}
 
-	for dir := range strings.SplitSeq(dataDirs, ":") {
+	for _, dir := range strings.Split(dataDirs, ":") {
 		if dir != "" {
 			primaryPaths = append(primaryPaths, filepath.Join(dir, "quickshell", "dms"))
 		}
@@ -33,7 +33,7 @@ func LocateDMSConfig() (string, error) {
 		configDirs = "/etc/xdg"
 	}
 
-	for dir := range strings.SplitSeq(configDirs, ":") {
+	for _, dir := range strings.Split(configDirs, ":") {
 		if dir != "" {
 			primaryPaths = append(primaryPaths, filepath.Join(dir, "quickshell", "dms"))
 		}

core/internal/config/embedded/hypr-binds.conf

@@ -1,156 +0,0 @@
-# === Application Launchers ===
-bind = SUPER, T, exec, {{TERMINAL_COMMAND}}
-bind = SUPER, space, exec, dms ipc call spotlight toggle
-bind = SUPER, V, exec, dms ipc call clipboard toggle
-bind = SUPER, M, exec, dms ipc call processlist focusOrToggle
-bind = SUPER, comma, exec, dms ipc call settings focusOrToggle
-bind = SUPER, N, exec, dms ipc call notifications toggle
-bind = SUPER SHIFT, N, exec, dms ipc call notepad toggle
-bind = SUPER, Y, exec, dms ipc call dankdash wallpaper
-bind = SUPER, TAB, exec, dms ipc call hypr toggleOverview
-bind = SUPER, X, exec, dms ipc call powermenu toggle
-
-# === Cheat sheet
-bind = SUPER SHIFT, Slash, exec, dms ipc call keybinds toggle hyprland
-
-# === Security ===
-bind = SUPER ALT, L, exec, dms ipc call lock lock
-bind = SUPER SHIFT, E, exit
-bind = CTRL ALT, Delete, exec, dms ipc call processlist focusOrToggle
-
-# === Audio Controls ===
-bindel = , XF86AudioRaiseVolume, exec, dms ipc call audio increment 3
-bindel = , XF86AudioLowerVolume, exec, dms ipc call audio decrement 3
-bindl = , XF86AudioMute, exec, dms ipc call audio mute
-bindl = , XF86AudioMicMute, exec, dms ipc call audio micmute
-bindl = , XF86AudioPause, exec, dms ipc call mpris playPause
-bindl = , XF86AudioPlay, exec, dms ipc call mpris playPause
-bindl = , XF86AudioPrev, exec, dms ipc call mpris previous
-bindl = , XF86AudioNext, exec, dms ipc call mpris next
-
-# === Brightness Controls ===
-bindel = , XF86MonBrightnessUp, exec, dms ipc call brightness increment 5 ""
-bindel = , XF86MonBrightnessDown, exec, dms ipc call brightness decrement 5 ""
-
-# === Window Management ===
-bind = SUPER, Q, killactive
-bind = SUPER, F, fullscreen, 1
-bind = SUPER SHIFT, F, fullscreen, 0
-bind = SUPER SHIFT, T, togglefloating
-bind = SUPER, W, togglegroup
-
-# === Focus Navigation ===
-bind = SUPER, left, movefocus, l
-bind = SUPER, down, movefocus, d
-bind = SUPER, up, movefocus, u
-bind = SUPER, right, movefocus, r
-bind = SUPER, H, movefocus, l
-bind = SUPER, J, movefocus, d
-bind = SUPER, K, movefocus, u
-bind = SUPER, L, movefocus, r
-
-# === Window Movement ===
-bind = SUPER SHIFT, left, movewindow, l
-bind = SUPER SHIFT, down, movewindow, d
-bind = SUPER SHIFT, up, movewindow, u
-bind = SUPER SHIFT, right, movewindow, r
-bind = SUPER SHIFT, H, movewindow, l
-bind = SUPER SHIFT, J, movewindow, d
-bind = SUPER SHIFT, K, movewindow, u
-bind = SUPER SHIFT, L, movewindow, r
-
-# === Column Navigation ===
-bind = SUPER, Home, focuswindow, first
-bind = SUPER, End, focuswindow, last
-
-# === Monitor Navigation ===
-bind = SUPER CTRL, left, focusmonitor, l
-bind = SUPER CTRL, right, focusmonitor, r
-bind = SUPER CTRL, H, focusmonitor, l
-bind = SUPER CTRL, J, focusmonitor, d
-bind = SUPER CTRL, K, focusmonitor, u
-bind = SUPER CTRL, L, focusmonitor, r
-
-# === Move to Monitor ===
-bind = SUPER SHIFT CTRL, left, movewindow, mon:l
-bind = SUPER SHIFT CTRL, down, movewindow, mon:d
-bind = SUPER SHIFT CTRL, up, movewindow, mon:u
-bind = SUPER SHIFT CTRL, right, movewindow, mon:r
-bind = SUPER SHIFT CTRL, H, movewindow, mon:l
-bind = SUPER SHIFT CTRL, J, movewindow, mon:d
-bind = SUPER SHIFT CTRL, K, movewindow, mon:u
-bind = SUPER SHIFT CTRL, L, movewindow, mon:r
-
-# === Workspace Navigation ===
-bind = SUPER, Page_Down, workspace, e+1
-bind = SUPER, Page_Up, workspace, e-1
-bind = SUPER, U, workspace, e+1
-bind = SUPER, I, workspace, e-1
-bind = SUPER CTRL, down, movetoworkspace, e+1
-bind = SUPER CTRL, up, movetoworkspace, e-1
-bind = SUPER CTRL, U, movetoworkspace, e+1
-bind = SUPER CTRL, I, movetoworkspace, e-1
-
-# === Move Workspaces ===
-bind = SUPER SHIFT, Page_Down, movetoworkspace, e+1
-bind = SUPER SHIFT, Page_Up, movetoworkspace, e-1
-bind = SUPER SHIFT, U, movetoworkspace, e+1
-bind = SUPER SHIFT, I, movetoworkspace, e-1
-
-# === Mouse Wheel Navigation ===
-bind = SUPER, mouse_down, workspace, e+1
-bind = SUPER, mouse_up, workspace, e-1
-bind = SUPER CTRL, mouse_down, movetoworkspace, e+1
-bind = SUPER CTRL, mouse_up, movetoworkspace, e-1
-
-# === Numbered Workspaces ===
-bind = SUPER, 1, workspace, 1
-bind = SUPER, 2, workspace, 2
-bind = SUPER, 3, workspace, 3
-bind = SUPER, 4, workspace, 4
-bind = SUPER, 5, workspace, 5
-bind = SUPER, 6, workspace, 6
-bind = SUPER, 7, workspace, 7
-bind = SUPER, 8, workspace, 8
-bind = SUPER, 9, workspace, 9
-
-# === Move to Numbered Workspaces ===
-bind = SUPER SHIFT, 1, movetoworkspace, 1
-bind = SUPER SHIFT, 2, movetoworkspace, 2
-bind = SUPER SHIFT, 3, movetoworkspace, 3
-bind = SUPER SHIFT, 4, movetoworkspace, 4
-bind = SUPER SHIFT, 5, movetoworkspace, 5
-bind = SUPER SHIFT, 6, movetoworkspace, 6
-bind = SUPER SHIFT, 7, movetoworkspace, 7
-bind = SUPER SHIFT, 8, movetoworkspace, 8
-bind = SUPER SHIFT, 9, movetoworkspace, 9
-
-# === Column Management ===
-bind = SUPER, bracketleft, layoutmsg, preselect l
-bind = SUPER, bracketright, layoutmsg, preselect r
-
-# === Sizing & Layout ===
-bind = SUPER, R, layoutmsg, togglesplit
-bind = SUPER CTRL, F, resizeactive, exact 100%
-
-# === Move/resize windows with mainMod + LMB/RMB and dragging ===
-bindmd = SUPER, mouse:272, Move window, movewindow
-bindmd = SUPER, mouse:273, Resize window, resizewindow
-
-# === Move/resize windows with mainMod + LMB/RMB and dragging ===
-bindd = SUPER, code:20, Expand window left, resizeactive, -100 0
-bindd = SUPER, code:21, Shrink window left, resizeactive, 100 0
-
-# === Manual Sizing ===
-binde = SUPER, minus, resizeactive, -10% 0
-binde = SUPER, equal, resizeactive, 10% 0
-binde = SUPER SHIFT, minus, resizeactive, 0 -10%
-binde = SUPER SHIFT, equal, resizeactive, 0 10%
-
-# === Screenshots ===
-bind = , Print, exec, dms screenshot
-bind = CTRL, Print, exec, dms screenshot full
-bind = ALT, Print, exec, dms screenshot window
-
-# === System Controls ===
-bind = SUPER SHIFT, P, dpms, toggle

core/internal/config/embedded/hypr-colors.conf

@@ -1,25 +0,0 @@
-# ! Auto-generated file. Do not edit directly.
-# Remove source = ./dms/colors.conf from your config to override.
-
-$primary  = rgb(d0bcff)
-$outline  = rgb(948f99)
-$error    = rgb(f2b8b5)
-
-general {
-  col.active_border   = $primary
-  col.inactive_border = $outline
-}
-
-group {
-  col.border_active   = $primary
-  col.border_inactive = $outline
-  col.border_locked_active   = $error
-  col.border_locked_inactive = $outline
-
-  groupbar {
-    col.active         = $primary
-    col.inactive       = $outline
-    col.locked_active   = $error
-    col.locked_inactive = $outline
-  }
-}

core/internal/config/embedded/hypr-layout.conf

@@ -1,11 +0,0 @@
-# Auto-generated by DMS - do not edit manually
-
-general {
-    gaps_in = 4
-    gaps_out = 4
-    border_size = 2
-}
-
-decoration {
-    rounding = 12
-}

core/internal/config/embedded/hyprland.conf

@@ -27,7 +27,10 @@ input {
 general {
     gaps_in = 5
     gaps_out = 5
-    border_size = 2
+    border_size = 0  # off in niri
+
+    col.active_border = rgba(707070ff)
+    col.inactive_border = rgba(d0d0d0ff)
 
     layout = dwindle
 }
@@ -39,7 +42,7 @@ decoration {
     rounding = 12
 
     active_opacity = 1.0
-    inactive_opacity = 1.0
+    inactive_opacity = 0.9
 
     shadow {
         enabled = true
@@ -87,32 +90,190 @@ misc {
 # ==================
 # WINDOW RULES
 # ==================
-windowrule = tile on, match:class ^(org\.wezfurlong\.wezterm)$
+windowrulev2 = tile, class:^(org\.wezfurlong\.wezterm)$
 
-windowrule = rounding 12, match:class ^(org\.gnome\.)
+windowrulev2 = rounding 12, class:^(org\.gnome\.)
+windowrulev2 = noborder, class:^(org\.gnome\.)
 
-windowrule = tile on, match:class ^(gnome-control-center)$
+windowrulev2 = tile, class:^(gnome-control-center)$
-windowrule = tile on, match:class ^(pavucontrol)$
+windowrulev2 = tile, class:^(pavucontrol)$
-windowrule = tile on, match:class ^(nm-connection-editor)$
+windowrulev2 = tile, class:^(nm-connection-editor)$
 
-windowrule = float on, match:class ^(gnome-calculator)$
+windowrulev2 = float, class:^(gnome-calculator)$
-windowrule = float on, match:class ^(galculator)$
+windowrulev2 = float, class:^(galculator)$
-windowrule = float on, match:class ^(blueman-manager)$
+windowrulev2 = float, class:^(blueman-manager)$
-windowrule = float on, match:class ^(org\.gnome\.Nautilus)$
+windowrulev2 = float, class:^(org\.gnome\.Nautilus)$
-windowrule = float on, match:class ^(steam)$
+windowrulev2 = float, class:^(steam)$
-windowrule = float on, match:class ^(xdg-desktop-portal)$
+windowrulev2 = float, class:^(xdg-desktop-portal)$
 
-windowrule = float on, match:class ^(firefox)$, match:title ^(Picture-in-Picture)$
+windowrulev2 = noborder, class:^(org\.wezfurlong\.wezterm)$
-windowrule = float on, match:class ^(zoom)$
+windowrulev2 = noborder, class:^(Alacritty)$
+windowrulev2 = noborder, class:^(zen)$
+windowrulev2 = noborder, class:^(com\.mitchellh\.ghostty)$
+windowrulev2 = noborder, class:^(kitty)$
+
+windowrulev2 = float, class:^(firefox)$, title:^(Picture-in-Picture)$
+windowrulev2 = float, class:^(zoom)$
 
 # DMS windows floating by default
-# ! Hyprland doesn't size these windows correctly so disabling by default here
+windowrulev2 = float, class:^(org.quickshell)$
-# windowrule = float on, match:class ^(org.quickshell)$
+windowrulev2 = opacity 0.9 0.9, floating:0, focus:0
 
-layerrule = no_anim on, match:namespace ^(quickshell)$
+layerrule = noanim, ^(quickshell)$
 
-source = ./dms/colors.conf
+# ==================
-source = ./dms/outputs.conf
+# KEYBINDINGS
-source = ./dms/layout.conf
+# ==================
-source = ./dms/cursor.conf
+$mod = SUPER
-source = ./dms/binds.conf
+
+# === Application Launchers ===
+bind = $mod, T, exec, {{TERMINAL_COMMAND}}
+bind = $mod, space, exec, dms ipc call spotlight toggle
+bind = $mod, V, exec, dms ipc call clipboard toggle
+bind = $mod, M, exec, dms ipc call processlist focusOrToggle
+bind = $mod, comma, exec, dms ipc call settings focusOrToggle
+bind = $mod, N, exec, dms ipc call notifications toggle
+bind = $mod SHIFT, N, exec, dms ipc call notepad toggle
+bind = $mod, Y, exec, dms ipc call dankdash wallpaper
+bind = $mod, TAB, exec, dms ipc call hypr toggleOverview
+
+# === Cheat sheet
+bind = $mod SHIFT, Slash, exec, dms ipc call keybinds toggle hyprland
+
+# === Security ===
+bind = $mod ALT, L, exec, dms ipc call lock lock
+bind = $mod SHIFT, E, exit
+bind = CTRL ALT, Delete, exec, dms ipc call processlist focusOrToggle
+
+# === Audio Controls ===
+bindel = , XF86AudioRaiseVolume, exec, dms ipc call audio increment 3
+bindel = , XF86AudioLowerVolume, exec, dms ipc call audio decrement 3
+bindl = , XF86AudioMute, exec, dms ipc call audio mute
+bindl = , XF86AudioMicMute, exec, dms ipc call audio micmute
+
+# === Brightness Controls ===
+bindel = , XF86MonBrightnessUp, exec, dms ipc call brightness increment 5 ""
+bindel = , XF86MonBrightnessDown, exec, dms ipc call brightness decrement 5 ""
+
+# === Window Management ===
+bind = $mod, Q, killactive
+bind = $mod, F, fullscreen, 1
+bind = $mod SHIFT, F, fullscreen, 0
+bind = $mod SHIFT, T, togglefloating
+bind = $mod, W, togglegroup
+
+# === Focus Navigation ===
+bind = $mod, left, movefocus, l
+bind = $mod, down, movefocus, d
+bind = $mod, up, movefocus, u
+bind = $mod, right, movefocus, r
+bind = $mod, H, movefocus, l
+bind = $mod, J, movefocus, d
+bind = $mod, K, movefocus, u
+bind = $mod, L, movefocus, r
+
+# === Window Movement ===
+bind = $mod SHIFT, left, movewindow, l
+bind = $mod SHIFT, down, movewindow, d
+bind = $mod SHIFT, up, movewindow, u
+bind = $mod SHIFT, right, movewindow, r
+bind = $mod SHIFT, H, movewindow, l
+bind = $mod SHIFT, J, movewindow, d
+bind = $mod SHIFT, K, movewindow, u
+bind = $mod SHIFT, L, movewindow, r
+
+# === Column Navigation ===
+bind = $mod, Home, focuswindow, first
+bind = $mod, End, focuswindow, last
+
+# === Monitor Navigation ===
+bind = $mod CTRL, left, focusmonitor, l
+bind = $mod CTRL, right, focusmonitor, r
+bind = $mod CTRL, H, focusmonitor, l
+bind = $mod CTRL, J, focusmonitor, d
+bind = $mod CTRL, K, focusmonitor, u
+bind = $mod CTRL, L, focusmonitor, r
+
+# === Move to Monitor ===
+bind = $mod SHIFT CTRL, left, movewindow, mon:l
+bind = $mod SHIFT CTRL, down, movewindow, mon:d
+bind = $mod SHIFT CTRL, up, movewindow, mon:u
+bind = $mod SHIFT CTRL, right, movewindow, mon:r
+bind = $mod SHIFT CTRL, H, movewindow, mon:l
+bind = $mod SHIFT CTRL, J, movewindow, mon:d
+bind = $mod SHIFT CTRL, K, movewindow, mon:u
+bind = $mod SHIFT CTRL, L, movewindow, mon:r
+
+# === Workspace Navigation ===
+bind = $mod, Page_Down, workspace, e+1
+bind = $mod, Page_Up, workspace, e-1
+bind = $mod, U, workspace, e+1
+bind = $mod, I, workspace, e-1
+bind = $mod CTRL, down, movetoworkspace, e+1
+bind = $mod CTRL, up, movetoworkspace, e-1
+bind = $mod CTRL, U, movetoworkspace, e+1
+bind = $mod CTRL, I, movetoworkspace, e-1
+
+# === Move Workspaces ===
+bind = $mod SHIFT, Page_Down, movetoworkspace, e+1
+bind = $mod SHIFT, Page_Up, movetoworkspace, e-1
+bind = $mod SHIFT, U, movetoworkspace, e+1
+bind = $mod SHIFT, I, movetoworkspace, e-1
+
+# === Mouse Wheel Navigation ===
+bind = $mod, mouse_down, workspace, e+1
+bind = $mod, mouse_up, workspace, e-1
+bind = $mod CTRL, mouse_down, movetoworkspace, e+1
+bind = $mod CTRL, mouse_up, movetoworkspace, e-1
+
+# === Numbered Workspaces ===
+bind = $mod, 1, workspace, 1
+bind = $mod, 2, workspace, 2
+bind = $mod, 3, workspace, 3
+bind = $mod, 4, workspace, 4
+bind = $mod, 5, workspace, 5
+bind = $mod, 6, workspace, 6
+bind = $mod, 7, workspace, 7
+bind = $mod, 8, workspace, 8
+bind = $mod, 9, workspace, 9
+
+# === Move to Numbered Workspaces ===
+bind = $mod SHIFT, 1, movetoworkspace, 1
+bind = $mod SHIFT, 2, movetoworkspace, 2
+bind = $mod SHIFT, 3, movetoworkspace, 3
+bind = $mod SHIFT, 4, movetoworkspace, 4
+bind = $mod SHIFT, 5, movetoworkspace, 5
+bind = $mod SHIFT, 6, movetoworkspace, 6
+bind = $mod SHIFT, 7, movetoworkspace, 7
+bind = $mod SHIFT, 8, movetoworkspace, 8
+bind = $mod SHIFT, 9, movetoworkspace, 9
+
+# === Column Management ===
+bind = $mod, bracketleft, layoutmsg, preselect l
+bind = $mod, bracketright, layoutmsg, preselect r
+
+# === Sizing & Layout ===
+bind = $mod, R, layoutmsg, togglesplit
+bind = $mod CTRL, F, resizeactive, exact 100%
+
+# === Move/resize windows with mainMod + LMB/RMB and dragging ===
+bindmd = $mod, mouse:272, Move window, movewindow
+bindmd = $mod, mouse:273, Resize window, resizewindow
+
+# === Move/resize windows with mainMod + LMB/RMB and dragging ===
+bindd = $mod, code:20, Expand window left, resizeactive, -100 0
+bindd = $mod, code:21, Shrink window left, resizeactive, 100 0
+
+# === Manual Sizing ===
+binde = $mod, minus, resizeactive, -10% 0
+binde = $mod, equal, resizeactive, 10% 0
+binde = $mod SHIFT, minus, resizeactive, 0 -10%
+binde = $mod SHIFT, equal, resizeactive, 0 10%
+
+# === Screenshots ===
+bind = , Print, exec, dms screenshot
+bind = CTRL, Print, exec, dms screenshot full
+bind = ALT, Print, exec, dms screenshot window
+
+# === System Controls ===
+bind = $mod SHIFT, P, dpms, toggle

core/internal/config/embedded/niri-binds.kdl

@@ -1,3 +1,8 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
 binds {
     // === System & Overview ===
     Mod+D repeat=false { toggle-overview; }
@@ -15,8 +20,6 @@ binds {
     Mod+M hotkey-overlay-title="Task Manager" {
         spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
     }
-
-    Super+X hotkey-overlay-title="Power Menu: Toggle" { spawn "dms" "ipc" "call" "powermenu" "toggle"; }
     Mod+Comma hotkey-overlay-title="Settings" {
         spawn "dms" "ipc" "call" "settings" "focusOrToggle";
     }
@@ -48,18 +51,6 @@ binds {
     XF86AudioMicMute allow-when-locked=true {
         spawn "dms" "ipc" "call" "audio" "micmute";
     }
-		XF86AudioPause allow-when-locked=true {
-		    spawn "dms" "ipc" "call" "mpris" "playPause";
-		}
-		XF86AudioPlay allow-when-locked=true {
-		    spawn "dms" "ipc" "call" "mpris" "playPause";
-		}
-		XF86AudioPrev allow-when-locked=true {
-		    spawn "dms" "ipc" "call" "mpris" "previous";
-		}
-		XF86AudioNext allow-when-locked=true {
-		    spawn "dms" "ipc" "call" "mpris" "next";
-		}
 
     // === Brightness Controls ===
     XF86MonBrightnessUp allow-when-locked=true {

core/internal/config/embedded/niri-colors.kdl

@@ -1,19 +1,21 @@
-// ! Auto-generated file. Do not edit directly.
+// ! DO NOT EDIT !
-// Remove `include "dms/colors.kdl"` from your config to override.
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
 
 layout {
     background-color "transparent"
 
     focus-ring {
-        active-color   "#d0bcff"
+        active-color   "#9dcbfb"
-        inactive-color "#948f99"
+        inactive-color "#8c9199"
-        urgent-color   "#f2b8b5"
+        urgent-color   "#ffb4ab"
     }
 
     border {
-        active-color   "#d0bcff"
+        active-color   "#9dcbfb"
-        inactive-color "#948f99"
+        inactive-color "#8c9199"
-        urgent-color   "#f2b8b5"
+        urgent-color   "#ffb4ab"
     }
 
     shadow {
@@ -21,19 +23,19 @@ layout {
     }
 
     tab-indicator {
-        active-color   "#d0bcff"
+        active-color   "#9dcbfb"
-        inactive-color "#948f99"
+        inactive-color "#8c9199"
-        urgent-color   "#f2b8b5"
+        urgent-color   "#ffb4ab"
     }
 
     insert-hint {
-        color "#d0bcff80"
+        color "#9dcbfb80"
     }
 }
 
 recent-windows {
     highlight {
-        active-color   "#4f378b"
+        active-color   "#124a73"
-        urgent-color   "#f2b8b5"
+        urgent-color   "#ffb4ab"
     }
 }

core/internal/config/embedded/niri.kdl

@@ -240,6 +240,10 @@ window-rule {
     match app-id="kitty"
     draw-border-with-background false
 }
+window-rule {
+    match is-active=false
+    opacity 0.9
+}
 window-rule {
     match app-id=r#"firefox$"# title="^Picture-in-Picture$"
     match app-id="zoom"
@@ -269,5 +273,3 @@ include "dms/colors.kdl"
 include "dms/layout.kdl"
 include "dms/alttab.kdl"
 include "dms/binds.kdl"
-include "dms/outputs.kdl"
-include "dms/cursor.kdl"

core/internal/config/hyprland.go

@@ -4,12 +4,3 @@ import _ "embed"
 
 //go:embed embedded/hyprland.conf
 var HyprlandConfig string
-
-//go:embed embedded/hypr-colors.conf
-var HyprColorsConfig string
-
-//go:embed embedded/hypr-layout.conf
-var HyprLayoutConfig string
-
-//go:embed embedded/hypr-binds.conf
-var HyprBindsConfig string

core/internal/dank16/dank16.go

@@ -345,7 +345,7 @@ func EnsureContrastDPSLstar(hexColor, hexBg string, minLc float64, isLightMode b
 	}
 
 	step := 0.5
-	for range 120 {
+	for i := 0; i < 120; i++ {
 		Lf = math.Max(0, math.Min(100, Lf+dir*step))
 		cand := labToHex(Lf, af, bf)
 		if DeltaPhiStarContrast(cand, hexBg, isLightMode) >= minLc {

core/internal/dank16/dank16_test.go

@@ -658,7 +658,7 @@ func TestContrastAlgorithmComparison(t *testing.T) {
 	}
 
 	differentCount := 0
-	for i := range 16 {
+	for i := 0; i < 16; i++ {
 		if wcagColors[i].Hex != dpsColors[i].Hex {
 			differentCount++
 		}

core/internal/distros/arch.go

@@ -7,7 +7,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
@@ -515,9 +514,12 @@ func (a *ArchDistribution) reorderAURPackages(packages []string) []string {
 			dmsShell = append(dmsShell, pkg)
 		} else {
 			isDep := false
-			if slices.Contains(dmsDepencies, pkg) {
+			for _, dep := range dmsDepencies {
-				deps = append(deps, pkg)
+				if pkg == dep {
-				isDep = true
+					deps = append(deps, pkg)
+					isDep = true
+					break
+				}
 			}
 			if !isDep {
 				others = append(others, pkg)
@@ -543,7 +545,7 @@ func (a *ArchDistribution) installSingleAURPackage(ctx context.Context, pkg, sud
 		a.log(fmt.Sprintf("Warning: failed to clean existing cache for %s: %v", pkg, err))
 	}
 
-	if err := os.MkdirAll(buildDir, 0o755); err != nil {
+	if err := os.MkdirAll(buildDir, 0755); err != nil {
 		return fmt.Errorf("failed to create build directory: %w", err)
 	}
 	defer func() {

core/internal/distros/fedora.go

@@ -153,7 +153,7 @@ func (f *FedoraDistribution) getDmsMapping(variant deps.PackageVariant) PackageM
 }
 
 func (f *FedoraDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
-	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "sdegler/hyprland"}
+	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "solopasha/hyprland"}
 }
 
 func (f *FedoraDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {

core/internal/distros/manual_packages.go

@@ -18,8 +18,8 @@ type ManualPackageInstaller struct {
 
 // parseLatestTagFromGitOutput parses git ls-remote output and returns the latest tag
 func (m *ManualPackageInstaller) parseLatestTagFromGitOutput(output string) string {
-	lines := strings.SplitSeq(output, "\n")
+	lines := strings.Split(output, "\n")
-	for line := range lines {
+	for _, line := range lines {
 		if strings.Contains(line, "refs/tags/") && !strings.Contains(line, "^{}") {
 			parts := strings.Split(line, "refs/tags/")
 			if len(parts) > 1 {
@@ -103,12 +103,12 @@ func (m *ManualPackageInstaller) installDgop(ctx context.Context, sudoPassword s
 	}
 
 	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "dgop-build")
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -160,10 +160,10 @@ func (m *ManualPackageInstaller) installNiri(ctx context.Context, sudoPassword s
 	homeDir, _ := os.UserHomeDir()
 	buildDir := filepath.Join(homeDir, ".cache", "dankinstall", "niri-build")
 	tmpDir := filepath.Join(homeDir, ".cache", "dankinstall", "tmp")
-	if err := os.MkdirAll(buildDir, 0o755); err != nil {
+	if err := os.MkdirAll(buildDir, 0755); err != nil {
 		return fmt.Errorf("failed to create build directory: %w", err)
 	}
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer func() {
@@ -237,12 +237,12 @@ func (m *ManualPackageInstaller) installQuickshell(ctx context.Context, variant
 	}
 
 	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "quickshell-build")
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -273,7 +273,7 @@ func (m *ManualPackageInstaller) installQuickshell(ctx context.Context, variant
 	}
 
 	buildDir := tmpDir + "/build"
-	if err := os.MkdirAll(buildDir, 0o755); err != nil {
+	if err := os.MkdirAll(buildDir, 0755); err != nil {
 		return fmt.Errorf("failed to create build directory: %w", err)
 	}
 
@@ -343,12 +343,12 @@ func (m *ManualPackageInstaller) installHyprland(ctx context.Context, sudoPasswo
 	}
 
 	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "hyprland-build")
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -406,12 +406,12 @@ func (m *ManualPackageInstaller) installGhostty(ctx context.Context, sudoPasswor
 	}
 
 	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "ghostty-build")
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -528,7 +528,7 @@ func (m *ManualPackageInstaller) installDankMaterialShell(ctx context.Context, v
 		}
 
 		configDir := filepath.Dir(dmsPath)
-		if err := os.MkdirAll(configDir, 0o755); err != nil {
+		if err := os.MkdirAll(configDir, 0755); err != nil {
 			return fmt.Errorf("failed to create quickshell config directory: %w", err)
 		}
 

core/internal/distros/opensuse.go

@@ -108,6 +108,7 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 	packages := map[string]PackageMapping{
 		// Standard zypper packages
 		"git":                    {Name: "git", Repository: RepoTypeSystem},
+		"ghostty":                {Name: "ghostty", Repository: RepoTypeSystem},
 		"kitty":                  {Name: "kitty", Repository: RepoTypeSystem},
 		"alacritty":              {Name: "alacritty", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
@@ -116,7 +117,6 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 		// DMS packages from OBS
 		"dms (DankMaterialShell)": o.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"quickshell":              o.getQuickshellMapping(variants["quickshell"]),
-		"ghostty":                 {Name: "ghostty", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 	}

core/internal/keybinds/discovery.go

@@ -23,7 +23,7 @@ func DefaultDiscoveryConfig() *DiscoveryConfig {
 
 	configDirs := os.Getenv("XDG_CONFIG_DIRS")
 	if configDirs != "" {
-		for dir := range strings.SplitSeq(configDirs, ":") {
+		for _, dir := range strings.Split(configDirs, ":") {
 			if dir != "" {
 				searchPaths = append(searchPaths, filepath.Join(dir, "DankMaterialShell", "cheatsheets"))
 			}

core/internal/keybinds/providers/hyprland.go

@@ -2,93 +2,45 @@ package providers
 
 import (
 	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type HyprlandProvider struct {
-	configPath       string
+	configPath string
-	dmsBindsIncluded bool
-	parsed           bool
 }
 
 func NewHyprlandProvider(configPath string) *HyprlandProvider {
 	if configPath == "" {
-		configPath = defaultHyprlandConfigDir()
+		configPath = "$HOME/.config/hypr"
 	}
 	return &HyprlandProvider{
 		configPath: configPath,
 	}
 }
 
-func defaultHyprlandConfigDir() string {
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(configDir, "hypr")
-}
-
 func (h *HyprlandProvider) Name() string {
 	return "hyprland"
 }
 
 func (h *HyprlandProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
-	result, err := ParseHyprlandKeysWithDMS(h.configPath)
+	section, err := ParseHyprlandKeys(h.configPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse hyprland config: %w", err)
 	}
 
-	h.dmsBindsIncluded = result.DMSBindsIncluded
-	h.parsed = true
-
 	categorizedBinds := make(map[string][]keybinds.Keybind)
-	h.convertSection(result.Section, "", categorizedBinds, result.ConflictingConfigs)
+	h.convertSection(section, "", categorizedBinds)
 
-	sheet := &keybinds.CheatSheet{
+	return &keybinds.CheatSheet{
-		Title:            "Hyprland Keybinds",
+		Title:    "Hyprland Keybinds",
-		Provider:         h.Name(),
+		Provider: h.Name(),
-		Binds:            categorizedBinds,
+		Binds:    categorizedBinds,
-		DMSBindsIncluded: result.DMSBindsIncluded,
+	}, nil
-	}
-
-	if result.DMSStatus != nil {
-		sheet.DMSStatus = &keybinds.DMSBindsStatus{
-			Exists:          result.DMSStatus.Exists,
-			Included:        result.DMSStatus.Included,
-			IncludePosition: result.DMSStatus.IncludePosition,
-			TotalIncludes:   result.DMSStatus.TotalIncludes,
-			BindsAfterDMS:   result.DMSStatus.BindsAfterDMS,
-			Effective:       result.DMSStatus.Effective,
-			OverriddenBy:    result.DMSStatus.OverriddenBy,
-			StatusMessage:   result.DMSStatus.StatusMessage,
-		}
-	}
-
-	return sheet, nil
 }
 
-func (h *HyprlandProvider) HasDMSBindsIncluded() bool {
+func (h *HyprlandProvider) convertSection(section *HyprlandSection, subcategory string, categorizedBinds map[string][]keybinds.Keybind) {
-	if h.parsed {
-		return h.dmsBindsIncluded
-	}
-
-	result, err := ParseHyprlandKeysWithDMS(h.configPath)
-	if err != nil {
-		return false
-	}
-
-	h.dmsBindsIncluded = result.DMSBindsIncluded
-	h.parsed = true
-	return h.dmsBindsIncluded
-}
-
-func (h *HyprlandProvider) convertSection(section *HyprlandSection, subcategory string, categorizedBinds map[string][]keybinds.Keybind, conflicts map[string]*HyprlandKeyBinding) {
 	currentSubcat := subcategory
 	if section.Name != "" {
 		currentSubcat = section.Name
@@ -96,12 +48,12 @@ func (h *HyprlandProvider) convertSection(section *HyprlandSection, subcategory
 
 	for _, kb := range section.Keybinds {
 		category := h.categorizeByDispatcher(kb.Dispatcher)
-		bind := h.convertKeybind(&kb, currentSubcat, conflicts)
+		bind := h.convertKeybind(&kb, currentSubcat)
 		categorizedBinds[category] = append(categorizedBinds[category], bind)
 	}
 
 	for _, child := range section.Children {
-		h.convertSection(&child, currentSubcat, categorizedBinds, conflicts)
+		h.convertSection(&child, currentSubcat, categorizedBinds)
 	}
 }
 
@@ -133,8 +85,8 @@ func (h *HyprlandProvider) categorizeByDispatcher(dispatcher string) string {
 	}
 }
 
-func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory string, conflicts map[string]*HyprlandKeyBinding) keybinds.Keybind {
+func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory string) keybinds.Keybind {
-	keyStr := h.formatKey(kb)
+	key := h.formatKey(kb)
 	rawAction := h.formatRawAction(kb.Dispatcher, kb.Params)
 	desc := kb.Comment
 
@@ -142,33 +94,12 @@ func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory st
 		desc = rawAction
 	}
 
-	source := "config"
+	return keybinds.Keybind{
-	if strings.Contains(kb.Source, "dms/binds.conf") {
+		Key:         key,
-		source = "dms"
-	}
-
-	bind := keybinds.Keybind{
-		Key:         keyStr,
 		Description: desc,
 		Action:      rawAction,
 		Subcategory: subcategory,
-		Source:      source,
-		Flags:       kb.Flags,
 	}
-
-	if source == "dms" && conflicts != nil {
-		normalizedKey := strings.ToLower(keyStr)
-		if conflictKb, ok := conflicts[normalizedKey]; ok {
-			bind.Conflict = &keybinds.Keybind{
-				Key:         keyStr,
-				Description: conflictKb.Comment,
-				Action:      h.formatRawAction(conflictKb.Dispatcher, conflictKb.Params),
-				Source:      "config",
-			}
-		}
-	}
-
-	return bind
 }
 
 func (h *HyprlandProvider) formatRawAction(dispatcher, params string) string {
@@ -184,314 +115,3 @@ func (h *HyprlandProvider) formatKey(kb *HyprlandKeyBinding) string {
 	parts = append(parts, kb.Key)
 	return strings.Join(parts, "+")
 }
-
-func (h *HyprlandProvider) GetOverridePath() string {
-	expanded, err := utils.ExpandPath(h.configPath)
-	if err != nil {
-		return filepath.Join(h.configPath, "dms", "binds.conf")
-	}
-	return filepath.Join(expanded, "dms", "binds.conf")
-}
-
-func (h *HyprlandProvider) validateAction(action string) error {
-	action = strings.TrimSpace(action)
-	switch {
-	case action == "":
-		return fmt.Errorf("action cannot be empty")
-	case action == "exec" || action == "exec ":
-		return fmt.Errorf("exec dispatcher requires arguments")
-	case strings.HasPrefix(action, "exec "):
-		rest := strings.TrimSpace(strings.TrimPrefix(action, "exec "))
-		if rest == "" {
-			return fmt.Errorf("exec dispatcher requires arguments")
-		}
-	}
-	return nil
-}
-
-func (h *HyprlandProvider) SetBind(key, action, description string, options map[string]any) error {
-	if err := h.validateAction(action); err != nil {
-		return err
-	}
-
-	overridePath := h.GetOverridePath()
-
-	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
-		return fmt.Errorf("failed to create dms directory: %w", err)
-	}
-
-	existingBinds, err := h.loadOverrideBinds()
-	if err != nil {
-		existingBinds = make(map[string]*hyprlandOverrideBind)
-	}
-
-	// Extract flags from options
-	var flags string
-	if options != nil {
-		if f, ok := options["flags"].(string); ok {
-			flags = f
-		}
-	}
-
-	normalizedKey := strings.ToLower(key)
-	existingBinds[normalizedKey] = &hyprlandOverrideBind{
-		Key:         key,
-		Action:      action,
-		Description: description,
-		Flags:       flags,
-		Options:     options,
-	}
-
-	return h.writeOverrideBinds(existingBinds)
-}
-
-func (h *HyprlandProvider) RemoveBind(key string) error {
-	existingBinds, err := h.loadOverrideBinds()
-	if err != nil {
-		return nil
-	}
-
-	normalizedKey := strings.ToLower(key)
-	delete(existingBinds, normalizedKey)
-	return h.writeOverrideBinds(existingBinds)
-}
-
-type hyprlandOverrideBind struct {
-	Key         string
-	Action      string
-	Description string
-	Flags       string // Bind flags: l=locked, r=release, e=repeat, n=non-consuming, m=mouse, t=transparent, i=ignore-mods, s=separate, d=description, o=long-press
-	Options     map[string]any
-}
-
-func (h *HyprlandProvider) loadOverrideBinds() (map[string]*hyprlandOverrideBind, error) {
-	overridePath := h.GetOverridePath()
-	binds := make(map[string]*hyprlandOverrideBind)
-
-	data, err := os.ReadFile(overridePath)
-	if os.IsNotExist(err) {
-		return binds, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	lines := strings.Split(string(data), "\n")
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		if !strings.HasPrefix(line, "bind") {
-			continue
-		}
-
-		parts := strings.SplitN(line, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-
-		// Extract flags from bind type
-		bindType := strings.TrimSpace(parts[0])
-		flags := extractBindFlags(bindType)
-		hasDescFlag := strings.Contains(flags, "d")
-
-		content := strings.TrimSpace(parts[1])
-		commentParts := strings.SplitN(content, "#", 2)
-		bindContent := strings.TrimSpace(commentParts[0])
-
-		var comment string
-		if len(commentParts) > 1 {
-			comment = strings.TrimSpace(commentParts[1])
-		}
-
-		// For bindd, format is: mods, key, description, dispatcher, params
-		var minFields, descIndex, dispatcherIndex int
-		if hasDescFlag {
-			minFields = 4
-			descIndex = 2
-			dispatcherIndex = 3
-		} else {
-			minFields = 3
-			dispatcherIndex = 2
-		}
-
-		fields := strings.SplitN(bindContent, ",", minFields+2)
-		if len(fields) < minFields {
-			continue
-		}
-
-		mods := strings.TrimSpace(fields[0])
-		keyName := strings.TrimSpace(fields[1])
-
-		var dispatcher, params string
-		if hasDescFlag {
-			if comment == "" {
-				comment = strings.TrimSpace(fields[descIndex])
-			}
-			dispatcher = strings.TrimSpace(fields[dispatcherIndex])
-			if len(fields) > dispatcherIndex+1 {
-				paramParts := fields[dispatcherIndex+1:]
-				params = strings.TrimSpace(strings.Join(paramParts, ","))
-			}
-		} else {
-			dispatcher = strings.TrimSpace(fields[dispatcherIndex])
-			if len(fields) > dispatcherIndex+1 {
-				paramParts := fields[dispatcherIndex+1:]
-				params = strings.TrimSpace(strings.Join(paramParts, ","))
-			}
-		}
-
-		keyStr := h.buildKeyString(mods, keyName)
-		normalizedKey := strings.ToLower(keyStr)
-		action := dispatcher
-		if params != "" {
-			action = dispatcher + " " + params
-		}
-
-		binds[normalizedKey] = &hyprlandOverrideBind{
-			Key:         keyStr,
-			Action:      action,
-			Description: comment,
-			Flags:       flags,
-		}
-	}
-
-	return binds, nil
-}
-
-func (h *HyprlandProvider) buildKeyString(mods, key string) string {
-	if mods == "" {
-		return key
-	}
-
-	modList := strings.FieldsFunc(mods, func(r rune) bool {
-		return r == '+' || r == ' '
-	})
-
-	parts := append(modList, key)
-	return strings.Join(parts, "+")
-}
-
-func (h *HyprlandProvider) getBindSortPriority(action string) int {
-	switch {
-	case strings.HasPrefix(action, "exec") && strings.Contains(action, "dms"):
-		return 0
-	case strings.Contains(action, "workspace"):
-		return 1
-	case strings.Contains(action, "window") || strings.Contains(action, "focus") ||
-		strings.Contains(action, "move") || strings.Contains(action, "swap") ||
-		strings.Contains(action, "resize"):
-		return 2
-	case strings.Contains(action, "monitor"):
-		return 3
-	case strings.HasPrefix(action, "exec"):
-		return 4
-	case action == "exit" || strings.Contains(action, "dpms"):
-		return 5
-	default:
-		return 6
-	}
-}
-
-func (h *HyprlandProvider) writeOverrideBinds(binds map[string]*hyprlandOverrideBind) error {
-	overridePath := h.GetOverridePath()
-	content := h.generateBindsContent(binds)
-	return os.WriteFile(overridePath, []byte(content), 0644)
-}
-
-func (h *HyprlandProvider) generateBindsContent(binds map[string]*hyprlandOverrideBind) string {
-	if len(binds) == 0 {
-		return ""
-	}
-
-	bindList := make([]*hyprlandOverrideBind, 0, len(binds))
-	for _, bind := range binds {
-		bindList = append(bindList, bind)
-	}
-
-	sort.Slice(bindList, func(i, j int) bool {
-		pi, pj := h.getBindSortPriority(bindList[i].Action), h.getBindSortPriority(bindList[j].Action)
-		if pi != pj {
-			return pi < pj
-		}
-		return bindList[i].Key < bindList[j].Key
-	})
-
-	var sb strings.Builder
-	for _, bind := range bindList {
-		h.writeBindLine(&sb, bind)
-	}
-
-	return sb.String()
-}
-
-func (h *HyprlandProvider) writeBindLine(sb *strings.Builder, bind *hyprlandOverrideBind) {
-	mods, key := h.parseKeyString(bind.Key)
-	dispatcher, params := h.parseAction(bind.Action)
-
-	// Write bind type with flags (e.g., "bind", "binde", "bindel")
-	sb.WriteString("bind")
-	if bind.Flags != "" {
-		sb.WriteString(bind.Flags)
-	}
-	sb.WriteString(" = ")
-	sb.WriteString(mods)
-	sb.WriteString(", ")
-	sb.WriteString(key)
-	sb.WriteString(", ")
-
-	// For bindd (description flag), include description before dispatcher
-	if strings.Contains(bind.Flags, "d") && bind.Description != "" {
-		sb.WriteString(bind.Description)
-		sb.WriteString(", ")
-	}
-
-	sb.WriteString(dispatcher)
-
-	if params != "" {
-		sb.WriteString(", ")
-		sb.WriteString(params)
-	}
-
-	// Only add comment if not using bindd (which has inline description)
-	if bind.Description != "" && !strings.Contains(bind.Flags, "d") {
-		sb.WriteString(" # ")
-		sb.WriteString(bind.Description)
-	}
-
-	sb.WriteString("\n")
-}
-
-func (h *HyprlandProvider) parseKeyString(keyStr string) (mods, key string) {
-	parts := strings.Split(keyStr, "+")
-	switch len(parts) {
-	case 0:
-		return "", keyStr
-	case 1:
-		return "", parts[0]
-	default:
-		return strings.Join(parts[:len(parts)-1], " "), parts[len(parts)-1]
-	}
-}
-
-func (h *HyprlandProvider) parseAction(action string) (dispatcher, params string) {
-	parts := strings.SplitN(action, " ", 2)
-	switch len(parts) {
-	case 0:
-		return action, ""
-	case 1:
-		dispatcher = parts[0]
-	default:
-		dispatcher = parts[0]
-		params = parts[1]
-	}
-
-	// Convert internal spawn format to Hyprland's exec
-	if dispatcher == "spawn" {
-		dispatcher = "exec"
-	}
-
-	return dispatcher, params
-}

core/internal/keybinds/providers/hyprland_parser.go

@@ -23,8 +23,6 @@ type HyprlandKeyBinding struct {
 	Dispatcher string   `json:"dispatcher"`
 	Params     string   `json:"params"`
 	Comment    string   `json:"comment"`
-	Source     string   `json:"source"`
-	Flags      string   `json:"flags"` // Bind flags: l=locked, r=release, e=repeat, n=non-consuming, m=mouse, t=transparent, i=ignore-mods, s=separate, d=description, o=long-press
 }
 
 type HyprlandSection struct {
@@ -34,36 +32,14 @@ type HyprlandSection struct {
 }
 
 type HyprlandParser struct {
-	contentLines       []string
+	contentLines []string
-	readingLine        int
+	readingLine  int
-	configDir          string
-	currentSource      string
-	dmsBindsExists     bool
-	dmsBindsIncluded   bool
-	includeCount       int
-	dmsIncludePos      int
-	bindsAfterDMS      int
-	dmsBindKeys        map[string]bool
-	configBindKeys     map[string]bool
-	conflictingConfigs map[string]*HyprlandKeyBinding
-	bindMap            map[string]*HyprlandKeyBinding
-	bindOrder          []string
-	processedFiles     map[string]bool
-	dmsProcessed       bool
 }
 
-func NewHyprlandParser(configDir string) *HyprlandParser {
+func NewHyprlandParser() *HyprlandParser {
 	return &HyprlandParser{
-		contentLines:       []string{},
+		contentLines: []string{},
-		readingLine:        0,
+		readingLine:  0,
-		configDir:          configDir,
-		dmsIncludePos:      -1,
-		dmsBindKeys:        make(map[string]bool),
-		configBindKeys:     make(map[string]bool),
-		conflictingConfigs: make(map[string]*HyprlandKeyBinding),
-		bindMap:            make(map[string]*HyprlandKeyBinding),
-		bindOrder:          []string{},
-		processedFiles:     make(map[string]bool),
 	}
 }
 
@@ -219,7 +195,71 @@ func hyprlandAutogenerateComment(dispatcher, params string) string {
 
 func (p *HyprlandParser) getKeybindAtLine(lineNumber int) *HyprlandKeyBinding {
 	line := p.contentLines[lineNumber]
-	return p.parseBindLine(line)
+	parts := strings.SplitN(line, "=", 2)
+	if len(parts) < 2 {
+		return nil
+	}
+
+	keys := parts[1]
+	keyParts := strings.SplitN(keys, "#", 2)
+	keys = keyParts[0]
+
+	var comment string
+	if len(keyParts) > 1 {
+		comment = strings.TrimSpace(keyParts[1])
+	}
+
+	keyFields := strings.SplitN(keys, ",", 5)
+	if len(keyFields) < 3 {
+		return nil
+	}
+
+	mods := strings.TrimSpace(keyFields[0])
+	key := strings.TrimSpace(keyFields[1])
+	dispatcher := strings.TrimSpace(keyFields[2])
+
+	var params string
+	if len(keyFields) > 3 {
+		paramParts := keyFields[3:]
+		params = strings.TrimSpace(strings.Join(paramParts, ","))
+	}
+
+	if comment != "" {
+		if strings.HasPrefix(comment, HideComment) {
+			return nil
+		}
+	} else {
+		comment = hyprlandAutogenerateComment(dispatcher, params)
+	}
+
+	var modList []string
+	if mods != "" {
+		modstring := mods + string(ModSeparators[0])
+		p := 0
+		for index, char := range modstring {
+			isModSep := false
+			for _, sep := range ModSeparators {
+				if char == sep {
+					isModSep = true
+					break
+				}
+			}
+			if isModSep {
+				if index-p > 1 {
+					modList = append(modList, modstring[p:index])
+				}
+				p = index + 1
+			}
+		}
+	}
+
+	return &HyprlandKeyBinding{
+		Mods:       modList,
+		Key:        key,
+		Dispatcher: dispatcher,
+		Params:     params,
+		Comment:    comment,
+	}
 }
 
 func (p *HyprlandParser) getBindsRecursive(currentContent *HyprlandSection, scope int) *HyprlandSection {
@@ -280,348 +320,9 @@ func (p *HyprlandParser) ParseKeys() *HyprlandSection {
 }
 
 func ParseHyprlandKeys(path string) (*HyprlandSection, error) {
-	parser := NewHyprlandParser(path)
+	parser := NewHyprlandParser()
 	if err := parser.ReadContent(path); err != nil {
 		return nil, err
 	}
 	return parser.ParseKeys(), nil
 }
-
-type HyprlandParseResult struct {
-	Section            *HyprlandSection
-	DMSBindsIncluded   bool
-	DMSStatus          *HyprlandDMSStatus
-	ConflictingConfigs map[string]*HyprlandKeyBinding
-}
-
-type HyprlandDMSStatus struct {
-	Exists          bool
-	Included        bool
-	IncludePosition int
-	TotalIncludes   int
-	BindsAfterDMS   int
-	Effective       bool
-	OverriddenBy    int
-	StatusMessage   string
-}
-
-func (p *HyprlandParser) buildDMSStatus() *HyprlandDMSStatus {
-	status := &HyprlandDMSStatus{
-		Exists:          p.dmsBindsExists,
-		Included:        p.dmsBindsIncluded,
-		IncludePosition: p.dmsIncludePos,
-		TotalIncludes:   p.includeCount,
-		BindsAfterDMS:   p.bindsAfterDMS,
-	}
-
-	switch {
-	case !p.dmsBindsExists:
-		status.Effective = false
-		status.StatusMessage = "dms/binds.conf does not exist"
-	case !p.dmsBindsIncluded:
-		status.Effective = false
-		status.StatusMessage = "dms/binds.conf is not sourced in config"
-	case p.bindsAfterDMS > 0:
-		status.Effective = true
-		status.OverriddenBy = p.bindsAfterDMS
-		status.StatusMessage = "Some DMS binds may be overridden by config binds"
-	default:
-		status.Effective = true
-		status.StatusMessage = "DMS binds are active"
-	}
-
-	return status
-}
-
-func (p *HyprlandParser) formatBindKey(kb *HyprlandKeyBinding) string {
-	parts := make([]string, 0, len(kb.Mods)+1)
-	parts = append(parts, kb.Mods...)
-	parts = append(parts, kb.Key)
-	return strings.Join(parts, "+")
-}
-
-func (p *HyprlandParser) normalizeKey(key string) string {
-	return strings.ToLower(key)
-}
-
-func (p *HyprlandParser) addBind(kb *HyprlandKeyBinding) bool {
-	key := p.formatBindKey(kb)
-	normalizedKey := p.normalizeKey(key)
-	isDMSBind := strings.Contains(kb.Source, "dms/binds.conf")
-
-	if isDMSBind {
-		p.dmsBindKeys[normalizedKey] = true
-	} else if p.dmsBindKeys[normalizedKey] {
-		p.bindsAfterDMS++
-		p.conflictingConfigs[normalizedKey] = kb
-		p.configBindKeys[normalizedKey] = true
-		return false
-	} else {
-		p.configBindKeys[normalizedKey] = true
-	}
-
-	if _, exists := p.bindMap[normalizedKey]; !exists {
-		p.bindOrder = append(p.bindOrder, key)
-	}
-	p.bindMap[normalizedKey] = kb
-	return true
-}
-
-func (p *HyprlandParser) ParseWithDMS() (*HyprlandSection, error) {
-	expandedDir, err := utils.ExpandPath(p.configDir)
-	if err != nil {
-		return nil, err
-	}
-
-	dmsBindsPath := filepath.Join(expandedDir, "dms", "binds.conf")
-	if _, err := os.Stat(dmsBindsPath); err == nil {
-		p.dmsBindsExists = true
-	}
-
-	mainConfig := filepath.Join(expandedDir, "hyprland.conf")
-	section, err := p.parseFileWithSource(mainConfig, "")
-	if err != nil {
-		return nil, err
-	}
-
-	if p.dmsBindsExists && !p.dmsProcessed {
-		p.parseDMSBindsDirectly(dmsBindsPath, section)
-	}
-
-	return section, nil
-}
-
-func (p *HyprlandParser) parseFileWithSource(filePath, sectionName string) (*HyprlandSection, error) {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if p.processedFiles[absPath] {
-		return &HyprlandSection{Name: sectionName}, nil
-	}
-	p.processedFiles[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return nil, err
-	}
-
-	prevSource := p.currentSource
-	p.currentSource = absPath
-
-	section := &HyprlandSection{Name: sectionName}
-	lines := strings.Split(string(data), "\n")
-
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-
-		if strings.HasPrefix(trimmed, "source") {
-			p.handleSource(trimmed, section, filepath.Dir(absPath))
-			continue
-		}
-
-		if !strings.HasPrefix(trimmed, "bind") {
-			continue
-		}
-
-		kb := p.parseBindLine(line)
-		if kb == nil {
-			continue
-		}
-		kb.Source = p.currentSource
-		if p.addBind(kb) {
-			section.Keybinds = append(section.Keybinds, *kb)
-		}
-	}
-
-	p.currentSource = prevSource
-	return section, nil
-}
-
-func (p *HyprlandParser) handleSource(line string, section *HyprlandSection, baseDir string) {
-	parts := strings.SplitN(line, "=", 2)
-	if len(parts) < 2 {
-		return
-	}
-
-	sourcePath := strings.TrimSpace(parts[1])
-	isDMSSource := sourcePath == "dms/binds.conf" || strings.HasSuffix(sourcePath, "/dms/binds.conf")
-
-	p.includeCount++
-	if isDMSSource {
-		p.dmsBindsIncluded = true
-		p.dmsIncludePos = p.includeCount
-		p.dmsProcessed = true
-	}
-
-	fullPath := sourcePath
-	if !filepath.IsAbs(sourcePath) {
-		fullPath = filepath.Join(baseDir, sourcePath)
-	}
-
-	expanded, err := utils.ExpandPath(fullPath)
-	if err != nil {
-		return
-	}
-
-	includedSection, err := p.parseFileWithSource(expanded, "")
-	if err != nil {
-		return
-	}
-
-	section.Children = append(section.Children, *includedSection)
-}
-
-func (p *HyprlandParser) parseDMSBindsDirectly(dmsBindsPath string, section *HyprlandSection) {
-	data, err := os.ReadFile(dmsBindsPath)
-	if err != nil {
-		return
-	}
-
-	prevSource := p.currentSource
-	p.currentSource = dmsBindsPath
-
-	lines := strings.Split(string(data), "\n")
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if !strings.HasPrefix(trimmed, "bind") {
-			continue
-		}
-
-		kb := p.parseBindLine(line)
-		if kb == nil {
-			continue
-		}
-		kb.Source = dmsBindsPath
-		if p.addBind(kb) {
-			section.Keybinds = append(section.Keybinds, *kb)
-		}
-	}
-
-	p.currentSource = prevSource
-	p.dmsProcessed = true
-}
-
-func (p *HyprlandParser) parseBindLine(line string) *HyprlandKeyBinding {
-	parts := strings.SplitN(line, "=", 2)
-	if len(parts) < 2 {
-		return nil
-	}
-
-	// Extract bind type and flags from the left side of "="
-	bindType := strings.TrimSpace(parts[0])
-	flags := extractBindFlags(bindType)
-	hasDescFlag := strings.Contains(flags, "d")
-
-	keys := parts[1]
-	keyParts := strings.SplitN(keys, "#", 2)
-	keys = keyParts[0]
-
-	var comment string
-	if len(keyParts) > 1 {
-		comment = strings.TrimSpace(keyParts[1])
-	}
-
-	// For bindd, the format is: bindd = MODS, key, description, dispatcher, params
-	// For regular binds: bind = MODS, key, dispatcher, params
-	var minFields, descIndex, dispatcherIndex int
-	if hasDescFlag {
-		minFields = 4 // mods, key, description, dispatcher
-		descIndex = 2
-		dispatcherIndex = 3
-	} else {
-		minFields = 3 // mods, key, dispatcher
-		dispatcherIndex = 2
-	}
-
-	keyFields := strings.SplitN(keys, ",", minFields+2) // Allow for params
-	if len(keyFields) < minFields {
-		return nil
-	}
-
-	mods := strings.TrimSpace(keyFields[0])
-	key := strings.TrimSpace(keyFields[1])
-
-	var dispatcher, params string
-	if hasDescFlag {
-		// bindd format: description is in the bind itself
-		if comment == "" {
-			comment = strings.TrimSpace(keyFields[descIndex])
-		}
-		dispatcher = strings.TrimSpace(keyFields[dispatcherIndex])
-		if len(keyFields) > dispatcherIndex+1 {
-			paramParts := keyFields[dispatcherIndex+1:]
-			params = strings.TrimSpace(strings.Join(paramParts, ","))
-		}
-	} else {
-		dispatcher = strings.TrimSpace(keyFields[dispatcherIndex])
-		if len(keyFields) > dispatcherIndex+1 {
-			paramParts := keyFields[dispatcherIndex+1:]
-			params = strings.TrimSpace(strings.Join(paramParts, ","))
-		}
-	}
-
-	if comment != "" && strings.HasPrefix(comment, HideComment) {
-		return nil
-	}
-
-	if comment == "" {
-		comment = hyprlandAutogenerateComment(dispatcher, params)
-	}
-
-	var modList []string
-	if mods != "" {
-		modstring := mods + string(ModSeparators[0])
-		idx := 0
-		for index, char := range modstring {
-			isModSep := false
-			for _, sep := range ModSeparators {
-				if char == sep {
-					isModSep = true
-					break
-				}
-			}
-			if isModSep {
-				if index-idx > 1 {
-					modList = append(modList, modstring[idx:index])
-				}
-				idx = index + 1
-			}
-		}
-	}
-
-	return &HyprlandKeyBinding{
-		Mods:       modList,
-		Key:        key,
-		Dispatcher: dispatcher,
-		Params:     params,
-		Comment:    comment,
-		Flags:      flags,
-	}
-}
-
-// extractBindFlags extracts the flags from a bind type string
-// e.g., "binde" -> "e", "bindel" -> "el", "bindd" -> "d"
-func extractBindFlags(bindType string) string {
-	bindType = strings.TrimSpace(bindType)
-	if !strings.HasPrefix(bindType, "bind") {
-		return ""
-	}
-	return bindType[4:] // Everything after "bind"
-}
-
-func ParseHyprlandKeysWithDMS(path string) (*HyprlandParseResult, error) {
-	parser := NewHyprlandParser(path)
-	section, err := parser.ParseWithDMS()
-	if err != nil {
-		return nil, err
-	}
-
-	return &HyprlandParseResult{
-		Section:            section,
-		DMSBindsIncluded:   parser.dmsBindsIncluded,
-		DMSStatus:          parser.buildDMSStatus(),
-		ConflictingConfigs: parser.conflictingConfigs,
-	}, nil
-}

core/internal/keybinds/providers/hyprland_parser_test.go

@@ -130,7 +130,7 @@ func TestHyprlandGetKeybindAtLine(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			parser := NewHyprlandParser("")
+			parser := NewHyprlandParser()
 			parser.contentLines = []string{tt.line}
 			result := parser.getKeybindAtLine(0)
 
@@ -285,7 +285,7 @@ func TestHyprlandReadContentMultipleFiles(t *testing.T) {
 		t.Fatalf("Failed to write file2: %v", err)
 	}
 
-	parser := NewHyprlandParser("")
+	parser := NewHyprlandParser()
 	if err := parser.ReadContent(tmpDir); err != nil {
 		t.Fatalf("ReadContent failed: %v", err)
 	}
@@ -343,7 +343,7 @@ func TestHyprlandReadContentWithTildeExpansion(t *testing.T) {
 		t.Skip("Cannot create relative path")
 	}
 
-	parser := NewHyprlandParser("")
+	parser := NewHyprlandParser()
 	tildePathMatch := "~/" + relPath
 	err = parser.ReadContent(tildePathMatch)
 
@@ -353,7 +353,7 @@ func TestHyprlandReadContentWithTildeExpansion(t *testing.T) {
 }
 
 func TestHyprlandKeybindWithParamsContainingCommas(t *testing.T) {
-	parser := NewHyprlandParser("")
+	parser := NewHyprlandParser()
 	parser.contentLines = []string{"bind = SUPER, R, exec, notify-send 'Title' 'Message, with comma'"}
 
 	result := parser.getKeybindAtLine(0)
@@ -394,126 +394,3 @@ bind = SUPER, T, exec, kitty
 		t.Errorf("Expected 2 keybinds (comments ignored), got %d", len(section.Keybinds))
 	}
 }
-
-func TestExtractBindFlags(t *testing.T) {
-	tests := []struct {
-		bindType string
-		expected string
-	}{
-		{"bind", ""},
-		{"binde", "e"},
-		{"bindl", "l"},
-		{"bindr", "r"},
-		{"bindd", "d"},
-		{"bindo", "o"},
-		{"bindel", "el"},
-		{"bindler", "ler"},
-		{"bindem", "em"},
-		{"  bind  ", ""},
-		{"  binde  ", "e"},
-		{"notbind", ""},
-		{"", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.bindType, func(t *testing.T) {
-			result := extractBindFlags(tt.bindType)
-			if result != tt.expected {
-				t.Errorf("extractBindFlags(%q) = %q, want %q", tt.bindType, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestHyprlandBindFlags(t *testing.T) {
-	tests := []struct {
-		name          string
-		line          string
-		expectedFlags string
-		expectedKey   string
-		expectedDisp  string
-		expectedDesc  string
-	}{
-		{
-			name:          "regular bind",
-			line:          "bind = SUPER, Q, killactive",
-			expectedFlags: "",
-			expectedKey:   "Q",
-			expectedDisp:  "killactive",
-			expectedDesc:  "Close window",
-		},
-		{
-			name:          "binde (repeat on hold)",
-			line:          "binde = , XF86AudioRaiseVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%+",
-			expectedFlags: "e",
-			expectedKey:   "XF86AudioRaiseVolume",
-			expectedDisp:  "exec",
-			expectedDesc:  "wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%+",
-		},
-		{
-			name:          "bindl (locked/inhibitor bypass)",
-			line:          "bindl = , XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-",
-			expectedFlags: "l",
-			expectedKey:   "XF86AudioLowerVolume",
-			expectedDisp:  "exec",
-			expectedDesc:  "wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-",
-		},
-		{
-			name:          "bindr (release trigger)",
-			line:          "bindr = SUPER, SUPER_L, exec, pkill wofi || wofi",
-			expectedFlags: "r",
-			expectedKey:   "SUPER_L",
-			expectedDisp:  "exec",
-			expectedDesc:  "pkill wofi || wofi",
-		},
-		{
-			name:          "bindd (description)",
-			line:          "bindd = SUPER, Q, Open my favourite terminal, exec, kitty",
-			expectedFlags: "d",
-			expectedKey:   "Q",
-			expectedDisp:  "exec",
-			expectedDesc:  "Open my favourite terminal",
-		},
-		{
-			name:          "bindo (long press)",
-			line:          "bindo = SUPER, XF86AudioNext, exec, playerctl next",
-			expectedFlags: "o",
-			expectedKey:   "XF86AudioNext",
-			expectedDisp:  "exec",
-			expectedDesc:  "playerctl next",
-		},
-		{
-			name:          "bindel (combined flags)",
-			line:          "bindel = , XF86AudioRaiseVolume, exec, wpctl set-volume -l 1.5 @DEFAULT_AUDIO_SINK@ 5%+",
-			expectedFlags: "el",
-			expectedKey:   "XF86AudioRaiseVolume",
-			expectedDisp:  "exec",
-			expectedDesc:  "wpctl set-volume -l 1.5 @DEFAULT_AUDIO_SINK@ 5%+",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			parser := NewHyprlandParser("")
-			parser.contentLines = []string{tt.line}
-			result := parser.getKeybindAtLine(0)
-
-			if result == nil {
-				t.Fatal("Expected keybind, got nil")
-			}
-
-			if result.Flags != tt.expectedFlags {
-				t.Errorf("Flags = %q, want %q", result.Flags, tt.expectedFlags)
-			}
-			if result.Key != tt.expectedKey {
-				t.Errorf("Key = %q, want %q", result.Key, tt.expectedKey)
-			}
-			if result.Dispatcher != tt.expectedDisp {
-				t.Errorf("Dispatcher = %q, want %q", result.Dispatcher, tt.expectedDisp)
-			}
-			if result.Comment != tt.expectedDesc {
-				t.Errorf("Comment = %q, want %q", result.Comment, tt.expectedDesc)
-			}
-		})
-	}
-}

core/internal/keybinds/providers/hyprland_test.go

@@ -7,30 +7,35 @@ import (
 )
 
 func TestNewHyprlandProvider(t *testing.T) {
-	t.Run("custom path", func(t *testing.T) {
+	tests := []struct {
-		p := NewHyprlandProvider("/custom/path")
+		name       string
-		if p == nil {
+		configPath string
-			t.Fatal("NewHyprlandProvider returned nil")
+		wantPath   string
-		}
+	}{
-		if p.configPath != "/custom/path" {
+		{
-			t.Errorf("configPath = %q, want %q", p.configPath, "/custom/path")
+			name:       "custom path",
-		}
+			configPath: "/custom/path",
-	})
+			wantPath:   "/custom/path",
+		},
+		{
+			name:       "empty path defaults",
+			configPath: "",
+			wantPath:   "$HOME/.config/hypr",
+		},
+	}
 
-	t.Run("empty path defaults", func(t *testing.T) {
+	for _, tt := range tests {
-		p := NewHyprlandProvider("")
+		t.Run(tt.name, func(t *testing.T) {
-		if p == nil {
+			p := NewHyprlandProvider(tt.configPath)
-			t.Fatal("NewHyprlandProvider returned nil")
+			if p == nil {
-		}
+				t.Fatal("NewHyprlandProvider returned nil")
-		configDir, err := os.UserConfigDir()
+			}
-		if err != nil {
+
-			t.Fatalf("UserConfigDir failed: %v", err)
+			if p.configPath != tt.wantPath {
-		}
+				t.Errorf("configPath = %q, want %q", p.configPath, tt.wantPath)
-		expected := filepath.Join(configDir, "hypr")
+			}
-		if p.configPath != expected {
+		})
-			t.Errorf("configPath = %q, want %q", p.configPath, expected)
+	}
-		}
-	})
 }
 
 func TestHyprlandProviderName(t *testing.T) {
@@ -104,7 +109,7 @@ func TestHyprlandProviderGetCheatSheetError(t *testing.T) {
 
 func TestFormatKey(t *testing.T) {
 	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "hyprland.conf")
+	configFile := filepath.Join(tmpDir, "test.conf")
 
 	tests := []struct {
 		name     string
@@ -158,7 +163,7 @@ func TestFormatKey(t *testing.T) {
 
 func TestDescriptionFallback(t *testing.T) {
 	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "hyprland.conf")
+	configFile := filepath.Join(tmpDir, "test.conf")
 
 	tests := []struct {
 		name     string

core/internal/keybinds/providers/jsonfile_test.go

@@ -12,7 +12,7 @@ func TestNewJSONFileProvider(t *testing.T) {
 	tmpDir := t.TempDir()
 	testFile := filepath.Join(tmpDir, "test.json")
 
-	if err := os.WriteFile(testFile, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(testFile, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create test file: %v", err)
 	}
 
@@ -81,7 +81,7 @@ func TestJSONFileProviderGetCheatSheet(t *testing.T) {
   }
 }`
 
-	if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test file: %v", err)
 	}
 
@@ -135,7 +135,7 @@ func TestJSONFileProviderGetCheatSheetNoProvider(t *testing.T) {
   "binds": {}
 }`
 
-	if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test file: %v", err)
 	}
 
@@ -181,7 +181,7 @@ func TestJSONFileProviderFlatArrayBackwardsCompat(t *testing.T) {
   ]
 }`
 
-	if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test file: %v", err)
 	}
 
@@ -216,7 +216,7 @@ func TestJSONFileProviderInvalidJSON(t *testing.T) {
 	tmpDir := t.TempDir()
 	testFile := filepath.Join(tmpDir, "invalid.json")
 
-	if err := os.WriteFile(testFile, []byte("not valid json"), 0o644); err != nil {
+	if err := os.WriteFile(testFile, []byte("not valid json"), 0644); err != nil {
 		t.Fatalf("Failed to write test file: %v", err)
 	}
 

core/internal/keybinds/providers/mangowc.go

@@ -2,94 +2,46 @@ package providers
 
 import (
 	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type MangoWCProvider struct {
-	configPath       string
+	configPath string
-	dmsBindsIncluded bool
-	parsed           bool
 }
 
 func NewMangoWCProvider(configPath string) *MangoWCProvider {
 	if configPath == "" {
-		configPath = defaultMangoWCConfigDir()
+		configPath = "$HOME/.config/mango"
 	}
 	return &MangoWCProvider{
 		configPath: configPath,
 	}
 }
 
-func defaultMangoWCConfigDir() string {
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(configDir, "mango")
-}
-
 func (m *MangoWCProvider) Name() string {
 	return "mangowc"
 }
 
 func (m *MangoWCProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
-	result, err := ParseMangoWCKeysWithDMS(m.configPath)
+	keybinds_list, err := ParseMangoWCKeys(m.configPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse mangowc config: %w", err)
 	}
 
-	m.dmsBindsIncluded = result.DMSBindsIncluded
-	m.parsed = true
-
 	categorizedBinds := make(map[string][]keybinds.Keybind)
-	for _, kb := range result.Keybinds {
+	for _, kb := range keybinds_list {
 		category := m.categorizeByCommand(kb.Command)
-		bind := m.convertKeybind(&kb, result.ConflictingConfigs)
+		bind := m.convertKeybind(&kb)
 		categorizedBinds[category] = append(categorizedBinds[category], bind)
 	}
 
-	sheet := &keybinds.CheatSheet{
+	return &keybinds.CheatSheet{
-		Title:            "MangoWC Keybinds",
+		Title:    "MangoWC Keybinds",
-		Provider:         m.Name(),
+		Provider: m.Name(),
-		Binds:            categorizedBinds,
+		Binds:    categorizedBinds,
-		DMSBindsIncluded: result.DMSBindsIncluded,
+	}, nil
-	}
-
-	if result.DMSStatus != nil {
-		sheet.DMSStatus = &keybinds.DMSBindsStatus{
-			Exists:          result.DMSStatus.Exists,
-			Included:        result.DMSStatus.Included,
-			IncludePosition: result.DMSStatus.IncludePosition,
-			TotalIncludes:   result.DMSStatus.TotalIncludes,
-			BindsAfterDMS:   result.DMSStatus.BindsAfterDMS,
-			Effective:       result.DMSStatus.Effective,
-			OverriddenBy:    result.DMSStatus.OverriddenBy,
-			StatusMessage:   result.DMSStatus.StatusMessage,
-		}
-	}
-
-	return sheet, nil
-}
-
-func (m *MangoWCProvider) HasDMSBindsIncluded() bool {
-	if m.parsed {
-		return m.dmsBindsIncluded
-	}
-
-	result, err := ParseMangoWCKeysWithDMS(m.configPath)
-	if err != nil {
-		return false
-	}
-
-	m.dmsBindsIncluded = result.DMSBindsIncluded
-	m.parsed = true
-	return m.dmsBindsIncluded
 }
 
 func (m *MangoWCProvider) categorizeByCommand(command string) string {
@@ -130,8 +82,8 @@ func (m *MangoWCProvider) categorizeByCommand(command string) string {
 	}
 }
 
-func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding, conflicts map[string]*MangoWCKeyBinding) keybinds.Keybind {
+func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding) keybinds.Keybind {
-	keyStr := m.formatKey(kb)
+	key := m.formatKey(kb)
 	rawAction := m.formatRawAction(kb.Command, kb.Params)
 	desc := kb.Comment
 
@@ -139,31 +91,11 @@ func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding, conflicts map[st
 		desc = rawAction
 	}
 
-	source := "config"
+	return keybinds.Keybind{
-	if strings.Contains(kb.Source, "dms/binds.conf") || strings.Contains(kb.Source, "dms"+string(filepath.Separator)+"binds.conf") {
+		Key:         key,
-		source = "dms"
-	}
-
-	bind := keybinds.Keybind{
-		Key:         keyStr,
 		Description: desc,
 		Action:      rawAction,
-		Source:      source,
 	}
-
-	if source == "dms" && conflicts != nil {
-		normalizedKey := strings.ToLower(keyStr)
-		if conflictKb, ok := conflicts[normalizedKey]; ok {
-			bind.Conflict = &keybinds.Keybind{
-				Key:         keyStr,
-				Description: conflictKb.Comment,
-				Action:      m.formatRawAction(conflictKb.Command, conflictKb.Params),
-				Source:      "config",
-			}
-		}
-	}
-
-	return bind
 }
 
 func (m *MangoWCProvider) formatRawAction(command, params string) string {
@@ -179,264 +111,3 @@ func (m *MangoWCProvider) formatKey(kb *MangoWCKeyBinding) string {
 	parts = append(parts, kb.Key)
 	return strings.Join(parts, "+")
 }
-
-func (m *MangoWCProvider) GetOverridePath() string {
-	expanded, err := utils.ExpandPath(m.configPath)
-	if err != nil {
-		return filepath.Join(m.configPath, "dms", "binds.conf")
-	}
-	return filepath.Join(expanded, "dms", "binds.conf")
-}
-
-func (m *MangoWCProvider) validateAction(action string) error {
-	action = strings.TrimSpace(action)
-	switch {
-	case action == "":
-		return fmt.Errorf("action cannot be empty")
-	case action == "spawn" || action == "spawn ":
-		return fmt.Errorf("spawn command requires arguments")
-	case action == "spawn_shell" || action == "spawn_shell ":
-		return fmt.Errorf("spawn_shell command requires arguments")
-	case strings.HasPrefix(action, "spawn "):
-		rest := strings.TrimSpace(strings.TrimPrefix(action, "spawn "))
-		if rest == "" {
-			return fmt.Errorf("spawn command requires arguments")
-		}
-	case strings.HasPrefix(action, "spawn_shell "):
-		rest := strings.TrimSpace(strings.TrimPrefix(action, "spawn_shell "))
-		if rest == "" {
-			return fmt.Errorf("spawn_shell command requires arguments")
-		}
-	}
-	return nil
-}
-
-func (m *MangoWCProvider) SetBind(key, action, description string, options map[string]any) error {
-	if err := m.validateAction(action); err != nil {
-		return err
-	}
-
-	overridePath := m.GetOverridePath()
-
-	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
-		return fmt.Errorf("failed to create dms directory: %w", err)
-	}
-
-	existingBinds, err := m.loadOverrideBinds()
-	if err != nil {
-		existingBinds = make(map[string]*mangowcOverrideBind)
-	}
-
-	normalizedKey := strings.ToLower(key)
-	existingBinds[normalizedKey] = &mangowcOverrideBind{
-		Key:         key,
-		Action:      action,
-		Description: description,
-		Options:     options,
-	}
-
-	return m.writeOverrideBinds(existingBinds)
-}
-
-func (m *MangoWCProvider) RemoveBind(key string) error {
-	existingBinds, err := m.loadOverrideBinds()
-	if err != nil {
-		return nil
-	}
-
-	normalizedKey := strings.ToLower(key)
-	delete(existingBinds, normalizedKey)
-	return m.writeOverrideBinds(existingBinds)
-}
-
-type mangowcOverrideBind struct {
-	Key         string
-	Action      string
-	Description string
-	Options     map[string]any
-}
-
-func (m *MangoWCProvider) loadOverrideBinds() (map[string]*mangowcOverrideBind, error) {
-	overridePath := m.GetOverridePath()
-	binds := make(map[string]*mangowcOverrideBind)
-
-	data, err := os.ReadFile(overridePath)
-	if os.IsNotExist(err) {
-		return binds, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	lines := strings.Split(string(data), "\n")
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		if !strings.HasPrefix(line, "bind") {
-			continue
-		}
-
-		parts := strings.SplitN(line, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-
-		content := strings.TrimSpace(parts[1])
-		commentParts := strings.SplitN(content, "#", 2)
-		bindContent := strings.TrimSpace(commentParts[0])
-
-		var comment string
-		if len(commentParts) > 1 {
-			comment = strings.TrimSpace(commentParts[1])
-		}
-
-		fields := strings.SplitN(bindContent, ",", 4)
-		if len(fields) < 3 {
-			continue
-		}
-
-		mods := strings.TrimSpace(fields[0])
-		keyName := strings.TrimSpace(fields[1])
-		command := strings.TrimSpace(fields[2])
-
-		var params string
-		if len(fields) > 3 {
-			params = strings.TrimSpace(fields[3])
-		}
-
-		keyStr := m.buildKeyString(mods, keyName)
-		normalizedKey := strings.ToLower(keyStr)
-		action := command
-		if params != "" {
-			action = command + " " + params
-		}
-
-		binds[normalizedKey] = &mangowcOverrideBind{
-			Key:         keyStr,
-			Action:      action,
-			Description: comment,
-		}
-	}
-
-	return binds, nil
-}
-
-func (m *MangoWCProvider) buildKeyString(mods, key string) string {
-	if mods == "" || strings.EqualFold(mods, "none") {
-		return key
-	}
-
-	modList := strings.FieldsFunc(mods, func(r rune) bool {
-		return r == '+' || r == ' '
-	})
-
-	parts := append(modList, key)
-	return strings.Join(parts, "+")
-}
-
-func (m *MangoWCProvider) getBindSortPriority(action string) int {
-	switch {
-	case strings.HasPrefix(action, "spawn") && strings.Contains(action, "dms"):
-		return 0
-	case strings.Contains(action, "view") || strings.Contains(action, "tag"):
-		return 1
-	case strings.Contains(action, "focus") || strings.Contains(action, "exchange") ||
-		strings.Contains(action, "resize") || strings.Contains(action, "move"):
-		return 2
-	case strings.Contains(action, "mon"):
-		return 3
-	case strings.HasPrefix(action, "spawn"):
-		return 4
-	case action == "quit" || action == "reload_config":
-		return 5
-	default:
-		return 6
-	}
-}
-
-func (m *MangoWCProvider) writeOverrideBinds(binds map[string]*mangowcOverrideBind) error {
-	overridePath := m.GetOverridePath()
-	content := m.generateBindsContent(binds)
-	return os.WriteFile(overridePath, []byte(content), 0644)
-}
-
-func (m *MangoWCProvider) generateBindsContent(binds map[string]*mangowcOverrideBind) string {
-	if len(binds) == 0 {
-		return ""
-	}
-
-	bindList := make([]*mangowcOverrideBind, 0, len(binds))
-	for _, bind := range binds {
-		bindList = append(bindList, bind)
-	}
-
-	sort.Slice(bindList, func(i, j int) bool {
-		pi, pj := m.getBindSortPriority(bindList[i].Action), m.getBindSortPriority(bindList[j].Action)
-		if pi != pj {
-			return pi < pj
-		}
-		return bindList[i].Key < bindList[j].Key
-	})
-
-	var sb strings.Builder
-	for _, bind := range bindList {
-		m.writeBindLine(&sb, bind)
-	}
-
-	return sb.String()
-}
-
-func (m *MangoWCProvider) writeBindLine(sb *strings.Builder, bind *mangowcOverrideBind) {
-	mods, key := m.parseKeyString(bind.Key)
-	command, params := m.parseAction(bind.Action)
-
-	sb.WriteString("bind=")
-	if mods == "" {
-		sb.WriteString("none")
-	} else {
-		sb.WriteString(mods)
-	}
-	sb.WriteString(",")
-	sb.WriteString(key)
-	sb.WriteString(",")
-	sb.WriteString(command)
-
-	if params != "" {
-		sb.WriteString(",")
-		sb.WriteString(params)
-	}
-
-	if bind.Description != "" {
-		sb.WriteString(" # ")
-		sb.WriteString(bind.Description)
-	}
-
-	sb.WriteString("\n")
-}
-
-func (m *MangoWCProvider) parseKeyString(keyStr string) (mods, key string) {
-	parts := strings.Split(keyStr, "+")
-	switch len(parts) {
-	case 0:
-		return "", keyStr
-	case 1:
-		return "", parts[0]
-	default:
-		return strings.Join(parts[:len(parts)-1], "+"), parts[len(parts)-1]
-	}
-}
-
-func (m *MangoWCProvider) parseAction(action string) (command, params string) {
-	parts := strings.SplitN(action, " ", 2)
-	switch len(parts) {
-	case 0:
-		return action, ""
-	case 1:
-		return parts[0], ""
-	default:
-		return parts[0], parts[1]
-	}
-}

core/internal/keybinds/providers/mangowc_parser.go

@@ -21,40 +21,17 @@ type MangoWCKeyBinding struct {
 	Command string   `json:"command"`
 	Params  string   `json:"params"`
 	Comment string   `json:"comment"`
-	Source  string   `json:"source"`
 }
 
 type MangoWCParser struct {
-	contentLines       []string
+	contentLines []string
-	readingLine        int
+	readingLine  int
-	configDir          string
-	currentSource      string
-	dmsBindsExists     bool
-	dmsBindsIncluded   bool
-	includeCount       int
-	dmsIncludePos      int
-	bindsAfterDMS      int
-	dmsBindKeys        map[string]bool
-	configBindKeys     map[string]bool
-	conflictingConfigs map[string]*MangoWCKeyBinding
-	bindMap            map[string]*MangoWCKeyBinding
-	bindOrder          []string
-	processedFiles     map[string]bool
-	dmsProcessed       bool
 }
 
-func NewMangoWCParser(configDir string) *MangoWCParser {
+func NewMangoWCParser() *MangoWCParser {
 	return &MangoWCParser{
-		contentLines:       []string{},
+		contentLines: []string{},
-		readingLine:        0,
+		readingLine:  0,
-		configDir:          configDir,
-		dmsIncludePos:      -1,
-		dmsBindKeys:        make(map[string]bool),
-		configBindKeys:     make(map[string]bool),
-		conflictingConfigs: make(map[string]*MangoWCKeyBinding),
-		bindMap:            make(map[string]*MangoWCKeyBinding),
-		bindOrder:          []string{},
-		processedFiles:     make(map[string]bool),
 	}
 }
 
@@ -317,320 +294,9 @@ func (p *MangoWCParser) ParseKeys() []MangoWCKeyBinding {
 }
 
 func ParseMangoWCKeys(path string) ([]MangoWCKeyBinding, error) {
-	parser := NewMangoWCParser(path)
+	parser := NewMangoWCParser()
 	if err := parser.ReadContent(path); err != nil {
 		return nil, err
 	}
 	return parser.ParseKeys(), nil
 }
-
-type MangoWCParseResult struct {
-	Keybinds           []MangoWCKeyBinding
-	DMSBindsIncluded   bool
-	DMSStatus          *MangoWCDMSStatus
-	ConflictingConfigs map[string]*MangoWCKeyBinding
-}
-
-type MangoWCDMSStatus struct {
-	Exists          bool
-	Included        bool
-	IncludePosition int
-	TotalIncludes   int
-	BindsAfterDMS   int
-	Effective       bool
-	OverriddenBy    int
-	StatusMessage   string
-}
-
-func (p *MangoWCParser) buildDMSStatus() *MangoWCDMSStatus {
-	status := &MangoWCDMSStatus{
-		Exists:          p.dmsBindsExists,
-		Included:        p.dmsBindsIncluded,
-		IncludePosition: p.dmsIncludePos,
-		TotalIncludes:   p.includeCount,
-		BindsAfterDMS:   p.bindsAfterDMS,
-	}
-
-	switch {
-	case !p.dmsBindsExists:
-		status.Effective = false
-		status.StatusMessage = "dms/binds.conf does not exist"
-	case !p.dmsBindsIncluded:
-		status.Effective = false
-		status.StatusMessage = "dms/binds.conf is not sourced in config"
-	case p.bindsAfterDMS > 0:
-		status.Effective = true
-		status.OverriddenBy = p.bindsAfterDMS
-		status.StatusMessage = "Some DMS binds may be overridden by config binds"
-	default:
-		status.Effective = true
-		status.StatusMessage = "DMS binds are active"
-	}
-
-	return status
-}
-
-func (p *MangoWCParser) formatBindKey(kb *MangoWCKeyBinding) string {
-	parts := make([]string, 0, len(kb.Mods)+1)
-	parts = append(parts, kb.Mods...)
-	parts = append(parts, kb.Key)
-	return strings.Join(parts, "+")
-}
-
-func (p *MangoWCParser) normalizeKey(key string) string {
-	return strings.ToLower(key)
-}
-
-func (p *MangoWCParser) addBind(kb *MangoWCKeyBinding) {
-	key := p.formatBindKey(kb)
-	normalizedKey := p.normalizeKey(key)
-	isDMSBind := strings.Contains(kb.Source, "dms/binds.conf") || strings.Contains(kb.Source, "dms"+string(os.PathSeparator)+"binds.conf")
-
-	if isDMSBind {
-		p.dmsBindKeys[normalizedKey] = true
-	} else if p.dmsBindKeys[normalizedKey] {
-		p.bindsAfterDMS++
-		p.conflictingConfigs[normalizedKey] = kb
-		p.configBindKeys[normalizedKey] = true
-		return
-	} else {
-		p.configBindKeys[normalizedKey] = true
-	}
-
-	if _, exists := p.bindMap[normalizedKey]; !exists {
-		p.bindOrder = append(p.bindOrder, key)
-	}
-	p.bindMap[normalizedKey] = kb
-}
-
-func (p *MangoWCParser) ParseWithDMS() ([]MangoWCKeyBinding, error) {
-	expandedDir, err := utils.ExpandPath(p.configDir)
-	if err != nil {
-		return nil, err
-	}
-
-	dmsBindsPath := filepath.Join(expandedDir, "dms", "binds.conf")
-	if _, err := os.Stat(dmsBindsPath); err == nil {
-		p.dmsBindsExists = true
-	}
-
-	mainConfig := filepath.Join(expandedDir, "config.conf")
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		mainConfig = filepath.Join(expandedDir, "mango.conf")
-	}
-
-	_, err = p.parseFileWithSource(mainConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	if p.dmsBindsExists && !p.dmsProcessed {
-		p.parseDMSBindsDirectly(dmsBindsPath)
-	}
-
-	var keybinds []MangoWCKeyBinding
-	for _, key := range p.bindOrder {
-		normalizedKey := p.normalizeKey(key)
-		if kb, exists := p.bindMap[normalizedKey]; exists {
-			keybinds = append(keybinds, *kb)
-		}
-	}
-
-	return keybinds, nil
-}
-
-func (p *MangoWCParser) parseFileWithSource(filePath string) ([]MangoWCKeyBinding, error) {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if p.processedFiles[absPath] {
-		return nil, nil
-	}
-	p.processedFiles[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return nil, err
-	}
-
-	prevSource := p.currentSource
-	p.currentSource = absPath
-
-	var keybinds []MangoWCKeyBinding
-	lines := strings.Split(string(data), "\n")
-
-	for lineNum, line := range lines {
-		trimmed := strings.TrimSpace(line)
-
-		if strings.HasPrefix(trimmed, "source") {
-			p.handleSource(trimmed, filepath.Dir(absPath), &keybinds)
-			continue
-		}
-
-		if !strings.HasPrefix(trimmed, "bind") {
-			continue
-		}
-
-		kb := p.getKeybindAtLineContent(line, lineNum)
-		if kb == nil {
-			continue
-		}
-		kb.Source = p.currentSource
-		p.addBind(kb)
-		keybinds = append(keybinds, *kb)
-	}
-
-	p.currentSource = prevSource
-	return keybinds, nil
-}
-
-func (p *MangoWCParser) handleSource(line, baseDir string, keybinds *[]MangoWCKeyBinding) {
-	parts := strings.SplitN(line, "=", 2)
-	if len(parts) < 2 {
-		return
-	}
-
-	sourcePath := strings.TrimSpace(parts[1])
-	isDMSSource := sourcePath == "dms/binds.conf" || sourcePath == "./dms/binds.conf" || strings.HasSuffix(sourcePath, "/dms/binds.conf")
-
-	p.includeCount++
-	if isDMSSource {
-		p.dmsBindsIncluded = true
-		p.dmsIncludePos = p.includeCount
-		p.dmsProcessed = true
-	}
-
-	fullPath := sourcePath
-	if !filepath.IsAbs(sourcePath) {
-		fullPath = filepath.Join(baseDir, sourcePath)
-	}
-
-	expanded, err := utils.ExpandPath(fullPath)
-	if err != nil {
-		return
-	}
-
-	includedBinds, err := p.parseFileWithSource(expanded)
-	if err != nil {
-		return
-	}
-
-	*keybinds = append(*keybinds, includedBinds...)
-}
-
-func (p *MangoWCParser) parseDMSBindsDirectly(dmsBindsPath string) []MangoWCKeyBinding {
-	data, err := os.ReadFile(dmsBindsPath)
-	if err != nil {
-		return nil
-	}
-
-	prevSource := p.currentSource
-	p.currentSource = dmsBindsPath
-
-	var keybinds []MangoWCKeyBinding
-	lines := strings.Split(string(data), "\n")
-
-	for lineNum, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if !strings.HasPrefix(trimmed, "bind") {
-			continue
-		}
-
-		kb := p.getKeybindAtLineContent(line, lineNum)
-		if kb == nil {
-			continue
-		}
-		kb.Source = dmsBindsPath
-		p.addBind(kb)
-		keybinds = append(keybinds, *kb)
-	}
-
-	p.currentSource = prevSource
-	p.dmsProcessed = true
-	return keybinds
-}
-
-func (p *MangoWCParser) getKeybindAtLineContent(line string, _ int) *MangoWCKeyBinding {
-	bindMatch := regexp.MustCompile(`^(bind[lsr]*)\s*=\s*(.+)$`)
-	matches := bindMatch.FindStringSubmatch(line)
-	if len(matches) < 3 {
-		return nil
-	}
-
-	content := matches[2]
-	parts := strings.SplitN(content, "#", 2)
-	keys := parts[0]
-
-	var comment string
-	if len(parts) > 1 {
-		comment = strings.TrimSpace(parts[1])
-	}
-
-	if strings.HasPrefix(comment, MangoWCHideComment) {
-		return nil
-	}
-
-	keyFields := strings.SplitN(keys, ",", 4)
-	if len(keyFields) < 3 {
-		return nil
-	}
-
-	mods := strings.TrimSpace(keyFields[0])
-	key := strings.TrimSpace(keyFields[1])
-	command := strings.TrimSpace(keyFields[2])
-
-	var params string
-	if len(keyFields) > 3 {
-		params = strings.TrimSpace(keyFields[3])
-	}
-
-	if comment == "" {
-		comment = mangowcAutogenerateComment(command, params)
-	}
-
-	var modList []string
-	if mods != "" && !strings.EqualFold(mods, "none") {
-		modstring := mods + string(MangoWCModSeparators[0])
-		idx := 0
-		for index, char := range modstring {
-			isModSep := false
-			for _, sep := range MangoWCModSeparators {
-				if char == sep {
-					isModSep = true
-					break
-				}
-			}
-			if isModSep {
-				if index-idx > 1 {
-					modList = append(modList, modstring[idx:index])
-				}
-				idx = index + 1
-			}
-		}
-	}
-
-	return &MangoWCKeyBinding{
-		Mods:    modList,
-		Key:     key,
-		Command: command,
-		Params:  params,
-		Comment: comment,
-	}
-}
-
-func ParseMangoWCKeysWithDMS(path string) (*MangoWCParseResult, error) {
-	parser := NewMangoWCParser(path)
-	keybinds, err := parser.ParseWithDMS()
-	if err != nil {
-		return nil, err
-	}
-
-	return &MangoWCParseResult{
-		Keybinds:           keybinds,
-		DMSBindsIncluded:   parser.dmsBindsIncluded,
-		DMSStatus:          parser.buildDMSStatus(),
-		ConflictingConfigs: parser.conflictingConfigs,
-	}, nil
-}

core/internal/keybinds/providers/mangowc_parser_test.go

@@ -172,7 +172,7 @@ func TestMangoWCGetKeybindAtLine(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			parser := NewMangoWCParser("")
+			parser := NewMangoWCParser()
 			parser.contentLines = []string{tt.line}
 			result := parser.getKeybindAtLine(0)
 
@@ -283,7 +283,7 @@ func TestMangoWCReadContentMultipleFiles(t *testing.T) {
 		t.Fatalf("Failed to write file2: %v", err)
 	}
 
-	parser := NewMangoWCParser("")
+	parser := NewMangoWCParser()
 	if err := parser.ReadContent(tmpDir); err != nil {
 		t.Fatalf("ReadContent failed: %v", err)
 	}
@@ -304,7 +304,7 @@ func TestMangoWCReadContentSingleFile(t *testing.T) {
 		t.Fatalf("Failed to write config: %v", err)
 	}
 
-	parser := NewMangoWCParser("")
+	parser := NewMangoWCParser()
 	if err := parser.ReadContent(configFile); err != nil {
 		t.Fatalf("ReadContent failed: %v", err)
 	}
@@ -362,7 +362,7 @@ func TestMangoWCReadContentWithTildeExpansion(t *testing.T) {
 		t.Skip("Cannot create relative path")
 	}
 
-	parser := NewMangoWCParser("")
+	parser := NewMangoWCParser()
 	tildePathMatch := "~/" + relPath
 	err = parser.ReadContent(tildePathMatch)
 
@@ -419,7 +419,7 @@ func TestMangoWCInvalidBindLines(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			parser := NewMangoWCParser("")
+			parser := NewMangoWCParser()
 			parser.contentLines = []string{tt.line}
 			result := parser.getKeybindAtLine(0)
 

core/internal/keybinds/providers/mangowc_test.go

@@ -15,17 +15,8 @@ func TestMangoWCProviderName(t *testing.T) {
 
 func TestMangoWCProviderDefaultPath(t *testing.T) {
 	provider := NewMangoWCProvider("")
-	configDir, err := os.UserConfigDir()
+	if provider.configPath != "$HOME/.config/mango" {
-	if err != nil {
+		t.Errorf("configPath = %q, want %q", provider.configPath, "$HOME/.config/mango")
-		// Fall back to testing for non-empty path
-		if provider.configPath == "" {
-			t.Error("configPath should not be empty")
-		}
-		return
-	}
-	expected := filepath.Join(configDir, "mango")
-	if provider.configPath != expected {
-		t.Errorf("configPath = %q, want %q", provider.configPath, expected)
 	}
 }
 
@@ -183,7 +174,7 @@ func TestMangoWCConvertKeybind(t *testing.T) {
 	provider := NewMangoWCProvider("")
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := provider.convertKeybind(tt.keybind, nil)
+			result := provider.convertKeybind(tt.keybind)
 			if result.Key != tt.wantKey {
 				t.Errorf("convertKeybind().Key = %q, want %q", result.Key, tt.wantKey)
 			}

core/internal/keybinds/providers/niri.go

@@ -187,15 +187,7 @@ func (n *NiriProvider) formatRawAction(action string, args []string) string {
 		}
 	}
 
-	quotedArgs := make([]string, len(args))
+	return action + " " + strings.Join(args, " ")
-	for i, arg := range args {
-		if arg == "" {
-			quotedArgs[i] = `""`
-		} else {
-			quotedArgs[i] = arg
-		}
-	}
-	return action + " " + strings.Join(quotedArgs, " ")
 }
 
 func (n *NiriProvider) formatKey(kb *NiriKeyBinding) string {
@@ -301,15 +293,9 @@ func (n *NiriProvider) loadOverrideBinds() (map[string]*overrideBind, error) {
 				continue
 			}
 			keyStr := parser.formatBindKey(kb)
-
-			action := n.buildActionFromNode(child)
-			if action == "" {
-				action = n.formatRawAction(kb.Action, kb.Args)
-			}
-
 			binds[keyStr] = &overrideBind{
 				Key:         keyStr,
-				Action:      action,
+				Action:      n.formatRawAction(kb.Action, kb.Args),
 				Description: kb.Description,
 				Options:     n.extractOptions(child),
 			}
@@ -319,42 +305,6 @@ func (n *NiriProvider) loadOverrideBinds() (map[string]*overrideBind, error) {
 	return binds, nil
 }
 
-func (n *NiriProvider) buildActionFromNode(bindNode *document.Node) string {
-	if len(bindNode.Children) == 0 {
-		return ""
-	}
-
-	actionNode := bindNode.Children[0]
-	actionName := actionNode.Name.String()
-	if actionName == "" {
-		return ""
-	}
-
-	parts := []string{actionName}
-	for _, arg := range actionNode.Arguments {
-		val := arg.ValueString()
-		if val == "" {
-			parts = append(parts, `""`)
-		} else {
-			parts = append(parts, val)
-		}
-	}
-
-	if actionNode.Properties != nil {
-		if val, ok := actionNode.Properties.Get("focus"); ok {
-			parts = append(parts, "focus="+val.String())
-		}
-		if val, ok := actionNode.Properties.Get("show-pointer"); ok {
-			parts = append(parts, "show-pointer="+val.String())
-		}
-		if val, ok := actionNode.Properties.Get("write-to-disk"); ok {
-			parts = append(parts, "write-to-disk="+val.String())
-		}
-	}
-
-	return strings.Join(parts, " ")
-}
-
 func (n *NiriProvider) extractOptions(node *document.Node) map[string]any {
 	if node.Properties == nil {
 		return make(map[string]any)
@@ -511,9 +461,16 @@ func (n *NiriProvider) getBindSortPriority(action string) int {
 	}
 }
 
+const dmsWarningHeader = `// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+`
+
 func (n *NiriProvider) generateBindsContent(binds map[string]*overrideBind) string {
 	if len(binds) == 0 {
-		return "binds {}\n"
+		return dmsWarningHeader + "binds {}\n"
 	}
 
 	var regularBinds, recentWindowsBinds []*overrideBind
@@ -540,6 +497,7 @@ func (n *NiriProvider) generateBindsContent(binds map[string]*overrideBind) stri
 
 	var sb strings.Builder
 
+	sb.WriteString(dmsWarningHeader)
 	sb.WriteString("binds {\n")
 	for _, bind := range regularBinds {
 		n.writeBindNode(&sb, bind, "    ")

core/internal/keybinds/providers/niri_test.go

@@ -6,6 +6,13 @@ import (
 	"testing"
 )
 
+const testHeader = `// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+`
+
 func TestNiriProviderName(t *testing.T) {
 	provider := NewNiriProvider("")
 	if provider.Name() != "niri" {
@@ -121,8 +128,6 @@ func TestNiriFormatRawAction(t *testing.T) {
 	}{
 		{"spawn", []string{"kitty"}, "spawn kitty"},
 		{"spawn", []string{"dms", "ipc", "call"}, "spawn dms ipc call"},
-		{"spawn", []string{"dms", "ipc", "call", "brightness", "increment", "5", ""}, `spawn dms ipc call brightness increment 5 ""`},
-		{"spawn", []string{"dms", "ipc", "call", "dash", "toggle", ""}, `spawn dms ipc call dash toggle ""`},
 		{"close-window", nil, "close-window"},
 		{"fullscreen-window", nil, "fullscreen-window"},
 		{"focus-workspace", []string{"1"}, "focus-workspace 1"},
@@ -199,7 +204,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 		{
 			name:     "empty binds",
 			binds:    map[string]*overrideBind{},
-			expected: "binds {}\n",
+			expected: testHeader + "binds {}\n",
 		},
 		{
 			name: "simple spawn bind",
@@ -210,7 +215,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Open Terminal",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Mod+T hotkey-overlay-title="Open Terminal" { spawn "kitty"; }
 }
 `,
@@ -224,7 +229,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Application Launcher",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Mod+Space hotkey-overlay-title="Application Launcher" { spawn "dms" "ipc" "call" "spotlight" "toggle"; }
 }
 `,
@@ -238,7 +243,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Options: map[string]any{"allow-when-locked": true},
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     XF86AudioMute allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "mute"; }
 }
 `,
@@ -252,7 +257,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Close Window",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Mod+Q hotkey-overlay-title="Close Window" { close-window; }
 }
 `,
@@ -265,7 +270,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Action: "next-window",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
 }
 
 recent-windows {
@@ -326,58 +331,6 @@ func TestNiriGenerateBindsContentRoundTrip(t *testing.T) {
 	}
 }
 
-func TestNiriEmptyArgsPreservation(t *testing.T) {
-	provider := NewNiriProvider("")
-
-	binds := map[string]*overrideBind{
-		"XF86MonBrightnessUp": {
-			Key:         "XF86MonBrightnessUp",
-			Action:      `spawn dms ipc call brightness increment 5 ""`,
-			Description: "Brightness Up",
-		},
-		"XF86MonBrightnessDown": {
-			Key:         "XF86MonBrightnessDown",
-			Action:      `spawn dms ipc call brightness decrement 5 ""`,
-			Description: "Brightness Down",
-		},
-		"Super+Alt+Page_Up": {
-			Key:         "Super+Alt+Page_Up",
-			Action:      `spawn dms ipc call dash toggle ""`,
-			Description: "Dashboard Toggle",
-		},
-	}
-
-	content := provider.generateBindsContent(binds)
-
-	tmpDir := t.TempDir()
-	dmsDir := filepath.Join(tmpDir, "dms")
-	if err := os.MkdirAll(dmsDir, 0755); err != nil {
-		t.Fatalf("Failed to create dms directory: %v", err)
-	}
-
-	bindsFile := filepath.Join(dmsDir, "binds.kdl")
-	if err := os.WriteFile(bindsFile, []byte(content), 0644); err != nil {
-		t.Fatalf("Failed to write binds file: %v", err)
-	}
-
-	testProvider := NewNiriProvider(tmpDir)
-	loadedBinds, err := testProvider.loadOverrideBinds()
-	if err != nil {
-		t.Fatalf("Failed to load binds: %v\nContent was:\n%s", err, content)
-	}
-
-	for key, expected := range binds {
-		loaded, ok := loadedBinds[key]
-		if !ok {
-			t.Errorf("Missing bind for key %s", key)
-			continue
-		}
-		if loaded.Action != expected.Action {
-			t.Errorf("Action mismatch for %s:\n  got:  %q\n  want: %q", key, loaded.Action, expected.Action)
-		}
-	}
-}
-
 func TestNiriProviderWithRealWorldConfig(t *testing.T) {
 	tmpDir := t.TempDir()
 	configFile := filepath.Join(tmpDir, "config.kdl")
@@ -469,7 +422,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Focus Workspace 1",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Mod+1 hotkey-overlay-title="Focus Workspace 1" { focus-workspace 1; }
 }
 `,
@@ -483,7 +436,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Focus Workspace 10",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Mod+0 hotkey-overlay-title="Focus Workspace 10" { focus-workspace 10; }
 }
 `,
@@ -497,7 +450,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Adjust Column Width -10%",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Super+Minus hotkey-overlay-title="Adjust Column Width -10%" { set-column-width "-10%"; }
 }
 `,
@@ -511,7 +464,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Adjust Column Width +10%",
 				},
 			},
-			expected: `binds {
+			expected: testHeader + `binds {
     Super+Equal hotkey-overlay-title="Adjust Column Width +10%" { set-column-width "+10%"; }
 }
 `,
@@ -540,7 +493,7 @@ func TestNiriGenerateActionWithUnquotedPercentArg(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := `binds {
+	expected := testHeader + `binds {
     Super+Equal hotkey-overlay-title="Adjust Window Height +10%" { set-window-height "+10%"; }
 }
 `
@@ -561,7 +514,7 @@ func TestNiriGenerateSpawnWithNumericArgs(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := `binds {
+	expected := testHeader + `binds {
     XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
 }
 `
@@ -582,7 +535,7 @@ func TestNiriGenerateSpawnNumericArgFromCLI(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := `binds {
+	expected := testHeader + `binds {
     XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
 }
 `

core/internal/keybinds/types.go

@@ -8,7 +8,6 @@ type Keybind struct {
 	Source        string   `json:"source,omitempty"`
 	HideOnOverlay bool     `json:"hideOnOverlay,omitempty"`
 	CooldownMs    int      `json:"cooldownMs,omitempty"`
-	Flags         string   `json:"flags,omitempty"` // Hyprland bind flags: e=repeat, l=locked, r=release, o=long-press
 	Conflict      *Keybind `json:"conflict,omitempty"`
 }
 

core/internal/matugen/matugen.go

@@ -16,63 +16,6 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
-type ColorMode string
-
-const (
-	ColorModeDark  ColorMode = "dark"
-	ColorModeLight ColorMode = "light"
-)
-
-type TemplateKind int
-
-const (
-	TemplateKindNormal TemplateKind = iota
-	TemplateKindTerminal
-	TemplateKindGTK
-	TemplateKindVSCode
-)
-
-type TemplateDef struct {
-	ID                 string
-	Commands           []string
-	Flatpaks           []string
-	ConfigFile         string
-	Kind               TemplateKind
-	RunUnconditionally bool
-}
-
-var templateRegistry = []TemplateDef{
-	{ID: "gtk", Kind: TemplateKindGTK, RunUnconditionally: true},
-	{ID: "niri", Commands: []string{"niri"}, ConfigFile: "niri.toml"},
-	{ID: "hyprland", Commands: []string{"Hyprland"}, ConfigFile: "hyprland.toml"},
-	{ID: "mangowc", Commands: []string{"mango"}, ConfigFile: "mangowc.toml"},
-	{ID: "qt5ct", Commands: []string{"qt5ct"}, ConfigFile: "qt5ct.toml"},
-	{ID: "qt6ct", Commands: []string{"qt6ct"}, ConfigFile: "qt6ct.toml"},
-	{ID: "firefox", Commands: []string{"firefox"}, ConfigFile: "firefox.toml"},
-	{ID: "pywalfox", Commands: []string{"pywalfox"}, ConfigFile: "pywalfox.toml"},
-	{ID: "zenbrowser", Commands: []string{"zen", "zen-browser"}, Flatpaks: []string{"app.zen_browser.zen"}, ConfigFile: "zenbrowser.toml"},
-	{ID: "vesktop", Commands: []string{"vesktop"}, Flatpaks: []string{"dev.vencord.Vesktop"}, ConfigFile: "vesktop.toml"},
-	{ID: "equibop", Commands: []string{"equibop"}, ConfigFile: "equibop.toml"},
-	{ID: "ghostty", Commands: []string{"ghostty"}, ConfigFile: "ghostty.toml", Kind: TemplateKindTerminal},
-	{ID: "kitty", Commands: []string{"kitty"}, ConfigFile: "kitty.toml", Kind: TemplateKindTerminal},
-	{ID: "foot", Commands: []string{"foot"}, ConfigFile: "foot.toml", Kind: TemplateKindTerminal},
-	{ID: "alacritty", Commands: []string{"alacritty"}, ConfigFile: "alacritty.toml", Kind: TemplateKindTerminal},
-	{ID: "wezterm", Commands: []string{"wezterm"}, ConfigFile: "wezterm.toml", Kind: TemplateKindTerminal},
-	{ID: "nvim", Commands: []string{"nvim"}, ConfigFile: "neovim.toml", Kind: TemplateKindTerminal},
-	{ID: "dgop", Commands: []string{"dgop"}, ConfigFile: "dgop.toml"},
-	{ID: "kcolorscheme", ConfigFile: "kcolorscheme.toml", RunUnconditionally: true},
-	{ID: "vscode", Kind: TemplateKindVSCode},
-}
-
-func (c *ColorMode) GTKTheme() string {
-	switch *c {
-	case ColorModeDark:
-		return "adw-gtk3-dark"
-	default:
-		return "adw-gtk3"
-	}
-}
-
 var (
 	matugenVersionOnce sync.Once
 	matugenSupportsCOE bool
@@ -84,7 +27,7 @@ type Options struct {
 	ConfigDir           string
 	Kind                string
 	Value               string
-	Mode                ColorMode
+	Mode                string
 	IconTheme           string
 	MatugenType         string
 	RunUserTemplates    bool
@@ -92,7 +35,6 @@ type Options struct {
 	SyncModeWithPortal  bool
 	TerminalsAlwaysDark bool
 	SkipTemplates       string
-	AppChecker          utils.AppChecker
 }
 
 type ColorsOutput struct {
@@ -135,7 +77,7 @@ func Run(opts Options) error {
 		return fmt.Errorf("value is required")
 	}
 	if opts.Mode == "" {
-		opts.Mode = ColorModeDark
+		opts.Mode = "dark"
 	}
 	if opts.MatugenType == "" {
 		opts.MatugenType = "scheme-tonal-spot"
@@ -143,9 +85,6 @@ func Run(opts Options) error {
 	if opts.IconTheme == "" {
 		opts.IconTheme = "System Default"
 	}
-	if opts.AppChecker == nil {
-		opts.AppChecker = utils.DefaultAppChecker{}
-	}
 
 	if err := os.MkdirAll(opts.StateDir, 0755); err != nil {
 		return fmt.Errorf("failed to create state dir: %w", err)
@@ -206,7 +145,7 @@ func buildOnce(opts *Options) error {
 		importArgs = []string{"--import-json-string", importData}
 
 		log.Info("Running matugen color hex with stock color overrides")
-		args := []string{"color", "hex", primaryDark, "-m", string(opts.Mode), "-t", opts.MatugenType, "-c", cfgFile.Name()}
+		args := []string{"color", "hex", primaryDark, "-m", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name()}
 		args = append(args, importArgs...)
 		if err := runMatugen(args); err != nil {
 			return err
@@ -242,7 +181,7 @@ func buildOnce(opts *Options) error {
 		default:
 			args = []string{opts.Kind, opts.Value}
 		}
-		args = append(args, "-m", string(opts.Mode), "-t", opts.MatugenType, "-c", cfgFile.Name())
+		args = append(args, "-m", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name())
 		args = append(args, importArgs...)
 		if err := runMatugen(args); err != nil {
 			return err
@@ -281,7 +220,7 @@ func buildMergedConfig(opts *Options, cfgFile *os.File, tmpDir string) error {
 			if strings.TrimSpace(line) == "[config]" {
 				continue
 			}
-			cfgFile.WriteString(substituteVars(line, opts.ShellDir) + "\n")
+			cfgFile.WriteString(substituteShellDir(line, opts.ShellDir) + "\n")
 		}
 		cfgFile.WriteString("\n")
 	}
@@ -292,34 +231,72 @@ output_path = '%s'
 
 `, opts.ShellDir, opts.ColorsOutput())
 
-	homeDir, _ := os.UserHomeDir()
+	if !opts.ShouldSkipTemplate("gtk") {
-	for _, tmpl := range templateRegistry {
+		switch opts.Mode {
-		if opts.ShouldSkipTemplate(tmpl.ID) {
+		case "light":
-			continue
+			appendConfig(opts, cfgFile, "skip", "gtk3-light.toml")
-		}
-
-		switch tmpl.Kind {
-		case TemplateKindGTK:
-			switch opts.Mode {
-			case ColorModeLight:
-				appendConfig(opts, cfgFile, nil, nil, "gtk3-light.toml")
-			default:
-				appendConfig(opts, cfgFile, nil, nil, "gtk3-dark.toml")
-			}
-		case TemplateKindTerminal:
-			appendTerminalConfig(opts, cfgFile, tmpDir, tmpl.Commands, tmpl.Flatpaks, tmpl.ConfigFile)
-		case TemplateKindVSCode:
-			appendVSCodeConfig(cfgFile, "vscode", filepath.Join(homeDir, ".vscode/extensions"), opts.ShellDir)
-			appendVSCodeConfig(cfgFile, "codium", filepath.Join(homeDir, ".vscode-oss/extensions"), opts.ShellDir)
-			appendVSCodeConfig(cfgFile, "codeoss", filepath.Join(homeDir, ".config/Code - OSS/extensions"), opts.ShellDir)
-			appendVSCodeConfig(cfgFile, "cursor", filepath.Join(homeDir, ".cursor/extensions"), opts.ShellDir)
-			appendVSCodeConfig(cfgFile, "windsurf", filepath.Join(homeDir, ".windsurf/extensions"), opts.ShellDir)
-			appendVSCodeConfig(cfgFile, "vscode-insiders", filepath.Join(homeDir, ".vscode-insiders/extensions"), opts.ShellDir)
 		default:
-			appendConfig(opts, cfgFile, tmpl.Commands, tmpl.Flatpaks, tmpl.ConfigFile)
+			appendConfig(opts, cfgFile, "skip", "gtk3-dark.toml")
 		}
 	}
 
+	if !opts.ShouldSkipTemplate("niri") {
+		appendConfig(opts, cfgFile, "niri", "niri.toml")
+	}
+	if !opts.ShouldSkipTemplate("qt5ct") {
+		appendConfig(opts, cfgFile, "qt5ct", "qt5ct.toml")
+	}
+	if !opts.ShouldSkipTemplate("qt6ct") {
+		appendConfig(opts, cfgFile, "qt6ct", "qt6ct.toml")
+	}
+	if !opts.ShouldSkipTemplate("firefox") {
+		appendConfig(opts, cfgFile, "firefox", "firefox.toml")
+	}
+	if !opts.ShouldSkipTemplate("pywalfox") {
+		appendConfig(opts, cfgFile, "pywalfox", "pywalfox.toml")
+	}
+	if !opts.ShouldSkipTemplate("vesktop") {
+		appendConfig(opts, cfgFile, "vesktop", "vesktop.toml")
+	}
+	if !opts.ShouldSkipTemplate("equibop") {
+		appendConfig(opts, cfgFile, "equibop", "equibop.toml")
+	}
+	if !opts.ShouldSkipTemplate("ghostty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "ghostty", "ghostty.toml")
+	}
+	if !opts.ShouldSkipTemplate("kitty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "kitty", "kitty.toml")
+	}
+	if !opts.ShouldSkipTemplate("foot") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "foot", "foot.toml")
+	}
+	if !opts.ShouldSkipTemplate("alacritty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "alacritty", "alacritty.toml")
+	}
+	if !opts.ShouldSkipTemplate("wezterm") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "wezterm", "wezterm.toml")
+	}
+	if !opts.ShouldSkipTemplate("nvim") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "nvim", "neovim.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("dgop") {
+		appendConfig(opts, cfgFile, "dgop", "dgop.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("kcolorscheme") {
+		appendConfig(opts, cfgFile, "skip", "kcolorscheme.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("vscode") {
+		homeDir, _ := os.UserHomeDir()
+		appendVSCodeConfig(cfgFile, "vscode", filepath.Join(homeDir, ".vscode/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "codium", filepath.Join(homeDir, ".vscode-oss/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "codeoss", filepath.Join(homeDir, ".config/Code - OSS/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "cursor", filepath.Join(homeDir, ".cursor/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "windsurf", filepath.Join(homeDir, ".windsurf/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	}
+
 	if opts.RunUserTemplates {
 		if data, err := os.ReadFile(userConfigPath); err == nil {
 			templatesSection := extractTOMLSection(string(data), "[templates]", "")
@@ -346,34 +323,28 @@ output_path = '%s'
 	return nil
 }
 
-func appendConfig(
+func appendConfig(opts *Options, cfgFile *os.File, checkCmd, fileName string) {
-	opts *Options,
-	cfgFile *os.File,
-	checkCmd []string,
-	checkFlatpaks []string,
-	fileName string,
-) {
 	configPath := filepath.Join(opts.ShellDir, "matugen", "configs", fileName)
 	if _, err := os.Stat(configPath); err != nil {
 		return
 	}
-	if !appExists(opts.AppChecker, checkCmd, checkFlatpaks) {
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
 	if err != nil {
 		return
 	}
-	cfgFile.WriteString(substituteVars(string(data), opts.ShellDir))
+	cfgFile.WriteString(substituteShellDir(string(data), opts.ShellDir))
 	cfgFile.WriteString("\n")
 }
 
-func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkCmd []string, checkFlatpaks []string, fileName string) {
+func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fileName string) {
 	configPath := filepath.Join(opts.ShellDir, "matugen", "configs", fileName)
 	if _, err := os.Stat(configPath); err != nil {
 		return
 	}
-	if !appExists(opts.AppChecker, checkCmd, checkFlatpaks) {
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
@@ -384,7 +355,7 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkC
 	content := string(data)
 
 	if !opts.TerminalsAlwaysDark {
-		cfgFile.WriteString(substituteVars(content, opts.ShellDir))
+		cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
 		cfgFile.WriteString("\n")
 		return
 	}
@@ -422,32 +393,14 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkC
 			fmt.Sprintf("'%s'", tmpPath))
 	}
 
-	cfgFile.WriteString(substituteVars(content, opts.ShellDir))
+	cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
 	cfgFile.WriteString("\n")
 }
 
-func appExists(checker utils.AppChecker, checkCmd []string, checkFlatpaks []string) bool {
+func appendVSCodeConfig(cfgFile *os.File, name, extDir, shellDir string) {
-	// Both nil is treated as "skip check" / unconditionally run
+	if _, err := os.Stat(extDir); err != nil {
-	if checkCmd == nil && checkFlatpaks == nil {
-		return true
-	}
-	if checkCmd != nil && checker.AnyCommandExists(checkCmd...) {
-		return true
-	}
-	if checkFlatpaks != nil && checker.AnyFlatpakExists(checkFlatpaks...) {
-		return true
-	}
-	return false
-}
-
-func appendVSCodeConfig(cfgFile *os.File, name, extBaseDir, shellDir string) {
-	pattern := filepath.Join(extBaseDir, "danklinux.dms-theme-*")
-	matches, err := filepath.Glob(pattern)
-	if err != nil || len(matches) == 0 {
 		return
 	}
-
-	extDir := matches[0]
 	templateDir := filepath.Join(shellDir, "matugen", "templates")
 	fmt.Fprintf(cfgFile, `[templates.dms%sdefault]
 input_path = '%s/vscode-color-theme-default.json'
@@ -467,12 +420,8 @@ output_path = '%s/themes/dankshell-light.json'
 	log.Infof("Added %s theme config (extension found at %s)", name, extDir)
 }
 
-func substituteVars(content, shellDir string) string {
+func substituteShellDir(content, shellDir string) string {
-	result := strings.ReplaceAll(content, "'SHELL_DIR/", "'"+shellDir+"/")
+	return strings.ReplaceAll(content, "'SHELL_DIR/", "'"+shellDir+"/")
-	result = strings.ReplaceAll(result, "'CONFIG_DIR/", "'"+utils.XDGConfigHome()+"/")
-	result = strings.ReplaceAll(result, "'DATA_DIR/", "'"+utils.XDGDataHome()+"/")
-	result = strings.ReplaceAll(result, "'CACHE_DIR/", "'"+utils.XDGCacheHome()+"/")
-	return result
 }
 
 func extractTOMLSection(content, startMarker, endMarker string) string {
@@ -604,19 +553,19 @@ func extractNestedColor(jsonStr, colorName, variant string) string {
 	return color
 }
 
-func generateDank16Variants(primaryDark, primaryLight, surface string, mode ColorMode) string {
+func generateDank16Variants(primaryDark, primaryLight, surface, mode string) string {
 	variantOpts := dank16.VariantOptions{
 		PrimaryDark:  primaryDark,
 		PrimaryLight: primaryLight,
 		Background:   surface,
 		UseDPS:       true,
-		IsLightMode:  mode == ColorModeLight,
+		IsLightMode:  mode == "light",
 	}
 	variantColors := dank16.GenerateVariantPalette(variantOpts)
 	return dank16.GenerateVariantJSON(variantColors)
 }
 
-func refreshGTK(configDir string, mode ColorMode) {
+func refreshGTK(configDir, mode string) {
 	gtkCSS := filepath.Join(configDir, "gtk-3.0", "gtk.css")
 
 	info, err := os.Lstat(gtkCSS)
@@ -642,7 +591,7 @@ func refreshGTK(configDir string, mode ColorMode) {
 	}
 
 	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "").Run()
-	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", mode.GTKTheme()).Run()
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "adw-gtk3-"+mode).Run()
 }
 
 func signalTerminals() {
@@ -672,9 +621,9 @@ func signalByName(name string, sig syscall.Signal) {
 	}
 }
 
-func syncColorScheme(mode ColorMode) {
+func syncColorScheme(mode string) {
 	scheme := "prefer-dark"
-	if mode == ColorModeLight {
+	if mode == "light" {
 		scheme = "default"
 	}
 
@@ -682,52 +631,3 @@ func syncColorScheme(mode ColorMode) {
 		exec.Command("dconf", "write", "/org/gnome/desktop/interface/color-scheme", "'"+scheme+"'").Run()
 	}
 }
-
-type TemplateCheck struct {
-	ID       string `json:"id"`
-	Detected bool   `json:"detected"`
-}
-
-func CheckTemplates(checker utils.AppChecker) []TemplateCheck {
-	if checker == nil {
-		checker = utils.DefaultAppChecker{}
-	}
-
-	homeDir, _ := os.UserHomeDir()
-	checks := make([]TemplateCheck, 0, len(templateRegistry))
-
-	for _, tmpl := range templateRegistry {
-		detected := false
-
-		switch {
-		case tmpl.RunUnconditionally:
-			detected = true
-		case tmpl.Kind == TemplateKindVSCode:
-			detected = checkVSCodeExtension(homeDir)
-		default:
-			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks)
-		}
-
-		checks = append(checks, TemplateCheck{ID: tmpl.ID, Detected: detected})
-	}
-
-	return checks
-}
-
-func checkVSCodeExtension(homeDir string) bool {
-	extDirs := []string{
-		filepath.Join(homeDir, ".vscode/extensions"),
-		filepath.Join(homeDir, ".vscode-oss/extensions"),
-		filepath.Join(homeDir, ".config/Code - OSS/extensions"),
-		filepath.Join(homeDir, ".cursor/extensions"),
-		filepath.Join(homeDir, ".windsurf/extensions"),
-	}
-
-	for _, extDir := range extDirs {
-		pattern := filepath.Join(extDir, "danklinux.dms-theme-*")
-		if matches, err := filepath.Glob(pattern); err == nil && len(matches) > 0 {
-			return true
-		}
-	}
-	return false
-}

core/internal/matugen/matugen_test.go

@@ -1,394 +0,0 @@
-package matugen
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	mocks_utils "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/utils"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAppendConfigBinaryExists(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "test config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyCommandExists("sh").Return(true)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, []string{"sh"}, nil, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) == 0 {
-		t.Errorf("expected config to be written when binary exists")
-	}
-	if string(output) != testConfig+"\n" {
-		t.Errorf("expected %q, got %q", testConfig+"\n", string(output))
-	}
-}
-
-func TestAppendConfigBinaryDoesNotExist(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "test config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyCommandExists("nonexistent-binary-12345").Return(false)
-	mockChecker.EXPECT().AnyFlatpakExists().Return(false)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, []string{"nonexistent-binary-12345"}, []string{}, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) != 0 {
-		t.Errorf("expected no config when binary doesn't exist, got: %q", string(output))
-	}
-}
-
-func TestAppendConfigFlatpakExists(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "zen config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyFlatpakExists("app.zen_browser.zen").Return(true)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, nil, []string{"app.zen_browser.zen"}, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) == 0 {
-		t.Errorf("expected config to be written when flatpak exists")
-	}
-}
-
-func TestAppendConfigFlatpakDoesNotExist(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "test config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyCommandExists().Return(false)
-	mockChecker.EXPECT().AnyFlatpakExists("com.nonexistent.flatpak").Return(false)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, []string{}, []string{"com.nonexistent.flatpak"}, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) != 0 {
-		t.Errorf("expected no config when flatpak doesn't exist, got: %q", string(output))
-	}
-}
-
-func TestAppendConfigBothExist(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "zen config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyCommandExists("sh").Return(true)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, []string{"sh"}, []string{"app.zen_browser.zen"}, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) == 0 {
-		t.Errorf("expected config to be written when both binary and flatpak exist")
-	}
-}
-
-func TestAppendConfigNeitherExists(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "test config content"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	mockChecker := mocks_utils.NewMockAppChecker(t)
-	mockChecker.EXPECT().AnyCommandExists("nonexistent-binary-12345").Return(false)
-	mockChecker.EXPECT().AnyFlatpakExists("com.nonexistent.flatpak").Return(false)
-
-	opts := &Options{ShellDir: shellDir, AppChecker: mockChecker}
-
-	appendConfig(opts, cfgFile, []string{"nonexistent-binary-12345"}, []string{"com.nonexistent.flatpak"}, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) != 0 {
-		t.Errorf("expected no config when neither exists, got: %q", string(output))
-	}
-}
-
-func TestAppendConfigNoChecks(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	testConfig := "always include"
-	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	opts := &Options{ShellDir: shellDir}
-
-	appendConfig(opts, cfgFile, nil, nil, "test.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) == 0 {
-		t.Errorf("expected config to be written when no checks specified")
-	}
-}
-
-func TestAppendConfigFileDoesNotExist(t *testing.T) {
-	tempDir := t.TempDir()
-
-	shellDir := filepath.Join(tempDir, "shell")
-	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0755); err != nil {
-		t.Fatalf("failed to create configs dir: %v", err)
-	}
-
-	outFile := filepath.Join(tempDir, "output.toml")
-	cfgFile, err := os.Create(outFile)
-	if err != nil {
-		t.Fatalf("failed to create output file: %v", err)
-	}
-	defer cfgFile.Close()
-
-	opts := &Options{ShellDir: shellDir}
-
-	appendConfig(opts, cfgFile, nil, nil, "nonexistent.toml")
-
-	cfgFile.Close()
-	output, err := os.ReadFile(outFile)
-	if err != nil {
-		t.Fatalf("failed to read output: %v", err)
-	}
-
-	if len(output) != 0 {
-		t.Errorf("expected no config when file doesn't exist, got: %q", string(output))
-	}
-}
-
-func TestSubstituteVars(t *testing.T) {
-	configDir := utils.XDGConfigHome()
-	dataDir := utils.XDGDataHome()
-	cacheDir := utils.XDGCacheHome()
-
-	tests := []struct {
-		name     string
-		input    string
-		shellDir string
-		expected string
-	}{
-		{
-			name:     "substitutes SHELL_DIR",
-			input:    "input_path = 'SHELL_DIR/matugen/templates/foo.conf'",
-			shellDir: "/home/user/shell",
-			expected: "input_path = '/home/user/shell/matugen/templates/foo.conf'",
-		},
-		{
-			name:     "substitutes CONFIG_DIR",
-			input:    "output_path = 'CONFIG_DIR/kitty/theme.conf'",
-			shellDir: "/home/user/shell",
-			expected: "output_path = '" + configDir + "/kitty/theme.conf'",
-		},
-		{
-			name:     "substitutes DATA_DIR",
-			input:    "output_path = 'DATA_DIR/color-schemes/theme.colors'",
-			shellDir: "/home/user/shell",
-			expected: "output_path = '" + dataDir + "/color-schemes/theme.colors'",
-		},
-		{
-			name:     "substitutes CACHE_DIR",
-			input:    "output_path = 'CACHE_DIR/wal/colors.json'",
-			shellDir: "/home/user/shell",
-			expected: "output_path = '" + cacheDir + "/wal/colors.json'",
-		},
-		{
-			name:     "substitutes all dir types",
-			input:    "'SHELL_DIR/a' 'CONFIG_DIR/b' 'DATA_DIR/c' 'CACHE_DIR/d'",
-			shellDir: "/shell",
-			expected: "'/shell/a' '" + configDir + "/b' '" + dataDir + "/c' '" + cacheDir + "/d'",
-		},
-		{
-			name:     "no substitution when no placeholders",
-			input:    "input_path = '/absolute/path/foo.conf'",
-			shellDir: "/home/user/shell",
-			expected: "input_path = '/absolute/path/foo.conf'",
-		},
-		{
-			name:     "multiple SHELL_DIR occurrences",
-			input:    "'SHELL_DIR/a' and 'SHELL_DIR/b'",
-			shellDir: "/shell",
-			expected: "'/shell/a' and '/shell/b'",
-		},
-		{
-			name:     "only substitutes quoted paths",
-			input:    "SHELL_DIR/unquoted and 'SHELL_DIR/quoted'",
-			shellDir: "/shell",
-			expected: "SHELL_DIR/unquoted and '/shell/quoted'",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := substituteVars(tc.input, tc.shellDir)
-			assert.Equal(t, tc.expected, result)
-		})
-	}
-}

core/internal/mocks/utils/mock_AppChecker.go

@@ -1,242 +0,0 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
-
-package mocks_utils
-
-import mock "github.com/stretchr/testify/mock"
-
-// MockAppChecker is an autogenerated mock type for the AppChecker type
-type MockAppChecker struct {
-	mock.Mock
-}
-
-type MockAppChecker_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MockAppChecker) EXPECT() *MockAppChecker_Expecter {
-	return &MockAppChecker_Expecter{mock: &_m.Mock}
-}
-
-// AnyCommandExists provides a mock function with given fields: cmds
-func (_m *MockAppChecker) AnyCommandExists(cmds ...string) bool {
-	_va := make([]interface{}, len(cmds))
-	for _i := range cmds {
-		_va[_i] = cmds[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AnyCommandExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(...string) bool); ok {
-		r0 = rf(cmds...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_AnyCommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyCommandExists'
-type MockAppChecker_AnyCommandExists_Call struct {
-	*mock.Call
-}
-
-// AnyCommandExists is a helper method to define mock.On call
-//   - cmds ...string
-func (_e *MockAppChecker_Expecter) AnyCommandExists(cmds ...interface{}) *MockAppChecker_AnyCommandExists_Call {
-	return &MockAppChecker_AnyCommandExists_Call{Call: _e.mock.On("AnyCommandExists",
-		append([]interface{}{}, cmds...)...)}
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) Run(run func(cmds ...string)) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) Return(_a0 bool) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// AnyFlatpakExists provides a mock function with given fields: flatpaks
-func (_m *MockAppChecker) AnyFlatpakExists(flatpaks ...string) bool {
-	_va := make([]interface{}, len(flatpaks))
-	for _i := range flatpaks {
-		_va[_i] = flatpaks[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AnyFlatpakExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(...string) bool); ok {
-		r0 = rf(flatpaks...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_AnyFlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyFlatpakExists'
-type MockAppChecker_AnyFlatpakExists_Call struct {
-	*mock.Call
-}
-
-// AnyFlatpakExists is a helper method to define mock.On call
-//   - flatpaks ...string
-func (_e *MockAppChecker_Expecter) AnyFlatpakExists(flatpaks ...interface{}) *MockAppChecker_AnyFlatpakExists_Call {
-	return &MockAppChecker_AnyFlatpakExists_Call{Call: _e.mock.On("AnyFlatpakExists",
-		append([]interface{}{}, flatpaks...)...)}
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) Run(run func(flatpaks ...string)) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) Return(_a0 bool) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CommandExists provides a mock function with given fields: cmd
-func (_m *MockAppChecker) CommandExists(cmd string) bool {
-	ret := _m.Called(cmd)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CommandExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(cmd)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_CommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandExists'
-type MockAppChecker_CommandExists_Call struct {
-	*mock.Call
-}
-
-// CommandExists is a helper method to define mock.On call
-//   - cmd string
-func (_e *MockAppChecker_Expecter) CommandExists(cmd interface{}) *MockAppChecker_CommandExists_Call {
-	return &MockAppChecker_CommandExists_Call{Call: _e.mock.On("CommandExists", cmd)}
-}
-
-func (_c *MockAppChecker_CommandExists_Call) Run(run func(cmd string)) *MockAppChecker_CommandExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_CommandExists_Call) Return(_a0 bool) *MockAppChecker_CommandExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_CommandExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_CommandExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FlatpakExists provides a mock function with given fields: name
-func (_m *MockAppChecker) FlatpakExists(name string) bool {
-	ret := _m.Called(name)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FlatpakExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(name)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_FlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlatpakExists'
-type MockAppChecker_FlatpakExists_Call struct {
-	*mock.Call
-}
-
-// FlatpakExists is a helper method to define mock.On call
-//   - name string
-func (_e *MockAppChecker_Expecter) FlatpakExists(name interface{}) *MockAppChecker_FlatpakExists_Call {
-	return &MockAppChecker_FlatpakExists_Call{Call: _e.mock.On("FlatpakExists", name)}
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) Run(run func(name string)) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) Return(_a0 bool) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewMockAppChecker creates a new instance of MockAppChecker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockAppChecker(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockAppChecker {
-	mock := &MockAppChecker{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/plugins/registry.go

@@ -26,7 +26,6 @@ type Plugin struct {
 	Compositors  []string `json:"compositors"`
 	Distro       []string `json:"distro"`
 	Screenshot   string   `json:"screenshot,omitempty"`
-	RequiresDMS  string   `json:"requires_dms,omitempty"`
 }
 
 type GitClient interface {

core/internal/screenshot/region_input.go

@@ -141,7 +141,7 @@ func (r *RegionSelector) setupKeyboardHandlers() {
 			for _, os := range r.surfaces {
 				r.redrawSurface(os)
 			}
-		case 28, 57, 96:
+		case 28, 57:
 			if r.selection.hasSelection {
 				r.finishSelection()
 			}

core/internal/server/apppicker/handlers.go

@@ -19,9 +19,9 @@ func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 func handleOpen(conn net.Conn, req models.Request, manager *Manager) {
 	log.Infof("AppPicker: Received %s request with params: %+v", req.Method, req.Params)
 
-	target, ok := models.Get[string](req, "target")
+	target, ok := req.Params["target"].(string)
 	if !ok {
-		target, ok = models.Get[string](req, "url")
+		target, ok = req.Params["url"].(string)
 		if !ok {
 			log.Warnf("AppPicker: Invalid target parameter in request")
 			models.RespondError(conn, req.ID, "invalid target parameter")
@@ -31,11 +31,14 @@ func handleOpen(conn net.Conn, req models.Request, manager *Manager) {
 
 	event := OpenEvent{
 		Target:      target,
-		RequestType: models.GetOr(req, "requestType", "url"),
+		RequestType: "url",
-		MimeType:    models.GetOr(req, "mimeType", ""),
 	}
 
-	if categories, ok := models.Get[[]any](req, "categories"); ok {
+	if mimeType, ok := req.Params["mimeType"].(string); ok {
+		event.MimeType = mimeType
+	}
+
+	if categories, ok := req.Params["categories"].([]any); ok {
 		event.Categories = make([]string, 0, len(categories))
 		for _, cat := range categories {
 			if catStr, ok := cat.(string); ok {
@@ -44,6 +47,10 @@ func handleOpen(conn net.Conn, req models.Request, manager *Manager) {
 		}
 	}
 
+	if requestType, ok := req.Params["requestType"].(string); ok {
+		event.RequestType = requestType
+	}
+
 	log.Infof("AppPicker: Broadcasting event: %+v", event)
 	manager.RequestOpen(event)
 	models.Respond(conn, req.ID, "ok")

core/internal/server/browser/handlers.go

@@ -9,7 +9,7 @@ import (
 func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "browser.open":
-		url, ok := models.Get[string](req, "url")
+		url, ok := req.Params["url"].(string)
 		if !ok {
 			models.RespondError(conn, req.ID, "invalid url parameter")
 			return

core/internal/server/clipboard/handlers.go

@@ -168,14 +168,14 @@ func handleSearch(conn net.Conn, req models.Request, m *Manager) {
 		Offset:   params.IntOpt(req.Params, "offset", 0),
 	}
 
-	if img, ok := models.Get[bool](req, "isImage"); ok {
+	if img, ok := req.Params["isImage"].(bool); ok {
 		p.IsImage = &img
 	}
-	if b, ok := models.Get[float64](req, "before"); ok {
+	if b, ok := req.Params["before"].(float64); ok {
 		v := int64(b)
 		p.Before = &v
 	}
-	if a, ok := models.Get[float64](req, "after"); ok {
+	if a, ok := req.Params["after"].(float64); ok {
 		v := int64(a)
 		p.After = &v
 	}
@@ -190,21 +190,24 @@ func handleGetConfig(conn net.Conn, req models.Request, m *Manager) {
 func handleSetConfig(conn net.Conn, req models.Request, m *Manager) {
 	cfg := m.GetConfig()
 
-	if v, ok := models.Get[float64](req, "maxHistory"); ok {
+	if _, ok := req.Params["maxHistory"]; ok {
-		cfg.MaxHistory = int(v)
+		cfg.MaxHistory = params.IntOpt(req.Params, "maxHistory", cfg.MaxHistory)
 	}
-	if v, ok := models.Get[float64](req, "maxEntrySize"); ok {
+	if _, ok := req.Params["maxEntrySize"]; ok {
-		cfg.MaxEntrySize = int64(v)
+		cfg.MaxEntrySize = int64(params.IntOpt(req.Params, "maxEntrySize", int(cfg.MaxEntrySize)))
 	}
-	if v, ok := models.Get[float64](req, "autoClearDays"); ok {
+	if _, ok := req.Params["autoClearDays"]; ok {
-		cfg.AutoClearDays = int(v)
+		cfg.AutoClearDays = params.IntOpt(req.Params, "autoClearDays", cfg.AutoClearDays)
 	}
-	if v, ok := models.Get[bool](req, "clearAtStartup"); ok {
+	if v, ok := req.Params["clearAtStartup"].(bool); ok {
 		cfg.ClearAtStartup = v
 	}
-	if v, ok := models.Get[bool](req, "disabled"); ok {
+	if v, ok := req.Params["disabled"].(bool); ok {
 		cfg.Disabled = v
 	}
+	if v, ok := req.Params["disableHistory"].(bool); ok {
+		cfg.DisableHistory = v
+	}
 
 	if err := m.SetConfig(cfg); err != nil {
 		models.RespondError(conn, req.ID, err.Error())

core/internal/server/clipboard/manager.go

@@ -11,34 +11,30 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"syscall"
 	"time"
 
-	"hash/fnv"
-
 	"github.com/fsnotify/fsnotify"
 	_ "golang.org/x/image/bmp"
 	_ "golang.org/x/image/tiff"
+	"hash/fnv"
 
 	bolt "go.etcd.io/bbolt"
 
-	clipboardstore "github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/ext_data_control"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/wlcontext"
 	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 )
 
-// These mime types won't be stored in history
-var sensitiveMimeTypes = []string{
-	"x-kde-passwordManagerHint",
-}
-
 func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error) {
+	if config.Disabled {
+		return nil, fmt.Errorf("clipboard disabled in config")
+	}
+
 	display := wlCtx.Display()
-	dbPath, err := clipboardstore.GetDBPath()
+	dbPath, err := getDBPath()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get db path: %w", err)
 	}
@@ -58,10 +54,8 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 		dbPath:         dbPath,
 	}
 
-	if !config.Disabled {
+	if err := m.setupRegistry(); err != nil {
-		if err := m.setupRegistry(); err != nil {
+		return nil, err
-			return nil, err
-		}
 	}
 
 	m.notifierWg.Add(1)
@@ -69,17 +63,17 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 
 	go m.watchConfig()
 
-	db, err := openDB(dbPath)
+	if !config.DisableHistory {
-	if err != nil {
+		db, err := openDB(dbPath)
-		return nil, fmt.Errorf("failed to open db: %w", err)
+		if err != nil {
-	}
+			return nil, fmt.Errorf("failed to open db: %w", err)
-	m.db = db
+		}
+		m.db = db
 
-	if err := m.migrateHashes(); err != nil {
+		if err := m.migrateHashes(); err != nil {
-		log.Errorf("Failed to migrate hashes: %v", err)
+			log.Errorf("Failed to migrate hashes: %v", err)
-	}
+		}
 
-	if !config.Disabled {
 		if config.ClearAtStartup {
 			if err := m.clearHistoryInternal(); err != nil {
 				log.Errorf("Failed to clear history at startup: %v", err)
@@ -96,13 +90,31 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 	m.alive = true
 	m.updateState()
 
-	if !config.Disabled && m.dataControlMgr != nil && m.seat != nil {
+	if m.dataControlMgr != nil && m.seat != nil {
 		m.setupDataDeviceSync()
 	}
 
 	return m, nil
 }
 
+func getDBPath() (string, error) {
+	cacheDir := os.Getenv("XDG_CACHE_HOME")
+	if cacheDir == "" {
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		cacheDir = filepath.Join(homeDir, ".cache")
+	}
+
+	dbDir := filepath.Join(cacheDir, "dms-clipboard")
+	if err := os.MkdirAll(dbDir, 0700); err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dbDir, "db"), nil
+}
+
 func openDB(path string) (*bolt.DB, error) {
 	db, err := bolt.Open(path, 0644, &bolt.Options{
 		Timeout: 1 * time.Second,
@@ -241,10 +253,6 @@ func (m *Manager) setupDataDeviceSync() {
 			return
 		}
 
-		if m.hasSensitiveMimeType(mimes) {
-			return
-		}
-
 		preferredMime := m.selectMimeType(mimes)
 		if preferredMime == "" {
 			return
@@ -307,7 +315,7 @@ func (m *Manager) readAndStore(r *os.File, mimeType string) {
 		return
 	}
 
-	if !cfg.Disabled && m.db != nil {
+	if !cfg.DisableHistory && m.db != nil {
 		m.storeClipboardEntry(data, mimeType)
 	}
 
@@ -484,12 +492,6 @@ func extractHash(data []byte) uint64 {
 	return binary.BigEndian.Uint64(data[len(data)-8:])
 }
 
-func (m *Manager) hasSensitiveMimeType(mimes []string) bool {
-	return slices.ContainsFunc(mimes, func(mime string) bool {
-		return slices.Contains(sensitiveMimeTypes, mime)
-	})
-}
-
 func (m *Manager) selectMimeType(mimes []string) string {
 	preferredTypes := []string{
 		"text/plain;charset=utf-8",
@@ -1192,13 +1194,23 @@ func (m *Manager) applyConfigChange(newCfg Config) {
 	m.config = newCfg
 	m.configMutex.Unlock()
 
-	switch {
+	if newCfg.DisableHistory && !oldCfg.DisableHistory && m.db != nil {
-	case newCfg.Disabled && !oldCfg.Disabled:
+		log.Info("Clipboard history disabled, closing database")
-		log.Info("Clipboard tracking disabled")
+		m.db.Close()
-	case !newCfg.Disabled && oldCfg.Disabled:
+		m.db = nil
-		log.Info("Clipboard tracking enabled")
 	}
 
+	if !newCfg.DisableHistory && oldCfg.DisableHistory && m.db == nil {
+		log.Info("Clipboard history enabled, opening database")
+		if db, err := openDB(m.dbPath); err == nil {
+			m.db = db
+		} else {
+			log.Errorf("Failed to reopen database: %v", err)
+		}
+	}
+
+	log.Infof("Clipboard config reloaded: disableHistory=%v", newCfg.DisableHistory)
+
 	m.updateState()
 	m.notifySubscribers()
 }
@@ -1206,8 +1218,8 @@ func (m *Manager) applyConfigChange(newCfg Config) {
 func (m *Manager) StoreData(data []byte, mimeType string) error {
 	cfg := m.getConfig()
 
-	if cfg.Disabled {
+	if cfg.DisableHistory {
-		return fmt.Errorf("clipboard tracking disabled")
+		return fmt.Errorf("clipboard history disabled")
 	}
 
 	if m.db == nil {

core/internal/server/clipboard/manager_test.go

@@ -457,6 +457,7 @@ func TestDefaultConfig(t *testing.T) {
 	assert.Equal(t, 0, cfg.AutoClearDays)
 	assert.False(t, cfg.ClearAtStartup)
 	assert.False(t, cfg.Disabled)
+	assert.False(t, cfg.DisableHistory)
 }
 
 func TestManager_PostDelegatesToWlContext(t *testing.T) {

core/internal/server/clipboard/types.go

@@ -18,7 +18,9 @@ type Config struct {
 	MaxEntrySize   int64 `json:"maxEntrySize"`
 	AutoClearDays  int   `json:"autoClearDays"`
 	ClearAtStartup bool  `json:"clearAtStartup"`
-	Disabled       bool  `json:"disabled"`
+
+	Disabled       bool `json:"disabled"`
+	DisableHistory bool `json:"disableHistory"`
 }
 
 func DefaultConfig() Config {

core/internal/server/dwl/handlers.go

@@ -41,19 +41,19 @@ func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 }
 
 func handleSetTags(conn net.Conn, req models.Request, manager *Manager) {
-	output, ok := models.Get[string](req, "output")
+	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	tagmask, ok := models.Get[float64](req, "tagmask")
+	tagmask, ok := req.Params["tagmask"].(float64)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'tagmask' parameter")
 		return
 	}
 
-	toggleTagset, ok := models.Get[float64](req, "toggleTagset")
+	toggleTagset, ok := req.Params["toggleTagset"].(float64)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'toggleTagset' parameter")
 		return
@@ -68,19 +68,19 @@ func handleSetTags(conn net.Conn, req models.Request, manager *Manager) {
 }
 
 func handleSetClientTags(conn net.Conn, req models.Request, manager *Manager) {
-	output, ok := models.Get[string](req, "output")
+	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	andTags, ok := models.Get[float64](req, "andTags")
+	andTags, ok := req.Params["andTags"].(float64)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'andTags' parameter")
 		return
 	}
 
-	xorTags, ok := models.Get[float64](req, "xorTags")
+	xorTags, ok := req.Params["xorTags"].(float64)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'xorTags' parameter")
 		return
@@ -95,13 +95,13 @@ func handleSetClientTags(conn net.Conn, req models.Request, manager *Manager) {
 }
 
 func handleSetLayout(conn net.Conn, req models.Request, manager *Manager) {
-	output, ok := models.Get[string](req, "output")
+	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	index, ok := models.Get[float64](req, "index")
+	index, ok := req.Params["index"].(float64)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'index' parameter")
 		return

core/internal/server/extworkspace/handlers.go

@@ -43,8 +43,12 @@ func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 }
 
 func handleActivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
-	groupID := models.GetOr(req, "groupID", "")
+	groupID, ok := req.Params["groupID"].(string)
-	workspaceID, ok := models.Get[string](req, "workspaceID")
+	if !ok {
+		groupID = ""
+	}
+
+	workspaceID, ok := req.Params["workspaceID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'workspaceID' parameter")
 		return
@@ -59,8 +63,12 @@ func handleActivateWorkspace(conn net.Conn, req models.Request, manager *Manager
 }
 
 func handleDeactivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
-	groupID := models.GetOr(req, "groupID", "")
+	groupID, ok := req.Params["groupID"].(string)
-	workspaceID, ok := models.Get[string](req, "workspaceID")
+	if !ok {
+		groupID = ""
+	}
+
+	workspaceID, ok := req.Params["workspaceID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'workspaceID' parameter")
 		return
@@ -75,8 +83,12 @@ func handleDeactivateWorkspace(conn net.Conn, req models.Request, manager *Manag
 }
 
 func handleRemoveWorkspace(conn net.Conn, req models.Request, manager *Manager) {
-	groupID := models.GetOr(req, "groupID", "")
+	groupID, ok := req.Params["groupID"].(string)
-	workspaceID, ok := models.Get[string](req, "workspaceID")
+	if !ok {
+		groupID = ""
+	}
+
+	workspaceID, ok := req.Params["workspaceID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'workspaceID' parameter")
 		return
@@ -91,13 +103,13 @@ func handleRemoveWorkspace(conn net.Conn, req models.Request, manager *Manager)
 }
 
 func handleCreateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
-	groupID, ok := models.Get[string](req, "groupID")
+	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'groupID' parameter")
 		return
 	}
 
-	workspaceName, ok := models.Get[string](req, "name")
+	workspaceName, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/matugen_handler.go

@@ -15,23 +15,37 @@ type MatugenQueueResult struct {
 }
 
 func handleMatugenQueue(conn net.Conn, req models.Request) {
-	opts := matugen.Options{
+	getString := func(key string) string {
-		StateDir:            models.GetOr(req, "stateDir", ""),
+		if v, ok := req.Params[key].(string); ok {
-		ShellDir:            models.GetOr(req, "shellDir", ""),
+			return v
-		ConfigDir:           models.GetOr(req, "configDir", ""),
+		}
-		Kind:                models.GetOr(req, "kind", ""),
+		return ""
-		Value:               models.GetOr(req, "value", ""),
-		Mode:                matugen.ColorMode(models.GetOr(req, "mode", "")),
-		IconTheme:           models.GetOr(req, "iconTheme", ""),
-		MatugenType:         models.GetOr(req, "matugenType", ""),
-		RunUserTemplates:    models.GetOr(req, "runUserTemplates", true),
-		StockColors:         models.GetOr(req, "stockColors", ""),
-		SyncModeWithPortal:  models.GetOr(req, "syncModeWithPortal", false),
-		TerminalsAlwaysDark: models.GetOr(req, "terminalsAlwaysDark", false),
-		SkipTemplates:       models.GetOr(req, "skipTemplates", ""),
 	}
 
-	wait := models.GetOr(req, "wait", true)
+	getBool := func(key string, def bool) bool {
+		if v, ok := req.Params[key].(bool); ok {
+			return v
+		}
+		return def
+	}
+
+	opts := matugen.Options{
+		StateDir:            getString("stateDir"),
+		ShellDir:            getString("shellDir"),
+		ConfigDir:           getString("configDir"),
+		Kind:                getString("kind"),
+		Value:               getString("value"),
+		Mode:                getString("mode"),
+		IconTheme:           getString("iconTheme"),
+		MatugenType:         getString("matugenType"),
+		RunUserTemplates:    getBool("runUserTemplates", true),
+		StockColors:         getString("stockColors"),
+		SyncModeWithPortal:  getBool("syncModeWithPortal", false),
+		TerminalsAlwaysDark: getBool("terminalsAlwaysDark", false),
+		SkipTemplates:       getString("skipTemplates"),
+	}
+
+	wait := getBool("wait", true)
 
 	queue := matugen.GetQueue()
 	resultCh := queue.Submit(opts)

core/internal/server/models/types.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
 type Request struct {
@@ -14,15 +13,6 @@ type Request struct {
 	Params map[string]any `json:"params,omitempty"`
 }
 
-func Get[T any](r Request, key string) (T, bool) {
-	v, err := params.Get[T](r.Params, key)
-	return v, err == nil
-}
-
-func GetOr[T any](r Request, key string, def T) T {
-	return params.GetOpt(r.Params, key, def)
-}
-
 type Response[T any] struct {
 	ID     int    `json:"id,omitempty"`
 	Result *T     `json:"result,omitempty"`

core/internal/server/models/types_test.go

@@ -1,52 +0,0 @@
-package models
-
-import "testing"
-
-func TestGet(t *testing.T) {
-	req := Request{Params: map[string]any{"name": "test", "count": 42, "enabled": true}}
-
-	name, ok := Get[string](req, "name")
-	if !ok || name != "test" {
-		t.Errorf("Get[string] = %q, %v; want 'test', true", name, ok)
-	}
-
-	count, ok := Get[int](req, "count")
-	if !ok || count != 42 {
-		t.Errorf("Get[int] = %d, %v; want 42, true", count, ok)
-	}
-
-	enabled, ok := Get[bool](req, "enabled")
-	if !ok || !enabled {
-		t.Errorf("Get[bool] = %v, %v; want true, true", enabled, ok)
-	}
-
-	_, ok = Get[string](req, "missing")
-	if ok {
-		t.Error("Get missing key should return false")
-	}
-
-	_, ok = Get[int](req, "name")
-	if ok {
-		t.Error("Get wrong type should return false")
-	}
-}
-
-func TestGetOr(t *testing.T) {
-	req := Request{Params: map[string]any{"name": "test", "enabled": true}}
-
-	if v := GetOr(req, "name", "default"); v != "test" {
-		t.Errorf("GetOr existing = %q; want 'test'", v)
-	}
-
-	if v := GetOr(req, "missing", "default"); v != "default" {
-		t.Errorf("GetOr missing = %q; want 'default'", v)
-	}
-
-	if v := GetOr(req, "enabled", false); !v {
-		t.Errorf("GetOr bool = %v; want true", v)
-	}
-
-	if v := GetOr(req, "name", 0); v != 0 {
-		t.Errorf("GetOr wrong type = %d; want 0 (default)", v)
-	}
-}

core/internal/server/network/agent_networkmanager.go

@@ -233,9 +233,6 @@ func (a *SecretAgent) GetSecrets(
 	if a.manager != nil && connType == "802-11-wireless" && a.manager.WasRecentlyFailed(ssid) {
 		reason = "wrong-password"
 	}
-	if settingName == "vpn" && isPKCS11Auth(conn, vpnSvc) {
-		reason = "pkcs11"
-	}
 
 	var connId, connUuid string
 	if c, ok := conn["connection"]; ok {
@@ -252,28 +249,6 @@ func (a *SecretAgent) GetSecrets(
 	}
 
 	if settingName == "vpn" && a.backend != nil {
-		// Check for cached PKCS11 PIN first
-		isPKCS11Request := len(fields) == 1 && fields[0] == "key_pass"
-		if isPKCS11Request {
-			a.backend.cachedPKCS11Mu.Lock()
-			cached := a.backend.cachedPKCS11PIN
-			if cached != nil && cached.ConnectionUUID == connUuid {
-				a.backend.cachedPKCS11PIN = nil
-				a.backend.cachedPKCS11Mu.Unlock()
-
-				log.Infof("[SecretAgent] Using cached PKCS11 PIN")
-
-				out := nmSettingMap{}
-				vpnSec := nmVariantMap{}
-				vpnSec["secrets"] = dbus.MakeVariant(map[string]string{"key_pass": cached.PIN})
-				out[settingName] = vpnSec
-
-				return out, nil
-			}
-			a.backend.cachedPKCS11Mu.Unlock()
-		}
-
-		// Check for cached VPN password
 		a.backend.cachedVPNCredsMu.Lock()
 		cached := a.backend.cachedVPNCreds
 		if cached != nil && cached.ConnectionUUID == connUuid {
@@ -283,9 +258,9 @@ func (a *SecretAgent) GetSecrets(
 			log.Infof("[SecretAgent] Using cached password from pre-activation prompt")
 
 			out := nmSettingMap{}
-			vpnSec := nmVariantMap{}
+			sec := nmVariantMap{}
-			vpnSec["secrets"] = dbus.MakeVariant(map[string]string{"password": cached.Password})
+			sec["password"] = dbus.MakeVariant(cached.Password)
-			out[settingName] = vpnSec
+			out[settingName] = sec
 
 			if cached.SavePassword {
 				a.backend.pendingVPNSaveMu.Lock()
@@ -389,41 +364,16 @@ func (a *SecretAgent) GetSecrets(
 		}
 		sec[k] = dbus.MakeVariant(v)
 	}
-
+	out[settingName] = sec
-	// Check if this is PKCS11 auth (key_pass)
-	pin, isPKCS11 := reply.Secrets["key_pass"]
 
 	switch settingName {
-	case "vpn":
-		// VPN secrets must be wrapped in a "secrets" key per NM spec
-		secretsDict := make(map[string]string)
-		for k, v := range reply.Secrets {
-			if k != "username" {
-				secretsDict[k] = v
-			}
-		}
-		vpnSec := nmVariantMap{}
-		vpnSec["secrets"] = dbus.MakeVariant(secretsDict)
-		out[settingName] = vpnSec
-		log.Infof("[SecretAgent] Returning VPN secrets with %d fields for %s", len(secretsDict), vpnSvc)
-
-		// Cache PKCS11 PIN in case GetSecrets is called again during activation
-		if isPKCS11 && a.backend != nil {
-			a.backend.cachedPKCS11Mu.Lock()
-			a.backend.cachedPKCS11PIN = &cachedPKCS11PIN{
-				ConnectionUUID: connUuid,
-				PIN:            pin,
-			}
-			a.backend.cachedPKCS11Mu.Unlock()
-			log.Infof("[SecretAgent] Cached PKCS11 PIN for potential re-request")
-		}
 	case "802-1x":
-		out[settingName] = sec
 		log.Infof("[SecretAgent] Returning 802-1x enterprise secrets with %d fields", len(sec))
-	default:
+	case "vpn":
-		out[settingName] = sec
+		log.Infof("[SecretAgent] Returning VPN secrets with %d fields for %s", len(sec), vpnSvc)
 	}
-	if settingName == "vpn" && a.backend != nil && !isPKCS11 && (vpnUsername != "" || reply.Save) {
+
+	if settingName == "vpn" && a.backend != nil && (vpnUsername != "" || reply.Save) {
 		pw := reply.Secrets["password"]
 		a.backend.pendingVPNSaveMu.Lock()
 		a.backend.pendingVPNSave = &pendingVPNCredentials{
@@ -629,15 +579,6 @@ func inferVPNFields(conn map[string]nmVariantMap, vpnService string) []string {
 	connType := dataMap["connection-type"]
 
 	switch {
-	case strings.Contains(vpnService, "openconnect"):
-		authType := dataMap["authtype"]
-		userCert := dataMap["usercert"]
-		if authType == "cert" && strings.HasPrefix(userCert, "pkcs11:") {
-			return []string{"key_pass"}
-		}
-		if dataMap["username"] == "" {
-			fields = []string{"username", "password"}
-		}
 	case strings.Contains(vpnService, "openvpn"):
 		if connType == "password" || connType == "password-tls" {
 			if dataMap["username"] == "" {
@@ -645,7 +586,7 @@ func inferVPNFields(conn map[string]nmVariantMap, vpnService string) []string {
 			}
 		}
 	case strings.Contains(vpnService, "vpnc"), strings.Contains(vpnService, "l2tp"),
-		strings.Contains(vpnService, "pptp"):
+		strings.Contains(vpnService, "pptp"), strings.Contains(vpnService, "openconnect"):
 		if dataMap["username"] == "" {
 			fields = []string{"username", "password"}
 		}
@@ -656,8 +597,6 @@ func inferVPNFields(conn map[string]nmVariantMap, vpnService string) []string {
 
 func vpnFieldMeta(field, vpnService string) (label string, isSecret bool) {
 	switch field {
-	case "key_pass":
-		return "PIN", true
 	case "password":
 		return "Password", true
 	case "Xauth password":
@@ -685,25 +624,6 @@ func vpnFieldMeta(field, vpnService string) (label string, isSecret bool) {
 	return titleCaser.String(strings.ReplaceAll(field, "-", " ")), false
 }
 
-func isPKCS11Auth(conn map[string]nmVariantMap, vpnService string) bool {
-	if !strings.Contains(vpnService, "openconnect") {
-		return false
-	}
-	vpnSettings, ok := conn["vpn"]
-	if !ok {
-		return false
-	}
-	dataVariant, ok := vpnSettings["data"]
-	if !ok {
-		return false
-	}
-	dataMap, ok := dataVariant.Value().(map[string]string)
-	if !ok {
-		return false
-	}
-	return dataMap["authtype"] == "cert" && strings.HasPrefix(dataMap["usercert"], "pkcs11:")
-}
-
 func readVPNPasswordFlags(conn map[string]nmVariantMap, settingName string) uint32 {
 	if settingName != "vpn" {
 		return 0xFFFF

core/internal/server/network/backend_networkmanager.go

@@ -13,7 +13,6 @@ const (
 	dbusNMPath                 = "/org/freedesktop/NetworkManager"
 	dbusNMInterface            = "org.freedesktop.NetworkManager"
 	dbusNMDeviceInterface      = "org.freedesktop.NetworkManager.Device"
-	dbusNMWiredInterface       = "org.freedesktop.NetworkManager.Device.Wired"
 	dbusNMWirelessInterface    = "org.freedesktop.NetworkManager.Device.Wireless"
 	dbusNMAccessPointInterface = "org.freedesktop.NetworkManager.AccessPoint"
 	dbusPropsInterface         = "org.freedesktop.DBus.Properties"
@@ -73,8 +72,6 @@ type NetworkManagerBackend struct {
 	pendingVPNSaveMu sync.Mutex
 	cachedVPNCreds   *cachedVPNCredentials
 	cachedVPNCredsMu sync.Mutex
-	cachedPKCS11PIN  *cachedPKCS11PIN
-	cachedPKCS11Mu   sync.Mutex
 
 	onStateChange func()
 }
@@ -92,11 +89,6 @@ type cachedVPNCredentials struct {
 	SavePassword   bool
 }
 
-type cachedPKCS11PIN struct {
-	ConnectionUUID string
-	PIN            string
-}
-
 func NewNetworkManagerBackend(nmConn ...gonetworkmanager.NetworkManager) (*NetworkManagerBackend, error) {
 	var nm gonetworkmanager.NetworkManager
 	var err error

core/internal/server/network/backend_networkmanager_signals.go

@@ -81,24 +81,44 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 		return err
 	}
 
-	for _, info := range b.wifiDevices {
+	if b.wifiDevice != nil {
+		dev := b.wifiDevice.(gonetworkmanager.Device)
 		if err := conn.AddMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dev.GetPath())),
 			dbus.WithMatchInterface(dbusPropsInterface),
 			dbus.WithMatchMember("PropertiesChanged"),
 		); err != nil {
+			conn.RemoveMatchSignal(
+				dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
+				dbus.WithMatchInterface(dbusPropsInterface),
+				dbus.WithMatchMember("PropertiesChanged"),
+			)
 			conn.RemoveSignal(signals)
 			conn.Close()
 			return err
 		}
 	}
 
-	for _, info := range b.ethernetDevices {
+	if b.ethernetDevice != nil {
+		dev := b.ethernetDevice.(gonetworkmanager.Device)
 		if err := conn.AddMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dev.GetPath())),
 			dbus.WithMatchInterface(dbusPropsInterface),
 			dbus.WithMatchMember("PropertiesChanged"),
 		); err != nil {
+			conn.RemoveMatchSignal(
+				dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
+				dbus.WithMatchInterface(dbusPropsInterface),
+				dbus.WithMatchMember("PropertiesChanged"),
+			)
+			if b.wifiDevice != nil {
+				dev := b.wifiDevice.(gonetworkmanager.Device)
+				conn.RemoveMatchSignal(
+					dbus.WithMatchObjectPath(dbus.ObjectPath(dev.GetPath())),
+					dbus.WithMatchInterface(dbusPropsInterface),
+					dbus.WithMatchMember("PropertiesChanged"),
+				)
+			}
 			conn.RemoveSignal(signals)
 			conn.Close()
 			return err
@@ -137,17 +157,19 @@ func (b *NetworkManagerBackend) stopSignalPump() {
 		dbus.WithMatchMember("PropertiesChanged"),
 	)
 
-	for _, info := range b.wifiDevices {
+	if b.wifiDevice != nil {
+		dev := b.wifiDevice.(gonetworkmanager.Device)
 		b.dbusConn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dev.GetPath())),
 			dbus.WithMatchInterface(dbusPropsInterface),
 			dbus.WithMatchMember("PropertiesChanged"),
 		)
 	}
 
-	for _, info := range b.ethernetDevices {
+	if b.ethernetDevice != nil {
+		dev := b.ethernetDevice.(gonetworkmanager.Device)
 		b.dbusConn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dev.GetPath())),
 			dbus.WithMatchInterface(dbusPropsInterface),
 			dbus.WithMatchMember("PropertiesChanged"),
 		)
@@ -210,10 +232,7 @@ func (b *NetworkManagerBackend) handleDBusSignal(sig *dbus.Signal) {
 		b.handleNetworkManagerChange(changes)
 
 	case dbusNMDeviceInterface:
-		b.handleDeviceChange(sig.Path, changes)
+		b.handleDeviceChange(changes)
-
-	case dbusNMWiredInterface:
-		b.handleWiredChange(changes)
 
 	case dbusNMWirelessInterface:
 		b.handleWiFiChange(changes)
@@ -259,10 +278,9 @@ func (b *NetworkManagerBackend) handleNetworkManagerChange(changes map[string]db
 	}
 }
 
-func (b *NetworkManagerBackend) handleDeviceChange(devicePath dbus.ObjectPath, changes map[string]dbus.Variant) {
+func (b *NetworkManagerBackend) handleDeviceChange(changes map[string]dbus.Variant) {
 	var needsUpdate bool
 	var stateChanged bool
-	var managedChanged bool
 
 	for key := range changes {
 		switch key {
@@ -271,61 +289,21 @@ func (b *NetworkManagerBackend) handleDeviceChange(devicePath dbus.ObjectPath, c
 			needsUpdate = true
 		case "Ip4Config":
 			needsUpdate = true
-		case "Managed":
-			managedChanged = true
 		default:
 			continue
 		}
 	}
 
-	if managedChanged {
+	if needsUpdate {
-		if managedVariant, ok := changes["Managed"]; ok {
+		b.updateEthernetState()
-			if managed, ok := managedVariant.Value().(bool); ok && managed {
+		b.updateWiFiState()
-				b.handleDeviceAdded(devicePath)
+		if stateChanged {
-				return
+			b.updatePrimaryConnection()
-			}
 		}
-	}
+		if b.onStateChange != nil {
-
+			b.onStateChange()
-	if !needsUpdate {
-		return
-	}
-
-	b.updateAllEthernetDevices()
-	b.updateEthernetState()
-	b.updateAllWiFiDevices()
-	b.updateWiFiState()
-	if stateChanged {
-		b.listEthernetConnections()
-		b.updatePrimaryConnection()
-	}
-	if b.onStateChange != nil {
-		b.onStateChange()
-	}
-}
-
-func (b *NetworkManagerBackend) handleWiredChange(changes map[string]dbus.Variant) {
-	var needsUpdate bool
-
-	for key := range changes {
-		switch key {
-		case "Carrier", "Speed", "HwAddress":
-			needsUpdate = true
-		default:
-			continue
 		}
 	}
-
-	if !needsUpdate {
-		return
-	}
-
-	b.updateAllEthernetDevices()
-	b.updateEthernetState()
-	b.updatePrimaryConnection()
-	if b.onStateChange != nil {
-		b.onStateChange()
-	}
 }
 
 func (b *NetworkManagerBackend) handleWiFiChange(changes map[string]dbus.Variant) {
@@ -391,18 +369,6 @@ func (b *NetworkManagerBackend) handleDeviceAdded(devicePath dbus.ObjectPath) {
 		return
 	}
 
-	if devType != gonetworkmanager.NmDeviceTypeEthernet && devType != gonetworkmanager.NmDeviceTypeWifi {
-		return
-	}
-
-	if b.dbusConn != nil {
-		b.dbusConn.AddMatchSignal(
-			dbus.WithMatchObjectPath(devicePath),
-			dbus.WithMatchInterface(dbusPropsInterface),
-			dbus.WithMatchMember("PropertiesChanged"),
-		)
-	}
-
 	managed, _ := dev.GetPropertyManaged()
 	if !managed {
 		return
@@ -432,6 +398,14 @@ func (b *NetworkManagerBackend) handleDeviceAdded(devicePath dbus.ObjectPath) {
 			b.ethernetDevice = dev
 		}
 
+		if b.dbusConn != nil {
+			b.dbusConn.AddMatchSignal(
+				dbus.WithMatchObjectPath(devicePath),
+				dbus.WithMatchInterface(dbusPropsInterface),
+				dbus.WithMatchMember("PropertiesChanged"),
+			)
+		}
+
 		b.updateAllEthernetDevices()
 		b.updateEthernetState()
 		b.listEthernetConnections()
@@ -456,6 +430,14 @@ func (b *NetworkManagerBackend) handleDeviceAdded(devicePath dbus.ObjectPath) {
 			b.wifiDev = w
 		}
 
+		if b.dbusConn != nil {
+			b.dbusConn.AddMatchSignal(
+				dbus.WithMatchObjectPath(devicePath),
+				dbus.WithMatchInterface(dbusPropsInterface),
+				dbus.WithMatchMember("PropertiesChanged"),
+			)
+		}
+
 		b.updateAllWiFiDevices()
 		b.updateWiFiState()
 	}

core/internal/server/network/backend_networkmanager_signals_test.go

@@ -159,7 +159,7 @@ func TestNetworkManagerBackend_HandleDeviceChange(t *testing.T) {
 	}
 
 	assert.NotPanics(t, func() {
-		backend.handleDeviceChange("/org/freedesktop/NetworkManager/Devices/1", changes)
+		backend.handleDeviceChange(changes)
 	})
 }
 
@@ -174,7 +174,7 @@ func TestNetworkManagerBackend_HandleDeviceChange_Ip4Config(t *testing.T) {
 	}
 
 	assert.NotPanics(t, func() {
-		backend.handleDeviceChange("/org/freedesktop/NetworkManager/Devices/1", changes)
+		backend.handleDeviceChange(changes)
 	})
 }
 

core/internal/server/network/backend_networkmanager_vpn.go

@@ -3,7 +3,6 @@ package network
 import (
 	"bufio"
 	"context"
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -283,26 +282,111 @@ func (b *NetworkManagerBackend) ConnectVPN(uuidOrName string, singleActive bool)
 		}
 	}
 
+	needsUsernamePrePrompt := false
 	var vpnServiceType string
-	var vpnData map[string]string
 	if vpnSettings, ok := targetSettings["vpn"]; ok {
 		if svc, ok := vpnSettings["service-type"].(string); ok {
 			vpnServiceType = svc
 		}
 		if data, ok := vpnSettings["data"].(map[string]string); ok {
-			vpnData = data
+			connType := data["connection-type"]
+			username := data["username"]
+			// OpenVPN password auth needs username in vpn.data
+			if strings.Contains(vpnServiceType, "openvpn") &&
+				(connType == "password" || connType == "password-tls") &&
+				username == "" {
+				needsUsernamePrePrompt = true
+			}
 		}
 	}
 
-	authAction := detectVPNAuthAction(vpnServiceType, vpnData)
+	// If username is needed but missing, prompt for it before activating
+	if needsUsernamePrePrompt && b.promptBroker != nil {
+		log.Infof("[ConnectVPN] OpenVPN requires username in vpn.data - prompting before activation")
 
-	switch authAction {
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
-	case "openvpn_username":
+		defer cancel()
-		if b.promptBroker == nil {
+
-			return fmt.Errorf("OpenVPN password authentication requires interactive prompt")
+		token, err := b.promptBroker.Ask(ctx, PromptRequest{
+			Name:           connName,
+			ConnType:       "vpn",
+			VpnService:     vpnServiceType,
+			SettingName:    "vpn",
+			Fields:         []string{"username", "password"},
+			FieldsInfo:     []FieldInfo{{Name: "username", Label: "Username", IsSecret: false}, {Name: "password", Label: "Password", IsSecret: true}},
+			Reason:         "required",
+			ConnectionId:   connName,
+			ConnectionUuid: targetUUID,
+			ConnectionPath: string(targetConn.GetPath()),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to request credentials: %w", err)
 		}
-		if err := b.handleOpenVPNUsernameAuth(targetConn, connName, targetUUID, vpnServiceType); err != nil {
+
-			return err
+		reply, err := b.promptBroker.Wait(ctx, token)
+		if err != nil {
+			return fmt.Errorf("credentials prompt failed: %w", err)
+		}
+
+		username := reply.Secrets["username"]
+		password := reply.Secrets["password"]
+		if username != "" {
+			connObj := b.dbusConn.Object("org.freedesktop.NetworkManager", targetConn.GetPath())
+			var existingSettings map[string]map[string]dbus.Variant
+			if err := connObj.Call("org.freedesktop.NetworkManager.Settings.Connection.GetSettings", 0).Store(&existingSettings); err != nil {
+				return fmt.Errorf("failed to get settings for username save: %w", err)
+			}
+
+			settings := make(map[string]map[string]dbus.Variant)
+			if connSection, ok := existingSettings["connection"]; ok {
+				settings["connection"] = connSection
+			}
+			vpn := existingSettings["vpn"]
+			var data map[string]string
+			if dataVariant, ok := vpn["data"]; ok {
+				if dm, ok := dataVariant.Value().(map[string]string); ok {
+					data = make(map[string]string)
+					for k, v := range dm {
+						data[k] = v
+					}
+				} else {
+					data = make(map[string]string)
+				}
+			} else {
+				data = make(map[string]string)
+			}
+			data["username"] = username
+
+			if reply.Save && password != "" {
+				data["password-flags"] = "0"
+				secs := make(map[string]string)
+				secs["password"] = password
+				vpn["secrets"] = dbus.MakeVariant(secs)
+				log.Infof("[ConnectVPN] Saving username and password to vpn.data")
+			} else {
+				log.Infof("[ConnectVPN] Saving username to vpn.data (password will be prompted)")
+			}
+
+			vpn["data"] = dbus.MakeVariant(data)
+			settings["vpn"] = vpn
+
+			var result map[string]dbus.Variant
+			if err := connObj.Call("org.freedesktop.NetworkManager.Settings.Connection.Update2", 0,
+				settings, uint32(0x1), map[string]dbus.Variant{}).Store(&result); err != nil {
+				return fmt.Errorf("failed to save username: %w", err)
+			}
+			log.Infof("[ConnectVPN] Username saved to connection, now activating")
+
+			if password != "" && !reply.Save {
+				b.cachedVPNCredsMu.Lock()
+				b.cachedVPNCreds = &cachedVPNCredentials{
+					ConnectionUUID: targetUUID,
+					Password:       password,
+					SavePassword:   reply.Save,
+				}
+				b.cachedVPNCredsMu.Unlock()
+				log.Infof("[ConnectVPN] Cached password for GetSecrets")
+			}
 		}
 	}
 
@@ -333,119 +417,6 @@ func (b *NetworkManagerBackend) ConnectVPN(uuidOrName string, singleActive bool)
 	return nil
 }
 
-func detectVPNAuthAction(serviceType string, data map[string]string) string {
-	if data == nil {
-		return ""
-	}
-
-	switch {
-	case strings.Contains(serviceType, "openvpn"):
-		connType := data["connection-type"]
-		username := data["username"]
-		if (connType == "password" || connType == "password-tls") && username == "" {
-			return "openvpn_username"
-		}
-	}
-	return ""
-}
-
-func (b *NetworkManagerBackend) handleOpenVPNUsernameAuth(targetConn gonetworkmanager.Connection, connName, targetUUID, vpnServiceType string) error {
-	log.Infof("[ConnectVPN] OpenVPN requires username in vpn.data - prompting before activation")
-
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
-	defer cancel()
-
-	token, err := b.promptBroker.Ask(ctx, PromptRequest{
-		Name:           connName,
-		ConnType:       "vpn",
-		VpnService:     vpnServiceType,
-		SettingName:    "vpn",
-		Fields:         []string{"username", "password"},
-		FieldsInfo:     []FieldInfo{{Name: "username", Label: "Username", IsSecret: false}, {Name: "password", Label: "Password", IsSecret: true}},
-		Reason:         "required",
-		ConnectionId:   connName,
-		ConnectionUuid: targetUUID,
-		ConnectionPath: string(targetConn.GetPath()),
-	})
-	if err != nil {
-		return fmt.Errorf("failed to request credentials: %w", err)
-	}
-
-	reply, err := b.promptBroker.Wait(ctx, token)
-	if err != nil {
-		return fmt.Errorf("credentials prompt failed: %w", err)
-	}
-
-	if reply.Cancel {
-		return fmt.Errorf("user cancelled authentication")
-	}
-
-	username := reply.Secrets["username"]
-	password := reply.Secrets["password"]
-	if username == "" {
-		return nil
-	}
-
-	connObj := b.dbusConn.Object("org.freedesktop.NetworkManager", targetConn.GetPath())
-	var existingSettings map[string]map[string]dbus.Variant
-	if err := connObj.Call("org.freedesktop.NetworkManager.Settings.Connection.GetSettings", 0).Store(&existingSettings); err != nil {
-		return fmt.Errorf("failed to get settings for username save: %w", err)
-	}
-
-	settings := make(map[string]map[string]dbus.Variant)
-	if connSection, ok := existingSettings["connection"]; ok {
-		settings["connection"] = connSection
-	}
-	vpn := existingSettings["vpn"]
-	var data map[string]string
-	if dataVariant, ok := vpn["data"]; ok {
-		if dm, ok := dataVariant.Value().(map[string]string); ok {
-			data = make(map[string]string)
-			for k, v := range dm {
-				data[k] = v
-			}
-		} else {
-			data = make(map[string]string)
-		}
-	} else {
-		data = make(map[string]string)
-	}
-	data["username"] = username
-
-	if reply.Save && password != "" {
-		data["password-flags"] = "0"
-		secs := make(map[string]string)
-		secs["password"] = password
-		vpn["secrets"] = dbus.MakeVariant(secs)
-		log.Infof("[ConnectVPN] Saving username and password to vpn.data")
-	} else {
-		log.Infof("[ConnectVPN] Saving username to vpn.data (password will be prompted)")
-	}
-
-	vpn["data"] = dbus.MakeVariant(data)
-	settings["vpn"] = vpn
-
-	var result map[string]dbus.Variant
-	if err := connObj.Call("org.freedesktop.NetworkManager.Settings.Connection.Update2", 0,
-		settings, uint32(0x1), map[string]dbus.Variant{}).Store(&result); err != nil {
-		return fmt.Errorf("failed to save username: %w", err)
-	}
-	log.Infof("[ConnectVPN] Username saved to connection")
-
-	if password != "" && !reply.Save {
-		b.cachedVPNCredsMu.Lock()
-		b.cachedVPNCreds = &cachedVPNCredentials{
-			ConnectionUUID: targetUUID,
-			Password:       password,
-			SavePassword:   reply.Save,
-		}
-		b.cachedVPNCredsMu.Unlock()
-		log.Infof("[ConnectVPN] Cached password for GetSecrets")
-	}
-
-	return nil
-}
-
 func (b *NetworkManagerBackend) DisconnectVPN(uuidOrName string) error {
 	nm := b.nmConn.(gonetworkmanager.NetworkManager)
 
@@ -684,11 +655,6 @@ func (b *NetworkManagerBackend) updateVPNConnectionState() {
 				b.state.LastError = ""
 				b.stateMutex.Unlock()
 
-				// Clear cached PKCS11 PIN on success
-				b.cachedPKCS11Mu.Lock()
-				b.cachedPKCS11PIN = nil
-				b.cachedPKCS11Mu.Unlock()
-
 				b.pendingVPNSaveMu.Lock()
 				pending := b.pendingVPNSave
 				b.pendingVPNSave = nil
@@ -705,11 +671,6 @@ func (b *NetworkManagerBackend) updateVPNConnectionState() {
 				b.state.ConnectingVPNUUID = ""
 				b.state.LastError = "VPN connection failed"
 				b.stateMutex.Unlock()
-
-				// Clear cached PKCS11 PIN on failure
-				b.cachedPKCS11Mu.Lock()
-				b.cachedPKCS11PIN = nil
-				b.cachedPKCS11Mu.Unlock()
 				return
 			}
 		}
@@ -722,11 +683,6 @@ func (b *NetworkManagerBackend) updateVPNConnectionState() {
 		b.state.ConnectingVPNUUID = ""
 		b.state.LastError = "VPN connection failed"
 		b.stateMutex.Unlock()
-
-		// Clear cached PKCS11 PIN
-		b.cachedPKCS11Mu.Lock()
-		b.cachedPKCS11PIN = nil
-		b.cachedPKCS11Mu.Unlock()
 	}
 }
 
@@ -926,24 +882,25 @@ func (b *NetworkManagerBackend) ImportVPN(filePath string, name string) (*VPNImp
 func (b *NetworkManagerBackend) importVPNWithNmcli(filePath string, name string) (*VPNImportResult, error) {
 	vpnTypes := []string{"openvpn", "wireguard", "vpnc", "pptp", "l2tp", "openconnect", "strongswan"}
 
-	var allErrors []error
+	var output []byte
-	var outputStr string
+	var err error
 	for _, vpnType := range vpnTypes {
-		cmd := exec.Command("nmcli", "connection", "import", "type", vpnType, "file", filePath)
+		args := []string{"connection", "import", "type", vpnType, "file", filePath}
-		output, err := cmd.CombinedOutput()
+		cmd := exec.Command("nmcli", args...)
+		output, err = cmd.CombinedOutput()
 		if err == nil {
-			outputStr = string(output)
 			break
 		}
-		allErrors = append(allErrors, fmt.Errorf("%s: %s", vpnType, strings.TrimSpace(string(output))))
 	}
 
-	if len(allErrors) == len(vpnTypes) {
+	if err != nil {
 		return &VPNImportResult{
 			Success: false,
-			Error:   errors.Join(allErrors...).Error(),
+			Error:   fmt.Sprintf("import failed: %s", strings.TrimSpace(string(output))),
 		}, nil
 	}
+
+	outputStr := string(output)
 	var connUUID, connName string
 
 	lines := strings.Split(outputStr, "\n")

core/internal/server/network/backend_networkmanager_wifi.go

@@ -357,51 +357,31 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 
 	savedSSIDs := make(map[string]bool)
 	autoconnectMap := make(map[string]bool)
-	hiddenSSIDs := make(map[string]bool)
 	for _, conn := range connections {
 		connSettings, err := conn.GetSettings()
 		if err != nil {
 			continue
 		}
 
-		connMeta, ok := connSettings["connection"]
+		if connMeta, ok := connSettings["connection"]; ok {
-		if !ok {
+			if connType, ok := connMeta["type"].(string); ok && connType == "802-11-wireless" {
-			continue
+				if wifiSettings, ok := connSettings["802-11-wireless"]; ok {
-		}
+					if ssidBytes, ok := wifiSettings["ssid"].([]byte); ok {
-
+						ssid := string(ssidBytes)
-		connType, ok := connMeta["type"].(string)
+						savedSSIDs[ssid] = true
-		if !ok || connType != "802-11-wireless" {
+						autoconnect := true
-			continue
+						if ac, ok := connMeta["autoconnect"].(bool); ok {
-		}
+							autoconnect = ac
-
+						}
-		wifiSettings, ok := connSettings["802-11-wireless"]
+						autoconnectMap[ssid] = autoconnect
-		if !ok {
+					}
-			continue
+				}
-		}
+			}
-
-		ssidBytes, ok := wifiSettings["ssid"].([]byte)
-		if !ok {
-			continue
-		}
-
-		ssid := string(ssidBytes)
-		savedSSIDs[ssid] = true
-		autoconnect := true
-		if ac, ok := connMeta["autoconnect"].(bool); ok {
-			autoconnect = ac
-		}
-		autoconnectMap[ssid] = autoconnect
-
-		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
-			hiddenSSIDs[ssid] = true
 		}
 	}
 
 	b.stateMutex.RLock()
 	currentSSID := b.state.WiFiSSID
-	wifiConnected := b.state.WiFiConnected
-	wifiSignal := b.state.WiFiSignal
-	wifiBSSID := b.state.WiFiBSSID
 	b.stateMutex.RUnlock()
 
 	seenSSIDs := make(map[string]*WiFiNetwork)
@@ -464,7 +444,6 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			Connected:   ssid == currentSSID,
 			Saved:       savedSSIDs[ssid],
 			Autoconnect: autoconnectMap[ssid],
-			Hidden:      hiddenSSIDs[ssid],
 			Frequency:   freq,
 			Mode:        modeStr,
 			Rate:        maxBitrate / 1000,
@@ -475,23 +454,6 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 		networks = append(networks, network)
 	}
 
-	if wifiConnected && currentSSID != "" {
-		if _, exists := seenSSIDs[currentSSID]; !exists {
-			hiddenNetwork := WiFiNetwork{
-				SSID:        currentSSID,
-				BSSID:       wifiBSSID,
-				Signal:      wifiSignal,
-				Secured:     true,
-				Connected:   true,
-				Saved:       savedSSIDs[currentSSID],
-				Autoconnect: autoconnectMap[currentSSID],
-				Hidden:      true,
-				Mode:        "infrastructure",
-			}
-			networks = append(networks, hiddenNetwork)
-		}
-	}
-
 	sortWiFiNetworks(networks)
 
 	b.stateMutex.Lock()
@@ -553,53 +515,40 @@ func (b *NetworkManagerBackend) createAndConnectWiFiOnDevice(req ConnectionReque
 	nm := b.nmConn.(gonetworkmanager.NetworkManager)
 	dev := devInfo.device
 	w := devInfo.wireless
+	apPaths, err := w.GetAccessPoints()
+	if err != nil {
+		return fmt.Errorf("failed to get access points: %w", err)
+	}
 
 	var targetAP gonetworkmanager.AccessPoint
-	var flags, wpaFlags, rsnFlags uint32
+	for _, ap := range apPaths {
-
+		ssid, err := ap.GetPropertySSID()
-	if !req.Hidden {
+		if err != nil || ssid != req.SSID {
-		apPaths, err := w.GetAccessPoints()
+			continue
-		if err != nil {
-			return fmt.Errorf("failed to get access points: %w", err)
 		}
-
+		targetAP = ap
-		for _, ap := range apPaths {
+		break
-			ssid, err := ap.GetPropertySSID()
-			if err != nil || ssid != req.SSID {
-				continue
-			}
-			targetAP = ap
-			break
-		}
-
-		if targetAP == nil {
-			return fmt.Errorf("access point not found: %s", req.SSID)
-		}
-
-		flags, _ = targetAP.GetPropertyFlags()
-		wpaFlags, _ = targetAP.GetPropertyWPAFlags()
-		rsnFlags, _ = targetAP.GetPropertyRSNFlags()
 	}
 
+	if targetAP == nil {
+		return fmt.Errorf("access point not found: %s", req.SSID)
+	}
+
+	flags, _ := targetAP.GetPropertyFlags()
+	wpaFlags, _ := targetAP.GetPropertyWPAFlags()
+	rsnFlags, _ := targetAP.GetPropertyRSNFlags()
+
 	const KeyMgmt8021x = uint32(512)
 	const KeyMgmtPsk = uint32(256)
 	const KeyMgmtSae = uint32(1024)
 
-	var isEnterprise, isPsk, isSae, secured bool
+	isEnterprise := (wpaFlags&KeyMgmt8021x) != 0 || (rsnFlags&KeyMgmt8021x) != 0
+	isPsk := (wpaFlags&KeyMgmtPsk) != 0 || (rsnFlags&KeyMgmtPsk) != 0
+	isSae := (wpaFlags&KeyMgmtSae) != 0 || (rsnFlags&KeyMgmtSae) != 0
 
-	switch {
+	secured := flags != uint32(gonetworkmanager.Nm80211APFlagsNone) ||
-	case req.Hidden:
+		wpaFlags != uint32(gonetworkmanager.Nm80211APSecNone) ||
-		secured = req.Password != "" || req.Username != ""
+		rsnFlags != uint32(gonetworkmanager.Nm80211APSecNone)
-		isEnterprise = req.Username != ""
-		isPsk = req.Password != "" && !isEnterprise
-	default:
-		isEnterprise = (wpaFlags&KeyMgmt8021x) != 0 || (rsnFlags&KeyMgmt8021x) != 0
-		isPsk = (wpaFlags&KeyMgmtPsk) != 0 || (rsnFlags&KeyMgmtPsk) != 0
-		isSae = (wpaFlags&KeyMgmtSae) != 0 || (rsnFlags&KeyMgmtSae) != 0
-		secured = flags != uint32(gonetworkmanager.Nm80211APFlagsNone) ||
-			wpaFlags != uint32(gonetworkmanager.Nm80211APSecNone) ||
-			rsnFlags != uint32(gonetworkmanager.Nm80211APSecNone)
-	}
 
 	if isEnterprise {
 		log.Infof("[createAndConnectWiFi] Enterprise network detected (802.1x) - SSID: %s, interactive: %v",
@@ -618,15 +567,11 @@ func (b *NetworkManagerBackend) createAndConnectWiFiOnDevice(req ConnectionReque
 	settings["ipv6"] = map[string]any{"method": "auto"}
 
 	if secured {
-		wifiSettings := map[string]any{
+		settings["802-11-wireless"] = map[string]any{
 			"ssid":     []byte(req.SSID),
 			"mode":     "infrastructure",
 			"security": "802-11-wireless-security",
 		}
-		if req.Hidden {
-			wifiSettings["hidden"] = true
-		}
-		settings["802-11-wireless"] = wifiSettings
 
 		switch {
 		case isEnterprise || req.Username != "":
@@ -713,14 +658,10 @@ func (b *NetworkManagerBackend) createAndConnectWiFiOnDevice(req ConnectionReque
 			return fmt.Errorf("secured network but not SAE/PSK/802.1X (rsn=0x%x wpa=0x%x)", rsnFlags, wpaFlags)
 		}
 	} else {
-		wifiSettings := map[string]any{
+		settings["802-11-wireless"] = map[string]any{
 			"ssid": []byte(req.SSID),
 			"mode": "infrastructure",
 		}
-		if req.Hidden {
-			wifiSettings["hidden"] = true
-		}
-		settings["802-11-wireless"] = wifiSettings
 	}
 
 	if req.Interactive {
@@ -744,23 +685,14 @@ func (b *NetworkManagerBackend) createAndConnectWiFiOnDevice(req ConnectionReque
 			log.Infof("[createAndConnectWiFi] Enterprise connection added, activating (secret agent will be called)")
 		}
 
-		if req.Hidden {
+		_, err = nm.ActivateWirelessConnection(conn, dev, targetAP)
-			_, err = nm.ActivateConnection(conn, dev, nil)
-		} else {
-			_, err = nm.ActivateWirelessConnection(conn, dev, targetAP)
-		}
 		if err != nil {
 			return fmt.Errorf("failed to activate connection: %w", err)
 		}
 
 		log.Infof("[createAndConnectWiFi] Connection activation initiated, waiting for NetworkManager state changes...")
 	} else {
-		var err error
+		_, err = nm.AddAndActivateWirelessConnection(settings, dev, targetAP)
-		if req.Hidden {
-			_, err = nm.AddAndActivateConnection(settings, dev)
-		} else {
-			_, err = nm.AddAndActivateWirelessConnection(settings, dev, targetAP)
-		}
 		if err != nil {
 			return fmt.Errorf("failed to connect: %w", err)
 		}
@@ -881,7 +813,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 
 	savedSSIDs := make(map[string]bool)
 	autoconnectMap := make(map[string]bool)
-	hiddenSSIDs := make(map[string]bool)
 	for _, conn := range connections {
 		connSettings, err := conn.GetSettings()
 		if err != nil {
@@ -915,10 +846,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 			autoconnect = ac
 		}
 		autoconnectMap[ssid] = autoconnect
-
-		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
-			hiddenSSIDs[ssid] = true
-		}
 	}
 
 	var devices []WiFiDevice
@@ -1012,7 +939,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					Connected:   connected && apSSID == ssid,
 					Saved:       savedSSIDs[apSSID],
 					Autoconnect: autoconnectMap[apSSID],
-					Hidden:      hiddenSSIDs[apSSID],
 					Frequency:   freq,
 					Mode:        modeStr,
 					Rate:        maxBitrate / 1000,
@@ -1023,25 +949,6 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 				seenSSIDs[apSSID] = &network
 				networks = append(networks, network)
 			}
-
-			if connected && ssid != "" {
-				if _, exists := seenSSIDs[ssid]; !exists {
-					hiddenNetwork := WiFiNetwork{
-						SSID:        ssid,
-						BSSID:       bssid,
-						Signal:      signal,
-						Secured:     true,
-						Connected:   true,
-						Saved:       savedSSIDs[ssid],
-						Autoconnect: autoconnectMap[ssid],
-						Hidden:      true,
-						Mode:        "infrastructure",
-						Device:      name,
-					}
-					networks = append(networks, hiddenNetwork)
-				}
-			}
-
 			sortWiFiNetworks(networks)
 		}
 

core/internal/server/network/handlers.go

@@ -157,7 +157,7 @@ func handleConnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	connReq.Username = params.StringOpt(req.Params, "username", "")
 	connReq.Device = params.StringOpt(req.Params, "device", "")
 
-	if interactive, ok := models.Get[bool](req, "interactive"); ok {
+	if interactive, ok := req.Params["interactive"].(bool); ok {
 		connReq.Interactive = interactive
 	} else {
 		state := manager.GetState()
@@ -185,7 +185,7 @@ func handleConnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	connReq.ClientCertPath = params.StringOpt(req.Params, "clientCertPath", "")
 	connReq.PrivateKeyPath = params.StringOpt(req.Params, "privateKeyPath", "")
 
-	if useSystemCACerts, ok := models.Get[bool](req, "useSystemCACerts"); ok {
+	if useSystemCACerts, ok := req.Params["useSystemCACerts"].(bool); ok {
 		connReq.UseSystemCACerts = &useSystemCACerts
 	}
 
@@ -528,13 +528,13 @@ func handleUpdateVPNConfig(conn net.Conn, req models.Request, manager *Manager)
 
 	updates := make(map[string]any)
 
-	if name, ok := models.Get[string](req, "name"); ok {
+	if name, ok := req.Params["name"].(string); ok {
 		updates["name"] = name
 	}
-	if autoconnect, ok := models.Get[bool](req, "autoconnect"); ok {
+	if autoconnect, ok := req.Params["autoconnect"].(bool); ok {
 		updates["autoconnect"] = autoconnect
 	}
-	if data, ok := models.Get[map[string]any](req, "data"); ok {
+	if data, ok := req.Params["data"].(map[string]any); ok {
 		updates["data"] = data
 	}
 

core/internal/server/network/priority.go

@@ -2,21 +2,9 @@ package network
 
 import (
 	"fmt"
-	"os/exec"
 	"time"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/Wifx/gonetworkmanager/v2"
-	"github.com/godbus/dbus/v5"
-)
-
-const (
-	priorityHigh    = int32(100)
-	priorityLow     = int32(10)
-	priorityDefault = int32(0)
-
-	metricPreferred    = int64(100)
-	metricNonPreferred = int64(300)
-	metricDefault      = int64(100)
 )
 
 func (m *Manager) SetConnectionPreference(pref ConnectionPreference) error {
@@ -48,124 +36,83 @@ func (m *Manager) SetConnectionPreference(pref ConnectionPreference) error {
 }
 
 func (m *Manager) prioritizeWiFi() error {
-	if err := m.setConnectionPriority("802-11-wireless", priorityHigh, metricPreferred); err != nil {
+	if err := m.setConnectionMetrics("802-11-wireless", 50); err != nil {
-		log.Warnf("Failed to set WiFi priority: %v", err)
+		return err
 	}
 
-	if err := m.setConnectionPriority("802-3-ethernet", priorityLow, metricNonPreferred); err != nil {
+	if err := m.setConnectionMetrics("802-3-ethernet", 100); err != nil {
-		log.Warnf("Failed to set Ethernet priority: %v", err)
+		return err
 	}
 
-	m.reapplyActiveConnections()
 	m.notifySubscribers()
 	return nil
 }
 
 func (m *Manager) prioritizeEthernet() error {
-	if err := m.setConnectionPriority("802-3-ethernet", priorityHigh, metricPreferred); err != nil {
+	if err := m.setConnectionMetrics("802-3-ethernet", 50); err != nil {
-		log.Warnf("Failed to set Ethernet priority: %v", err)
+		return err
 	}
 
-	if err := m.setConnectionPriority("802-11-wireless", priorityLow, metricNonPreferred); err != nil {
+	if err := m.setConnectionMetrics("802-11-wireless", 100); err != nil {
-		log.Warnf("Failed to set WiFi priority: %v", err)
+		return err
 	}
 
-	m.reapplyActiveConnections()
 	m.notifySubscribers()
 	return nil
 }
 
 func (m *Manager) balancePriorities() error {
-	if err := m.setConnectionPriority("802-3-ethernet", priorityDefault, metricDefault); err != nil {
+	if err := m.setConnectionMetrics("802-3-ethernet", 50); err != nil {
-		log.Warnf("Failed to reset Ethernet priority: %v", err)
+		return err
 	}
 
-	if err := m.setConnectionPriority("802-11-wireless", priorityDefault, metricDefault); err != nil {
+	if err := m.setConnectionMetrics("802-11-wireless", 50); err != nil {
-		log.Warnf("Failed to reset WiFi priority: %v", err)
+		return err
 	}
 
-	m.reapplyActiveConnections()
 	m.notifySubscribers()
 	return nil
 }
 
-func (m *Manager) reapplyActiveConnections() {
+func (m *Manager) setConnectionMetrics(connType string, metric uint32) error {
-	m.stateMutex.RLock()
+	settingsMgr, err := gonetworkmanager.NewSettings()
-	ethDev := m.state.EthernetDevice
-	wifiDev := m.state.WiFiDevice
-	m.stateMutex.RUnlock()
-
-	if ethDev != "" {
-		exec.Command("nmcli", "dev", "reapply", ethDev).Run()
-	}
-	if wifiDev != "" {
-		exec.Command("nmcli", "dev", "reapply", wifiDev).Run()
-	}
-}
-
-func (m *Manager) setConnectionPriority(connType string, autoconnectPriority int32, routeMetric int64) error {
-	conn, err := dbus.ConnectSystemBus()
 	if err != nil {
-		return fmt.Errorf("failed to connect to system bus: %w", err)
+		return fmt.Errorf("failed to get settings: %w", err)
-	}
-	defer conn.Close()
-
-	settingsObj := conn.Object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager/Settings")
-
-	var connPaths []dbus.ObjectPath
-	if err := settingsObj.Call("org.freedesktop.NetworkManager.Settings.ListConnections", 0).Store(&connPaths); err != nil {
-		return fmt.Errorf("failed to list connections: %w", err)
 	}
 
-	for _, connPath := range connPaths {
+	connections, err := settingsMgr.ListConnections()
-		connObj := conn.Object("org.freedesktop.NetworkManager", connPath)
+	if err != nil {
+		return fmt.Errorf("failed to get connections: %w", err)
+	}
 
-		var settings map[string]map[string]dbus.Variant
+	for _, conn := range connections {
-		if err := connObj.Call("org.freedesktop.NetworkManager.Settings.Connection.GetSettings", 0).Store(&settings); err != nil {
+		connSettings, err := conn.GetSettings()
+		if err != nil {
 			continue
 		}
 
-		connSection, ok := settings["connection"]
+		if connMeta, ok := connSettings["connection"]; ok {
-		if !ok {
+			if cType, ok := connMeta["type"].(string); ok && cType == connType {
-			continue
+				if connSettings["ipv4"] == nil {
-		}
+					connSettings["ipv4"] = make(map[string]any)
+				}
+				if ipv4Map := connSettings["ipv4"]; ipv4Map != nil {
+					ipv4Map["route-metric"] = int64(metric)
+				}
 
-		typeVariant, ok := connSection["type"]
+				if connSettings["ipv6"] == nil {
-		if !ok {
+					connSettings["ipv6"] = make(map[string]any)
-			continue
+				}
-		}
+				if ipv6Map := connSettings["ipv6"]; ipv6Map != nil {
+					ipv6Map["route-metric"] = int64(metric)
+				}
 
-		cType, ok := typeVariant.Value().(string)
+				err = conn.Update(connSettings)
-		if !ok || cType != connType {
+				if err != nil {
-			continue
+					continue
+				}
+			}
 		}
-
-		connName := ""
-		if idVariant, ok := connSection["id"]; ok {
-			connName, _ = idVariant.Value().(string)
-		}
-
-		if connName == "" {
-			continue
-		}
-
-		if err := exec.Command("nmcli", "con", "mod", connName,
-			"connection.autoconnect-priority", fmt.Sprintf("%d", autoconnectPriority)).Run(); err != nil {
-			log.Warnf("Failed to set autoconnect-priority for %v: %v", connName, err)
-			continue
-		}
-
-		if err := exec.Command("nmcli", "con", "mod", connName,
-			"ipv4.route-metric", fmt.Sprintf("%d", routeMetric)).Run(); err != nil {
-			log.Warnf("Failed to set ipv4.route-metric for %v: %v", connName, err)
-		}
-
-		if err := exec.Command("nmcli", "con", "mod", connName,
-			"ipv6.route-metric", fmt.Sprintf("%d", routeMetric)).Run(); err != nil {
-			log.Warnf("Failed to set ipv6.route-metric for %v: %v", connName, err)
-		}
-
-		log.Infof("Updated %v: autoconnect-priority=%d, route-metric=%d", connName, autoconnectPriority, routeMetric)
 	}
 
 	return nil
@@ -178,18 +125,14 @@ func (m *Manager) GetConnectionPreference() ConnectionPreference {
 }
 
 func (m *Manager) WasRecentlyFailed(ssid string) bool {
-	nm, ok := m.backend.(*NetworkManagerBackend)
+	if nm, ok := m.backend.(*NetworkManagerBackend); ok {
-	if !ok {
+		nm.failedMutex.RLock()
-		return false
+		defer nm.failedMutex.RUnlock()
+
+		if nm.lastFailedSSID == ssid {
+			elapsed := time.Now().Unix() - nm.lastFailedTime
+			return elapsed < 10
+		}
 	}
-
+	return false
-	nm.failedMutex.RLock()
-	defer nm.failedMutex.RUnlock()
-
-	if nm.lastFailedSSID != ssid {
-		return false
-	}
-
-	elapsed := time.Now().Unix() - nm.lastFailedTime
-	return elapsed < 10
 }

core/internal/server/network/types.go

@@ -33,7 +33,6 @@ type WiFiNetwork struct {
 	Connected   bool   `json:"connected"`
 	Saved       bool   `json:"saved"`
 	Autoconnect bool   `json:"autoconnect"`
-	Hidden      bool   `json:"hidden"`
 	Frequency   uint32 `json:"frequency"`
 	Mode        string `json:"mode"`
 	Rate        uint32 `json:"rate"`
@@ -128,7 +127,6 @@ type ConnectionRequest struct {
 	AnonymousIdentity string `json:"anonymousIdentity,omitempty"`
 	DomainSuffixMatch string `json:"domainSuffixMatch,omitempty"`
 	Interactive       bool   `json:"interactive,omitempty"`
-	Hidden            bool   `json:"hidden,omitempty"`
 	Device            string `json:"device,omitempty"`
 	EAPMethod         string `json:"eapMethod,omitempty"`
 	Phase2Auth        string `json:"phase2Auth,omitempty"`

core/internal/server/plugins/install.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleInstall(conn net.Conn, req models.Request) {
-	idOrName, ok := models.Get[string](req, "name")
+	idOrName, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/plugins/list.go

@@ -44,7 +44,6 @@ func HandleList(conn net.Conn, req models.Request) {
 			Dependencies: p.Dependencies,
 			Installed:    installed,
 			FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-			RequiresDMS:  p.RequiresDMS,
 		}
 	}
 

core/internal/server/plugins/list_installed.go

@@ -60,7 +60,6 @@ func HandleListInstalled(conn net.Conn, req models.Request) {
 				Dependencies: plugin.Dependencies,
 				FirstParty:   strings.HasPrefix(plugin.Repo, "https://github.com/AvengeMedia"),
 				HasUpdate:    hasUpdate,
-				RequiresDMS:  plugin.RequiresDMS,
 			})
 		} else {
 			result = append(result, PluginInfo{

core/internal/server/plugins/search.go

@@ -10,7 +10,7 @@ import (
 )
 
 func HandleSearch(conn net.Conn, req models.Request) {
-	query, ok := models.Get[string](req, "query")
+	query, ok := req.Params["query"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'query' parameter")
 		return
@@ -30,15 +30,15 @@ func HandleSearch(conn net.Conn, req models.Request) {
 
 	searchResults := plugins.FuzzySearch(query, pluginList)
 
-	if category := models.GetOr(req, "category", ""); category != "" {
+	if category, ok := req.Params["category"].(string); ok && category != "" {
 		searchResults = plugins.FilterByCategory(category, searchResults)
 	}
 
-	if compositor := models.GetOr(req, "compositor", ""); compositor != "" {
+	if compositor, ok := req.Params["compositor"].(string); ok && compositor != "" {
 		searchResults = plugins.FilterByCompositor(compositor, searchResults)
 	}
 
-	if capability := models.GetOr(req, "capability", ""); capability != "" {
+	if capability, ok := req.Params["capability"].(string); ok && capability != "" {
 		searchResults = plugins.FilterByCapability(capability, searchResults)
 	}
 
@@ -66,7 +66,6 @@ func HandleSearch(conn net.Conn, req models.Request) {
 			Dependencies: p.Dependencies,
 			Installed:    installed,
 			FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-			RequiresDMS:  p.RequiresDMS,
 		}
 	}
 

core/internal/server/plugins/types.go

@@ -15,7 +15,6 @@ type PluginInfo struct {
 	FirstParty   bool     `json:"firstParty,omitempty"`
 	Note         string   `json:"note,omitempty"`
 	HasUpdate    bool     `json:"hasUpdate,omitempty"`
-	RequiresDMS  string   `json:"requires_dms,omitempty"`
 }
 
 type SuccessResult struct {

core/internal/server/plugins/uninstall.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleUninstall(conn net.Conn, req models.Request) {
-	name, ok := models.Get[string](req, "name")
+	name, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/plugins/update.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleUpdate(conn net.Conn, req models.Request) {
-	name, ok := models.Get[string](req, "name")
+	name, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/router.go

@@ -192,21 +192,24 @@ func RouteRequest(conn net.Conn, req models.Request) {
 func handleClipboardSetConfig(conn net.Conn, req models.Request) {
 	cfg := clipboard.LoadConfig()
 
-	if v, ok := models.Get[float64](req, "maxHistory"); ok {
+	if v, ok := req.Params["maxHistory"].(float64); ok {
 		cfg.MaxHistory = int(v)
 	}
-	if v, ok := models.Get[float64](req, "maxEntrySize"); ok {
+	if v, ok := req.Params["maxEntrySize"].(float64); ok {
 		cfg.MaxEntrySize = int64(v)
 	}
-	if v, ok := models.Get[float64](req, "autoClearDays"); ok {
+	if v, ok := req.Params["autoClearDays"].(float64); ok {
 		cfg.AutoClearDays = int(v)
 	}
-	if v, ok := models.Get[bool](req, "clearAtStartup"); ok {
+	if v, ok := req.Params["clearAtStartup"].(bool); ok {
 		cfg.ClearAtStartup = v
 	}
-	if v, ok := models.Get[bool](req, "disabled"); ok {
+	if v, ok := req.Params["disabled"].(bool); ok {
 		cfg.Disabled = v
 	}
+	if v, ok := req.Params["disableHistory"].(bool); ok {
+		cfg.DisableHistory = v
+	}
 
 	if err := clipboard.SaveConfig(cfg); err != nil {
 		models.RespondError(conn, req.ID, err.Error())

core/internal/server/server.go

@@ -520,7 +520,7 @@ func handleSubscribe(conn net.Conn, req models.Request) {
 	clientID := fmt.Sprintf("meta-client-%p", conn)
 
 	var services []string
-	if servicesParam, ok := models.Get[[]any](req, "services"); ok {
+	if servicesParam, ok := req.Params["services"].([]any); ok {
 		for _, s := range servicesParam {
 			if str, ok := s.(string); ok {
 				services = append(services, str)

core/internal/server/themes/install.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleInstall(conn net.Conn, req models.Request) {
-	idOrName, ok := models.Get[string](req, "name")
+	idOrName, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/themes/search.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleSearch(conn net.Conn, req models.Request) {
-	query, ok := models.Get[string](req, "query")
+	query, ok := req.Params["query"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'query' parameter")
 		return

core/internal/server/themes/uninstall.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleUninstall(conn net.Conn, req models.Request) {
-	idOrName, ok := models.Get[string](req, "name")
+	idOrName, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/themes/update.go

@@ -9,7 +9,7 @@ import (
 )
 
 func HandleUpdate(conn net.Conn, req models.Request) {
-	idOrName, ok := models.Get[string](req, "name")
+	idOrName, ok := req.Params["name"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
 		return

core/internal/server/wayland/handlers.go

@@ -45,7 +45,7 @@ func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 func handleSetTemperature(conn net.Conn, req models.Request, manager *Manager) {
 	var lowTemp, highTemp int
 
-	if temp, ok := models.Get[float64](req, "temp"); ok {
+	if temp, ok := req.Params["temp"].(float64); ok {
 		lowTemp = int(temp)
 		highTemp = int(temp)
 	} else {
@@ -93,10 +93,24 @@ func handleSetLocation(conn net.Conn, req models.Request, manager *Manager) {
 }
 
 func handleSetManualTimes(conn net.Conn, req models.Request, manager *Manager) {
-	sunriseStr, sunriseOK := models.Get[string](req, "sunrise")
+	sunriseParam := req.Params["sunrise"]
-	sunsetStr, sunsetOK := models.Get[string](req, "sunset")
+	sunsetParam := req.Params["sunset"]
 
-	if !sunriseOK || !sunsetOK || sunriseStr == "" || sunsetStr == "" {
+	if sunriseParam == nil || sunsetParam == nil {
+		manager.ClearManualTimes()
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
+		return
+	}
+
+	sunriseStr, ok := sunriseParam.(string)
+	if !ok || sunriseStr == "" {
+		manager.ClearManualTimes()
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
+		return
+	}
+
+	sunsetStr, ok := sunsetParam.(string)
+	if !ok || sunsetStr == "" {
 		manager.ClearManualTimes()
 		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return