Fixed an issue where the UI width was shifted due to the clock widget when using non-monospaced fonts. (#1491)

fixes #1268

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,65 +0,0 @@
----
-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

@@ -0,0 +1,96 @@
+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: textarea
+    id: dms_doctor
+    attributes:
+      label: dms doctor -v
+      description: Output of `dms doctor -v` command
+      placeholder: Paste the output of `dms doctor -v` here
+    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

@@ -1,33 +0,0 @@
----
-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

@@ -0,0 +1,55 @@
+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

@@ -1,40 +0,0 @@
----
-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

@@ -0,0 +1,69 @@
+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: textarea
+    id: dms_doctor
+    attributes:
+      label: dms doctor -v
+      description: Output of `dms doctor -v` command
+      placeholder: Paste the output of `dms doctor -v` here
+    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,6 +28,15 @@ 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,5 +11,14 @@ 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/run-obs.yml

@@ -4,13 +4,14 @@ on:
   workflow_dispatch:
     inputs:
       package:
-        description: "Package to update (dms, dms-git, or all)"
-        required: false
-        default: "all"
-      tag_version:
-        description: "Specific tag version for dms stable (e.g., v1.0.2). Leave empty to auto-detect latest release."
-        required: false
-        default: ""
+        description: "Package to update"
+        required: true
+        type: choice
+        options:
+          - dms
+          - dms-git
+          - all
+        default: "dms"
       rebuild_release:
         description: "Release number for rebuilds (e.g., 2, 3, 4 to increment spec Release)"
         required: false
@@ -56,8 +57,9 @@ jobs:
           }
 
           # Helper function to check dms stable tag
+          # Sets LATEST_TAG variable in parent scope if update needed
           check_dms_stable() {
-            local LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "v\?\([^"]*\)".*/\1/' || echo "")
+            LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "\([^"]*\)".*/\1/' || echo "")
             local OBS_SPEC=$(curl -s -u "$OBS_USERNAME:$OBS_PASSWORD" "https://api.opensuse.org/source/home:AvengeMedia:dms/dms/dms.spec" 2>/dev/null || echo "")
             local OBS_VERSION=$(echo "$OBS_SPEC" | grep "^Version:" | awk '{print $2}' | xargs || echo "")
 
@@ -73,8 +75,8 @@ jobs:
           # Main logic
           REBUILD="${{ github.event.inputs.rebuild_release }}"
 
-          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
-            # Tag push - always update stable package
+          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            # Tag selected or pushed - always update stable package
             echo "packages=dms" >> $GITHUB_OUTPUT
             VERSION="${GITHUB_REF#refs/tags/}"
             echo "version=$VERSION" >> $GITHUB_OUTPUT
@@ -104,7 +106,12 @@ jobs:
               # Check each package and build list of those needing updates
               PACKAGES_TO_UPDATE=()
               check_dms_git && PACKAGES_TO_UPDATE+=("dms-git")
-              check_dms_stable && PACKAGES_TO_UPDATE+=("dms")
+              if check_dms_stable; then
+                PACKAGES_TO_UPDATE+=("dms")
+                if [[ -n "$LATEST_TAG" ]]; then
+                  echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
+                fi
+              fi
 
               if [[ ${#PACKAGES_TO_UPDATE[@]} -gt 0 ]]; then
                 echo "packages=${PACKAGES_TO_UPDATE[*]}" >> $GITHUB_OUTPUT
@@ -129,6 +136,9 @@ jobs:
               if check_dms_stable; then
                 echo "packages=$PKG" >> $GITHUB_OUTPUT
                 echo "has_updates=true" >> $GITHUB_OUTPUT
+                if [[ -n "$LATEST_TAG" ]]; then
+                  echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
+                fi
               else
                 echo "packages=" >> $GITHUB_OUTPUT
                 echo "has_updates=false" >> $GITHUB_OUTPUT
@@ -161,12 +171,19 @@ jobs:
       - name: Determine packages to update
         id: packages
         run: |
-          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
-            # Tag push event - use the pushed tag
+          # Check if GITHUB_REF points to a tag (works for both push events and workflow_dispatch with tag selected)
+          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            # Tag selected or pushed - use the tag from GITHUB_REF
             echo "packages=dms" >> $GITHUB_OUTPUT
             VERSION="${GITHUB_REF#refs/tags/}"
             echo "version=$VERSION" >> $GITHUB_OUTPUT
-            echo "Triggered by tag: $VERSION"
+            echo "Using tag from GITHUB_REF: $VERSION"
+          # Check if check-updates already determined a version (from auto-detection)
+          elif [[ -n "${{ needs.check-updates.outputs.version }}" ]]; then
+            # Use version from check-updates job
+            echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+            echo "version=${{ needs.check-updates.outputs.version }}" >> $GITHUB_OUTPUT
+            echo "Using version from check-updates: ${{ needs.check-updates.outputs.version }}"
           elif [[ "${{ github.event_name }}" == "schedule" ]]; then
             # Scheduled run - dms-git only
             echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
@@ -176,22 +193,28 @@ jobs:
 
             # Determine version for dms stable
             if [[ "${{ github.event.inputs.package }}" == "dms" ]]; then
-              # For explicit dms selection, require tag_version
-              if [[ -n "${{ github.event.inputs.tag_version }}" ]]; then
-                VERSION="${{ github.event.inputs.tag_version }}"
+              # Use github.ref if tag selected, otherwise auto-detect latest
+              if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+                VERSION="${GITHUB_REF#refs/tags/}"
                 echo "version=$VERSION" >> $GITHUB_OUTPUT
-                echo "Using specified tag: $VERSION"
+                echo "Using tag from GITHUB_REF: $VERSION"
               else
-                echo "ERROR: tag_version is required when package=dms"
-                echo "Please specify a tag version (e.g., v1.0.2) or use package=all for auto-detection"
-                exit 1
+                # Auto-detect latest release for dms
+                LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "\([^"]*\)".*/\1/' || echo "")
+                if [[ -n "$LATEST_TAG" ]]; then
+                  echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
+                  echo "Auto-detected latest release: $LATEST_TAG"
+                else
+                  echo "ERROR: Could not auto-detect latest release"
+                  exit 1
+                fi
               fi
             elif [[ "${{ github.event.inputs.package }}" == "all" ]]; then
-              # For "all", auto-detect if tag_version not specified
-              if [[ -n "${{ github.event.inputs.tag_version }}" ]]; then
-                VERSION="${{ github.event.inputs.tag_version }}"
+              # Use github.ref if tag selected, otherwise auto-detect latest
+              if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+                VERSION="${GITHUB_REF#refs/tags/}"
                 echo "version=$VERSION" >> $GITHUB_OUTPUT
-                echo "Using specified tag: $VERSION"
+                echo "Using tag from GITHUB_REF: $VERSION"
               else
                 # Auto-detect latest release for "all"
                 LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "\([^"]*\)".*/\1/' || echo "")
@@ -206,7 +229,7 @@ jobs:
             fi
 
             # Use filtered packages from check-updates when package="all" and no rebuild/tag specified
-            if [[ "${{ github.event.inputs.package }}" == "all" ]] && [[ -z "${{ github.event.inputs.rebuild_release }}" ]] && [[ -z "${{ github.event.inputs.tag_version }}" ]]; then
+            if [[ "${{ github.event.inputs.package }}" == "all" ]] && [[ -z "${{ github.event.inputs.rebuild_release }}" ]] && [[ ! "${{ github.ref }}" =~ ^refs/tags/ ]]; then
               echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
               echo "Manual trigger: all (filtered to: ${{ needs.check-updates.outputs.packages }})"
             else
@@ -215,6 +238,9 @@ jobs:
             fi
           else
             echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+            if [[ -n "${{ needs.check-updates.outputs.version }}" ]]; then
+              echo "version=${{ needs.check-updates.outputs.version }}" >> $GITHUB_OUTPUT
+            fi
           fi
 
       - name: Update dms-git spec version

.github/workflows/stable.yml

@@ -5,15 +5,27 @@ on:
     tags:
       - "v*"
 
+permissions:
+  contents: write
+
 jobs:
   update-stable:
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
     steps:
-      - uses: actions/checkout@v4
+      - name: Create GitHub App token
+        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
-        run: git push origin HEAD:refs/heads/stable --force
+        env:
+          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,3 +108,5 @@ bin/
 # direnv
 .envrc
 .direnv/
+quickshell/dms-plugins
+__pycache__

CHANGELOG.MD

@@ -1,5 +1,14 @@
 This file is more of a quick reference so I know what to account for before next releases.
 
+# 1.4.0
+
+- Overhauled system monitor, graphs, styling
+- dbus API for plugins, KDEConnect
+- new dank16 algorithm
+- launcher actions, customize env, args, name, icon
+- launcher v2 - omega stuff, GIF search, supa powerful
+- dock on bar
+
 # 1.2.0
 
 - Added clipboard and clipboard history integration
@@ -15,3 +24,9 @@ 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

Makefile

@@ -43,7 +43,6 @@ install-shell:
 	@mkdir -p $(SHELL_INSTALL_DIR)
 	@cp -r $(SHELL_DIR)/* $(SHELL_INSTALL_DIR)/
 	@rm -rf $(SHELL_INSTALL_DIR)/.git* $(SHELL_INSTALL_DIR)/.github
-	@$(MAKE) --no-print-directory -C $(CORE_DIR) print-version > $(SHELL_INSTALL_DIR)/VERSION
 	@echo "Shell files installed"
 
 install-completions:

core/.mockery.yml

@@ -68,3 +68,9 @@ 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 i := 0; i < sepLen; i++ {
+	for range sepLen {
 		fmt.Print("─")
 	}
 	fmt.Println()

core/cmd/dms/commands_chroma.go

@@ -0,0 +1,300 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/formatters/html"
+	"github.com/alecthomas/chroma/v2/lexers"
+	"github.com/alecthomas/chroma/v2/styles"
+	"github.com/spf13/cobra"
+	"github.com/yuin/goldmark"
+	highlighting "github.com/yuin/goldmark-highlighting/v2"
+	"github.com/yuin/goldmark/extension"
+	"github.com/yuin/goldmark/parser"
+	ghtml "github.com/yuin/goldmark/renderer/html"
+)
+
+var (
+	chromaLanguage    string
+	chromaStyle       string
+	chromaInline      bool
+	chromaMarkdown    bool
+	chromaLineNumbers bool
+
+	// Caching layer for performance
+	lexerCache     = make(map[string]chroma.Lexer)
+	styleCache     = make(map[string]*chroma.Style)
+	formatterCache = make(map[string]*html.Formatter)
+	cacheMutex     sync.RWMutex
+	maxFileSize    = int64(5 * 1024 * 1024) // 5MB default
+)
+
+var chromaCmd = &cobra.Command{
+	Use:   "chroma [file]",
+	Short: "Syntax highlight source code",
+	Long: `Generate syntax-highlighted HTML from source code.
+
+Reads from file or stdin, outputs HTML with syntax highlighting.
+Language is auto-detected from filename or can be specified with --language.
+
+Examples:
+  dms chroma main.go
+  dms chroma --language python script.py
+  echo "def foo(): pass" | dms chroma -l python
+  cat code.rs | dms chroma -l rust --style dracula
+  dms chroma --markdown README.md
+  dms chroma --markdown --style github-dark notes.md
+  dms chroma list-languages
+  dms chroma list-styles`,
+	Args: cobra.MaximumNArgs(1),
+	Run:  runChroma,
+}
+
+var chromaListLanguagesCmd = &cobra.Command{
+	Use:   "list-languages",
+	Short: "List all supported languages",
+	Run: func(cmd *cobra.Command, args []string) {
+		for _, name := range lexers.Names(true) {
+			fmt.Println(name)
+		}
+	},
+}
+
+var chromaListStylesCmd = &cobra.Command{
+	Use:   "list-styles",
+	Short: "List all available color styles",
+	Run: func(cmd *cobra.Command, args []string) {
+		for _, name := range styles.Names() {
+			fmt.Println(name)
+		}
+	},
+}
+
+func init() {
+	chromaCmd.Flags().StringVarP(&chromaLanguage, "language", "l", "", "Language for highlighting (auto-detect if not specified)")
+	chromaCmd.Flags().StringVarP(&chromaStyle, "style", "s", "monokai", "Color style (monokai, dracula, github, etc.)")
+	chromaCmd.Flags().BoolVar(&chromaInline, "inline", false, "Output inline styles instead of CSS classes")
+	chromaCmd.Flags().BoolVar(&chromaLineNumbers, "line-numbers", false, "Show line numbers in output")
+	chromaCmd.Flags().BoolVarP(&chromaMarkdown, "markdown", "m", false, "Render markdown with syntax-highlighted code blocks")
+	chromaCmd.Flags().Int64Var(&maxFileSize, "max-size", 5*1024*1024, "Maximum file size to process without warning (bytes)")
+
+	chromaCmd.AddCommand(chromaListLanguagesCmd)
+	chromaCmd.AddCommand(chromaListStylesCmd)
+}
+
+func getCachedLexer(key string, fallbackFunc func() chroma.Lexer) chroma.Lexer {
+	cacheMutex.RLock()
+	if lexer, ok := lexerCache[key]; ok {
+		cacheMutex.RUnlock()
+		return lexer
+	}
+	cacheMutex.RUnlock()
+
+	lexer := fallbackFunc()
+	if lexer != nil {
+		cacheMutex.Lock()
+		lexerCache[key] = lexer
+		cacheMutex.Unlock()
+	}
+	return lexer
+}
+
+func getCachedStyle(name string) *chroma.Style {
+	cacheMutex.RLock()
+	if style, ok := styleCache[name]; ok {
+		cacheMutex.RUnlock()
+		return style
+	}
+	cacheMutex.RUnlock()
+
+	style := styles.Get(name)
+	if style == nil {
+		fmt.Fprintf(os.Stderr, "Warning: Style '%s' not found, using fallback\n", name)
+		style = styles.Fallback
+	}
+
+	cacheMutex.Lock()
+	styleCache[name] = style
+	cacheMutex.Unlock()
+	return style
+}
+
+func getCachedFormatter(inline bool, lineNumbers bool) *html.Formatter {
+	key := fmt.Sprintf("inline=%t,lineNumbers=%t", inline, lineNumbers)
+
+	cacheMutex.RLock()
+	if formatter, ok := formatterCache[key]; ok {
+		cacheMutex.RUnlock()
+		return formatter
+	}
+	cacheMutex.RUnlock()
+
+	var opts []html.Option
+	if inline {
+		opts = append(opts, html.WithClasses(false))
+	} else {
+		opts = append(opts, html.WithClasses(true))
+	}
+	opts = append(opts, html.TabWidth(4))
+
+	if lineNumbers {
+		opts = append(opts, html.WithLineNumbers(true))
+		opts = append(opts, html.LineNumbersInTable(false))
+		opts = append(opts, html.WithLinkableLineNumbers(false, ""))
+	}
+
+	formatter := html.New(opts...)
+
+	cacheMutex.Lock()
+	formatterCache[key] = formatter
+	cacheMutex.Unlock()
+	return formatter
+}
+
+func runChroma(cmd *cobra.Command, args []string) {
+	var source string
+	var filename string
+
+	// Read from file or stdin
+	if len(args) > 0 {
+		filename = args[0]
+
+		// Check file size before reading
+		fileInfo, err := os.Stat(filename)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading file info: %v\n", err)
+			os.Exit(1)
+		}
+
+		if fileInfo.Size() > maxFileSize {
+			fmt.Fprintf(os.Stderr, "Warning: File size (%d bytes) exceeds recommended limit (%d bytes)\n",
+				fileInfo.Size(), maxFileSize)
+			fmt.Fprintf(os.Stderr, "Processing may be slow. Consider using smaller files.\n")
+		}
+
+		content, err := os.ReadFile(filename)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading file: %v\n", err)
+			os.Exit(1)
+		}
+		source = string(content)
+	} else {
+		stat, _ := os.Stdin.Stat()
+		if (stat.Mode() & os.ModeCharDevice) != 0 {
+			_ = cmd.Help()
+			os.Exit(0)
+		}
+
+		content, err := io.ReadAll(os.Stdin)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading stdin: %v\n", err)
+			os.Exit(1)
+		}
+		source = string(content)
+	}
+
+	// Handle empty input
+	if strings.TrimSpace(source) == "" {
+		return
+	}
+
+	// Handle Markdown rendering
+	if chromaMarkdown {
+		md := goldmark.New(
+			goldmark.WithExtensions(
+				extension.GFM,
+				highlighting.NewHighlighting(
+					highlighting.WithStyle(chromaStyle),
+					highlighting.WithFormatOptions(
+						html.WithClasses(!chromaInline),
+					),
+				),
+			),
+			goldmark.WithParserOptions(
+				parser.WithAutoHeadingID(),
+			),
+			goldmark.WithRendererOptions(
+				ghtml.WithHardWraps(),
+				ghtml.WithXHTML(),
+			),
+		)
+
+		var buf bytes.Buffer
+		if err := md.Convert([]byte(source), &buf); err != nil {
+			fmt.Fprintf(os.Stderr, "Markdown rendering error: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Print(buf.String())
+		return
+	}
+
+	// Detect or use specified lexer
+	var lexer chroma.Lexer
+	if chromaLanguage != "" {
+		lexer = getCachedLexer(chromaLanguage, func() chroma.Lexer {
+			l := lexers.Get(chromaLanguage)
+			if l == nil {
+				fmt.Fprintf(os.Stderr, "Unknown language: %s\n", chromaLanguage)
+				os.Exit(1)
+			}
+			return l
+		})
+	} else if filename != "" {
+		lexer = getCachedLexer("file:"+filename, func() chroma.Lexer {
+			return lexers.Match(filename)
+		})
+	}
+
+	// Try content analysis if no lexer found (limit to first 1KB for performance)
+	if lexer == nil {
+		analyzeContent := source
+		if len(source) > 1024 {
+			analyzeContent = source[:1024]
+		}
+		lexer = lexers.Analyse(analyzeContent)
+	}
+
+	// Fallback to plaintext
+	if lexer == nil {
+		lexer = lexers.Fallback
+	}
+
+	lexer = chroma.Coalesce(lexer)
+
+	// Get cached style
+	style := getCachedStyle(chromaStyle)
+
+	// Get cached formatter
+	formatter := getCachedFormatter(chromaInline, chromaLineNumbers)
+
+	// Tokenize
+	iterator, err := lexer.Tokenise(nil, source)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Tokenization error: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Format and output
+	if chromaLineNumbers {
+		var buf bytes.Buffer
+		if err := formatter.Format(&buf, style, iterator); err != nil {
+			fmt.Fprintf(os.Stderr, "Formatting error: %v\n", err)
+			os.Exit(1)
+		}
+		// Add spacing between line numbers
+		output := buf.String()
+		output = strings.ReplaceAll(output, "</span><span>", "</span>\u00A0\u00A0<span>")
+		fmt.Print(output)
+	} else {
+		if err := formatter.Format(os.Stdout, style, iterator); err != nil {
+			fmt.Fprintf(os.Stderr, "Formatting error: %v\n", err)
+			os.Exit(1)
+		}
+	}
+}

core/cmd/dms/commands_clipboard.go

@@ -1,17 +1,29 @@
 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"
@@ -142,10 +154,32 @@ 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")
@@ -167,15 +201,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 manager entirely")
-	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")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisabled, "disable", false, "Disable clipboard tracking")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnabled, "enable", false, "Enable clipboard tracking")
 
 	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)
+	clipboardCmd.AddCommand(clipCopyCmd, clipPasteCmd, clipWatchCmd, clipHistoryCmd, clipGetCmd, clipDeleteCmd, clipClearCmd, clipSearchCmd, clipConfigCmd, clipExportCmd, clipImportCmd, clipMigrateCmd)
 }
 
 func runClipCopy(cmd *cobra.Command, args []string) {
@@ -587,12 +621,6 @@ 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")
@@ -616,3 +644,154 @@ 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

@@ -64,9 +64,8 @@ var killCmd = &cobra.Command{
 }
 
 var ipcCmd = &cobra.Command{
-	Use:     "ipc",
+	Use:     "ipc [target] [function] [args...]",
 	Short:   "Send IPC commands to running DMS shell",
-	Long:    "Send IPC commands to running DMS shell (qs -c dms ipc <args>)",
 	PreRunE: findConfig,
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		_ = findConfig(cmd, args)
@@ -77,6 +76,13 @@ var ipcCmd = &cobra.Command{
 	},
 }
 
+func init() {
+	ipcCmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
+		_ = findConfig(cmd, args)
+		printIPCHelp()
+	})
+}
+
 var debugSrvCmd = &cobra.Command{
 	Use:   "debug-srv",
 	Short: "Start the debug server",
@@ -511,7 +517,12 @@ func getCommonCommands() []*cobra.Command {
 		colorCmd,
 		screenshotCmd,
 		notifyActionCmd,
+		notifyCmd,
+		genericNotifyActionCmd,
 		matugenCmd,
 		clipboardCmd,
+		chromaCmd,
+		doctorCmd,
+		configCmd,
 	}
 }

core/cmd/dms/commands_config.go

@@ -0,0 +1,318 @@
+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

@@ -0,0 +1,931 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"slices"
+	"strings"
+
+	"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",
+	Long:  "Check system health, verify dependencies, and diagnose configuration issues for DMS",
+	Run:   runDoctor,
+}
+
+var (
+	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
+
+const (
+	catSystem category = iota
+	catVersions
+	catInstallation
+	catCompositor
+	catQuickshellFeatures
+	catOptionalFeatures
+	catConfigFiles
+	catServices
+	catEnvironment
+)
+
+func (c category) String() string {
+	switch c {
+	case catSystem:
+		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
+	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()
+	}
+
+	qsFeatures, qsMissingFeatures := checkQuickshellFeatures()
+
+	results := slices.Concat(
+		checkSystemInfo(),
+		checkVersions(qsMissingFeatures),
+		checkDMSInstallation(),
+		checkWindowManagers(),
+		qsFeatures,
+		checkOptionalDependencies(),
+		checkConfigurationFiles(),
+		checkSystemdServices(),
+		checkEnvironmentVars(),
+	)
+
+	if doctorJSON {
+		printResultsJSON(results)
+	} else {
+		printResults(results)
+		printSummary(results, qsMissingFeatures)
+	}
+}
+
+func printDoctorHeader() {
+	theme := tui.TerminalTheme()
+	styles := tui.NewStyles(theme)
+
+	fmt.Println(getThemedASCII())
+	fmt.Println(styles.Title.Render("System Health Check"))
+	fmt.Println(styles.Subtle.Render("──────────────────────────────────────"))
+	fmt.Println()
+}
+
+func checkSystemInfo() []checkResult {
+	var results []checkResult
+
+	osInfo, err := distros.GetOSInfo()
+	if err != nil {
+		status, message, details := statusWarn, fmt.Sprintf("Unknown (%v)", err), ""
+
+		if strings.Contains(err.Error(), "Unsupported distribution") {
+			osRelease := readOSRelease()
+			switch {
+			case osRelease["ID"] == "nixos":
+				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"] != "":
+				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"})
+	} else {
+		status := statusOK
+		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
+			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
+	if arch != "amd64" && arch != "arm64" {
+		archStatus = statusError
+	}
+	results = append(results, checkResult{catSystem, "Architecture", archStatus, arch, "", doctorDocsURL + "#architecture"})
+
+	waylandDisplay := os.Getenv("WAYLAND_DISPLAY")
+	xdgSessionType := os.Getenv("XDG_SESSION_TYPE")
+
+	switch {
+	case waylandDisplay != "" || xdgSessionType == "wayland":
+		results = append(results, checkResult{
+			catSystem, "Display Server", statusOK, "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"})
+	default:
+		results = append(results, checkResult{
+			catSystem, "Display Server", statusWarn, "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")
+	if err != nil {
+		return result
+	}
+	for line := range strings.SplitSeq(string(data), "\n") {
+		if parts := strings.SplitN(line, "=", 2); len(parts) == 2 {
+			result[parts[0]] = strings.Trim(parts[1], "\"")
+		}
+	}
+	return result
+}
+
+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"},
+	}
+
+	qsVersion, qsStatus, qsPath := getQuickshellVersionInfo(qsMissingFeatures)
+	qsDetails := ""
+	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"})
+	} else {
+		results = append(results, checkResult{catVersions, "DMS Shell", statusError, "Not installed or not detected", "Run 'dms setup' to install", doctorDocsURL + "#dms-shell"})
+	}
+
+	return results
+}
+
+func getDMSShellVersion() (version, path string) {
+	if err := findConfig(nil, nil); err == nil && configPath != "" {
+		versionFile := filepath.Join(configPath, "VERSION")
+		if data, err := os.ReadFile(versionFile); err == nil {
+			return strings.TrimSpace(string(data)), configPath
+		}
+		return "installed", configPath
+	}
+
+	if dmsPath, err := config.LocateDMSConfig(); err == nil {
+		versionFile := filepath.Join(dmsPath, "VERSION")
+		if data, err := os.ReadFile(versionFile); err == nil {
+			return strings.TrimSpace(string(data)), dmsPath
+		}
+		return "installed", dmsPath
+	}
+
+	return "", ""
+}
+
+func getQuickshellVersionInfo(missingFeatures bool) (string, status, string) {
+	if !utils.CommandExists("qs") {
+		return "Not installed", statusError, ""
+	}
+
+	qsPath, _ := exec.LookPath("qs")
+
+	output, err := exec.Command("qs", "--version").Output()
+	if err != nil {
+		return "Installed (version check failed)", statusWarn, qsPath
+	}
+
+	fullVersion := strings.TrimSpace(string(output))
+	if matches := quickshellVersionRegex.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
+		}
+		if missingFeatures {
+			return fullVersion, statusWarn, qsPath
+		}
+		return fullVersion, statusOK, qsPath
+	}
+
+	return fullVersion, statusWarn, qsPath
+}
+
+func checkDMSInstallation() []checkResult {
+	var results []checkResult
+
+	dmsPath := ""
+	if err := findConfig(nil, nil); err == nil && configPath != "" {
+		dmsPath = configPath
+	} else if path, err := config.LocateDMSConfig(); err == nil {
+		dmsPath = path
+	}
+
+	if dmsPath == "" {
+		return []checkResult{{catInstallation, "DMS Configuration", statusError, "Not found", "shell.qml not found in any config path", doctorDocsURL + "#dms-configuration"}}
+	}
+
+	results = append(results, checkResult{catInstallation, "DMS Configuration", statusOK, "Found", dmsPath, doctorDocsURL + "#dms-configuration"})
+
+	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"})
+	} else {
+		results = append(results, checkResult{catInstallation, "shell.qml", statusOK, "Present", shellQml, doctorDocsURL + "#dms-configuration"})
+	}
+
+	if doctorVerbose {
+		installType := "Unknown"
+		switch {
+		case strings.Contains(dmsPath, "/nix/store"):
+			installType = "Nix store"
+		case strings.Contains(dmsPath, ".local/share") || strings.Contains(dmsPath, "/usr/share"):
+			installType = "System package"
+		case strings.Contains(dmsPath, ".config"):
+			installType = "User config"
+		}
+		results = append(results, checkResult{catInstallation, "Install Type", statusInfo, installType, dmsPath, doctorDocsURL + "#dms-configuration"})
+	}
+
+	return results
+}
+
+func checkWindowManagers() []checkResult {
+	compositors := []struct {
+		name, versionCmd, versionArg string
+		versionRegex                 *regexp.Regexp
+		commands                     []string
+	}{
+		{"Hyprland", "Hyprland", "--version", hyprlandVersionRegex, []string{"hyprland", "Hyprland"}},
+		{"niri", "niri", "--version", niriVersionRegex, []string{"niri"}},
+		{"Sway", "sway", "--version", swayVersionRegex, []string{"sway"}},
+		{"River", "river", "-version", riverVersionRegex, []string{"river"}},
+		{"Wayfire", "wayfire", "--version", wayfireVersionRegex, []string{"wayfire"}},
+		{"labwc", "labwc", "--version", labwcVersionRegex, []string{"labwc"}},
+		{"mangowc", "mango", "-v", mangowcVersionRegex, []string{"mango"}},
+	}
+
+	var results []checkResult
+	foundAny := false
+
+	for _, c := range compositors {
+		if !slices.ContainsFunc(c.commands, utils.CommandExists) {
+			continue
+		}
+		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,
+			"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"})
+	}
+
+	return results
+}
+
+func getVersionFromCommand(cmd, arg string, regex *regexp.Regexp) string {
+	output, err := exec.Command(cmd, arg).CombinedOutput()
+	if err != nil && len(output) == 0 {
+		return "installed"
+	}
+
+	outStr := string(output)
+	if matches := regex.FindStringSubmatch(outStr); len(matches) > 1 {
+		ver := matches[1]
+		if strings.Contains(outStr, "git") || strings.Contains(outStr, "dirty") {
+			return ver + " (git)"
+		}
+		return ver
+	}
+	return strings.TrimSpace(outStr)
+}
+
+func detectRunningWM() string {
+	switch {
+	case os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") != "":
+		return "Hyprland"
+	case os.Getenv("NIRI_SOCKET") != "":
+		return "niri"
+	case os.Getenv("XDG_CURRENT_DESKTOP") != "":
+		return os.Getenv("XDG_CURRENT_DESKTOP")
+	}
+	return ""
+}
+
+func checkQuickshellFeatures() ([]checkResult, bool) {
+	if !utils.CommandExists("qs") {
+		return nil, false
+	}
+
+	tmpDir := os.TempDir()
+	testScript := filepath.Join(tmpDir, "qs-feature-test.qml")
+	defer os.Remove(testScript)
+
+	qmlContent := `
+import QtQuick
+import Quickshell
+
+ShellRoot {
+	id: root
+
+	property bool polkitAvailable: false
+	property bool idleMonitorAvailable: false
+	property bool idleInhibitorAvailable: false
+	property bool shortcutInhibitorAvailable: false
+
+	Timer {
+		interval: 50
+		running: true
+		repeat: false
+		onTriggered: {
+			try {
+				var polkitTest = Qt.createQmlObject(
+					'import Quickshell.Services.Polkit; import QtQuick; Item {}',
+					root
+				)
+				root.polkitAvailable = true
+				polkitTest.destroy()
+			} catch (e) {}
+
+			try {
+				var testItem = Qt.createQmlObject(
+					'import Quickshell.Wayland; import QtQuick; QtObject { ' +
+					'readonly property bool hasIdleMonitor: typeof IdleMonitor !== "undefined"; ' +
+					'readonly property bool hasIdleInhibitor: typeof IdleInhibitor !== "undefined"; ' +
+					'readonly property bool hasShortcutInhibitor: typeof ShortcutInhibitor !== "undefined" ' +
+					'}',
+					root
+				)
+				root.idleMonitorAvailable = testItem.hasIdleMonitor
+				root.idleInhibitorAvailable = testItem.hasIdleInhibitor
+				root.shortcutInhibitorAvailable = testItem.hasShortcutInhibitor
+				testItem.destroy()
+			} catch (e) {}
+
+			console.warn(root.polkitAvailable ? "FEATURE:Polkit:OK" : "FEATURE:Polkit:UNAVAILABLE")
+			console.warn(root.idleMonitorAvailable ? "FEATURE:IdleMonitor:OK" : "FEATURE:IdleMonitor:UNAVAILABLE")
+			console.warn(root.idleInhibitorAvailable ? "FEATURE:IdleInhibitor:OK" : "FEATURE:IdleInhibitor:UNAVAILABLE")
+			console.warn(root.shortcutInhibitorAvailable ? "FEATURE:ShortcutInhibitor:OK" : "FEATURE:ShortcutInhibitor:UNAVAILABLE")
+
+			Quickshell.execDetached(["kill", "-TERM", String(Quickshell.processId)])
+		}
+	}
+}
+`
+
+	if err := os.WriteFile(testScript, []byte(qmlContent), 0644); err != nil {
+		return nil, false
+	}
+
+	cmd := exec.Command("qs", "-p", testScript)
+	cmd.Env = append(os.Environ(), "NO_COLOR=1")
+	output, _ := cmd.CombinedOutput()
+	outputStr := string(output)
+
+	features := []struct{ name, desc string }{
+		{"Polkit", "Authentication prompts"},
+		{"IdleMonitor", "Idle detection"},
+		{"IdleInhibitor", "Prevent idle/sleep"},
+		{"ShortcutInhibitor", "Allow shortcut management (niri)"},
+	}
+
+	var results []checkResult
+	missingFeatures := false
+
+	for _, f := range features {
+		available := strings.Contains(outputStr, fmt.Sprintf("FEATURE:%s:OK", f.name))
+		status, message := statusOK, "Available"
+		if !available {
+			status, message = statusInfo, "Not available"
+			missingFeatures = true
+		}
+		results = append(results, checkResult{catQuickshellFeatures, f.name, status, message, f.desc, doctorDocsURL + "#quickshell-features"})
+	}
+
+	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
+
+	optionalFeaturesURL := doctorDocsURL + "#optional-features"
+
+	accountsStatus, accountsMsg := getOptionalDBusStatus("org.freedesktop.Accounts")
+	results = append(results, checkResult{catOptionalFeatures, "accountsservice", accountsStatus, accountsMsg, "User accounts", optionalFeaturesURL})
+
+	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 {
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusOK, terminals[idx], "", optionalFeaturesURL})
+	} else {
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusWarn, "None found", "Install ghostty, kitty, or alacritty", optionalFeaturesURL})
+	}
+
+	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
+	}
+
+	results = append(results, checkResult{catOptionalFeatures, "Network", networkStatus, networkMessage, networkDetails, optionalFeaturesURL})
+
+	deps := []struct {
+		name, cmd, desc string
+		important       bool
+	}{
+		{"matugen", "matugen", "Dynamic theming", true},
+		{"dgop", "dgop", "System monitoring", true},
+		{"cava", "cava", "Audio visualizer", true},
+		{"khal", "khal", "Calendar events", false},
+		{"danksearch", "dsearch", "File search", false},
+		{"fprintd", "fprintd-list", "Fingerprint auth", false},
+	}
+
+	for _, d := range deps {
+		found := utils.CommandExists(d.cmd)
+
+		switch {
+		case found:
+			results = append(results, checkResult{catOptionalFeatures, d.name, statusOK, "Installed", d.desc, optionalFeaturesURL})
+		case d.important:
+			results = append(results, checkResult{catOptionalFeatures, d.name, statusWarn, "Missing", d.desc, optionalFeaturesURL})
+		default:
+			results = append(results, checkResult{catOptionalFeatures, d.name, statusInfo, "Not installed", d.desc, optionalFeaturesURL})
+		}
+	}
+
+	return results
+}
+
+func checkConfigurationFiles() []checkResult {
+	configDir, _ := os.UserConfigDir()
+	cacheDir, _ := os.UserCacheDir()
+	dmsDir := "DankMaterialShell"
+
+	configFiles := []struct{ name, path string }{
+		{"settings.json", filepath.Join(configDir, dmsDir, "settings.json")},
+		{"clsettings.json", filepath.Join(configDir, dmsDir, "clsettings.json")},
+		{"plugin_settings.json", filepath.Join(configDir, dmsDir, "plugin_settings.json")},
+		{"session.json", filepath.Join(utils.XDGStateHome(), dmsDir, "session.json")},
+		{"dms-colors.json", filepath.Join(cacheDir, dmsDir, "dms-colors.json")},
+	}
+
+	var results []checkResult
+	for _, cf := range configFiles {
+		info, err := os.Stat(cf.path)
+		if err != nil {
+			results = append(results, checkResult{catConfigFiles, cf.name, statusInfo, "Not yet created", cf.path, doctorDocsURL + "#config-files"})
+			continue
+		}
+
+		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
+}
+
+func checkSystemdServices() []checkResult {
+	if !utils.CommandExists("systemctl") {
+		return nil
+	}
+
+	var results []checkResult
+
+	dmsState := getServiceState("dms", true)
+	if !dmsState.exists {
+		results = append(results, checkResult{catServices, "dms.service", statusInfo, "Not installed", "Optional user service", doctorDocsURL + "#services"})
+	} else {
+		status, message := statusOK, dmsState.enabled
+		if dmsState.active != "" {
+			message = fmt.Sprintf("%s, %s", dmsState.enabled, dmsState.active)
+		}
+		switch {
+		case dmsState.enabled == "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"})
+	}
+
+	greetdState := getServiceState("greetd", false)
+	switch {
+	case greetdState.exists:
+		status := statusOK
+		if greetdState.enabled == "disabled" {
+			status = statusInfo
+		}
+		results = append(results, checkResult{catServices, "greetd", status, greetdState.enabled, "", doctorDocsURL + "#services"})
+	case doctorVerbose:
+		results = append(results, checkResult{catServices, "greetd", statusInfo, "Not installed", "Optional greeter service", doctorDocsURL + "#services"})
+	}
+
+	return results
+}
+
+type serviceState struct {
+	exists  bool
+	enabled string
+	active  string
+}
+
+func getServiceState(name string, userService bool) serviceState {
+	args := []string{"is-enabled", name}
+	if userService {
+		args = []string{"--user", "is-enabled", name}
+	}
+
+	output, _ := exec.Command("systemctl", args...).Output()
+	enabled := strings.TrimSpace(string(output))
+
+	if enabled == "" || enabled == "not-found" {
+		return serviceState{}
+	}
+
+	state := serviceState{exists: true, enabled: enabled}
+
+	if userService {
+		output, _ = exec.Command("systemctl", "--user", "is-active", name).Output()
+		if active := strings.TrimSpace(string(output)); active != "" && active != "unknown" {
+			state.active = active
+		}
+	}
+
+	return state
+}
+
+func printResults(results []checkResult) {
+	theme := tui.TerminalTheme()
+	styles := tui.NewStyles(theme)
+
+	currentCategory := category(-1)
+	for _, r := range results {
+		if r.category != currentCategory {
+			if currentCategory != -1 {
+				fmt.Println()
+			}
+			fmt.Printf("  %s\n", styles.Bold.Render(r.category.String()))
+			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)
+
+	name := r.name
+	nameLen := len(name)
+
+	if nameLen > checkNameMaxLength {
+		name = name[:checkNameMaxLength-1] + "…"
+		nameLen = checkNameMaxLength
+	}
+	dots := strings.Repeat("·", checkNameMaxLength-nameLen)
+
+	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
+	for _, r := range results {
+		ds.Add(r)
+	}
+
+	fmt.Println()
+	fmt.Printf("  %s\n", styles.Subtle.Render("──────────────────────────────────────"))
+
+	if !ds.HasIssues() {
+		fmt.Printf("  %s\n", styles.Success.Render("✓ All checks passed!"))
+	} else {
+		var parts []string
+
+		if ds.ErrorCount() > 0 {
+			parts = append(parts, styles.Error.Render(fmt.Sprintf("%d error(s)", ds.ErrorCount())))
+		}
+		if ds.WarningCount() > 0 {
+			parts = append(parts, styles.Warning.Render(fmt.Sprintf("%d warning(s)", ds.WarningCount())))
+		}
+		parts = append(parts, styles.Success.Render(fmt.Sprintf("%d ok", ds.OKCount())))
+		fmt.Printf("  %s\n", strings.Join(parts, ", "))
+
+		if qsMissingFeatures {
+			fmt.Println()
+			fmt.Printf("  %s\n", styles.Subtle.Render("→ Consider using quickshell-git for full feature support"))
+		}
+	}
+	fmt.Println()
+}

core/cmd/dms/commands_features.go

@@ -377,7 +377,7 @@ func updateDMSBinary() error {
 	}
 
 	version := ""
-	for _, line := range strings.Split(string(output), "\n") {
+	for line := range strings.SplitSeq(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, 0755); err != nil {
+	if err := os.Chmod(decompressedPath, 0o755); 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.Split(string(data), "\n")
-	for _, line := range lines {
+	lines := strings.SplitSeq(string(data), "\n")
+	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), 0644); err != nil {
+	if err := os.WriteFile(tmpFile, []byte(newConfig), 0o644); 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.Split(configContent, "\n")
-			for _, line := range lines {
+			lines := strings.SplitSeq(configContent, "\n")
+			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,12 +57,14 @@ 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)
@@ -110,12 +112,21 @@ func initializeProviders() {
 	}
 }
 
-func runKeybindsList(_ *cobra.Command, _ []string) {
+func runKeybindsList(cmd *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)
@@ -201,6 +212,9 @@ 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,6 +2,7 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"time"
 
@@ -29,9 +30,16 @@ 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")
@@ -74,7 +82,7 @@ func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
 		ConfigDir:           configDir,
 		Kind:                kind,
 		Value:               value,
-		Mode:                mode,
+		Mode:                matugen.ColorMode(mode),
 		IconTheme:           iconTheme,
 		MatugenType:         matugenType,
 		RunUserTemplates:    runUserTemplates,
@@ -162,3 +170,12 @@ 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_notify.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/notify"
+	"github.com/spf13/cobra"
+)
+
+var (
+	notifyAppName string
+	notifyIcon    string
+	notifyFile    string
+	notifyTimeout int
+)
+
+var notifyCmd = &cobra.Command{
+	Use:   "notify <summary> [body]",
+	Short: "Send a desktop notification",
+	Long: `Send a desktop notification with optional actions.
+
+If --file is provided, the notification will have "Open" and "Open Folder" actions.
+
+Examples:
+  dms notify "Hello" "World"
+  dms notify "File received" "photo.jpg" --file ~/Downloads/photo.jpg --icon smartphone
+  dms notify "Download complete" --file ~/Downloads/file.zip --app "My App"`,
+	Args: cobra.MinimumNArgs(1),
+	Run:  runNotify,
+}
+
+var genericNotifyActionCmd = &cobra.Command{
+	Use:    "notify-action-generic",
+	Hidden: true,
+	Run: func(cmd *cobra.Command, args []string) {
+		notify.RunActionListener(args)
+	},
+}
+
+func init() {
+	notifyCmd.Flags().StringVar(&notifyAppName, "app", "DMS", "Application name")
+	notifyCmd.Flags().StringVar(&notifyIcon, "icon", "", "Icon name or path")
+	notifyCmd.Flags().StringVar(&notifyFile, "file", "", "File path (enables Open/Open Folder actions)")
+	notifyCmd.Flags().IntVar(&notifyTimeout, "timeout", 5000, "Timeout in milliseconds")
+}
+
+func runNotify(cmd *cobra.Command, args []string) {
+	summary := args[0]
+	body := ""
+	if len(args) > 1 {
+		body = args[1]
+	}
+
+	n := notify.Notification{
+		AppName:  notifyAppName,
+		Icon:     notifyIcon,
+		Summary:  summary,
+		Body:     body,
+		FilePath: notifyFile,
+		Timeout:  int32(notifyTimeout),
+	}
+
+	if err := notify.Send(n); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+}

core/cmd/dms/commands_root.go

@@ -7,9 +7,7 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/dms"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
 )
 
@@ -20,11 +18,9 @@ var rootCmd = &cobra.Command{
 	Use:   "dms",
 	Short: "dms CLI",
 	Long:  "dms is the DankMaterialShell management CLI and backend server.",
-	Run:   runInteractiveMode,
 }
 
 func init() {
-	// Add the -c flag
 	rootCmd.PersistentFlags().StringVarP(&customConfigPath, "config", "c", "", "Specify a custom path to the DMS config directory")
 }
 
@@ -38,7 +34,7 @@ func findConfig(cmd *cobra.Command, args []string) error {
 		if statErr == nil && !info.IsDir() {
 			configPath = customConfigPath
 			log.Debug("Using config from: %s", configPath)
-			return nil // <-- Guard statement
+			return nil
 		}
 
 		if statErr != nil {
@@ -50,15 +46,18 @@ func findConfig(cmd *cobra.Command, args []string) error {
 
 	configStateFile := filepath.Join(getRuntimeDir(), "danklinux.path")
 	if data, readErr := os.ReadFile(configStateFile); readErr == nil {
-		statePath := strings.TrimSpace(string(data))
-		shellPath := filepath.Join(statePath, "shell.qml")
-
-		if info, statErr := os.Stat(shellPath); statErr == nil && !info.IsDir() {
-			log.Debug("Using config from active session state file: %s", statePath)
-			configPath = statePath
-			log.Debug("Using config from: %s", configPath)
-			return nil // <-- Guard statement
+		if len(getAllDMSPIDs()) == 0 {
+			os.Remove(configStateFile)
 		} else {
+			statePath := strings.TrimSpace(string(data))
+			shellPath := filepath.Join(statePath, "shell.qml")
+
+			if info, statErr := os.Stat(shellPath); statErr == nil && !info.IsDir() {
+				log.Debug("Using config from active session state file: %s", statePath)
+				configPath = statePath
+				log.Debug("Using config from: %s", configPath)
+				return nil
+			}
 			os.Remove(configStateFile)
 		}
 	}
@@ -73,18 +72,3 @@ func findConfig(cmd *cobra.Command, args []string) error {
 	log.Debug("Using config from: %s", configPath)
 	return nil
 }
-func runInteractiveMode(cmd *cobra.Command, args []string) {
-	detector, _ := dms.NewDetector()
-
-	if !detector.IsDMSInstalled() {
-		log.Error("DankMaterialShell (DMS) is not detected as installed on this system.")
-		log.Info("Please install DMS using dankinstall before using this management interface.")
-		os.Exit(1)
-	}
-
-	model := dms.NewModel(Version)
-	p := tea.NewProgram(model, tea.WithAltScreen())
-	if _, err := p.Run(); err != nil {
-		log.Fatalf("Error running program: %v", err)
-	}
-}

core/cmd/dms/dpms_client.go

@@ -87,20 +87,14 @@ func newDPMSClient() (*dpmsClient, error) {
 		switch e.Interface {
 		case wlr_output_power.ZwlrOutputPowerManagerV1InterfaceName:
 			powerMgr := wlr_output_power.NewZwlrOutputPowerManagerV1(c.ctx)
-			version := e.Version
-			if version > 1 {
-				version = 1
-			}
+			version := min(e.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 := e.Version
-			if version > 4 {
-				version = 4
-			}
+			version := min(e.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,8 +7,10 @@ import (
 	"os/exec"
 	"os/signal"
 	"path/filepath"
+	"slices"
 	"strconv"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -184,8 +186,10 @@ func runShellInteractive(session bool) {
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
 	cmd.Env = append(os.Environ(), "DMS_SOCKET="+socketPath)
-	if qtRules := log.GetQtLoggingRules(); qtRules != "" {
-		cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
+	if os.Getenv("QT_LOGGING_RULES") == "" {
+		if qtRules := log.GetQtLoggingRules(); qtRules != "" {
+			cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
+		}
 	}
 
 	if isSessionManaged && hasSystemdRun() {
@@ -371,13 +375,7 @@ func killShell() {
 
 func runShellDaemon(session bool) {
 	isSessionManaged = session
-	isDaemonChild := false
-	for _, arg := range os.Args {
-		if arg == "--daemon-child" {
-			isDaemonChild = true
-			break
-		}
-	}
+	isDaemonChild := slices.Contains(os.Args, "--daemon-child")
 
 	if !isDaemonChild {
 		fmt.Fprintf(os.Stderr, "dms %s\n", Version)
@@ -428,8 +426,10 @@ func runShellDaemon(session bool) {
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
 	cmd.Env = append(os.Environ(), "DMS_SOCKET="+socketPath)
-	if qtRules := log.GetQtLoggingRules(); qtRules != "" {
-		cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
+	if os.Getenv("QT_LOGGING_RULES") == "" {
+		if qtRules := log.GetQtLoggingRules(); qtRules != "" {
+			cmd.Env = append(cmd.Env, "QT_LOGGING_RULES="+qtRules)
+		}
 	}
 
 	if isSessionManaged && hasSystemdRun() {
@@ -531,12 +531,20 @@ 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.Split(output, "\n") {
-		if strings.HasPrefix(line, "target ") {
-			currentTarget = strings.TrimSpace(strings.TrimPrefix(line, "target "))
+	for line := range strings.SplitSeq(output, "\n") {
+		if after, ok := strings.CutPrefix(line, "target "); ok {
+			currentTarget = strings.TrimSpace(after)
 			targets[currentTarget] = make(map[string][]string)
 		}
 		if strings.HasPrefix(line, "  function") && currentTarget != "" {
@@ -561,7 +569,11 @@ func parseTargetsFromIPCShowOutput(output string) ipcTargets {
 }
 
 func getShellIPCCompletions(args []string, _ string) []string {
-	cmdArgs := []string{"-p", configPath, "ipc", "show"}
+	cmdArgs := []string{"ipc"}
+	if qsHasAnyDisplay() {
+		cmdArgs = append(cmdArgs, "--any-display")
+	}
+	cmdArgs = append(cmdArgs, "-p", configPath, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 	var targets ipcTargets
 
@@ -606,16 +618,20 @@ func getShellIPCCompletions(args []string, _ string) []string {
 
 func runShellIPCCommand(args []string) {
 	if len(args) == 0 {
-		log.Error("IPC command requires arguments")
-		log.Info("Usage: dms ipc <command> [args...]")
-		os.Exit(1)
+		printIPCHelp()
+		return
 	}
 
 	if args[0] != "call" {
 		args = append([]string{"call"}, args...)
 	}
 
-	cmdArgs := append([]string{"-p", configPath, "ipc"}, args...)
+	cmdArgs := []string{"ipc"}
+	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
@@ -625,3 +641,45 @@ func runShellIPCCommand(args []string) {
 		log.Fatalf("Error running IPC command: %v", err)
 	}
 }
+
+func printIPCHelp() {
+	fmt.Println("Usage: dms ipc <target> <function> [args...]")
+	fmt.Println()
+
+	cmdArgs := []string{"ipc"}
+	if qsHasAnyDisplay() {
+		cmdArgs = append(cmdArgs, "--any-display")
+	}
+	cmdArgs = append(cmdArgs, "-p", configPath, "show")
+	cmd := exec.Command("qs", cmdArgs...)
+
+	output, err := cmd.Output()
+	if err != nil {
+		fmt.Println("Could not retrieve available IPC targets (is DMS running?)")
+		return
+	}
+
+	targets := parseTargetsFromIPCShowOutput(string(output))
+	if len(targets) == 0 {
+		fmt.Println("No IPC targets available")
+		return
+	}
+
+	fmt.Println("Targets:")
+
+	targetNames := make([]string, 0, len(targets))
+	for name := range targets {
+		targetNames = append(targetNames, name)
+	}
+	slices.Sort(targetNames)
+
+	for _, targetName := range targetNames {
+		funcs := targets[targetName]
+		funcNames := make([]string, 0, len(funcs))
+		for fn := range funcs {
+			funcNames = append(funcNames, fn)
+		}
+		slices.Sort(funcNames)
+		fmt.Printf("  %-16s %s\n", targetName, strings.Join(funcNames, ", "))
+	}
+}

core/cmd/dms/utils.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os/exec"
+	"slices"
 	"strings"
 )
 
@@ -36,13 +37,7 @@ 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 := false
-		for _, known := range knownStates {
-			if stateStr == known {
-				isKnownState = true
-				break
-			}
-		}
+		isKnownState := slices.Contains(knownStates, stateStr)
 
 		if !isKnownState {
 			return stateStr, false, fmt.Errorf("systemctl is-enabled failed: %w (output: %s)", err, stateStr)

core/go.mod

@@ -4,33 +4,37 @@ go 1.24.6
 
 require (
 	github.com/Wifx/gonetworkmanager/v2 v2.2.0
+	github.com/alecthomas/chroma/v2 v2.17.2
 	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10
 	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.0
+	github.com/godbus/dbus/v5 v5.2.2
 	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-20250930225324-bf4099d4614a
-	github.com/spf13/cobra v1.10.1
+	github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3
+	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
+	github.com/yuin/goldmark v1.7.16
+	github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc
 	go.etcd.io/bbolt v1.4.3
-	golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39
-	golang.org/x/image v0.34.0
+	golang.org/x/exp v0.0.0-20260112195511-716be5621a96
+	golang.org/x/image v0.35.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.0 // indirect
+	github.com/clipperhouse/displaywidth v0.7.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.1 // indirect
+	github.com/cloudflare/circl v1.6.2 // indirect
 	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
+	github.com/dlclark/regexp2 v1.11.5 // 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-20251126203821-7f9c95185ee0 // indirect
+	github.com/go-git/go-billy/v6 v6.0.0-20260114122816-19306b749ecc // 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 +42,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.45.0 // indirect
-	golang.org/x/net v0.47.0 // indirect
+	golang.org/x/crypto v0.47.0 // indirect
+	golang.org/x/net v0.49.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.3.3 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.2 // indirect
+	github.com/charmbracelet/x/ansi v0.11.4 // 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-20251128074608-48f817f57805
+	github.com/go-git/go-git/v6 v6.0.0-20260114124804-a8db3a6585a6
 	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 +70,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.38.0
-	golang.org/x/text v0.32.0
+	golang.org/x/sys v0.40.0
+	golang.org/x/text v0.33.0
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

core/go.sum

@@ -4,6 +4,14 @@ github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBi
 github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
 github.com/Wifx/gonetworkmanager/v2 v2.2.0 h1:kPstgsQtY8CmDOOFZd81ytM9Gi3f6ImzPCKF7nNhQ2U=
 github.com/Wifx/gonetworkmanager/v2 v2.2.0/go.mod h1:fMDb//SHsKWxyDUAwXvCqurV3npbIyyaQWenGpZ/uXg=
+github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
+github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/chroma/v2 v2.2.0/go.mod h1:vf4zrexSH54oEjJ7EdB65tGNHmH3pGZmVkgTP5RHvAs=
+github.com/alecthomas/chroma/v2 v2.17.2 h1:Rm81SCZ2mPoH+Q8ZCc/9YvzPUN/E7HgPiPJD8SLV6GI=
+github.com/alecthomas/chroma/v2 v2.17.2/go.mod h1:RVX6AvYm4VfYe/zsk7mjHueLDZor3aWCNE14TFlepBk=
+github.com/alecthomas/repr v0.0.0-20220113201626-b1b626ac65ae/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
@@ -16,36 +24,38 @@ github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u
 github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
 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=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
 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.4 h1:6G65PLu6HjmE858CnTUQY1LXT3ZUWwfvqEROLF8vqHI=
+github.com/charmbracelet/x/ansi v0.11.4/go.mod h1:/5AZ+UfWExW3int5H5ugnsG/PWjNcSQcwYsHBlPFQN4=
 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.7.0 h1:QNv1GYsnLX9QBrcWUtMlogpTXuM5FVnBwKWp1O5NwmE=
+github.com/clipperhouse/displaywidth v0.7.0/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=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
-github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
+github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
+github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
+github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
@@ -56,22 +66,24 @@ github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 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-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/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-billy/v6 v6.0.0-20260114122816-19306b749ecc h1:rhkjrnRkamkRC7woapp425E4CAH6RPcqsS9X8LA93IY=
+github.com/go-git/go-billy/v6 v6.0.0-20260114122816-19306b749ecc/go.mod h1:X1oe0Z2qMsa9hkar3AAPuL9hu4Mi3ztXEjdqRhr6fcc=
+github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20251229094738-4b14af179146 h1:xYfxAopYyL44ot6dMBIb1Z1njFM0ZBQ99HdIB99KxLs=
+github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20251229094738-4b14af179146/go.mod h1:QE/75B8tBSLNGyUUbA9tw3EGHoFtYOtypa2h8YJxsWI=
+github.com/go-git/go-git/v6 v6.0.0-20260114124804-a8db3a6585a6 h1:Yo1MlE8LpvD0pr7mZ04b6hKZKQcPvLrQFgyY1jNMEyU=
+github.com/go-git/go-git/v6 v6.0.0-20260114124804-a8db3a6585a6/go.mod h1:enMzPHv+9hL4B7tH7OJGQKNzCkMzXovUoaiXfsLF7Xs=
 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=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83 h1:B+A58zGFuDrvEZpPN+yS6swJA0nzqgZvDzgl/OPyefU=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83/go.mod h1:iHAf8OIncO2gcQ8XOjS7CMJ2aPbX2Bs0wl5pZyanEqk=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -112,14 +124,14 @@ github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUc
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 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=
@@ -127,35 +139,43 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
 github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/yuin/goldmark v1.4.15/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
+github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
+github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc h1:+IAOyRda+RLrxa1WC7umKOZRsGq4QrFFMYApOeHzQwQ=
+github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc/go.mod h1:ovIvrum6DQJA4QsJSovrkC4saKHQVs7TvcaeO8AIl5I=
 go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
 go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
-golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
-golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
-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/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=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
+golang.org/x/image v0.35.0 h1:LKjiHdgMtO8z7Fh18nGY6KDcoEtVfsgLDPeLyguqb7I=
+golang.org/x/image v0.35.0/go.mod h1:MwPLTVgvxSASsxdLzKrl8BRFuyqMyGhLwmC+TO1Sybk=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
 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/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/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
-golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
+golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

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,12 +121,31 @@ func getDBPath() (string, error) {
 		cacheDir = filepath.Join(homeDir, ".cache")
 	}
 
-	dbDir := filepath.Join(cacheDir, "dms-clipboard")
-	if err := os.MkdirAll(dbDir, 0700); err != nil {
-		return "", err
+	newDir := filepath.Join(cacheDir, "DankMaterialShell", "clipboard")
+	newPath := filepath.Join(newDir, "db")
+
+	if _, err := os.Stat(newPath); err == nil {
+		return newPath, nil
 	}
 
-	return filepath.Join(dbDir, "db"), 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
 }
 
 func deduplicateInTx(b *bolt.Bucket, hash uint64) error {

core/internal/colorpicker/picker.go

@@ -221,10 +221,7 @@ func (p *Picker) handleGlobal(e client.RegistryGlobalEvent) {
 
 	case client.OutputInterfaceName:
 		output := client.NewOutput(p.ctx)
-		version := e.Version
-		if version > 4 {
-			version = 4
-		}
+		version := min(e.Version, 4)
 		if err := p.registry.Bind(e.Name, e.Interface, version, output); err == nil {
 			p.outputsMu.Lock()
 			p.outputs[e.Name] = &Output{
@@ -239,20 +236,14 @@ func (p *Picker) handleGlobal(e client.RegistryGlobalEvent) {
 
 	case wlr_layer_shell.ZwlrLayerShellV1InterfaceName:
 		layerShell := wlr_layer_shell.NewZwlrLayerShellV1(p.ctx)
-		version := e.Version
-		if version > 4 {
-			version = 4
-		}
+		version := min(e.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 := e.Version
-		if version > 3 {
-			version = 3
-		}
+		version := min(e.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 := 0; row < fontH; row++ {
+	for row := range fontH {
 		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 := 0; colIdx < fontW; colIdx++ {
+		for colIdx := range fontW {
 			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 := 0; i < goroutines; i++ {
+	for i := range goroutines {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for j := range iterations {
 				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 := 0; i < goroutines/2; i++ {
+	for i := range goroutines / 2 {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				s.SetScale(int32(id%3 + 1))
 			}
 		}(i)
 	}
 
-	for i := 0; i < goroutines/2; i++ {
+	for range goroutines / 2 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				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 := 0; i < goroutines/2; i++ {
+	for i := range goroutines / 2 {
 		wg.Add(1)
 		go func(id int) {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for j := range iterations {
 				_ = s.OnLayerConfigure(1920+id, 1080+j)
 			}
 		}(i)
 	}
 
-	for i := 0; i < goroutines/2; i++ {
+	for range goroutines / 2 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				w, h := s.LogicalSize()
 				_ = w
 				_ = h
@@ -97,31 +97,31 @@ func TestSurfaceState_ConcurrentIsDone(t *testing.T) {
 	const goroutines = 30
 	const iterations = 100
 
-	for i := 0; i < goroutines/3; i++ {
+	for range goroutines / 3 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				s.OnPointerButton(0x110, 1)
 			}
 		}()
 	}
 
-	for i := 0; i < goroutines/3; i++ {
+	for range goroutines / 3 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				s.OnKey(1, 1)
 			}
 		}()
 	}
 
-	for i := 0; i < goroutines/3; i++ {
+	for range goroutines / 3 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				picked, cancelled := s.IsDone()
 				_ = picked
 				_ = cancelled
@@ -139,11 +139,11 @@ func TestSurfaceState_ConcurrentIsReady(t *testing.T) {
 	const goroutines = 20
 	const iterations = 100
 
-	for i := 0; i < goroutines; i++ {
+	for range goroutines {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				_ = s.IsReady()
 			}
 		}()
@@ -159,11 +159,11 @@ func TestSurfaceState_ConcurrentSwapBuffers(t *testing.T) {
 	const goroutines = 20
 	const iterations = 100
 
-	for i := 0; i < goroutines; i++ {
+	for range goroutines {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < iterations; j++ {
+			for range iterations {
 				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)
+		mergedConfig, err := cd.mergeNiriOutputSections(newConfig, existingConfig, dmsDir)
 		if err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to merge output sections: %v", err))
 		} else {
@@ -209,12 +209,14 @@ 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 {
 		path := filepath.Join(dmsDir, cfg.name)
-		// Skip if file already exists to preserve user modifications
-		if _, err := os.Stat(path); err == nil {
+		// Skip if file already exists and is not empty to preserve user modifications
+		if info, err := os.Stat(path); err == nil && info.Size() > 0 {
 			cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
 			continue
 		}
@@ -421,24 +423,31 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 	return results, nil
 }
 
-// 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)
+func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig, dmsDir string) (string, error) {
 	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
 	}
 
-	// Remove the example output section from the new config
+	outputsPath := filepath.Join(dmsDir, "outputs.kdl")
+	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)
 
@@ -446,7 +455,6 @@ func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig stri
 		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
@@ -476,6 +484,12 @@ 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")
@@ -515,7 +529,7 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 	}
 
 	if existingConfig != "" {
-		mergedConfig, err := cd.mergeHyprlandMonitorSections(newConfig, existingConfig)
+		mergedConfig, err := cd.mergeHyprlandMonitorSections(newConfig, existingConfig, dmsDir)
 		if err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to merge monitor sections: %v", err))
 		} else {
@@ -529,13 +543,45 @@ 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
 }
 
-// mergeHyprlandMonitorSections extracts monitor sections from existing config and merges them into the new config
-func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig string) (string, error) {
+func (cd *ConfigDeployer) deployHyprlandDmsConfigs(dmsDir string, terminalCommand string) error {
+	configs := []struct {
+		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)
+		// Skip if file already exists and is not empty to preserve user modifications
+		if info, err := os.Stat(path); err == nil && info.Size() > 0 {
+			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)
 
@@ -543,6 +589,20 @@ 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,7 +161,8 @@ layout {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := cd.mergeNiriOutputSections(tt.newConfig, tt.existingConfig)
+			tmpDir := t.TempDir()
+			result, err := cd.mergeNiriOutputSections(tt.newConfig, tt.existingConfig, tmpDir)
 
 			if tt.wantError {
 				assert.Error(t, err)
@@ -362,7 +363,8 @@ input {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := cd.mergeHyprlandMonitorSections(tt.newConfig, tt.existingConfig)
+			tmpDir := t.TempDir()
+			result, err := cd.mergeHyprlandMonitorSections(tt.newConfig, tt.existingConfig, tmpDir)
 
 			if tt.wantError {
 				assert.Error(t, err)
@@ -406,7 +408,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), "bind = $mod, T, exec, ghostty")
+		assert.Contains(t, string(content), "source = ./dms/binds.conf")
 		assert.Contains(t, string(content), "exec-once = ")
 	})
 
@@ -442,7 +444,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), "bind = $mod, T, exec, kitty")
+		assert.Contains(t, string(newContent), "source = ./dms/binds.conf")
 		assert.NotContains(t, string(newContent), "monitor = eDP-2")
 	})
 }
@@ -459,10 +461,7 @@ 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, "# 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)$")
+	assert.Contains(t, HyprlandConfig, "source = ./dms/binds.conf")
 }
 
 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.Split(dataDirs, ":") {
+	for dir := range strings.SplitSeq(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.Split(configDirs, ":") {
+	for dir := range strings.SplitSeq(configDirs, ":") {
 		if dir != "" {
 			primaryPaths = append(primaryPaths, filepath.Join(dir, "quickshell", "dms"))
 		}

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

@@ -0,0 +1,159 @@
+# === 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
+
+# === Workspace Management ===
+bind = CTRL SHIFT, R, exec, dms ipc call workspace-rename open
+
+# === 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

@@ -0,0 +1,25 @@
+# ! 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

@@ -0,0 +1,11 @@
+# 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,10 +27,7 @@ input {
 general {
     gaps_in = 5
     gaps_out = 5
-    border_size = 0  # off in niri
-
-    col.active_border = rgba(707070ff)
-    col.inactive_border = rgba(d0d0d0ff)
+    border_size = 2
 
     layout = dwindle
 }
@@ -42,7 +39,7 @@ decoration {
     rounding = 12
 
     active_opacity = 1.0
-    inactive_opacity = 0.9
+    inactive_opacity = 1.0
 
     shadow {
         enabled = true
@@ -90,190 +87,32 @@ misc {
 # ==================
 # WINDOW RULES
 # ==================
-windowrulev2 = tile, class:^(org\.wezfurlong\.wezterm)$
+windowrule = tile on, match:class ^(org\.wezfurlong\.wezterm)$
 
-windowrulev2 = rounding 12, class:^(org\.gnome\.)
-windowrulev2 = noborder, class:^(org\.gnome\.)
+windowrule = rounding 12, match:class ^(org\.gnome\.)
 
-windowrulev2 = tile, class:^(gnome-control-center)$
-windowrulev2 = tile, class:^(pavucontrol)$
-windowrulev2 = tile, class:^(nm-connection-editor)$
+windowrule = tile on, match:class ^(gnome-control-center)$
+windowrule = tile on, match:class ^(pavucontrol)$
+windowrule = tile on, match:class ^(nm-connection-editor)$
 
-windowrulev2 = float, class:^(gnome-calculator)$
-windowrulev2 = float, class:^(galculator)$
-windowrulev2 = float, class:^(blueman-manager)$
-windowrulev2 = float, class:^(org\.gnome\.Nautilus)$
-windowrulev2 = float, class:^(steam)$
-windowrulev2 = float, class:^(xdg-desktop-portal)$
+windowrule = float on, match:class ^(gnome-calculator)$
+windowrule = float on, match:class ^(galculator)$
+windowrule = float on, match:class ^(blueman-manager)$
+windowrule = float on, match:class ^(org\.gnome\.Nautilus)$
+windowrule = float on, match:class ^(steam)$
+windowrule = float on, match:class ^(xdg-desktop-portal)$
 
-windowrulev2 = noborder, class:^(org\.wezfurlong\.wezterm)$
-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)$
+windowrule = float on, match:class ^(firefox)$, match:title ^(Picture-in-Picture)$
+windowrule = float on, match:class ^(zoom)$
 
 # DMS windows floating by default
-windowrulev2 = float, class:^(org.quickshell)$
-windowrulev2 = opacity 0.9 0.9, floating:0, focus:0
+# ! Hyprland doesn't size these windows correctly so disabling by default here
+# windowrule = float on, match:class ^(org.quickshell)$
 
-layerrule = noanim, ^(quickshell)$
+layerrule = no_anim on, match:namespace ^(quickshell)$
 
-# ==================
-# KEYBINDINGS
-# ==================
-$mod = SUPER
-
-# === 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
+source = ./dms/colors.conf
+source = ./dms/outputs.conf
+source = ./dms/layout.conf
+source = ./dms/cursor.conf
+source = ./dms/binds.conf

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

@@ -1,8 +1,3 @@
-// ! 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; }
@@ -20,6 +15,8 @@ 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";
     }
@@ -51,6 +48,18 @@ 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 {
@@ -124,6 +133,11 @@ binds {
     Mod+Ctrl+U         { move-column-to-workspace-down; }
     Mod+Ctrl+I         { move-column-to-workspace-up; }
 
+    // === Workspace Management ===
+    Ctrl+Shift+R hotkey-overlay-title="Rename Workspace" {
+        spawn "dms" "ipc" "call" "workspace-rename" "open";
+    }
+
     // === Move Workspaces ===
     Mod+Shift+Page_Down { move-workspace-down; }
     Mod+Shift+Page_Up   { move-workspace-up; }

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

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

core/internal/config/embedded/niri.kdl

@@ -240,10 +240,6 @@ 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"
@@ -273,3 +269,5 @@ 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,3 +4,12 @@ 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

@@ -199,31 +199,6 @@ func labToHex(L, a, b float64) string {
 	return fmt.Sprintf("#%02x%02x%02x", r, g, b2)
 }
 
-// Adjust brightness while keeping the same hue
-func retoneToL(hex string, Ltarget float64) string {
-	rgb := HexToRGB(hex)
-	col := colorful.Color{R: rgb.R, G: rgb.G, B: rgb.B}
-	L, a, b := col.Lab()
-	L100 := L * 100.0
-
-	scale := 1.0
-	if L100 != 0 {
-		scale = Ltarget / L100
-	}
-
-	a2, b2 := a*scale, b*scale
-
-	// Don't let it get too saturated
-	maxChroma := 0.4
-	if math.Hypot(a2, b2) > maxChroma {
-		k := maxChroma / math.Hypot(a2, b2)
-		a2 *= k
-		b2 *= k
-	}
-
-	return labToHex(Ltarget, a2, b2)
-}
-
 func DeltaPhiStar(hexFg, hexBg string, negativePolarity bool) float64 {
 	Lf := getLstar(hexFg)
 	Lb := getLstar(hexBg)
@@ -345,7 +320,7 @@ func EnsureContrastDPSLstar(hexColor, hexBg string, minLc float64, isLightMode b
 	}
 
 	step := 0.5
-	for i := 0; i < 120; i++ {
+	for range 120 {
 		Lf = math.Max(0, math.Min(100, Lf+dir*step))
 		cand := labToHex(Lf, af, bf)
 		if DeltaPhiStarContrast(cand, hexBg, isLightMode) >= minLc {
@@ -356,6 +331,59 @@ func EnsureContrastDPSLstar(hexColor, hexBg string, minLc float64, isLightMode b
 	return hexColor
 }
 
+// Bidirectional contrast - tries both lighter and darker, picks closest to original
+func EnsureContrastDPSBidirectional(hexColor, hexBg string, minLc float64, isLightMode bool) string {
+	current := DeltaPhiStarContrast(hexColor, hexBg, isLightMode)
+	if current >= minLc {
+		return hexColor
+	}
+
+	fg := HexToRGB(hexColor)
+	cf := colorful.Color{R: fg.R, G: fg.G, B: fg.B}
+	origL, af, bf := cf.Lab()
+
+	var darkerResult, lighterResult string
+	darkerL, lighterL := origL, origL
+	darkerFound, lighterFound := false, false
+
+	step := 0.5
+	for i := range 120 {
+		if !darkerFound {
+			darkerL = math.Max(0, origL-float64(i)*step)
+			cand := labToHex(darkerL, af, bf)
+			if DeltaPhiStarContrast(cand, hexBg, isLightMode) >= minLc {
+				darkerResult = cand
+				darkerFound = true
+			}
+		}
+		if !lighterFound {
+			lighterL = math.Min(100, origL+float64(i)*step)
+			cand := labToHex(lighterL, af, bf)
+			if DeltaPhiStarContrast(cand, hexBg, isLightMode) >= minLc {
+				lighterResult = cand
+				lighterFound = true
+			}
+		}
+		if darkerFound && lighterFound {
+			break
+		}
+	}
+
+	if darkerFound && lighterFound {
+		if math.Abs(darkerL-origL) <= math.Abs(lighterL-origL) {
+			return darkerResult
+		}
+		return lighterResult
+	}
+	if darkerFound {
+		return darkerResult
+	}
+	if lighterFound {
+		return lighterResult
+	}
+	return hexColor
+}
+
 type PaletteOptions struct {
 	IsLight    bool
 	Background string
@@ -369,6 +397,29 @@ func ensureContrastAuto(hexColor, hexBg string, target float64, opts PaletteOpti
 	return EnsureContrast(hexColor, hexBg, target, opts.IsLight)
 }
 
+func ensureContrastBidirectional(hexColor, hexBg string, target float64, opts PaletteOptions) string {
+	if opts.UseDPS {
+		return EnsureContrastDPSBidirectional(hexColor, hexBg, target, opts.IsLight)
+	}
+	return EnsureContrast(hexColor, hexBg, target, opts.IsLight)
+}
+
+func blendHue(base, target, factor float64) float64 {
+	diff := target - base
+	if diff > 0.5 {
+		diff -= 1.0
+	} else if diff < -0.5 {
+		diff += 1.0
+	}
+	result := base + diff*factor
+	if result < 0 {
+		result += 1.0
+	} else if result >= 1.0 {
+		result -= 1.0
+	}
+	return result
+}
+
 func DeriveContainer(primary string, isLight bool) string {
 	rgb := HexToRGB(primary)
 	hsv := RGBToHSV(rgb)
@@ -389,6 +440,9 @@ func GeneratePalette(primaryColor string, opts PaletteOptions) Palette {
 	rgb := HexToRGB(baseColor)
 	hsv := RGBToHSV(rgb)
 
+	pr := HexToRGB(primaryColor)
+	ph := RGBToHSV(pr)
+
 	var palette Palette
 
 	var normalTextTarget, secondaryTarget float64
@@ -410,115 +464,136 @@ func GeneratePalette(primaryColor string, opts PaletteOptions) Palette {
 	}
 	palette.Color0 = NewColorInfo(bgColor)
 
-	hueShift := (hsv.H - 0.6) * 0.12
-	satBoost := 1.15
+	baseSat := math.Max(ph.S, 0.5)
+	baseVal := math.Max(ph.V, 0.5)
 
-	redH := math.Mod(0.0+hueShift+1.0, 1.0)
-	var redColor string
-	if opts.IsLight {
-		redColor = RGBToHex(HSVToRGB(HSV{H: redH, S: math.Min(0.80*satBoost, 1.0), V: 0.55}))
-		palette.Color1 = NewColorInfo(ensureContrastAuto(redColor, bgColor, normalTextTarget, opts))
-	} else {
-		redColor = RGBToHex(HSVToRGB(HSV{H: redH, S: math.Min(0.65*satBoost, 1.0), V: 0.80}))
-		palette.Color1 = NewColorInfo(ensureContrastAuto(redColor, bgColor, normalTextTarget, opts))
-	}
+	redH := blendHue(0.0, ph.H, 0.12)
+	greenH := blendHue(0.33, ph.H, 0.10)
+	yellowH := blendHue(0.14, ph.H, 0.04)
 
-	greenH := math.Mod(0.33+hueShift+1.0, 1.0)
-	var greenColor string
-	if opts.IsLight {
-		greenColor = RGBToHex(HSVToRGB(HSV{H: greenH, S: math.Min(math.Max(hsv.S*0.9, 0.80)*satBoost, 1.0), V: 0.45}))
-		palette.Color2 = NewColorInfo(ensureContrastAuto(greenColor, bgColor, normalTextTarget, opts))
-	} else {
-		greenColor = RGBToHex(HSVToRGB(HSV{H: greenH, S: math.Min(0.42*satBoost, 1.0), V: 0.84}))
-		palette.Color2 = NewColorInfo(ensureContrastAuto(greenColor, bgColor, normalTextTarget, opts))
-	}
-
-	yellowH := math.Mod(0.15+hueShift+1.0, 1.0)
-	var yellowColor string
-	if opts.IsLight {
-		yellowColor = RGBToHex(HSVToRGB(HSV{H: yellowH, S: math.Min(0.75*satBoost, 1.0), V: 0.50}))
-		palette.Color3 = NewColorInfo(ensureContrastAuto(yellowColor, bgColor, normalTextTarget, opts))
-	} else {
-		yellowColor = RGBToHex(HSVToRGB(HSV{H: yellowH, S: math.Min(0.38*satBoost, 1.0), V: 0.86}))
-		palette.Color3 = NewColorInfo(ensureContrastAuto(yellowColor, bgColor, normalTextTarget, opts))
-	}
-
-	var blueColor string
-	if opts.IsLight {
-		blueColor = RGBToHex(HSVToRGB(HSV{H: hsv.H, S: math.Max(hsv.S*0.9, 0.7), V: hsv.V * 1.1}))
-		palette.Color4 = NewColorInfo(ensureContrastAuto(blueColor, bgColor, normalTextTarget, opts))
-	} else {
-		blueColor = RGBToHex(HSVToRGB(HSV{H: hsv.H, S: math.Max(hsv.S*0.8, 0.6), V: math.Min(hsv.V*1.6, 1.0)}))
-		palette.Color4 = NewColorInfo(ensureContrastAuto(blueColor, bgColor, normalTextTarget, opts))
-	}
-
-	magH := hsv.H - 0.03
-	if magH < 0 {
-		magH += 1.0
-	}
-	var magColor string
-	hr := HexToRGB(primaryColor)
-	hh := RGBToHSV(hr)
-	if opts.IsLight {
-		magColor = RGBToHex(HSVToRGB(HSV{H: hh.H, S: math.Max(hh.S*0.9, 0.7), V: hh.V * 0.85}))
-		palette.Color5 = NewColorInfo(ensureContrastAuto(magColor, bgColor, normalTextTarget, opts))
-	} else {
-		magColor = RGBToHex(HSVToRGB(HSV{H: hh.H, S: hh.S * 0.8, V: hh.V * 0.75}))
-		palette.Color5 = NewColorInfo(ensureContrastAuto(magColor, bgColor, normalTextTarget, opts))
-	}
-
-	cyanH := hsv.H + 0.08
-	if cyanH > 1.0 {
-		cyanH -= 1.0
-	}
-	palette.Color6 = NewColorInfo(ensureContrastAuto(primaryColor, bgColor, normalTextTarget, opts))
+	accentTarget := secondaryTarget * 0.7
 
 	if opts.IsLight {
-		palette.Color7 = NewColorInfo("#1a1a1a")
-		palette.Color8 = NewColorInfo("#2e2e2e")
-	} else {
-		palette.Color7 = NewColorInfo("#abb2bf")
-		palette.Color8 = NewColorInfo("#5c6370")
-	}
+		redS := math.Min(baseSat*1.2, 1.0)
+		redV := baseVal * 0.95
+		palette.Color1 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: redH, S: redS, V: redV})), bgColor, normalTextTarget, opts))
 
-	if opts.IsLight {
-		brightRed := RGBToHex(HSVToRGB(HSV{H: redH, S: math.Min(0.70*satBoost, 1.0), V: 0.65}))
-		palette.Color9 = NewColorInfo(ensureContrastAuto(brightRed, bgColor, secondaryTarget, opts))
-		brightGreen := RGBToHex(HSVToRGB(HSV{H: greenH, S: math.Min(math.Max(hsv.S*0.85, 0.75)*satBoost, 1.0), V: 0.55}))
-		palette.Color10 = NewColorInfo(ensureContrastAuto(brightGreen, bgColor, secondaryTarget, opts))
-		brightYellow := RGBToHex(HSVToRGB(HSV{H: yellowH, S: math.Min(0.68*satBoost, 1.0), V: 0.60}))
-		palette.Color11 = NewColorInfo(ensureContrastAuto(brightYellow, bgColor, secondaryTarget, opts))
-		hr := HexToRGB(primaryColor)
-		hh := RGBToHSV(hr)
-		brightBlue := RGBToHex(HSVToRGB(HSV{H: hh.H, S: math.Min(hh.S*1.1, 1.0), V: math.Min(hh.V*1.2, 1.0)}))
-		palette.Color12 = NewColorInfo(ensureContrastAuto(brightBlue, bgColor, secondaryTarget, opts))
-		brightMag := RGBToHex(HSVToRGB(HSV{H: magH, S: math.Max(hsv.S*0.9, 0.75), V: math.Min(hsv.V*1.25, 1.0)}))
-		palette.Color13 = NewColorInfo(ensureContrastAuto(brightMag, bgColor, secondaryTarget, opts))
-		brightCyan := RGBToHex(HSVToRGB(HSV{H: cyanH, S: math.Max(hsv.S*0.75, 0.65), V: math.Min(hsv.V*1.25, 1.0)}))
-		palette.Color14 = NewColorInfo(ensureContrastAuto(brightCyan, bgColor, secondaryTarget, opts))
-	} else {
-		brightRed := RGBToHex(HSVToRGB(HSV{H: redH, S: math.Min(0.50*satBoost, 1.0), V: 0.88}))
-		palette.Color9 = NewColorInfo(ensureContrastAuto(brightRed, bgColor, secondaryTarget, opts))
-		brightGreen := RGBToHex(HSVToRGB(HSV{H: greenH, S: math.Min(0.35*satBoost, 1.0), V: 0.88}))
-		palette.Color10 = NewColorInfo(ensureContrastAuto(brightGreen, bgColor, secondaryTarget, opts))
-		brightYellow := RGBToHex(HSVToRGB(HSV{H: yellowH, S: math.Min(0.30*satBoost, 1.0), V: 0.91}))
-		palette.Color11 = NewColorInfo(ensureContrastAuto(brightYellow, bgColor, secondaryTarget, opts))
-		brightBlue := retoneToL(primaryColor, 85.0)
-		palette.Color12 = NewColorInfo(brightBlue)
-		brightMag := RGBToHex(HSVToRGB(HSV{H: magH, S: math.Max(hsv.S*0.7, 0.6), V: math.Min(hsv.V*1.3, 0.9)}))
-		palette.Color13 = NewColorInfo(ensureContrastAuto(brightMag, bgColor, secondaryTarget, opts))
-		brightCyanH := hsv.H + 0.02
-		if brightCyanH > 1.0 {
-			brightCyanH -= 1.0
-		}
-		brightCyan := RGBToHex(HSVToRGB(HSV{H: brightCyanH, S: math.Max(hsv.S*0.6, 0.5), V: math.Min(hsv.V*1.2, 0.85)}))
-		palette.Color14 = NewColorInfo(ensureContrastAuto(brightCyan, bgColor, secondaryTarget, opts))
-	}
+		greenS := math.Min(baseSat*1.3, 1.0)
+		greenV := baseVal * 0.75
+		palette.Color2 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: greenH, S: greenS, V: greenV})), bgColor, normalTextTarget, opts))
 
-	if opts.IsLight {
-		palette.Color15 = NewColorInfo("#1a1a1a")
+		yellowS := math.Min(baseSat*1.5, 1.0)
+		yellowV := math.Min(baseVal*1.2, 1.0)
+		palette.Color3 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: yellowH, S: yellowS, V: yellowV})), bgColor, accentTarget, opts))
+
+		blueS := math.Min(ph.S*1.05, 1.0)
+		blueV := math.Min(ph.V*1.05, 1.0)
+		palette.Color4 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: ph.H, S: blueS, V: blueV})), bgColor, normalTextTarget, opts))
+
+		// Color5 matches primary_container exactly (light container in light mode)
+		container5 := DeriveContainer(primaryColor, true)
+		palette.Color5 = NewColorInfo(container5)
+
+		palette.Color6 = NewColorInfo(primaryColor)
+
+		gray7S := baseSat * 0.08
+		gray7V := baseVal * 0.28
+		palette.Color7 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: gray7S, V: gray7V})), bgColor, normalTextTarget, opts))
+
+		gray8S := baseSat * 0.05
+		gray8V := baseVal * 0.85
+		dimTarget := secondaryTarget * 0.5
+		palette.Color8 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: gray8S, V: gray8V})), bgColor, dimTarget, opts))
+
+		brightRedS := math.Min(baseSat*1.0, 1.0)
+		brightRedV := math.Min(baseVal*1.2, 1.0)
+		palette.Color9 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: redH, S: brightRedS, V: brightRedV})), bgColor, accentTarget, opts))
+
+		brightGreenS := math.Min(baseSat*1.1, 1.0)
+		brightGreenV := math.Min(baseVal*1.1, 1.0)
+		palette.Color10 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: greenH, S: brightGreenS, V: brightGreenV})), bgColor, accentTarget, opts))
+
+		brightYellowS := math.Min(baseSat*1.4, 1.0)
+		brightYellowV := math.Min(baseVal*1.3, 1.0)
+		palette.Color11 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: yellowH, S: brightYellowS, V: brightYellowV})), bgColor, accentTarget, opts))
+
+		brightBlueS := math.Min(ph.S*1.1, 1.0)
+		brightBlueV := math.Min(ph.V*1.15, 1.0)
+		palette.Color12 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: ph.H, S: brightBlueS, V: brightBlueV})), bgColor, accentTarget, opts))
+
+		lightContainer := DeriveContainer(primaryColor, true)
+		palette.Color13 = NewColorInfo(lightContainer)
+
+		brightCyanS := ph.S * 0.5
+		brightCyanV := math.Min(ph.V*1.3, 1.0)
+		palette.Color14 = NewColorInfo(RGBToHex(HSVToRGB(HSV{H: ph.H, S: brightCyanS, V: brightCyanV})))
+
+		white15S := baseSat * 0.04
+		white15V := math.Min(baseVal*1.5, 1.0)
+		palette.Color15 = NewColorInfo(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: white15S, V: white15V})))
 	} else {
-		palette.Color15 = NewColorInfo("#ffffff")
+		redS := math.Min(baseSat*1.1, 1.0)
+		redV := math.Min(baseVal*1.15, 1.0)
+		palette.Color1 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: redH, S: redS, V: redV})), bgColor, normalTextTarget, opts))
+
+		greenS := math.Min(baseSat*1.0, 1.0)
+		greenV := math.Min(baseVal*1.0, 1.0)
+		palette.Color2 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: greenH, S: greenS, V: greenV})), bgColor, normalTextTarget, opts))
+
+		yellowS := math.Min(baseSat*1.1, 1.0)
+		yellowV := math.Min(baseVal*1.25, 1.0)
+		palette.Color3 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: yellowH, S: yellowS, V: yellowV})), bgColor, normalTextTarget, opts))
+
+		// Slightly more saturated variant of primary
+		blueS := math.Min(ph.S*1.2, 1.0)
+		blueV := ph.V * 0.95
+		palette.Color4 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: ph.H, S: blueS, V: blueV})), bgColor, normalTextTarget, opts))
+
+		// Color5 matches primary_container exactly (dark container in dark mode)
+		darkContainer := DeriveContainer(primaryColor, false)
+		palette.Color5 = NewColorInfo(darkContainer)
+
+		palette.Color6 = NewColorInfo(primaryColor)
+
+		gray7S := baseSat * 0.12
+		gray7V := math.Min(baseVal*1.05, 1.0)
+		palette.Color7 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: gray7S, V: gray7V})), bgColor, normalTextTarget, opts))
+
+		gray8S := baseSat * 0.15
+		gray8V := baseVal * 0.65
+		palette.Color8 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: gray8S, V: gray8V})), bgColor, secondaryTarget, opts))
+
+		brightRedS := math.Min(baseSat*0.75, 1.0)
+		brightRedV := math.Min(baseVal*1.35, 1.0)
+		palette.Color9 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: redH, S: brightRedS, V: brightRedV})), bgColor, accentTarget, opts))
+
+		brightGreenS := math.Min(baseSat*0.7, 1.0)
+		brightGreenV := math.Min(baseVal*1.2, 1.0)
+		palette.Color10 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: greenH, S: brightGreenS, V: brightGreenV})), bgColor, accentTarget, opts))
+
+		brightYellowS := math.Min(baseSat*0.7, 1.0)
+		brightYellowV := math.Min(baseVal*1.5, 1.0)
+		palette.Color11 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: yellowH, S: brightYellowS, V: brightYellowV})), bgColor, accentTarget, opts))
+
+		// Create a gradient of primary variants: Color12 -> Color13 -> Color14 -> Color15 (near white)
+		// Color12: Start of the lighter gradient - slightly desaturated
+		brightBlueS := ph.S * 0.85
+		brightBlueV := math.Min(ph.V*1.1, 1.0)
+		palette.Color12 = NewColorInfo(ensureContrastBidirectional(RGBToHex(HSVToRGB(HSV{H: ph.H, S: brightBlueS, V: brightBlueV})), bgColor, accentTarget, opts))
+
+		// Medium-high saturation pastel primary
+		color13S := ph.S * 0.7
+		color13V := math.Min(ph.V*1.3, 1.0)
+		palette.Color13 = NewColorInfo(RGBToHex(HSVToRGB(HSV{H: ph.H, S: color13S, V: color13V})))
+
+		// Lower saturation, lighter variant
+		color14S := ph.S * 0.45
+		color14V := math.Min(ph.V*1.4, 1.0)
+		palette.Color14 = NewColorInfo(RGBToHex(HSVToRGB(HSV{H: ph.H, S: color14S, V: color14V})))
+
+		white15S := baseSat * 0.05
+		white15V := math.Min(baseVal*1.45, 1.0)
+		palette.Color15 = NewColorInfo(ensureContrastAuto(RGBToHex(HSVToRGB(HSV{H: hsv.H, S: white15S, V: white15V})), bgColor, normalTextTarget, opts))
 	}
 
 	return palette

core/internal/dank16/dank16_test.go

@@ -366,10 +366,19 @@ func TestGeneratePalette(t *testing.T) {
 				t.Errorf("Light mode background = %s, expected #f8f8f8", result.Color0.Hex)
 			}
 
-			if tt.opts.IsLight && result.Color15.Hex != "#1a1a1a" {
-				t.Errorf("Light mode foreground = %s, expected #1a1a1a", result.Color15.Hex)
-			} else if !tt.opts.IsLight && result.Color15.Hex != "#ffffff" {
-				t.Errorf("Dark mode foreground = %s, expected #ffffff", result.Color15.Hex)
+			// Color15 is now derived from primary, so just verify it's a valid color
+			// and has appropriate luminance for the mode (now theme-tinted, not pure white/black)
+			color15Lum := Luminance(result.Color15.Hex)
+			if tt.opts.IsLight {
+				// Light mode: Color15 should still be relatively light
+				if color15Lum < 0.5 {
+					t.Errorf("Light mode Color15 = %s (lum %.2f) is too dark", result.Color15.Hex, color15Lum)
+				}
+			} else {
+				// Dark mode: Color15 should be light (but may have theme tint, so lower threshold)
+				if color15Lum < 0.5 {
+					t.Errorf("Dark mode Color15 = %s (lum %.2f) is too dark", result.Color15.Hex, color15Lum)
+				}
 			}
 		})
 	}
@@ -579,6 +588,10 @@ func TestGeneratePaletteWithDPS(t *testing.T) {
 
 			bgColor := result.Color0.Hex
 			for i := 1; i < 8; i++ {
+				// Skip Color5 (container) and Color6 (exact primary) - intentionally not contrast-adjusted
+				if i == 5 || i == 6 {
+					continue
+				}
 				lc := DeltaPhiStarContrast(colors[i].Hex, bgColor, tt.opts.IsLight)
 				minLc := 30.0
 				if lc < minLc && lc > 0 {
@@ -658,7 +671,7 @@ func TestContrastAlgorithmComparison(t *testing.T) {
 	}
 
 	differentCount := 0
-	for i := 0; i < 16; i++ {
+	for i := range 16 {
 		if wcagColors[i].Hex != dpsColors[i].Hex {
 			differentCount++
 		}

core/internal/distros/arch.go

@@ -7,6 +7,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
@@ -40,6 +41,9 @@ func init() {
 	Register("artix", "#1793D1", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewArchDistribution(config, logChan)
 	})
+	Register("XeroLinux", "#888fe2", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
+		return NewArchDistribution(config, logChan)
+	})
 }
 
 type ArchDistribution struct {
@@ -514,12 +518,9 @@ func (a *ArchDistribution) reorderAURPackages(packages []string) []string {
 			dmsShell = append(dmsShell, pkg)
 		} else {
 			isDep := false
-			for _, dep := range dmsDepencies {
-				if pkg == dep {
-					deps = append(deps, pkg)
-					isDep = true
-					break
-				}
+			if slices.Contains(dmsDepencies, pkg) {
+				deps = append(deps, pkg)
+				isDep = true
 			}
 			if !isDep {
 				others = append(others, pkg)
@@ -545,7 +546,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, 0755); err != nil {
+	if err := os.MkdirAll(buildDir, 0o755); 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: "solopasha/hyprland"}
+	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "sdegler/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.Split(output, "\n")
-	for _, line := range lines {
+	lines := strings.SplitSeq(output, "\n")
+	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, 0755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "dgop-build")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); 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, 0755); err != nil {
+	if err := os.MkdirAll(buildDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create build directory: %w", err)
 	}
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); 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, 0755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "quickshell-build")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); 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, 0755); err != nil {
+	if err := os.MkdirAll(buildDir, 0o755); 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, 0755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "hyprland-build")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); 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, 0755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "ghostty-build")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); 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, 0755); err != nil {
+		if err := os.MkdirAll(configDir, 0o755); err != nil {
 			return fmt.Errorf("failed to create quickshell config directory: %w", err)
 		}
 

core/internal/distros/opensuse.go

@@ -108,7 +108,6 @@ 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},
@@ -117,6 +116,7 @@ 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/dms/app.go

@@ -1,450 +0,0 @@
-//go:build !distro_binary
-
-package dms
-
-import (
-	"os/exec"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-type AppState int
-
-const (
-	StateMainMenu AppState = iota
-	StateUpdate
-	StateUpdatePassword
-	StateUpdateProgress
-	StateShell
-	StatePluginsMenu
-	StatePluginsBrowse
-	StatePluginDetail
-	StatePluginSearch
-	StatePluginsInstalled
-	StatePluginInstalledDetail
-	StateGreeterMenu
-	StateGreeterCompositorSelect
-	StateGreeterPassword
-	StateGreeterInstalling
-	StateAbout
-)
-
-type Model struct {
-	version      string
-	detector     *Detector
-	dependencies []DependencyInfo
-	state        AppState
-	selectedItem int
-	width        int
-	height       int
-
-	// Menu items
-	menuItems []MenuItem
-
-	updateDeps        []DependencyInfo
-	selectedUpdateDep int
-	updateToggles     map[string]bool
-
-	updateProgressChan chan updateProgressMsg
-	updateProgress     updateProgressMsg
-	updateLogs         []string
-	sudoPassword       string
-	passwordInput      string
-	passwordError      string
-
-	// Window manager states
-	hyprlandInstalled bool
-	niriInstalled     bool
-
-	selectedGreeterItem     int
-	greeterInstallChan      chan greeterProgressMsg
-	greeterProgress         greeterProgressMsg
-	greeterLogs             []string
-	greeterPasswordInput    string
-	greeterPasswordError    string
-	greeterSudoPassword     string
-	greeterCompositors      []string
-	greeterSelectedComp     int
-	greeterChosenCompositor string
-
-	pluginsMenuItems        []MenuItem
-	selectedPluginsMenuItem int
-	pluginsList             []pluginInfo
-	filteredPluginsList     []pluginInfo
-	selectedPluginIndex     int
-	pluginsLoading          bool
-	pluginsError            string
-	pluginSearchQuery       string
-	installedPluginsList    []pluginInfo
-	selectedInstalledIndex  int
-	installedPluginsLoading bool
-	installedPluginsError   string
-	pluginInstallStatus     map[string]bool
-}
-
-type pluginInfo struct {
-	ID           string
-	Name         string
-	Category     string
-	Author       string
-	Description  string
-	Repo         string
-	Path         string
-	Capabilities []string
-	Compositors  []string
-	Dependencies []string
-	FirstParty   bool
-}
-
-type MenuItem struct {
-	Label  string
-	Action AppState
-}
-
-func NewModel(version string) Model {
-	detector, _ := NewDetector()
-	var dependencies []DependencyInfo
-	var hyprlandInstalled, niriInstalled bool
-	var err error
-	if detector != nil {
-		dependencies = detector.GetInstalledComponents()
-
-		// Use the proper detection method for both window managers
-		hyprlandInstalled, niriInstalled, err = detector.GetWindowManagerStatus()
-		if err != nil {
-			// Fallback to false if detection fails
-			hyprlandInstalled = false
-			niriInstalled = false
-		}
-	}
-
-	updateToggles := make(map[string]bool)
-	for _, dep := range dependencies {
-		if dep.Name == "dms (DankMaterialShell)" && dep.Status == deps.StatusNeedsUpdate {
-			updateToggles[dep.Name] = true
-			break
-		}
-	}
-
-	m := Model{
-		version:             version,
-		detector:            detector,
-		dependencies:        dependencies,
-		state:               StateMainMenu,
-		selectedItem:        0,
-		updateToggles:       updateToggles,
-		updateDeps:          dependencies,
-		updateProgressChan:  make(chan updateProgressMsg, 100),
-		hyprlandInstalled:   hyprlandInstalled,
-		niriInstalled:       niriInstalled,
-		greeterInstallChan:  make(chan greeterProgressMsg, 100),
-		pluginInstallStatus: make(map[string]bool),
-	}
-
-	m.menuItems = m.buildMenuItems()
-	return m
-}
-
-func (m *Model) buildMenuItems() []MenuItem {
-	items := []MenuItem{
-		{Label: "Update", Action: StateUpdate},
-	}
-
-	// Shell management
-	if m.isShellRunning() {
-		items = append(items, MenuItem{Label: "Terminate Shell", Action: StateShell})
-	} else {
-		items = append(items, MenuItem{Label: "Start Shell (Daemon)", Action: StateShell})
-	}
-
-	// Plugins management
-	items = append(items, MenuItem{Label: "Plugins", Action: StatePluginsMenu})
-
-	// Greeter management
-	items = append(items, MenuItem{Label: "Greeter", Action: StateGreeterMenu})
-
-	items = append(items, MenuItem{Label: "About", Action: StateAbout})
-
-	return items
-}
-
-func (m *Model) buildPluginsMenuItems() []MenuItem {
-	return []MenuItem{
-		{Label: "Browse Plugins", Action: StatePluginsBrowse},
-		{Label: "View Installed", Action: StatePluginsInstalled},
-	}
-}
-
-func (m *Model) isShellRunning() bool {
-	// Check for both -c and -p flag patterns since quickshell can be started either way
-	// -c dms: config name mode
-	// -p <path>/dms: path mode (used when installed via system packages)
-	cmd := exec.Command("pgrep", "-f", "qs.*dms")
-	err := cmd.Run()
-	return err == nil
-}
-
-func (m Model) Init() tea.Cmd {
-	return nil
-}
-
-func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
-	case shellStartedMsg:
-		m.menuItems = m.buildMenuItems()
-		if m.selectedItem >= len(m.menuItems) {
-			m.selectedItem = len(m.menuItems) - 1
-		}
-		return m, nil
-	case updateProgressMsg:
-		m.updateProgress = msg
-		if msg.logOutput != "" {
-			m.updateLogs = append(m.updateLogs, msg.logOutput)
-		}
-		return m, m.waitForProgress()
-	case updateCompleteMsg:
-		m.updateProgress.complete = true
-		m.updateProgress.err = msg.err
-		m.dependencies = m.detector.GetInstalledComponents()
-		m.updateDeps = m.dependencies
-		m.menuItems = m.buildMenuItems()
-
-		// Restart shell if update was successful and shell is running
-		if msg.err == nil && m.isShellRunning() {
-			restartShell()
-		}
-		return m, nil
-	case greeterProgressMsg:
-		m.greeterProgress = msg
-		if msg.logOutput != "" {
-			m.greeterLogs = append(m.greeterLogs, msg.logOutput)
-		}
-		return m, m.waitForGreeterProgress()
-	case pluginsLoadedMsg:
-		m.pluginsLoading = false
-		if msg.err != nil {
-			m.pluginsError = msg.err.Error()
-		} else {
-			m.pluginsList = make([]pluginInfo, len(msg.plugins))
-			for i, p := range msg.plugins {
-				m.pluginsList[i] = pluginInfo{
-					ID:           p.ID,
-					Name:         p.Name,
-					Category:     p.Category,
-					Author:       p.Author,
-					Description:  p.Description,
-					Repo:         p.Repo,
-					Path:         p.Path,
-					Capabilities: p.Capabilities,
-					Compositors:  p.Compositors,
-					Dependencies: p.Dependencies,
-					FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-				}
-			}
-			m.filteredPluginsList = m.pluginsList
-			m.selectedPluginIndex = 0
-			m.updatePluginInstallStatus()
-		}
-		return m, nil
-	case installedPluginsLoadedMsg:
-		m.installedPluginsLoading = false
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-		} else {
-			m.installedPluginsList = make([]pluginInfo, len(msg.plugins))
-			for i, p := range msg.plugins {
-				m.installedPluginsList[i] = pluginInfo{
-					ID:           p.ID,
-					Name:         p.Name,
-					Category:     p.Category,
-					Author:       p.Author,
-					Description:  p.Description,
-					Repo:         p.Repo,
-					Path:         p.Path,
-					Capabilities: p.Capabilities,
-					Compositors:  p.Compositors,
-					Dependencies: p.Dependencies,
-					FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-				}
-			}
-			m.selectedInstalledIndex = 0
-		}
-		return m, nil
-	case pluginUninstalledMsg:
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-			m.state = StatePluginInstalledDetail
-		} else {
-			m.state = StatePluginsInstalled
-			m.installedPluginsLoading = true
-			m.installedPluginsError = ""
-			return m, loadInstalledPlugins
-		}
-		return m, nil
-	case pluginUpdatedMsg:
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-		} else {
-			m.installedPluginsError = ""
-		}
-		return m, nil
-	case pluginInstalledMsg:
-		if msg.err != nil {
-			m.pluginsError = msg.err.Error()
-		} else {
-			m.pluginInstallStatus[msg.pluginName] = true
-			m.pluginsError = ""
-		}
-		return m, nil
-	case greeterPasswordValidMsg:
-		if msg.valid {
-			m.greeterSudoPassword = msg.password
-			m.greeterPasswordInput = ""
-			m.greeterPasswordError = ""
-			m.state = StateGreeterInstalling
-			m.greeterProgress = greeterProgressMsg{step: "Starting greeter installation..."}
-			m.greeterLogs = []string{}
-			return m, tea.Batch(m.performGreeterInstall(), m.waitForGreeterProgress())
-		} else {
-			m.greeterPasswordError = "Incorrect password. Please try again."
-			m.greeterPasswordInput = ""
-		}
-		return m, nil
-	case passwordValidMsg:
-		if msg.valid {
-			m.sudoPassword = msg.password
-			m.passwordInput = ""
-			m.passwordError = ""
-			m.state = StateUpdateProgress
-			m.updateProgress = updateProgressMsg{progress: 0.0, step: "Starting update..."}
-			m.updateLogs = []string{}
-			return m, tea.Batch(m.performUpdate(), m.waitForProgress())
-		} else {
-			m.passwordError = "Incorrect password. Please try again."
-			m.passwordInput = ""
-		}
-		return m, nil
-	case tea.KeyMsg:
-		switch m.state {
-		case StateMainMenu:
-			return m.updateMainMenu(msg)
-		case StateUpdate:
-			return m.updateUpdateView(msg)
-		case StateUpdatePassword:
-			return m.updatePasswordView(msg)
-		case StateUpdateProgress:
-			return m.updateProgressView(msg)
-		case StateShell:
-			return m.updateShellView(msg)
-		case StatePluginsMenu:
-			return m.updatePluginsMenu(msg)
-		case StatePluginsBrowse:
-			return m.updatePluginsBrowse(msg)
-		case StatePluginDetail:
-			return m.updatePluginDetail(msg)
-		case StatePluginSearch:
-			return m.updatePluginSearch(msg)
-		case StatePluginsInstalled:
-			return m.updatePluginsInstalled(msg)
-		case StatePluginInstalledDetail:
-			return m.updatePluginInstalledDetail(msg)
-		case StateGreeterMenu:
-			return m.updateGreeterMenu(msg)
-		case StateGreeterCompositorSelect:
-			return m.updateGreeterCompositorSelect(msg)
-		case StateGreeterPassword:
-			return m.updateGreeterPasswordView(msg)
-		case StateGreeterInstalling:
-			return m.updateGreeterInstalling(msg)
-		case StateAbout:
-			return m.updateAboutView(msg)
-		}
-	}
-
-	return m, nil
-}
-
-type updateProgressMsg struct {
-	progress  float64
-	step      string
-	complete  bool
-	err       error
-	logOutput string
-}
-
-type updateCompleteMsg struct {
-	err error
-}
-
-type passwordValidMsg struct {
-	password string
-	valid    bool
-}
-
-type greeterProgressMsg struct {
-	step      string
-	complete  bool
-	err       error
-	logOutput string
-}
-
-type greeterPasswordValidMsg struct {
-	password string
-	valid    bool
-}
-
-func (m Model) waitForProgress() tea.Cmd {
-	return func() tea.Msg {
-		return <-m.updateProgressChan
-	}
-}
-
-func (m Model) waitForGreeterProgress() tea.Cmd {
-	return func() tea.Msg {
-		return <-m.greeterInstallChan
-	}
-}
-
-func (m Model) View() string {
-	switch m.state {
-	case StateMainMenu:
-		return m.renderMainMenu()
-	case StateUpdate:
-		return m.renderUpdateView()
-	case StateUpdatePassword:
-		return m.renderPasswordView()
-	case StateUpdateProgress:
-		return m.renderProgressView()
-	case StateShell:
-		return m.renderShellView()
-	case StatePluginsMenu:
-		return m.renderPluginsMenu()
-	case StatePluginsBrowse:
-		return m.renderPluginsBrowse()
-	case StatePluginDetail:
-		return m.renderPluginDetail()
-	case StatePluginSearch:
-		return m.renderPluginSearch()
-	case StatePluginsInstalled:
-		return m.renderPluginsInstalled()
-	case StatePluginInstalledDetail:
-		return m.renderPluginInstalledDetail()
-	case StateGreeterMenu:
-		return m.renderGreeterMenu()
-	case StateGreeterCompositorSelect:
-		return m.renderGreeterCompositorSelect()
-	case StateGreeterPassword:
-		return m.renderGreeterPasswordView()
-	case StateGreeterInstalling:
-		return m.renderGreeterInstalling()
-	case StateAbout:
-		return m.renderAboutView()
-	default:
-		return m.renderMainMenu()
-	}
-}

core/internal/dms/app_distro.go

@@ -1,267 +0,0 @@
-//go:build distro_binary
-
-package dms
-
-import (
-	"os/exec"
-	"strings"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-type AppState int
-
-const (
-	StateMainMenu AppState = iota
-	StateShell
-	StatePluginsMenu
-	StatePluginsBrowse
-	StatePluginDetail
-	StatePluginSearch
-	StatePluginsInstalled
-	StatePluginInstalledDetail
-	StateAbout
-)
-
-type Model struct {
-	version      string
-	detector     *Detector
-	dependencies []DependencyInfo
-	state        AppState
-	selectedItem int
-	width        int
-	height       int
-
-	// Menu items
-	menuItems []MenuItem
-
-	// Window manager states
-	hyprlandInstalled bool
-	niriInstalled     bool
-
-	pluginsMenuItems        []MenuItem
-	selectedPluginsMenuItem int
-	pluginsList             []pluginInfo
-	filteredPluginsList     []pluginInfo
-	selectedPluginIndex     int
-	pluginsLoading          bool
-	pluginsError            string
-	pluginSearchQuery       string
-	installedPluginsList    []pluginInfo
-	selectedInstalledIndex  int
-	installedPluginsLoading bool
-	installedPluginsError   string
-	pluginInstallStatus     map[string]bool
-}
-
-type pluginInfo struct {
-	ID           string
-	Name         string
-	Category     string
-	Author       string
-	Description  string
-	Repo         string
-	Path         string
-	Capabilities []string
-	Compositors  []string
-	Dependencies []string
-	FirstParty   bool
-}
-
-type MenuItem struct {
-	Label  string
-	Action AppState
-}
-
-func NewModel(version string) Model {
-	detector, _ := NewDetector()
-
-	var dependencies []DependencyInfo
-	var hyprlandInstalled, niriInstalled bool
-
-	if detector != nil {
-		dependencies = detector.GetInstalledComponents()
-		hyprlandInstalled, niriInstalled, _ = detector.GetWindowManagerStatus()
-	}
-
-	m := Model{
-		version:             version,
-		detector:            detector,
-		dependencies:        dependencies,
-		state:               StateMainMenu,
-		selectedItem:        0,
-		hyprlandInstalled:   hyprlandInstalled,
-		niriInstalled:       niriInstalled,
-		pluginInstallStatus: make(map[string]bool),
-	}
-
-	m.menuItems = m.buildMenuItems()
-	return m
-}
-
-func (m *Model) buildMenuItems() []MenuItem {
-	items := []MenuItem{}
-
-	// Shell management
-	if m.isShellRunning() {
-		items = append(items, MenuItem{Label: "Terminate Shell", Action: StateShell})
-	} else {
-		items = append(items, MenuItem{Label: "Start Shell (Daemon)", Action: StateShell})
-	}
-
-	// Plugins management
-	items = append(items, MenuItem{Label: "Plugins", Action: StatePluginsMenu})
-
-	items = append(items, MenuItem{Label: "About", Action: StateAbout})
-
-	return items
-}
-
-func (m *Model) buildPluginsMenuItems() []MenuItem {
-	return []MenuItem{
-		{Label: "Browse Plugins", Action: StatePluginsBrowse},
-		{Label: "View Installed", Action: StatePluginsInstalled},
-	}
-}
-
-func (m *Model) isShellRunning() bool {
-	cmd := exec.Command("pgrep", "-f", "qs -c dms")
-	err := cmd.Run()
-	return err == nil
-}
-
-func (m Model) Init() tea.Cmd {
-	return nil
-}
-
-func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
-	case pluginsLoadedMsg:
-		m.pluginsLoading = false
-		if msg.err != nil {
-			m.pluginsError = msg.err.Error()
-		} else {
-			m.pluginsList = make([]pluginInfo, len(msg.plugins))
-			for i, p := range msg.plugins {
-				m.pluginsList[i] = pluginInfo{
-					ID:           p.ID,
-					Name:         p.Name,
-					Category:     p.Category,
-					Author:       p.Author,
-					Description:  p.Description,
-					Repo:         p.Repo,
-					Path:         p.Path,
-					Capabilities: p.Capabilities,
-					Compositors:  p.Compositors,
-					Dependencies: p.Dependencies,
-					FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-				}
-			}
-			m.filteredPluginsList = m.pluginsList
-			m.selectedPluginIndex = 0
-			m.updatePluginInstallStatus()
-		}
-		return m, nil
-	case installedPluginsLoadedMsg:
-		m.installedPluginsLoading = false
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-		} else {
-			m.installedPluginsList = make([]pluginInfo, len(msg.plugins))
-			for i, p := range msg.plugins {
-				m.installedPluginsList[i] = pluginInfo{
-					ID:           p.ID,
-					Name:         p.Name,
-					Category:     p.Category,
-					Author:       p.Author,
-					Description:  p.Description,
-					Repo:         p.Repo,
-					Path:         p.Path,
-					Capabilities: p.Capabilities,
-					Compositors:  p.Compositors,
-					Dependencies: p.Dependencies,
-					FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-				}
-			}
-			m.selectedInstalledIndex = 0
-		}
-		return m, nil
-	case pluginUninstalledMsg:
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-			m.state = StatePluginInstalledDetail
-		} else {
-			m.state = StatePluginsInstalled
-			m.installedPluginsLoading = true
-			m.installedPluginsError = ""
-			return m, loadInstalledPlugins
-		}
-		return m, nil
-	case pluginUpdatedMsg:
-		if msg.err != nil {
-			m.installedPluginsError = msg.err.Error()
-		} else {
-			m.installedPluginsError = ""
-		}
-		return m, nil
-	case pluginInstalledMsg:
-		if msg.err != nil {
-			m.pluginsError = msg.err.Error()
-		} else {
-			m.pluginInstallStatus[msg.pluginName] = true
-			m.pluginsError = ""
-		}
-		return m, nil
-	case tea.KeyMsg:
-		switch m.state {
-		case StateMainMenu:
-			return m.updateMainMenu(msg)
-		case StateShell:
-			return m.updateShellView(msg)
-		case StatePluginsMenu:
-			return m.updatePluginsMenu(msg)
-		case StatePluginsBrowse:
-			return m.updatePluginsBrowse(msg)
-		case StatePluginDetail:
-			return m.updatePluginDetail(msg)
-		case StatePluginSearch:
-			return m.updatePluginSearch(msg)
-		case StatePluginsInstalled:
-			return m.updatePluginsInstalled(msg)
-		case StatePluginInstalledDetail:
-			return m.updatePluginInstalledDetail(msg)
-		case StateAbout:
-			return m.updateAboutView(msg)
-		}
-	}
-
-	return m, nil
-}
-
-func (m Model) View() string {
-	switch m.state {
-	case StateMainMenu:
-		return m.renderMainMenu()
-	case StateShell:
-		return m.renderShellView()
-	case StatePluginsMenu:
-		return m.renderPluginsMenu()
-	case StatePluginsBrowse:
-		return m.renderPluginsBrowse()
-	case StatePluginDetail:
-		return m.renderPluginDetail()
-	case StatePluginSearch:
-		return m.renderPluginSearch()
-	case StatePluginsInstalled:
-		return m.renderPluginsInstalled()
-	case StatePluginInstalledDetail:
-		return m.renderPluginInstalledDetail()
-	case StateAbout:
-		return m.renderAboutView()
-	default:
-		return m.renderMainMenu()
-	}
-}

core/internal/dms/detector.go

@@ -1,143 +0,0 @@
-package dms
-
-import (
-	"context"
-	"os"
-	"os/exec"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
-)
-
-type Detector struct {
-	homeDir      string
-	distribution distros.Distribution
-}
-
-func (d *Detector) GetDistribution() distros.Distribution {
-	return d.distribution
-}
-
-func NewDetector() (*Detector, error) {
-	homeDir, err := os.UserHomeDir()
-	if err != nil {
-		return nil, err
-	}
-
-	logChan := make(chan string, 100)
-	go func() {
-		for range logChan {
-		}
-	}()
-
-	osInfo, err := distros.GetOSInfo()
-	if err != nil {
-		return nil, err
-	}
-
-	dist, err := distros.NewDistribution(osInfo.Distribution.ID, logChan)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Detector{
-		homeDir:      homeDir,
-		distribution: dist,
-	}, nil
-}
-
-func (d *Detector) IsDMSInstalled() bool {
-	_, err := config.LocateDMSConfig()
-	return err == nil
-}
-
-func (d *Detector) GetDependencyStatus() ([]deps.Dependency, error) {
-	hyprlandDeps, err := d.distribution.DetectDependencies(context.Background(), deps.WindowManagerHyprland)
-	if err != nil {
-		return nil, err
-	}
-
-	niriDeps, err := d.distribution.DetectDependencies(context.Background(), deps.WindowManagerNiri)
-	if err != nil {
-		return nil, err
-	}
-
-	// Combine dependencies and deduplicate
-	depMap := make(map[string]deps.Dependency)
-
-	for _, dep := range hyprlandDeps {
-		depMap[dep.Name] = dep
-	}
-
-	for _, dep := range niriDeps {
-		// If dependency already exists, keep the one that's installed or needs update
-		if existing, exists := depMap[dep.Name]; exists {
-			if dep.Status > existing.Status {
-				depMap[dep.Name] = dep
-			}
-		} else {
-			depMap[dep.Name] = dep
-		}
-	}
-
-	// Convert map back to slice
-	var allDeps []deps.Dependency
-	for _, dep := range depMap {
-		allDeps = append(allDeps, dep)
-	}
-
-	return allDeps, nil
-}
-
-func (d *Detector) GetWindowManagerStatus() (bool, bool, error) {
-	// Reuse the existing command detection logic from BaseDistribution
-	// Since all distros embed BaseDistribution, we can access it via interface
-	type CommandChecker interface {
-		CommandExists(string) bool
-	}
-
-	checker, ok := d.distribution.(CommandChecker)
-	if !ok {
-		// Fallback to direct command check if interface not available
-		hyprlandInstalled := d.commandExists("hyprland") || d.commandExists("Hyprland")
-		niriInstalled := d.commandExists("niri")
-		return hyprlandInstalled, niriInstalled, nil
-	}
-
-	hyprlandInstalled := checker.CommandExists("hyprland") || checker.CommandExists("Hyprland")
-	niriInstalled := checker.CommandExists("niri")
-
-	return hyprlandInstalled, niriInstalled, nil
-}
-
-func (d *Detector) commandExists(cmd string) bool {
-	_, err := exec.LookPath(cmd)
-	return err == nil
-}
-
-func (d *Detector) GetInstalledComponents() []DependencyInfo {
-	dependencies, err := d.GetDependencyStatus()
-	if err != nil {
-		return []DependencyInfo{}
-	}
-
-	var components []DependencyInfo
-	for _, dep := range dependencies {
-		components = append(components, DependencyInfo{
-			Name:        dep.Name,
-			Status:      dep.Status,
-			Description: dep.Description,
-			Required:    dep.Required,
-		})
-	}
-
-	return components
-}
-
-type DependencyInfo struct {
-	Name        string
-	Status      deps.DependencyStatus
-	Description string
-	Required    bool
-}

core/internal/dms/handlers_common.go

@@ -1,54 +0,0 @@
-package dms
-
-import (
-	"os/exec"
-	"time"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func (m Model) updateShellView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateMainMenu
-	default:
-		return m, tea.Quit
-	}
-	return m, nil
-}
-
-func (m Model) updateAboutView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q", "esc":
-		if msg.String() == "esc" {
-			m.state = StateMainMenu
-		} else {
-			return m, tea.Quit
-		}
-	}
-	return m, nil
-}
-
-func terminateShell() {
-	patterns := []string{"dms run", "qs -c dms"}
-	for _, pattern := range patterns {
-		cmd := exec.Command("pkill", "-f", pattern)
-		cmd.Run()
-	}
-}
-
-func startShellDaemon() {
-	cmd := exec.Command("dms", "run", "-d")
-	if err := cmd.Start(); err != nil {
-		log.Errorf("Error starting daemon: %v", err)
-	}
-}
-
-func restartShell() {
-	terminateShell()
-	time.Sleep(500 * time.Millisecond)
-	startShellDaemon()
-}

core/internal/dms/handlers_features.go

@@ -1,392 +0,0 @@
-//go:build !distro_binary
-
-package dms
-
-import (
-	"context"
-	"fmt"
-	"os/exec"
-	"strings"
-	"time"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/greeter"
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func (m Model) updateUpdateView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	filteredDeps := m.getFilteredDeps()
-	maxIndex := len(filteredDeps) - 1
-
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateMainMenu
-	case "up", "k":
-		if m.selectedUpdateDep > 0 {
-			m.selectedUpdateDep--
-		}
-	case "down", "j":
-		if m.selectedUpdateDep < maxIndex {
-			m.selectedUpdateDep++
-		}
-	case " ":
-		if dep := m.getDepAtVisualIndex(m.selectedUpdateDep); dep != nil {
-			m.updateToggles[dep.Name] = !m.updateToggles[dep.Name]
-		}
-	case "enter":
-		hasSelected := false
-		for _, toggle := range m.updateToggles {
-			if toggle {
-				hasSelected = true
-				break
-			}
-		}
-
-		if !hasSelected {
-			m.state = StateMainMenu
-			return m, nil
-		}
-
-		m.state = StateUpdatePassword
-		m.passwordInput = ""
-		m.passwordError = ""
-		return m, nil
-	}
-	return m, nil
-}
-
-func (m Model) updatePasswordView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateUpdate
-		m.passwordInput = ""
-		m.passwordError = ""
-		return m, nil
-	case "enter":
-		if m.passwordInput == "" {
-			return m, nil
-		}
-		return m, m.validatePassword(m.passwordInput)
-	case "backspace":
-		if len(m.passwordInput) > 0 {
-			m.passwordInput = m.passwordInput[:len(m.passwordInput)-1]
-		}
-	default:
-		if len(msg.String()) == 1 && msg.String()[0] >= 32 && msg.String()[0] <= 126 {
-			m.passwordInput += msg.String()
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updateProgressView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		if m.updateProgress.complete {
-			m.state = StateMainMenu
-			m.updateProgress = updateProgressMsg{}
-			m.updateLogs = []string{}
-		}
-	}
-	return m, nil
-}
-
-func (m Model) validatePassword(password string) tea.Cmd {
-	return func() tea.Msg {
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, "sudo", "-S", "-v")
-		stdin, err := cmd.StdinPipe()
-		if err != nil {
-			return passwordValidMsg{password: "", valid: false}
-		}
-
-		go func() {
-			defer stdin.Close()
-			fmt.Fprintf(stdin, "%s\n", password)
-		}()
-
-		output, err := cmd.CombinedOutput()
-		outputStr := string(output)
-
-		if err != nil {
-			if strings.Contains(outputStr, "Sorry, try again") ||
-				strings.Contains(outputStr, "incorrect password") ||
-				strings.Contains(outputStr, "authentication failure") {
-				return passwordValidMsg{password: "", valid: false}
-			}
-			return passwordValidMsg{password: "", valid: false}
-		}
-
-		return passwordValidMsg{password: password, valid: true}
-	}
-}
-
-func (m Model) performUpdate() tea.Cmd {
-	var depsToUpdate []deps.Dependency
-
-	for _, depInfo := range m.updateDeps {
-		if m.updateToggles[depInfo.Name] {
-			depsToUpdate = append(depsToUpdate, deps.Dependency{
-				Name:        depInfo.Name,
-				Status:      depInfo.Status,
-				Description: depInfo.Description,
-				Required:    depInfo.Required,
-			})
-		}
-	}
-
-	if len(depsToUpdate) == 0 {
-		return func() tea.Msg {
-			return updateCompleteMsg{err: nil}
-		}
-	}
-
-	wm := deps.WindowManagerHyprland
-	if m.niriInstalled {
-		wm = deps.WindowManagerNiri
-	}
-
-	sudoPassword := m.sudoPassword
-	reinstallFlags := make(map[string]bool)
-	for name, toggled := range m.updateToggles {
-		if toggled {
-			reinstallFlags[name] = true
-		}
-	}
-
-	distribution := m.detector.GetDistribution()
-	progressChan := m.updateProgressChan
-
-	return func() tea.Msg {
-		installerChan := make(chan distros.InstallProgressMsg, 100)
-
-		go func() {
-			ctx := context.Background()
-			disabledFlags := make(map[string]bool)
-			err := distribution.InstallPackages(ctx, depsToUpdate, wm, sudoPassword, reinstallFlags, disabledFlags, false, installerChan)
-			close(installerChan)
-
-			if err != nil {
-				progressChan <- updateProgressMsg{complete: true, err: err}
-			} else {
-				progressChan <- updateProgressMsg{complete: true}
-			}
-		}()
-
-		go func() {
-			for msg := range installerChan {
-				progressChan <- updateProgressMsg{
-					progress:  msg.Progress,
-					step:      msg.Step,
-					complete:  msg.IsComplete,
-					err:       msg.Error,
-					logOutput: msg.LogOutput,
-				}
-			}
-		}()
-
-		return nil
-	}
-}
-
-func (m Model) updateGreeterMenu(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	greeterMenuItems := []string{"Install Greeter"}
-
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateMainMenu
-	case "up", "k":
-		if m.selectedGreeterItem > 0 {
-			m.selectedGreeterItem--
-		}
-	case "down", "j":
-		if m.selectedGreeterItem < len(greeterMenuItems)-1 {
-			m.selectedGreeterItem++
-		}
-	case "enter", " ":
-		if m.selectedGreeterItem == 0 {
-			compositors := greeter.DetectCompositors()
-			if len(compositors) == 0 {
-				return m, nil
-			}
-
-			m.greeterCompositors = compositors
-
-			if len(compositors) > 1 {
-				m.state = StateGreeterCompositorSelect
-				m.greeterSelectedComp = 0
-				return m, nil
-			} else {
-				m.greeterChosenCompositor = compositors[0]
-				m.state = StateGreeterPassword
-				m.greeterPasswordInput = ""
-				m.greeterPasswordError = ""
-				return m, nil
-			}
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updateGreeterCompositorSelect(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateGreeterMenu
-		return m, nil
-	case "up", "k":
-		if m.greeterSelectedComp > 0 {
-			m.greeterSelectedComp--
-		}
-	case "down", "j":
-		if m.greeterSelectedComp < len(m.greeterCompositors)-1 {
-			m.greeterSelectedComp++
-		}
-	case "enter", " ":
-		m.greeterChosenCompositor = m.greeterCompositors[m.greeterSelectedComp]
-		m.state = StateGreeterPassword
-		m.greeterPasswordInput = ""
-		m.greeterPasswordError = ""
-		return m, nil
-	}
-	return m, nil
-}
-
-func (m Model) updateGreeterPasswordView(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateGreeterMenu
-		m.greeterPasswordInput = ""
-		m.greeterPasswordError = ""
-		return m, nil
-	case "enter":
-		if m.greeterPasswordInput == "" {
-			return m, nil
-		}
-		return m, m.validateGreeterPassword(m.greeterPasswordInput)
-	case "backspace":
-		if len(m.greeterPasswordInput) > 0 {
-			m.greeterPasswordInput = m.greeterPasswordInput[:len(m.greeterPasswordInput)-1]
-		}
-	default:
-		if len(msg.String()) == 1 && msg.String()[0] >= 32 && msg.String()[0] <= 126 {
-			m.greeterPasswordInput += msg.String()
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updateGreeterInstalling(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		if m.greeterProgress.complete {
-			m.state = StateMainMenu
-			m.greeterProgress = greeterProgressMsg{}
-			m.greeterLogs = []string{}
-		}
-	}
-	return m, nil
-}
-
-func (m Model) performGreeterInstall() tea.Cmd {
-	progressChan := m.greeterInstallChan
-	sudoPassword := m.greeterSudoPassword
-	compositor := m.greeterChosenCompositor
-
-	return func() tea.Msg {
-		go func() {
-			logFunc := func(msg string) {
-				progressChan <- greeterProgressMsg{step: msg, logOutput: msg}
-			}
-
-			progressChan <- greeterProgressMsg{step: "Checking greetd installation..."}
-			if err := performGreeterInstallSteps(progressChan, logFunc, sudoPassword, compositor); err != nil {
-				progressChan <- greeterProgressMsg{step: "Installation failed", complete: true, err: err}
-				return
-			}
-
-			progressChan <- greeterProgressMsg{step: "Installation complete", complete: true}
-		}()
-		return nil
-	}
-}
-
-func (m Model) validateGreeterPassword(password string) tea.Cmd {
-	return func() tea.Msg {
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, "sudo", "-S", "-v")
-		stdin, err := cmd.StdinPipe()
-		if err != nil {
-			return greeterPasswordValidMsg{password: "", valid: false}
-		}
-
-		go func() {
-			defer stdin.Close()
-			fmt.Fprintf(stdin, "%s\n", password)
-		}()
-
-		output, err := cmd.CombinedOutput()
-		outputStr := string(output)
-
-		if err != nil {
-			if strings.Contains(outputStr, "Sorry, try again") ||
-				strings.Contains(outputStr, "incorrect password") ||
-				strings.Contains(outputStr, "authentication failure") {
-				return greeterPasswordValidMsg{password: "", valid: false}
-			}
-			return greeterPasswordValidMsg{password: "", valid: false}
-		}
-
-		return greeterPasswordValidMsg{password: password, valid: true}
-	}
-}
-
-func performGreeterInstallSteps(progressChan chan greeterProgressMsg, logFunc func(string), sudoPassword string, compositor string) error {
-	if err := greeter.EnsureGreetdInstalled(logFunc, sudoPassword); err != nil {
-		return err
-	}
-
-	progressChan <- greeterProgressMsg{step: "Detecting DMS installation..."}
-	dmsPath, err := greeter.DetectDMSPath()
-	if err != nil {
-		return err
-	}
-	logFunc(fmt.Sprintf("✓ Found DMS at: %s", dmsPath))
-
-	logFunc(fmt.Sprintf("✓ Selected compositor: %s", compositor))
-
-	progressChan <- greeterProgressMsg{step: "Copying greeter files..."}
-	if err := greeter.CopyGreeterFiles(dmsPath, compositor, logFunc, sudoPassword); err != nil {
-		return err
-	}
-
-	progressChan <- greeterProgressMsg{step: "Configuring greetd..."}
-	if err := greeter.ConfigureGreetd(dmsPath, compositor, logFunc, sudoPassword); err != nil {
-		return err
-	}
-
-	progressChan <- greeterProgressMsg{step: "Synchronizing DMS configurations..."}
-	if err := greeter.SyncDMSConfigs(dmsPath, logFunc, sudoPassword); err != nil {
-		return err
-	}
-
-	return nil
-}

core/internal/dms/handlers_mainmenu.go

@@ -1,61 +0,0 @@
-//go:build !distro_binary
-
-package dms
-
-import (
-	"time"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-type shellStartedMsg struct{}
-
-func (m Model) updateMainMenu(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q", "esc":
-		return m, tea.Quit
-	case "up", "k":
-		if m.selectedItem > 0 {
-			m.selectedItem--
-		}
-	case "down", "j":
-		if m.selectedItem < len(m.menuItems)-1 {
-			m.selectedItem++
-		}
-	case "enter", " ":
-		if m.selectedItem < len(m.menuItems) {
-			selectedAction := m.menuItems[m.selectedItem].Action
-			selectedLabel := m.menuItems[m.selectedItem].Label
-
-			switch selectedAction {
-			case StateUpdate:
-				m.state = StateUpdate
-				m.selectedUpdateDep = 0
-			case StateShell:
-				if selectedLabel == "Terminate Shell" {
-					terminateShell()
-					m.menuItems = m.buildMenuItems()
-					if m.selectedItem >= len(m.menuItems) {
-						m.selectedItem = len(m.menuItems) - 1
-					}
-				} else {
-					startShellDaemon()
-					// Wait a moment for the daemon to actually start before checking status
-					return m, tea.Tick(300*time.Millisecond, func(t time.Time) tea.Msg {
-						return shellStartedMsg{}
-					})
-				}
-			case StatePluginsMenu:
-				m.state = StatePluginsMenu
-				m.selectedPluginsMenuItem = 0
-				m.pluginsMenuItems = m.buildPluginsMenuItems()
-			case StateGreeterMenu:
-				m.state = StateGreeterMenu
-				m.selectedGreeterItem = 0
-			case StateAbout:
-				m.state = StateAbout
-			}
-		}
-	}
-	return m, nil
-}

core/internal/dms/handlers_mainmenu_distro.go

@@ -1,55 +0,0 @@
-//go:build distro_binary
-
-package dms
-
-import (
-	"time"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-type shellStartedMsg struct{}
-
-func (m Model) updateMainMenu(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q", "esc":
-		return m, tea.Quit
-	case "up", "k":
-		if m.selectedItem > 0 {
-			m.selectedItem--
-		}
-	case "down", "j":
-		if m.selectedItem < len(m.menuItems)-1 {
-			m.selectedItem++
-		}
-	case "enter", " ":
-		if m.selectedItem < len(m.menuItems) {
-			selectedAction := m.menuItems[m.selectedItem].Action
-			selectedLabel := m.menuItems[m.selectedItem].Label
-
-			switch selectedAction {
-			case StateShell:
-				if selectedLabel == "Terminate Shell" {
-					terminateShell()
-					m.menuItems = m.buildMenuItems()
-					if m.selectedItem >= len(m.menuItems) {
-						m.selectedItem = len(m.menuItems) - 1
-					}
-				} else {
-					startShellDaemon()
-					// Wait a moment for the daemon to actually start before checking status
-					return m, tea.Tick(300*time.Millisecond, func(t time.Time) tea.Msg {
-						return shellStartedMsg{}
-					})
-				}
-			case StatePluginsMenu:
-				m.state = StatePluginsMenu
-				m.selectedPluginsMenuItem = 0
-				m.pluginsMenuItems = m.buildPluginsMenuItems()
-			case StateAbout:
-				m.state = StateAbout
-			}
-		}
-	}
-	return m, nil
-}

core/internal/dms/plugins_handlers.go

@@ -1,377 +0,0 @@
-package dms
-
-import (
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/plugins"
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func (m Model) updatePluginsMenu(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StateMainMenu
-	case "up", "k":
-		if m.selectedPluginsMenuItem > 0 {
-			m.selectedPluginsMenuItem--
-		}
-	case "down", "j":
-		if m.selectedPluginsMenuItem < len(m.pluginsMenuItems)-1 {
-			m.selectedPluginsMenuItem++
-		}
-	case "enter", " ":
-		if m.selectedPluginsMenuItem < len(m.pluginsMenuItems) {
-			selectedAction := m.pluginsMenuItems[m.selectedPluginsMenuItem].Action
-			switch selectedAction {
-			case StatePluginsBrowse:
-				m.state = StatePluginsBrowse
-				m.pluginsLoading = true
-				m.pluginsError = ""
-				m.pluginsList = nil
-				return m, loadPlugins
-			case StatePluginsInstalled:
-				m.state = StatePluginsInstalled
-				m.installedPluginsLoading = true
-				m.installedPluginsError = ""
-				m.installedPluginsList = nil
-				return m, loadInstalledPlugins
-			}
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updatePluginsBrowse(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StatePluginsMenu
-		m.pluginSearchQuery = ""
-		m.filteredPluginsList = m.pluginsList
-		m.selectedPluginIndex = 0
-	case "up", "k":
-		if m.selectedPluginIndex > 0 {
-			m.selectedPluginIndex--
-		}
-	case "down", "j":
-		if m.selectedPluginIndex < len(m.filteredPluginsList)-1 {
-			m.selectedPluginIndex++
-		}
-	case "enter", " ":
-		if m.selectedPluginIndex < len(m.filteredPluginsList) {
-			m.state = StatePluginDetail
-		}
-	case "/":
-		m.state = StatePluginSearch
-		m.pluginSearchQuery = ""
-	}
-	return m, nil
-}
-
-func (m Model) updatePluginDetail(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StatePluginsBrowse
-	case "i":
-		if m.selectedPluginIndex < len(m.filteredPluginsList) {
-			plugin := m.filteredPluginsList[m.selectedPluginIndex]
-			installed := m.pluginInstallStatus[plugin.Name]
-			if !installed {
-				return m, installPlugin(plugin)
-			}
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updatePluginSearch(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c":
-		return m, tea.Quit
-	case "esc":
-		m.state = StatePluginsBrowse
-		m.pluginSearchQuery = ""
-		m.filteredPluginsList = m.pluginsList
-		m.selectedPluginIndex = 0
-	case "enter":
-		m.state = StatePluginsBrowse
-		m.filterPlugins()
-	case "backspace":
-		if len(m.pluginSearchQuery) > 0 {
-			m.pluginSearchQuery = m.pluginSearchQuery[:len(m.pluginSearchQuery)-1]
-		}
-	default:
-		if len(msg.String()) == 1 {
-			m.pluginSearchQuery += msg.String()
-		}
-	}
-	return m, nil
-}
-
-func (m *Model) filterPlugins() {
-	if m.pluginSearchQuery == "" {
-		m.filteredPluginsList = m.pluginsList
-		m.selectedPluginIndex = 0
-		return
-	}
-
-	rawPlugins := make([]plugins.Plugin, len(m.pluginsList))
-	for i, p := range m.pluginsList {
-		rawPlugins[i] = plugins.Plugin{
-			ID:           p.ID,
-			Name:         p.Name,
-			Category:     p.Category,
-			Author:       p.Author,
-			Description:  p.Description,
-			Repo:         p.Repo,
-			Path:         p.Path,
-			Capabilities: p.Capabilities,
-			Compositors:  p.Compositors,
-			Dependencies: p.Dependencies,
-		}
-	}
-
-	searchResults := plugins.FuzzySearch(m.pluginSearchQuery, rawPlugins)
-	searchResults = plugins.SortByFirstParty(searchResults)
-
-	filtered := make([]pluginInfo, len(searchResults))
-	for i, p := range searchResults {
-		filtered[i] = pluginInfo{
-			ID:           p.ID,
-			Name:         p.Name,
-			Category:     p.Category,
-			Author:       p.Author,
-			Description:  p.Description,
-			Repo:         p.Repo,
-			Path:         p.Path,
-			Capabilities: p.Capabilities,
-			Compositors:  p.Compositors,
-			Dependencies: p.Dependencies,
-			FirstParty:   strings.HasPrefix(p.Repo, "https://github.com/AvengeMedia"),
-		}
-	}
-
-	m.filteredPluginsList = filtered
-	m.selectedPluginIndex = 0
-}
-
-type pluginsLoadedMsg struct {
-	plugins []plugins.Plugin
-	err     error
-}
-
-func loadPlugins() tea.Msg {
-	registry, err := plugins.NewRegistry()
-	if err != nil {
-		return pluginsLoadedMsg{err: err}
-	}
-
-	pluginList, err := registry.List()
-	if err != nil {
-		return pluginsLoadedMsg{err: err}
-	}
-
-	return pluginsLoadedMsg{plugins: pluginList}
-}
-
-func (m *Model) updatePluginInstallStatus() {
-	manager, err := plugins.NewManager()
-	if err != nil {
-		return
-	}
-
-	for _, plugin := range m.pluginsList {
-		p := plugins.Plugin{ID: plugin.ID}
-		installed, err := manager.IsInstalled(p)
-		if err == nil {
-			m.pluginInstallStatus[plugin.Name] = installed
-		}
-	}
-}
-
-func (m Model) updatePluginsInstalled(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StatePluginsMenu
-	case "up", "k":
-		if m.selectedInstalledIndex > 0 {
-			m.selectedInstalledIndex--
-		}
-	case "down", "j":
-		if m.selectedInstalledIndex < len(m.installedPluginsList)-1 {
-			m.selectedInstalledIndex++
-		}
-	case "enter", " ":
-		if m.selectedInstalledIndex < len(m.installedPluginsList) {
-			m.state = StatePluginInstalledDetail
-		}
-	}
-	return m, nil
-}
-
-func (m Model) updatePluginInstalledDetail(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	case "esc":
-		m.state = StatePluginsInstalled
-	case "u":
-		if m.selectedInstalledIndex < len(m.installedPluginsList) {
-			plugin := m.installedPluginsList[m.selectedInstalledIndex]
-			return m, uninstallPlugin(plugin)
-		}
-	case "p":
-		if m.selectedInstalledIndex < len(m.installedPluginsList) {
-			plugin := m.installedPluginsList[m.selectedInstalledIndex]
-			return m, updatePlugin(plugin)
-		}
-	}
-	return m, nil
-}
-
-type installedPluginsLoadedMsg struct {
-	plugins []plugins.Plugin
-	err     error
-}
-
-type pluginUninstalledMsg struct {
-	pluginName string
-	err        error
-}
-
-type pluginInstalledMsg struct {
-	pluginName string
-	err        error
-}
-
-type pluginUpdatedMsg struct {
-	pluginName string
-	err        error
-}
-
-func loadInstalledPlugins() tea.Msg {
-	manager, err := plugins.NewManager()
-	if err != nil {
-		return installedPluginsLoadedMsg{err: err}
-	}
-
-	registry, err := plugins.NewRegistry()
-	if err != nil {
-		return installedPluginsLoadedMsg{err: err}
-	}
-
-	installedNames, err := manager.ListInstalled()
-	if err != nil {
-		return installedPluginsLoadedMsg{err: err}
-	}
-
-	allPlugins, err := registry.List()
-	if err != nil {
-		return installedPluginsLoadedMsg{err: err}
-	}
-
-	var installed []plugins.Plugin
-	for _, id := range installedNames {
-		for _, p := range allPlugins {
-			if p.ID == id {
-				installed = append(installed, p)
-				break
-			}
-		}
-	}
-
-	installed = plugins.SortByFirstParty(installed)
-
-	return installedPluginsLoadedMsg{plugins: installed}
-}
-
-func installPlugin(plugin pluginInfo) tea.Cmd {
-	return func() tea.Msg {
-		manager, err := plugins.NewManager()
-		if err != nil {
-			return pluginInstalledMsg{pluginName: plugin.Name, err: err}
-		}
-
-		p := plugins.Plugin{
-			ID:           plugin.ID,
-			Name:         plugin.Name,
-			Category:     plugin.Category,
-			Author:       plugin.Author,
-			Description:  plugin.Description,
-			Repo:         plugin.Repo,
-			Path:         plugin.Path,
-			Capabilities: plugin.Capabilities,
-			Compositors:  plugin.Compositors,
-			Dependencies: plugin.Dependencies,
-		}
-
-		if err := manager.Install(p); err != nil {
-			return pluginInstalledMsg{pluginName: plugin.Name, err: err}
-		}
-
-		return pluginInstalledMsg{pluginName: plugin.Name}
-	}
-}
-
-func uninstallPlugin(plugin pluginInfo) tea.Cmd {
-	return func() tea.Msg {
-		manager, err := plugins.NewManager()
-		if err != nil {
-			return pluginUninstalledMsg{pluginName: plugin.Name, err: err}
-		}
-
-		p := plugins.Plugin{
-			ID:           plugin.ID,
-			Name:         plugin.Name,
-			Category:     plugin.Category,
-			Author:       plugin.Author,
-			Description:  plugin.Description,
-			Repo:         plugin.Repo,
-			Path:         plugin.Path,
-			Capabilities: plugin.Capabilities,
-			Compositors:  plugin.Compositors,
-			Dependencies: plugin.Dependencies,
-		}
-
-		if err := manager.Uninstall(p); err != nil {
-			return pluginUninstalledMsg{pluginName: plugin.Name, err: err}
-		}
-
-		return pluginUninstalledMsg{pluginName: plugin.Name}
-	}
-}
-
-func updatePlugin(plugin pluginInfo) tea.Cmd {
-	return func() tea.Msg {
-		manager, err := plugins.NewManager()
-		if err != nil {
-			return pluginUpdatedMsg{pluginName: plugin.Name, err: err}
-		}
-
-		p := plugins.Plugin{
-			ID:           plugin.ID,
-			Name:         plugin.Name,
-			Category:     plugin.Category,
-			Author:       plugin.Author,
-			Description:  plugin.Description,
-			Repo:         plugin.Repo,
-			Path:         plugin.Path,
-			Capabilities: plugin.Capabilities,
-			Compositors:  plugin.Compositors,
-			Dependencies: plugin.Dependencies,
-		}
-
-		if err := manager.Update(p); err != nil {
-			return pluginUpdatedMsg{pluginName: plugin.Name, err: err}
-		}
-
-		return pluginUpdatedMsg{pluginName: plugin.Name}
-	}
-}

core/internal/dms/plugins_views.go

@@ -1,367 +0,0 @@
-package dms
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-func (m Model) renderPluginsMenu() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	b.WriteString(titleStyle.Render("Plugins"))
-	b.WriteString("\n\n")
-
-	for i, item := range m.pluginsMenuItems {
-		if i == m.selectedPluginsMenuItem {
-			b.WriteString(selectedStyle.Render(fmt.Sprintf("→ %s", item.Label)))
-		} else {
-			b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", item.Label)))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-	b.WriteString(instructionStyle.Render("↑/↓: Navigate | Enter: Select | Esc: Back | q: Quit"))
-
-	return b.String()
-}
-
-func (m Model) renderPluginsBrowse() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	errorStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FF0000"))
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	b.WriteString(titleStyle.Render("Browse Plugins"))
-	b.WriteString("\n\n")
-
-	if m.pluginsLoading {
-		b.WriteString(normalStyle.Render("Fetching plugins from registry..."))
-	} else if m.pluginsError != "" {
-		b.WriteString(errorStyle.Render(fmt.Sprintf("Error: %s", m.pluginsError)))
-	} else if len(m.filteredPluginsList) == 0 {
-		if m.pluginSearchQuery != "" {
-			b.WriteString(normalStyle.Render(fmt.Sprintf("No plugins match '%s'", m.pluginSearchQuery)))
-		} else {
-			b.WriteString(normalStyle.Render("No plugins found in registry."))
-		}
-	} else {
-		installedStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#888888"))
-
-		for i, plugin := range m.filteredPluginsList {
-			installed := m.pluginInstallStatus[plugin.Name]
-			installMarker := ""
-			if installed {
-				installMarker = " [Installed]"
-			}
-
-			if i == m.selectedPluginIndex {
-				b.WriteString(selectedStyle.Render(fmt.Sprintf("→ %s", plugin.Name)))
-				if installed {
-					b.WriteString(installedStyle.Render(installMarker))
-				}
-			} else {
-				b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", plugin.Name)))
-				if installed {
-					b.WriteString(installedStyle.Render(installMarker))
-				}
-			}
-			b.WriteString("\n")
-		}
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-
-	if m.pluginsLoading || m.pluginsError != "" {
-		b.WriteString(instructionStyle.Render("Esc: Back | q: Quit"))
-	} else {
-		b.WriteString(instructionStyle.Render("↑/↓: Navigate | Enter: View/Install | /: Search | Esc: Back | q: Quit"))
-	}
-
-	return b.String()
-}
-
-func (m Model) renderPluginDetail() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	labelStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-
-	if m.selectedPluginIndex >= len(m.filteredPluginsList) {
-		return "No plugin selected"
-	}
-
-	plugin := m.filteredPluginsList[m.selectedPluginIndex]
-
-	b.WriteString(titleStyle.Render(plugin.Name))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("ID: "))
-	b.WriteString(normalStyle.Render(plugin.ID))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Category: "))
-	b.WriteString(normalStyle.Render(plugin.Category))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Author: "))
-	b.WriteString(normalStyle.Render(plugin.Author))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Description:"))
-	b.WriteString("\n")
-	wrapped := wrapText(plugin.Description, 60)
-	b.WriteString(normalStyle.Render(wrapped))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Repository: "))
-	b.WriteString(normalStyle.Render(plugin.Repo))
-	b.WriteString("\n\n")
-
-	if len(plugin.Capabilities) > 0 {
-		b.WriteString(labelStyle.Render("Capabilities: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Capabilities, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	if len(plugin.Compositors) > 0 {
-		b.WriteString(labelStyle.Render("Compositors: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Compositors, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	if len(plugin.Dependencies) > 0 {
-		b.WriteString(labelStyle.Render("Dependencies: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Dependencies, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	installed := m.pluginInstallStatus[plugin.Name]
-	if installed {
-		b.WriteString(labelStyle.Render("Status: "))
-		installedStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#00D4AA"))
-		b.WriteString(installedStyle.Render("Installed"))
-		b.WriteString("\n\n")
-	}
-
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-
-	if installed {
-		b.WriteString(instructionStyle.Render("Esc: Back | q: Quit"))
-	} else {
-		b.WriteString(instructionStyle.Render("i: Install | Esc: Back | q: Quit"))
-	}
-
-	return b.String()
-}
-
-func (m Model) renderPluginSearch() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(titleStyle.Render("Search Plugins"))
-	b.WriteString("\n\n")
-
-	b.WriteString(normalStyle.Render("Query: "))
-	b.WriteString(titleStyle.Render(m.pluginSearchQuery + "▌"))
-	b.WriteString("\n\n")
-
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-	b.WriteString(instructionStyle.Render("Enter: Search | Esc: Cancel"))
-
-	return b.String()
-}
-
-func (m Model) renderPluginsInstalled() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	errorStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FF0000"))
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	b.WriteString(titleStyle.Render("Installed Plugins"))
-	b.WriteString("\n\n")
-
-	if m.installedPluginsLoading {
-		b.WriteString(normalStyle.Render("Loading installed plugins..."))
-	} else if m.installedPluginsError != "" {
-		b.WriteString(errorStyle.Render(fmt.Sprintf("Error: %s", m.installedPluginsError)))
-	} else if len(m.installedPluginsList) == 0 {
-		b.WriteString(normalStyle.Render("No plugins installed."))
-	} else {
-		for i, plugin := range m.installedPluginsList {
-			if i == m.selectedInstalledIndex {
-				b.WriteString(selectedStyle.Render(fmt.Sprintf("→ %s", plugin.Name)))
-			} else {
-				b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", plugin.Name)))
-			}
-			b.WriteString("\n")
-		}
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-
-	if m.installedPluginsLoading || m.installedPluginsError != "" {
-		b.WriteString(instructionStyle.Render("Esc: Back | q: Quit"))
-	} else {
-		b.WriteString(instructionStyle.Render("↑/↓: Navigate | Enter: Details | Esc: Back | q: Quit"))
-	}
-
-	return b.String()
-}
-
-func (m Model) renderPluginInstalledDetail() string {
-	var b strings.Builder
-
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	labelStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-
-	errorStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FF0000"))
-
-	if m.selectedInstalledIndex >= len(m.installedPluginsList) {
-		return "No plugin selected"
-	}
-
-	plugin := m.installedPluginsList[m.selectedInstalledIndex]
-
-	b.WriteString(titleStyle.Render(plugin.Name))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("ID: "))
-	b.WriteString(normalStyle.Render(plugin.ID))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Category: "))
-	b.WriteString(normalStyle.Render(plugin.Category))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Author: "))
-	b.WriteString(normalStyle.Render(plugin.Author))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Description:"))
-	b.WriteString("\n")
-	wrapped := wrapText(plugin.Description, 60)
-	b.WriteString(normalStyle.Render(wrapped))
-	b.WriteString("\n\n")
-
-	b.WriteString(labelStyle.Render("Repository: "))
-	b.WriteString(normalStyle.Render(plugin.Repo))
-	b.WriteString("\n\n")
-
-	if len(plugin.Capabilities) > 0 {
-		b.WriteString(labelStyle.Render("Capabilities: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Capabilities, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	if len(plugin.Compositors) > 0 {
-		b.WriteString(labelStyle.Render("Compositors: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Compositors, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	if len(plugin.Dependencies) > 0 {
-		b.WriteString(labelStyle.Render("Dependencies: "))
-		b.WriteString(normalStyle.Render(strings.Join(plugin.Dependencies, ", ")))
-		b.WriteString("\n\n")
-	}
-
-	if m.installedPluginsError != "" {
-		b.WriteString(errorStyle.Render(fmt.Sprintf("Error: %s", m.installedPluginsError)))
-		b.WriteString("\n\n")
-	}
-
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888"))
-	b.WriteString(instructionStyle.Render("u: Uninstall | Esc: Back | q: Quit"))
-
-	return b.String()
-}
-
-func wrapText(text string, width int) string {
-	words := strings.Fields(text)
-	if len(words) == 0 {
-		return text
-	}
-
-	var lines []string
-	currentLine := words[0]
-
-	for _, word := range words[1:] {
-		if len(currentLine)+1+len(word) <= width {
-			currentLine += " " + word
-		} else {
-			lines = append(lines, currentLine)
-			currentLine = word
-		}
-	}
-	lines = append(lines, currentLine)
-
-	return strings.Join(lines, "\n")
-}

core/internal/dms/views_common.go

@@ -1,152 +0,0 @@
-package dms
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/tui"
-	"github.com/charmbracelet/lipgloss"
-)
-
-func (m Model) renderMainMenu() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("dms"))
-	b.WriteString("\n")
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	for i, item := range m.menuItems {
-		if i == m.selectedItem {
-			b.WriteString(selectedStyle.Render(fmt.Sprintf("▶ %s", item.Label)))
-		} else {
-			b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", item.Label)))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "↑/↓: Navigate, Enter: Select, q/Esc: Exit"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderShellView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Shell"))
-	b.WriteString("\n\n")
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(normalStyle.Render("Opening interactive shell..."))
-	b.WriteString("\n")
-	b.WriteString(normalStyle.Render("This will launch a shell with DMS environment loaded."))
-	b.WriteString("\n\n")
-
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "Press any key to launch shell, Esc: Back"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderAboutView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("About DankMaterialShell"))
-	b.WriteString("\n\n")
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(normalStyle.Render(fmt.Sprintf("DMS Management Interface %s", m.version)))
-	b.WriteString("\n\n")
-	b.WriteString(normalStyle.Render("DankMaterialShell is a comprehensive desktop environment"))
-	b.WriteString("\n")
-	b.WriteString(normalStyle.Render("built around Quickshell, providing a modern Material Design"))
-	b.WriteString("\n")
-	b.WriteString(normalStyle.Render("experience for Wayland compositors."))
-	b.WriteString("\n\n")
-
-	b.WriteString(normalStyle.Render("Components:"))
-	b.WriteString("\n")
-	if len(m.dependencies) == 0 {
-		b.WriteString(normalStyle.Render("\n  Component detection not supported on this platform."))
-	}
-	for _, dep := range m.dependencies {
-		status := "✗"
-		if dep.Status == 1 {
-			status = "✓"
-		}
-		b.WriteString(normalStyle.Render(fmt.Sprintf("  %s %s", status, dep.Name)))
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "Esc: Back to main menu"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderBanner() string {
-	theme := tui.TerminalTheme()
-
-	logo := `
-██████╗  █████╗ ███╗   ██╗██╗  ██╗
-██╔══██╗██╔══██╗████╗  ██║██║ ██╔╝
-██║  ██║███████║██╔██╗ ██║█████╔╝
-██║  ██║██╔══██║██║╚██╗██║██╔═██╗
-██████╔╝██║  ██║██║ ╚████║██║  ██╗
-╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝`
-
-	titleStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color(theme.Primary)).
-		Bold(true).
-		MarginBottom(1)
-
-	return titleStyle.Render(logo)
-}

core/internal/dms/views_features.go

@@ -1,529 +0,0 @@
-//go:build !distro_binary
-
-package dms
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-func (m Model) renderUpdateView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Update Dependencies"))
-	b.WriteString("\n")
-
-	if len(m.updateDeps) == 0 {
-		b.WriteString("Loading dependencies...\n")
-		return b.String()
-	}
-
-	categories := m.categorizeDependencies()
-	currentIndex := 0
-
-	for _, category := range []string{"Shell", "Shared Components", "Hyprland Components", "Niri Components"} {
-		deps, exists := categories[category]
-		if !exists || len(deps) == 0 {
-			continue
-		}
-
-		categoryStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#7060ac")).
-			Bold(true).
-			MarginTop(1)
-
-		b.WriteString(categoryStyle.Render(category + ":"))
-		b.WriteString("\n")
-
-		for _, dep := range deps {
-			var statusText, icon, reinstallMarker string
-			var style lipgloss.Style
-
-			if m.updateToggles[dep.Name] {
-				reinstallMarker = "🔄 "
-				if dep.Status == 0 {
-					statusText = "Will be installed"
-				} else {
-					statusText = "Will be upgraded"
-				}
-				style = lipgloss.NewStyle().Foreground(lipgloss.Color("#FFA500"))
-			} else {
-				switch dep.Status {
-				case 1:
-					icon = "✓"
-					statusText = "Installed"
-					style = lipgloss.NewStyle().Foreground(lipgloss.Color("#FFFFFF"))
-				case 0:
-					icon = "○"
-					statusText = "Not installed"
-					style = lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-				case 2:
-					icon = "△"
-					statusText = "Needs update"
-					style = lipgloss.NewStyle().Foreground(lipgloss.Color("#FFA500"))
-				case 3:
-					icon = "!"
-					statusText = "Needs reinstall"
-					style = lipgloss.NewStyle().Foreground(lipgloss.Color("#FFA500"))
-				}
-			}
-
-			line := fmt.Sprintf("%s%s%-25s %s", reinstallMarker, icon, dep.Name, statusText)
-
-			if currentIndex == m.selectedUpdateDep {
-				line = "▶ " + line
-				selectedStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#7060ac")).Bold(true)
-				b.WriteString(selectedStyle.Render(line))
-			} else {
-				line = "  " + line
-				b.WriteString(style.Render(line))
-			}
-			b.WriteString("\n")
-			currentIndex++
-		}
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "↑/↓: Navigate, Space: Toggle, Enter: Update Selected, Esc: Back"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderPasswordView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Sudo Authentication"))
-	b.WriteString("\n\n")
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(normalStyle.Render("Package installation requires sudo privileges."))
-	b.WriteString("\n")
-	b.WriteString(normalStyle.Render("Please enter your password to continue:"))
-	b.WriteString("\n\n")
-
-	inputStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	maskedPassword := strings.Repeat("*", len(m.passwordInput))
-	b.WriteString(inputStyle.Render("Password: " + maskedPassword))
-	b.WriteString("\n")
-
-	if m.passwordError != "" {
-		errorStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#FF0000"))
-		b.WriteString(errorStyle.Render("✗ " + m.passwordError))
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "Enter: Continue, Esc: Back, Ctrl+C: Cancel"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderProgressView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Updating Packages"))
-	b.WriteString("\n\n")
-
-	if !m.updateProgress.complete {
-		progressStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#00D4AA"))
-
-		b.WriteString(progressStyle.Render(m.updateProgress.step))
-		b.WriteString("\n\n")
-
-		progressBar := fmt.Sprintf("[%s%s] %.0f%%",
-			strings.Repeat("█", int(m.updateProgress.progress*30)),
-			strings.Repeat("░", 30-int(m.updateProgress.progress*30)),
-			m.updateProgress.progress*100)
-		b.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("#FFFFFF")).Render(progressBar))
-		b.WriteString("\n")
-
-		if len(m.updateLogs) > 0 {
-			b.WriteString("\n")
-			logHeader := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888")).Render("Live Output:")
-			b.WriteString(logHeader)
-			b.WriteString("\n")
-
-			maxLines := 8
-			startIdx := 0
-			if len(m.updateLogs) > maxLines {
-				startIdx = len(m.updateLogs) - maxLines
-			}
-
-			logStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-			for i := startIdx; i < len(m.updateLogs); i++ {
-				if m.updateLogs[i] != "" {
-					b.WriteString(logStyle.Render("  " + m.updateLogs[i]))
-					b.WriteString("\n")
-				}
-			}
-		}
-	}
-
-	if m.updateProgress.err != nil {
-		errorStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#FF0000"))
-
-		b.WriteString("\n")
-		b.WriteString(errorStyle.Render(fmt.Sprintf("✗ Update failed: %v", m.updateProgress.err)))
-		b.WriteString("\n")
-
-		if len(m.updateLogs) > 0 {
-			b.WriteString("\n")
-			logHeader := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888")).Render("Error Logs:")
-			b.WriteString(logHeader)
-			b.WriteString("\n")
-
-			maxLines := 15
-			startIdx := 0
-			if len(m.updateLogs) > maxLines {
-				startIdx = len(m.updateLogs) - maxLines
-			}
-
-			logStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-			for i := startIdx; i < len(m.updateLogs); i++ {
-				if m.updateLogs[i] != "" {
-					b.WriteString(logStyle.Render("  " + m.updateLogs[i]))
-					b.WriteString("\n")
-				}
-			}
-		}
-
-		b.WriteString("\n")
-		instructionStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#888888"))
-		b.WriteString(instructionStyle.Render("Press Esc to go back"))
-	} else if m.updateProgress.complete {
-		successStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#00D4AA"))
-
-		b.WriteString("\n")
-		b.WriteString(successStyle.Render("✓ Update complete!"))
-		b.WriteString("\n\n")
-
-		instructionStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#888888"))
-		b.WriteString(instructionStyle.Render("Press Esc to return to main menu"))
-	}
-
-	return b.String()
-}
-
-func (m Model) getFilteredDeps() []DependencyInfo {
-	categories := m.categorizeDependencies()
-	var filtered []DependencyInfo
-
-	for _, category := range []string{"Shell", "Shared Components", "Hyprland Components", "Niri Components"} {
-		deps, exists := categories[category]
-		if exists {
-			filtered = append(filtered, deps...)
-		}
-	}
-
-	return filtered
-}
-
-func (m Model) getDepAtVisualIndex(index int) *DependencyInfo {
-	filtered := m.getFilteredDeps()
-	if index >= 0 && index < len(filtered) {
-		return &filtered[index]
-	}
-	return nil
-}
-
-func (m Model) renderGreeterPasswordView() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Sudo Authentication"))
-	b.WriteString("\n\n")
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(normalStyle.Render("Greeter installation requires sudo privileges."))
-	b.WriteString("\n")
-	b.WriteString(normalStyle.Render("Please enter your password to continue:"))
-	b.WriteString("\n\n")
-
-	inputStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA"))
-
-	maskedPassword := strings.Repeat("*", len(m.greeterPasswordInput))
-	b.WriteString(inputStyle.Render("Password: " + maskedPassword))
-	b.WriteString("\n")
-
-	if m.greeterPasswordError != "" {
-		errorStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#FF0000"))
-		b.WriteString(errorStyle.Render("✗ " + m.greeterPasswordError))
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "Enter: Continue, Esc: Back, Ctrl+C: Cancel"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderGreeterCompositorSelect() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Select Compositor"))
-	b.WriteString("\n\n")
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	b.WriteString(normalStyle.Render("Multiple compositors detected. Choose which one to use for the greeter:"))
-	b.WriteString("\n\n")
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	for i, comp := range m.greeterCompositors {
-		if i == m.greeterSelectedComp {
-			b.WriteString(selectedStyle.Render(fmt.Sprintf("▶ %s", comp)))
-		} else {
-			b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", comp)))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "↑/↓: Navigate, Enter: Select, Esc: Back"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderGreeterMenu() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Greeter Management"))
-	b.WriteString("\n")
-
-	greeterMenuItems := []string{"Install Greeter"}
-
-	selectedStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#00D4AA")).
-		Bold(true)
-
-	normalStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF"))
-
-	for i, item := range greeterMenuItems {
-		if i == m.selectedGreeterItem {
-			b.WriteString(selectedStyle.Render(fmt.Sprintf("▶ %s", item)))
-		} else {
-			b.WriteString(normalStyle.Render(fmt.Sprintf("  %s", item)))
-		}
-		b.WriteString("\n")
-	}
-
-	b.WriteString("\n")
-	instructionStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#888888")).
-		MarginTop(1)
-
-	instructions := "↑/↓: Navigate, Enter: Select, Esc: Back"
-	b.WriteString(instructionStyle.Render(instructions))
-
-	return b.String()
-}
-
-func (m Model) renderGreeterInstalling() string {
-	var b strings.Builder
-
-	b.WriteString(m.renderBanner())
-	b.WriteString("\n")
-
-	headerStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Bold(true).
-		MarginBottom(1)
-
-	b.WriteString(headerStyle.Render("Installing Greeter"))
-	b.WriteString("\n\n")
-
-	if !m.greeterProgress.complete {
-		progressStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#00D4AA"))
-
-		b.WriteString(progressStyle.Render(m.greeterProgress.step))
-		b.WriteString("\n\n")
-
-		if len(m.greeterLogs) > 0 {
-			b.WriteString("\n")
-			logHeader := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888")).Render("Output:")
-			b.WriteString(logHeader)
-			b.WriteString("\n")
-
-			maxLines := 10
-			startIdx := 0
-			if len(m.greeterLogs) > maxLines {
-				startIdx = len(m.greeterLogs) - maxLines
-			}
-
-			logStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-			for i := startIdx; i < len(m.greeterLogs); i++ {
-				if m.greeterLogs[i] != "" {
-					b.WriteString(logStyle.Render("  " + m.greeterLogs[i]))
-					b.WriteString("\n")
-				}
-			}
-		}
-	}
-
-	if m.greeterProgress.err != nil {
-		errorStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#FF0000"))
-
-		b.WriteString("\n")
-		b.WriteString(errorStyle.Render(fmt.Sprintf("✗ Installation failed: %v", m.greeterProgress.err)))
-		b.WriteString("\n\n")
-
-		instructionStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#888888"))
-		b.WriteString(instructionStyle.Render("Press Esc to go back"))
-	} else if m.greeterProgress.complete {
-		successStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#00D4AA"))
-
-		b.WriteString("\n")
-		b.WriteString(successStyle.Render("✓ Greeter installation complete!"))
-		b.WriteString("\n\n")
-
-		normalStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#FFFFFF"))
-
-		b.WriteString(normalStyle.Render("To test the greeter, run:"))
-		b.WriteString("\n")
-		b.WriteString(normalStyle.Render("  sudo systemctl start greetd"))
-		b.WriteString("\n\n")
-		b.WriteString(normalStyle.Render("To enable on boot, run:"))
-		b.WriteString("\n")
-		b.WriteString(normalStyle.Render("  sudo systemctl enable --now greetd"))
-		b.WriteString("\n\n")
-
-		instructionStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#888888"))
-		b.WriteString(instructionStyle.Render("Press Esc to return to main menu"))
-	}
-
-	return b.String()
-}
-
-func (m Model) categorizeDependencies() map[string][]DependencyInfo {
-	categories := map[string][]DependencyInfo{
-		"Shell":               {},
-		"Shared Components":   {},
-		"Hyprland Components": {},
-		"Niri Components":     {},
-	}
-
-	excludeList := map[string]bool{
-		"git":                         true,
-		"polkit-agent":                true,
-		"jq":                          true,
-		"xdg-desktop-portal":          true,
-		"xdg-desktop-portal-wlr":      true,
-		"xdg-desktop-portal-hyprland": true,
-		"xdg-desktop-portal-gtk":      true,
-	}
-
-	for _, dep := range m.updateDeps {
-		if excludeList[dep.Name] {
-			continue
-		}
-
-		switch dep.Name {
-		case "dms (DankMaterialShell)", "quickshell":
-			categories["Shell"] = append(categories["Shell"], dep)
-		case "hyprland", "hyprctl":
-			categories["Hyprland Components"] = append(categories["Hyprland Components"], dep)
-		case "niri":
-			categories["Niri Components"] = append(categories["Niri Components"], dep)
-		case "kitty", "alacritty", "ghostty":
-			categories["Shared Components"] = append(categories["Shared Components"], dep)
-		default:
-			categories["Shared Components"] = append(categories["Shared Components"], dep)
-		}
-	}
-
-	return categories
-}

core/internal/keybinds/discovery.go

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

core/internal/keybinds/providers/hyprland.go

@@ -2,45 +2,93 @@ 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 = "$HOME/.config/hypr"
+		configPath = defaultHyprlandConfigDir()
 	}
 	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) {
-	section, err := ParseHyprlandKeys(h.configPath)
+	result, err := ParseHyprlandKeysWithDMS(h.configPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse hyprland config: %w", err)
 	}
 
-	categorizedBinds := make(map[string][]keybinds.Keybind)
-	h.convertSection(section, "", categorizedBinds)
+	h.dmsBindsIncluded = result.DMSBindsIncluded
+	h.parsed = true
 
-	return &keybinds.CheatSheet{
-		Title:    "Hyprland Keybinds",
-		Provider: h.Name(),
-		Binds:    categorizedBinds,
-	}, nil
+	categorizedBinds := make(map[string][]keybinds.Keybind)
+	h.convertSection(result.Section, "", categorizedBinds, result.ConflictingConfigs)
+
+	sheet := &keybinds.CheatSheet{
+		Title:            "Hyprland Keybinds",
+		Provider:         h.Name(),
+		Binds:            categorizedBinds,
+		DMSBindsIncluded: result.DMSBindsIncluded,
+	}
+
+	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) convertSection(section *HyprlandSection, subcategory string, categorizedBinds map[string][]keybinds.Keybind) {
+func (h *HyprlandProvider) HasDMSBindsIncluded() bool {
+	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
@@ -48,12 +96,12 @@ func (h *HyprlandProvider) convertSection(section *HyprlandSection, subcategory
 
 	for _, kb := range section.Keybinds {
 		category := h.categorizeByDispatcher(kb.Dispatcher)
-		bind := h.convertKeybind(&kb, currentSubcat)
+		bind := h.convertKeybind(&kb, currentSubcat, conflicts)
 		categorizedBinds[category] = append(categorizedBinds[category], bind)
 	}
 
 	for _, child := range section.Children {
-		h.convertSection(&child, currentSubcat, categorizedBinds)
+		h.convertSection(&child, currentSubcat, categorizedBinds, conflicts)
 	}
 }
 
@@ -85,8 +133,8 @@ func (h *HyprlandProvider) categorizeByDispatcher(dispatcher string) string {
 	}
 }
 
-func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory string) keybinds.Keybind {
-	key := h.formatKey(kb)
+func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory string, conflicts map[string]*HyprlandKeyBinding) keybinds.Keybind {
+	keyStr := h.formatKey(kb)
 	rawAction := h.formatRawAction(kb.Dispatcher, kb.Params)
 	desc := kb.Comment
 
@@ -94,12 +142,33 @@ func (h *HyprlandProvider) convertKeybind(kb *HyprlandKeyBinding, subcategory st
 		desc = rawAction
 	}
 
-	return keybinds.Keybind{
-		Key:         key,
+	source := "config"
+	if strings.Contains(kb.Source, "dms/binds.conf") {
+		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 {
@@ -115,3 +184,314 @@ 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,6 +23,8 @@ 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 {
@@ -32,14 +34,36 @@ type HyprlandSection struct {
 }
 
 type HyprlandParser struct {
-	contentLines []string
-	readingLine  int
+	contentLines       []string
+	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() *HyprlandParser {
+func NewHyprlandParser(configDir string) *HyprlandParser {
 	return &HyprlandParser{
-		contentLines: []string{},
-		readingLine:  0,
+		contentLines:       []string{},
+		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),
 	}
 }
 
@@ -195,71 +219,7 @@ func hyprlandAutogenerateComment(dispatcher, params string) string {
 
 func (p *HyprlandParser) getKeybindAtLine(lineNumber int) *HyprlandKeyBinding {
 	line := p.contentLines[lineNumber]
-	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,
-	}
+	return p.parseBindLine(line)
 }
 
 func (p *HyprlandParser) getBindsRecursive(currentContent *HyprlandSection, scope int) *HyprlandSection {
@@ -320,9 +280,348 @@ func (p *HyprlandParser) ParseKeys() *HyprlandSection {
 }
 
 func ParseHyprlandKeys(path string) (*HyprlandSection, error) {
-	parser := NewHyprlandParser()
+	parser := NewHyprlandParser(path)
 	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,3 +394,126 @@ 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,35 +7,30 @@ import (
 )
 
 func TestNewHyprlandProvider(t *testing.T) {
-	tests := []struct {
-		name       string
-		configPath string
-		wantPath   string
-	}{
-		{
-			name:       "custom path",
-			configPath: "/custom/path",
-			wantPath:   "/custom/path",
-		},
-		{
-			name:       "empty path defaults",
-			configPath: "",
-			wantPath:   "$HOME/.config/hypr",
-		},
-	}
+	t.Run("custom path", func(t *testing.T) {
+		p := NewHyprlandProvider("/custom/path")
+		if p == nil {
+			t.Fatal("NewHyprlandProvider returned nil")
+		}
+		if p.configPath != "/custom/path" {
+			t.Errorf("configPath = %q, want %q", p.configPath, "/custom/path")
+		}
+	})
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			p := NewHyprlandProvider(tt.configPath)
-			if p == nil {
-				t.Fatal("NewHyprlandProvider returned nil")
-			}
-
-			if p.configPath != tt.wantPath {
-				t.Errorf("configPath = %q, want %q", p.configPath, tt.wantPath)
-			}
-		})
-	}
+	t.Run("empty path defaults", func(t *testing.T) {
+		p := NewHyprlandProvider("")
+		if p == nil {
+			t.Fatal("NewHyprlandProvider returned nil")
+		}
+		configDir, err := os.UserConfigDir()
+		if err != nil {
+			t.Fatalf("UserConfigDir failed: %v", err)
+		}
+		expected := filepath.Join(configDir, "hypr")
+		if p.configPath != expected {
+			t.Errorf("configPath = %q, want %q", p.configPath, expected)
+		}
+	})
 }
 
 func TestHyprlandProviderName(t *testing.T) {
@@ -109,7 +104,7 @@ func TestHyprlandProviderGetCheatSheetError(t *testing.T) {
 
 func TestFormatKey(t *testing.T) {
 	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "test.conf")
+	configFile := filepath.Join(tmpDir, "hyprland.conf")
 
 	tests := []struct {
 		name     string
@@ -163,7 +158,7 @@ func TestFormatKey(t *testing.T) {
 
 func TestDescriptionFallback(t *testing.T) {
 	tmpDir := t.TempDir()
-	configFile := filepath.Join(tmpDir, "test.conf")
+	configFile := filepath.Join(tmpDir, "hyprland.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("{}"), 0644); err != nil {
+	if err := os.WriteFile(testFile, []byte("{}"), 0o644); 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), 0644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0o644); 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), 0644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0o644); 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), 0644); err != nil {
+	if err := os.WriteFile(testFile, []byte(content), 0o644); 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"), 0644); err != nil {
+	if err := os.WriteFile(testFile, []byte("not valid json"), 0o644); err != nil {
 		t.Fatalf("Failed to write test file: %v", err)
 	}
 

core/internal/keybinds/providers/mangowc.go

@@ -2,46 +2,94 @@ 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 = "$HOME/.config/mango"
+		configPath = defaultMangoWCConfigDir()
 	}
 	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) {
-	keybinds_list, err := ParseMangoWCKeys(m.configPath)
+	result, err := ParseMangoWCKeysWithDMS(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 keybinds_list {
+	for _, kb := range result.Keybinds {
 		category := m.categorizeByCommand(kb.Command)
-		bind := m.convertKeybind(&kb)
+		bind := m.convertKeybind(&kb, result.ConflictingConfigs)
 		categorizedBinds[category] = append(categorizedBinds[category], bind)
 	}
 
-	return &keybinds.CheatSheet{
-		Title:    "MangoWC Keybinds",
-		Provider: m.Name(),
-		Binds:    categorizedBinds,
-	}, nil
+	sheet := &keybinds.CheatSheet{
+		Title:            "MangoWC Keybinds",
+		Provider:         m.Name(),
+		Binds:            categorizedBinds,
+		DMSBindsIncluded: result.DMSBindsIncluded,
+	}
+
+	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 {
@@ -82,8 +130,8 @@ func (m *MangoWCProvider) categorizeByCommand(command string) string {
 	}
 }
 
-func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding) keybinds.Keybind {
-	key := m.formatKey(kb)
+func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding, conflicts map[string]*MangoWCKeyBinding) keybinds.Keybind {
+	keyStr := m.formatKey(kb)
 	rawAction := m.formatRawAction(kb.Command, kb.Params)
 	desc := kb.Comment
 
@@ -91,11 +139,31 @@ func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding) keybinds.Keybind
 		desc = rawAction
 	}
 
-	return keybinds.Keybind{
-		Key:         key,
+	source := "config"
+	if strings.Contains(kb.Source, "dms/binds.conf") || strings.Contains(kb.Source, "dms"+string(filepath.Separator)+"binds.conf") {
+		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 {
@@ -111,3 +179,264 @@ 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,17 +21,40 @@ type MangoWCKeyBinding struct {
 	Command string   `json:"command"`
 	Params  string   `json:"params"`
 	Comment string   `json:"comment"`
+	Source  string   `json:"source"`
 }
 
 type MangoWCParser struct {
-	contentLines []string
-	readingLine  int
+	contentLines       []string
+	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() *MangoWCParser {
+func NewMangoWCParser(configDir string) *MangoWCParser {
 	return &MangoWCParser{
-		contentLines: []string{},
-		readingLine:  0,
+		contentLines:       []string{},
+		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),
 	}
 }
 
@@ -294,9 +317,297 @@ func (p *MangoWCParser) ParseKeys() []MangoWCKeyBinding {
 }
 
 func ParseMangoWCKeys(path string) ([]MangoWCKeyBinding, error) {
-	parser := NewMangoWCParser()
+	parser := NewMangoWCParser(path)
 	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
+	}
+
+	expanded, err := utils.ExpandPath(sourcePath)
+	if err != nil {
+		return
+	}
+
+	fullPath := expanded
+	if !filepath.IsAbs(expanded) {
+		fullPath = filepath.Join(baseDir, expanded)
+	}
+
+	includedBinds, err := p.parseFileWithSource(fullPath)
+	if err != nil {
+		return
+	}
+
+	*keybinds = append(*keybinds, includedBinds...)
+}
+
+func (p *MangoWCParser) parseDMSBindsDirectly(dmsBindsPath string) []MangoWCKeyBinding {
+	keybinds, err := p.parseFileWithSource(dmsBindsPath)
+	if err != nil {
+		return nil
+	}
+	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,8 +15,17 @@ func TestMangoWCProviderName(t *testing.T) {
 
 func TestMangoWCProviderDefaultPath(t *testing.T) {
 	provider := NewMangoWCProvider("")
-	if provider.configPath != "$HOME/.config/mango" {
-		t.Errorf("configPath = %q, want %q", provider.configPath, "$HOME/.config/mango")
+	configDir, err := os.UserConfigDir()
+	if err != nil {
+		// 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)
 	}
 }
 
@@ -174,7 +183,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)
+			result := provider.convertKeybind(tt.keybind, nil)
 			if result.Key != tt.wantKey {
 				t.Errorf("convertKeybind().Key = %q, want %q", result.Key, tt.wantKey)
 			}

core/internal/keybinds/providers/niri.go

@@ -187,7 +187,15 @@ func (n *NiriProvider) formatRawAction(action string, args []string) string {
 		}
 	}
 
-	return action + " " + strings.Join(args, " ")
+	quotedArgs := make([]string, len(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 {
@@ -293,9 +301,15 @@ 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:      n.formatRawAction(kb.Action, kb.Args),
+				Action:      action,
 				Description: kb.Description,
 				Options:     n.extractOptions(child),
 			}
@@ -305,6 +319,42 @@ 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)
@@ -461,16 +511,9 @@ 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 dmsWarningHeader + "binds {}\n"
+		return "binds {}\n"
 	}
 
 	var regularBinds, recentWindowsBinds []*overrideBind
@@ -497,7 +540,6 @@ 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,13 +6,6 @@ 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" {
@@ -128,6 +121,8 @@ 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"},
@@ -204,7 +199,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 		{
 			name:     "empty binds",
 			binds:    map[string]*overrideBind{},
-			expected: testHeader + "binds {}\n",
+			expected: "binds {}\n",
 		},
 		{
 			name: "simple spawn bind",
@@ -215,7 +210,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Open Terminal",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Mod+T hotkey-overlay-title="Open Terminal" { spawn "kitty"; }
 }
 `,
@@ -229,7 +224,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Application Launcher",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Mod+Space hotkey-overlay-title="Application Launcher" { spawn "dms" "ipc" "call" "spotlight" "toggle"; }
 }
 `,
@@ -243,7 +238,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Options: map[string]any{"allow-when-locked": true},
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     XF86AudioMute allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "mute"; }
 }
 `,
@@ -257,7 +252,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Description: "Close Window",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Mod+Q hotkey-overlay-title="Close Window" { close-window; }
 }
 `,
@@ -270,7 +265,7 @@ func TestNiriGenerateBindsContent(t *testing.T) {
 					Action: "next-window",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
 }
 
 recent-windows {
@@ -331,6 +326,58 @@ 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")
@@ -422,7 +469,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Focus Workspace 1",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Mod+1 hotkey-overlay-title="Focus Workspace 1" { focus-workspace 1; }
 }
 `,
@@ -436,7 +483,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Focus Workspace 10",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Mod+0 hotkey-overlay-title="Focus Workspace 10" { focus-workspace 10; }
 }
 `,
@@ -450,7 +497,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Adjust Column Width -10%",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Super+Minus hotkey-overlay-title="Adjust Column Width -10%" { set-column-width "-10%"; }
 }
 `,
@@ -464,7 +511,7 @@ func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
 					Description: "Adjust Column Width +10%",
 				},
 			},
-			expected: testHeader + `binds {
+			expected: `binds {
     Super+Equal hotkey-overlay-title="Adjust Column Width +10%" { set-column-width "+10%"; }
 }
 `,
@@ -493,7 +540,7 @@ func TestNiriGenerateActionWithUnquotedPercentArg(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := testHeader + `binds {
+	expected := `binds {
     Super+Equal hotkey-overlay-title="Adjust Window Height +10%" { set-window-height "+10%"; }
 }
 `
@@ -514,7 +561,7 @@ func TestNiriGenerateSpawnWithNumericArgs(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := testHeader + `binds {
+	expected := `binds {
     XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
 }
 `
@@ -535,7 +582,7 @@ func TestNiriGenerateSpawnNumericArgFromCLI(t *testing.T) {
 	}
 
 	content := provider.generateBindsContent(binds)
-	expected := testHeader + `binds {
+	expected := `binds {
     XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
 }
 `

core/internal/keybinds/types.go

@@ -8,6 +8,7 @@ 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,6 +16,64 @@ 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},
+	{ID: "emacs", Commands: []string{"emacs"}, ConfigFile: "emacs.toml"},
+}
+
+func (c *ColorMode) GTKTheme() string {
+	switch *c {
+	case ColorModeDark:
+		return "adw-gtk3-dark"
+	default:
+		return "adw-gtk3"
+	}
+}
+
 var (
 	matugenVersionOnce sync.Once
 	matugenSupportsCOE bool
@@ -27,7 +85,7 @@ type Options struct {
 	ConfigDir           string
 	Kind                string
 	Value               string
-	Mode                string
+	Mode                ColorMode
 	IconTheme           string
 	MatugenType         string
 	RunUserTemplates    bool
@@ -35,6 +93,7 @@ type Options struct {
 	SyncModeWithPortal  bool
 	TerminalsAlwaysDark bool
 	SkipTemplates       string
+	AppChecker          utils.AppChecker
 }
 
 type ColorsOutput struct {
@@ -77,7 +136,7 @@ func Run(opts Options) error {
 		return fmt.Errorf("value is required")
 	}
 	if opts.Mode == "" {
-		opts.Mode = "dark"
+		opts.Mode = ColorModeDark
 	}
 	if opts.MatugenType == "" {
 		opts.MatugenType = "scheme-tonal-spot"
@@ -85,6 +144,9 @@ 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)
@@ -145,7 +207,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", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name()}
+		args := []string{"color", "hex", primaryDark, "-m", string(opts.Mode), "-t", opts.MatugenType, "-c", cfgFile.Name()}
 		args = append(args, importArgs...)
 		if err := runMatugen(args); err != nil {
 			return err
@@ -181,7 +243,7 @@ func buildOnce(opts *Options) error {
 		default:
 			args = []string{opts.Kind, opts.Value}
 		}
-		args = append(args, "-m", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name())
+		args = append(args, "-m", string(opts.Mode), "-t", opts.MatugenType, "-c", cfgFile.Name())
 		args = append(args, importArgs...)
 		if err := runMatugen(args); err != nil {
 			return err
@@ -220,7 +282,7 @@ func buildMergedConfig(opts *Options, cfgFile *os.File, tmpDir string) error {
 			if strings.TrimSpace(line) == "[config]" {
 				continue
 			}
-			cfgFile.WriteString(substituteShellDir(line, opts.ShellDir) + "\n")
+			cfgFile.WriteString(substituteVars(line, opts.ShellDir) + "\n")
 		}
 		cfgFile.WriteString("\n")
 	}
@@ -231,70 +293,32 @@ output_path = '%s'
 
 `, opts.ShellDir, opts.ColorsOutput())
 
-	if !opts.ShouldSkipTemplate("gtk") {
-		switch opts.Mode {
-		case "light":
-			appendConfig(opts, cfgFile, "skip", "gtk3-light.toml")
-		default:
-			appendConfig(opts, cfgFile, "skip", "gtk3-dark.toml")
+	homeDir, _ := os.UserHomeDir()
+	for _, tmpl := range templateRegistry {
+		if opts.ShouldSkipTemplate(tmpl.ID) {
+			continue
 		}
-	}
 
-	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)
+		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)
+		}
 	}
 
 	if opts.RunUserTemplates {
@@ -323,28 +347,34 @@ output_path = '%s'
 	return nil
 }
 
-func appendConfig(opts *Options, cfgFile *os.File, checkCmd, fileName string) {
+func appendConfig(
+	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 checkCmd != "skip" && !utils.CommandExists(checkCmd) {
+	if !appExists(opts.AppChecker, checkCmd, checkFlatpaks) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
 	if err != nil {
 		return
 	}
-	cfgFile.WriteString(substituteShellDir(string(data), opts.ShellDir))
+	cfgFile.WriteString(substituteVars(string(data), opts.ShellDir))
 	cfgFile.WriteString("\n")
 }
 
-func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fileName string) {
+func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkCmd []string, checkFlatpaks []string, fileName string) {
 	configPath := filepath.Join(opts.ShellDir, "matugen", "configs", fileName)
 	if _, err := os.Stat(configPath); err != nil {
 		return
 	}
-	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
+	if !appExists(opts.AppChecker, checkCmd, checkFlatpaks) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
@@ -355,7 +385,7 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fil
 	content := string(data)
 
 	if !opts.TerminalsAlwaysDark {
-		cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
+		cfgFile.WriteString(substituteVars(content, opts.ShellDir))
 		cfgFile.WriteString("\n")
 		return
 	}
@@ -393,14 +423,32 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fil
 			fmt.Sprintf("'%s'", tmpPath))
 	}
 
-	cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
+	cfgFile.WriteString(substituteVars(content, opts.ShellDir))
 	cfgFile.WriteString("\n")
 }
 
-func appendVSCodeConfig(cfgFile *os.File, name, extDir, shellDir string) {
-	if _, err := os.Stat(extDir); err != nil {
+func appExists(checker utils.AppChecker, checkCmd []string, checkFlatpaks []string) bool {
+	// Both nil is treated as "skip check" / unconditionally run
+	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'
@@ -420,8 +468,12 @@ output_path = '%s/themes/dankshell-light.json'
 	log.Infof("Added %s theme config (extension found at %s)", name, extDir)
 }
 
-func substituteShellDir(content, shellDir string) string {
-	return strings.ReplaceAll(content, "'SHELL_DIR/", "'"+shellDir+"/")
+func substituteVars(content, shellDir string) string {
+	result := 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 {
@@ -553,19 +605,19 @@ func extractNestedColor(jsonStr, colorName, variant string) string {
 	return color
 }
 
-func generateDank16Variants(primaryDark, primaryLight, surface, mode string) string {
+func generateDank16Variants(primaryDark, primaryLight, surface string, mode ColorMode) string {
 	variantOpts := dank16.VariantOptions{
 		PrimaryDark:  primaryDark,
 		PrimaryLight: primaryLight,
 		Background:   surface,
 		UseDPS:       true,
-		IsLightMode:  mode == "light",
+		IsLightMode:  mode == ColorModeLight,
 	}
 	variantColors := dank16.GenerateVariantPalette(variantOpts)
 	return dank16.GenerateVariantJSON(variantColors)
 }
 
-func refreshGTK(configDir, mode string) {
+func refreshGTK(configDir string, mode ColorMode) {
 	gtkCSS := filepath.Join(configDir, "gtk-3.0", "gtk.css")
 
 	info, err := os.Lstat(gtkCSS)
@@ -591,7 +643,7 @@ func refreshGTK(configDir, mode string) {
 	}
 
 	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "").Run()
-	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "adw-gtk3-"+mode).Run()
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", mode.GTKTheme()).Run()
 }
 
 func signalTerminals() {
@@ -621,9 +673,9 @@ func signalByName(name string, sig syscall.Signal) {
 	}
 }
 
-func syncColorScheme(mode string) {
+func syncColorScheme(mode ColorMode) {
 	scheme := "prefer-dark"
-	if mode == "light" {
+	if mode == ColorModeLight {
 		scheme = "default"
 	}
 
@@ -631,3 +683,52 @@ func syncColorScheme(mode string) {
 		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

@@ -0,0 +1,394 @@
+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

@@ -0,0 +1,242 @@
+// 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/notify/notify.go

@@ -0,0 +1,170 @@
+package notify
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"syscall"
+
+	"github.com/godbus/dbus/v5"
+)
+
+const (
+	notifyDest      = "org.freedesktop.Notifications"
+	notifyPath      = "/org/freedesktop/Notifications"
+	notifyInterface = "org.freedesktop.Notifications"
+)
+
+type Notification struct {
+	AppName  string
+	Icon     string
+	Summary  string
+	Body     string
+	FilePath string
+	Timeout  int32
+}
+
+func Send(n Notification) error {
+	conn, err := dbus.SessionBus()
+	if err != nil {
+		return fmt.Errorf("dbus session failed: %w", err)
+	}
+
+	if n.AppName == "" {
+		n.AppName = "DMS"
+	}
+	if n.Timeout == 0 {
+		n.Timeout = 5000
+	}
+
+	var actions []string
+	if n.FilePath != "" {
+		actions = []string{
+			"open", "Open",
+			"folder", "Open Folder",
+		}
+	}
+
+	hints := map[string]dbus.Variant{}
+	if n.FilePath != "" {
+		hints["image_path"] = dbus.MakeVariant(n.FilePath)
+	}
+
+	obj := conn.Object(notifyDest, notifyPath)
+	call := obj.Call(
+		notifyInterface+".Notify",
+		0,
+		n.AppName,
+		uint32(0),
+		n.Icon,
+		n.Summary,
+		n.Body,
+		actions,
+		hints,
+		n.Timeout,
+	)
+
+	if call.Err != nil {
+		return fmt.Errorf("notify call failed: %w", call.Err)
+	}
+
+	var notificationID uint32
+	if err := call.Store(&notificationID); err != nil {
+		return fmt.Errorf("failed to get notification id: %w", err)
+	}
+
+	if len(actions) > 0 && n.FilePath != "" {
+		spawnActionListener(notificationID, n.FilePath)
+	}
+
+	return nil
+}
+
+func spawnActionListener(notificationID uint32, filePath string) {
+	exe, err := os.Executable()
+	if err != nil {
+		return
+	}
+
+	cmd := exec.Command(exe, "notify-action-generic", fmt.Sprintf("%d", notificationID), filePath)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+	cmd.Start()
+}
+
+func RunActionListener(args []string) {
+	if len(args) < 2 {
+		return
+	}
+
+	notificationID, err := strconv.ParseUint(args[0], 10, 32)
+	if err != nil {
+		return
+	}
+
+	filePath := args[1]
+
+	conn, err := dbus.SessionBus()
+	if err != nil {
+		return
+	}
+
+	if err := conn.AddMatchSignal(
+		dbus.WithMatchObjectPath(notifyPath),
+		dbus.WithMatchInterface(notifyInterface),
+	); err != nil {
+		return
+	}
+
+	signals := make(chan *dbus.Signal, 10)
+	conn.Signal(signals)
+
+	for sig := range signals {
+		switch sig.Name {
+		case notifyInterface + ".ActionInvoked":
+			if len(sig.Body) < 2 {
+				continue
+			}
+			id, ok := sig.Body[0].(uint32)
+			if !ok || id != uint32(notificationID) {
+				continue
+			}
+			action, ok := sig.Body[1].(string)
+			if !ok {
+				continue
+			}
+			handleAction(action, filePath)
+			return
+
+		case notifyInterface + ".NotificationClosed":
+			if len(sig.Body) < 1 {
+				continue
+			}
+			id, ok := sig.Body[0].(uint32)
+			if !ok || id != uint32(notificationID) {
+				continue
+			}
+			return
+		}
+	}
+}
+
+func handleAction(action, filePath string) {
+	switch action {
+	case "open", "default":
+		openPath(filePath)
+	case "folder":
+		openPath(filepath.Dir(filePath))
+	}
+}
+
+func openPath(path string) {
+	cmd := exec.Command("xdg-open", path)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+	cmd.Start()
+}

core/internal/plugins/registry.go

@@ -26,6 +26,7 @@ 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:
+		case 28, 57, 96:
 			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 := req.Params["target"].(string)
+	target, ok := models.Get[string](req, "target")
 	if !ok {
-		target, ok = req.Params["url"].(string)
+		target, ok = models.Get[string](req, "url")
 		if !ok {
 			log.Warnf("AppPicker: Invalid target parameter in request")
 			models.RespondError(conn, req.ID, "invalid target parameter")
@@ -31,14 +31,11 @@ func handleOpen(conn net.Conn, req models.Request, manager *Manager) {
 
 	event := OpenEvent{
 		Target:      target,
-		RequestType: "url",
+		RequestType: models.GetOr(req, "requestType", "url"),
+		MimeType:    models.GetOr(req, "mimeType", ""),
 	}
 
-	if mimeType, ok := req.Params["mimeType"].(string); ok {
-		event.MimeType = mimeType
-	}
-
-	if categories, ok := req.Params["categories"].([]any); ok {
+	if categories, ok := models.Get[[]any](req, "categories"); ok {
 		event.Categories = make([]string, 0, len(categories))
 		for _, cat := range categories {
 			if catStr, ok := cat.(string); ok {
@@ -47,10 +44,6 @@ 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/bluez/manager.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
 	"github.com/godbus/dbus/v5"
 )
 
@@ -110,17 +111,15 @@ func (m *Manager) updateAdapterState() error {
 	if err != nil {
 		return err
 	}
-	powered, _ := poweredVar.Value().(bool)
 
 	discoveringVar, err := obj.GetProperty(adapter1Iface + ".Discovering")
 	if err != nil {
 		return err
 	}
-	discovering, _ := discoveringVar.Value().(bool)
 
 	m.stateMutex.Lock()
-	m.state.Powered = powered
-	m.state.Discovering = discovering
+	m.state.Powered = dbusutil.AsOr(poweredVar, false)
+	m.state.Discovering = dbusutil.AsOr(discoveringVar, false)
 	m.stateMutex.Unlock()
 
 	return nil
@@ -169,65 +168,20 @@ func (m *Manager) updateDevices() error {
 }
 
 func (m *Manager) deviceFromProps(path string, props map[string]dbus.Variant) Device {
-	dev := Device{Path: path}
-
-	if v, ok := props["Address"]; ok {
-		if addr, ok := v.Value().(string); ok {
-			dev.Address = addr
-		}
+	return Device{
+		Path:          path,
+		Address:       dbusutil.GetOr(props, "Address", ""),
+		Name:          dbusutil.GetOr(props, "Name", ""),
+		Alias:         dbusutil.GetOr(props, "Alias", ""),
+		Paired:        dbusutil.GetOr(props, "Paired", false),
+		Trusted:       dbusutil.GetOr(props, "Trusted", false),
+		Blocked:       dbusutil.GetOr(props, "Blocked", false),
+		Connected:     dbusutil.GetOr(props, "Connected", false),
+		Class:         dbusutil.GetOr(props, "Class", uint32(0)),
+		Icon:          dbusutil.GetOr(props, "Icon", ""),
+		RSSI:          dbusutil.GetOr(props, "RSSI", int16(0)),
+		LegacyPairing: dbusutil.GetOr(props, "LegacyPairing", false),
 	}
-	if v, ok := props["Name"]; ok {
-		if name, ok := v.Value().(string); ok {
-			dev.Name = name
-		}
-	}
-	if v, ok := props["Alias"]; ok {
-		if alias, ok := v.Value().(string); ok {
-			dev.Alias = alias
-		}
-	}
-	if v, ok := props["Paired"]; ok {
-		if paired, ok := v.Value().(bool); ok {
-			dev.Paired = paired
-		}
-	}
-	if v, ok := props["Trusted"]; ok {
-		if trusted, ok := v.Value().(bool); ok {
-			dev.Trusted = trusted
-		}
-	}
-	if v, ok := props["Blocked"]; ok {
-		if blocked, ok := v.Value().(bool); ok {
-			dev.Blocked = blocked
-		}
-	}
-	if v, ok := props["Connected"]; ok {
-		if connected, ok := v.Value().(bool); ok {
-			dev.Connected = connected
-		}
-	}
-	if v, ok := props["Class"]; ok {
-		if class, ok := v.Value().(uint32); ok {
-			dev.Class = class
-		}
-	}
-	if v, ok := props["Icon"]; ok {
-		if icon, ok := v.Value().(string); ok {
-			dev.Icon = icon
-		}
-	}
-	if v, ok := props["RSSI"]; ok {
-		if rssi, ok := v.Value().(int16); ok {
-			dev.RSSI = rssi
-		}
-	}
-	if v, ok := props["LegacyPairing"]; ok {
-		if legacy, ok := v.Value().(bool); ok {
-			dev.LegacyPairing = legacy
-		}
-	}
-
-	return dev
 }
 
 func (m *Manager) startAgent() error {
@@ -328,17 +282,13 @@ func (m *Manager) handleAdapterPropertiesChanged(changed map[string]dbus.Variant
 	m.stateMutex.Lock()
 	dirty := false
 
-	if v, ok := changed["Powered"]; ok {
-		if powered, ok := v.Value().(bool); ok {
-			m.state.Powered = powered
-			dirty = true
-		}
+	if powered, ok := dbusutil.Get[bool](changed, "Powered"); ok {
+		m.state.Powered = powered
+		dirty = true
 	}
-	if v, ok := changed["Discovering"]; ok {
-		if discovering, ok := v.Value().(bool); ok {
-			m.state.Discovering = discovering
-			dirty = true
-		}
+	if discovering, ok := dbusutil.Get[bool](changed, "Discovering"); ok {
+		m.state.Discovering = discovering
+		dirty = true
 	}
 
 	m.stateMutex.Unlock()
@@ -349,31 +299,28 @@ func (m *Manager) handleAdapterPropertiesChanged(changed map[string]dbus.Variant
 }
 
 func (m *Manager) handleDevicePropertiesChanged(path dbus.ObjectPath, changed map[string]dbus.Variant) {
-	pairedVar, hasPaired := changed["Paired"]
+	paired, hasPaired := dbusutil.Get[bool](changed, "Paired")
 	_, hasConnected := changed["Connected"]
 	_, hasTrusted := changed["Trusted"]
 
 	if hasPaired {
 		devicePath := string(path)
-		if paired, ok := pairedVar.Value().(bool); ok {
-			if paired {
-				_, wasPending := m.pendingPairings.LoadAndDelete(devicePath)
-
-				if wasPending {
-					select {
-					case m.eventQueue <- func() {
-						time.Sleep(300 * time.Millisecond)
-						log.Infof("[Bluetooth] Auto-connecting newly paired device: %s", devicePath)
-						if err := m.ConnectDevice(devicePath); err != nil {
-							log.Warnf("[Bluetooth] Auto-connect failed: %v", err)
-						}
-					}:
-					default:
+		if paired {
+			_, wasPending := m.pendingPairings.LoadAndDelete(devicePath)
+			if wasPending {
+				select {
+				case m.eventQueue <- func() {
+					time.Sleep(300 * time.Millisecond)
+					log.Infof("[Bluetooth] Auto-connecting newly paired device: %s", devicePath)
+					if err := m.ConnectDevice(devicePath); err != nil {
+						log.Warnf("[Bluetooth] Auto-connect failed: %v", err)
 					}
+				}:
+				default:
 				}
-			} else {
-				m.pendingPairings.Delete(devicePath)
 			}
+		} else {
+			m.pendingPairings.Delete(devicePath)
 		}
 	}
 

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 := req.Params["url"].(string)
+		url, ok := models.Get[string](req, "url")
 		if !ok {
 			models.RespondError(conn, req.ID, "invalid url parameter")
 			return

core/internal/server/clipboard/handlers.go

@@ -37,6 +37,14 @@ func HandleRequest(conn net.Conn, req models.Request, m *Manager) {
 		handleSetConfig(conn, req, m)
 	case "clipboard.store":
 		handleStore(conn, req, m)
+	case "clipboard.pinEntry":
+		handlePinEntry(conn, req, m)
+	case "clipboard.unpinEntry":
+		handleUnpinEntry(conn, req, m)
+	case "clipboard.getPinnedEntries":
+		handleGetPinnedEntries(conn, req, m)
+	case "clipboard.getPinnedCount":
+		handleGetPinnedCount(conn, req, m)
 	default:
 		models.RespondError(conn, req.ID, "unknown method: "+req.Method)
 	}
@@ -168,14 +176,14 @@ func handleSearch(conn net.Conn, req models.Request, m *Manager) {
 		Offset:   params.IntOpt(req.Params, "offset", 0),
 	}
 
-	if img, ok := req.Params["isImage"].(bool); ok {
+	if img, ok := models.Get[bool](req, "isImage"); ok {
 		p.IsImage = &img
 	}
-	if b, ok := req.Params["before"].(float64); ok {
+	if b, ok := models.Get[float64](req, "before"); ok {
 		v := int64(b)
 		p.Before = &v
 	}
-	if a, ok := req.Params["after"].(float64); ok {
+	if a, ok := models.Get[float64](req, "after"); ok {
 		v := int64(a)
 		p.After = &v
 	}
@@ -190,23 +198,23 @@ func handleGetConfig(conn net.Conn, req models.Request, m *Manager) {
 func handleSetConfig(conn net.Conn, req models.Request, m *Manager) {
 	cfg := m.GetConfig()
 
-	if _, ok := req.Params["maxHistory"]; ok {
-		cfg.MaxHistory = params.IntOpt(req.Params, "maxHistory", cfg.MaxHistory)
+	if v, ok := models.Get[float64](req, "maxHistory"); ok {
+		cfg.MaxHistory = int(v)
 	}
-	if _, ok := req.Params["maxEntrySize"]; ok {
-		cfg.MaxEntrySize = int64(params.IntOpt(req.Params, "maxEntrySize", int(cfg.MaxEntrySize)))
+	if v, ok := models.Get[float64](req, "maxEntrySize"); ok {
+		cfg.MaxEntrySize = int64(v)
 	}
-	if _, ok := req.Params["autoClearDays"]; ok {
-		cfg.AutoClearDays = params.IntOpt(req.Params, "autoClearDays", cfg.AutoClearDays)
+	if v, ok := models.Get[float64](req, "autoClearDays"); ok {
+		cfg.AutoClearDays = int(v)
 	}
-	if v, ok := req.Params["clearAtStartup"].(bool); ok {
+	if v, ok := models.Get[bool](req, "clearAtStartup"); ok {
 		cfg.ClearAtStartup = v
 	}
-	if v, ok := req.Params["disabled"].(bool); ok {
+	if v, ok := models.Get[bool](req, "disabled"); ok {
 		cfg.Disabled = v
 	}
-	if v, ok := req.Params["disableHistory"].(bool); ok {
-		cfg.DisableHistory = v
+	if v, ok := models.Get[float64](req, "maxPinned"); ok {
+		cfg.MaxPinned = int(v)
 	}
 
 	if err := m.SetConfig(cfg); err != nil {
@@ -233,3 +241,43 @@ func handleStore(conn net.Conn, req models.Request, m *Manager) {
 
 	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "stored"})
 }
+
+func handlePinEntry(conn net.Conn, req models.Request, m *Manager) {
+	id, err := params.Int(req.Params, "id")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	if err := m.PinEntry(uint64(id)); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "entry pinned"})
+}
+
+func handleUnpinEntry(conn net.Conn, req models.Request, m *Manager) {
+	id, err := params.Int(req.Params, "id")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	if err := m.UnpinEntry(uint64(id)); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "entry unpinned"})
+}
+
+func handleGetPinnedEntries(conn net.Conn, req models.Request, m *Manager) {
+	pinned := m.GetPinnedEntries()
+	models.Respond(conn, req.ID, pinned)
+}
+
+func handleGetPinnedCount(conn net.Conn, req models.Request, m *Manager) {
+	count := m.GetPinnedCount()
+	models.Respond(conn, req.ID, map[string]int{"count": count})
+}

core/internal/server/clipboard/manager.go

@@ -11,30 +11,34 @@ 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"
 )
 
-func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error) {
-	if config.Disabled {
-		return nil, fmt.Errorf("clipboard disabled in config")
-	}
+// These mime types won't be stored in history
+var sensitiveMimeTypes = []string{
+	"x-kde-passwordManagerHint",
+}
 
+func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error) {
 	display := wlCtx.Display()
-	dbPath, err := getDBPath()
+	dbPath, err := clipboardstore.GetDBPath()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get db path: %w", err)
 	}
@@ -54,8 +58,10 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 		dbPath:         dbPath,
 	}
 
-	if err := m.setupRegistry(); err != nil {
-		return nil, err
+	if !config.Disabled {
+		if err := m.setupRegistry(); err != nil {
+			return nil, err
+		}
 	}
 
 	m.notifierWg.Add(1)
@@ -63,17 +69,17 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 
 	go m.watchConfig()
 
-	if !config.DisableHistory {
-		db, err := openDB(dbPath)
-		if err != nil {
-			return nil, fmt.Errorf("failed to open db: %w", err)
-		}
-		m.db = db
+	db, err := openDB(dbPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open db: %w", err)
+	}
+	m.db = db
 
-		if err := m.migrateHashes(); err != nil {
-			log.Errorf("Failed to migrate hashes: %v", err)
-		}
+	if err := m.migrateHashes(); err != nil {
+		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)
@@ -90,31 +96,13 @@ func NewManager(wlCtx wlcontext.WaylandContext, config Config) (*Manager, error)
 	m.alive = true
 	m.updateState()
 
-	if m.dataControlMgr != nil && m.seat != nil {
+	if !config.Disabled && 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,
@@ -253,6 +241,10 @@ func (m *Manager) setupDataDeviceSync() {
 			return
 		}
 
+		if m.hasSensitiveMimeType(mimes) {
+			return
+		}
+
 		preferredMime := m.selectMimeType(mimes)
 		if preferredMime == "" {
 			return
@@ -315,7 +307,7 @@ func (m *Manager) readAndStore(r *os.File, mimeType string) {
 		return
 	}
 
-	if !cfg.DisableHistory && m.db != nil {
+	if !cfg.Disabled && m.db != nil {
 		m.storeClipboardEntry(data, mimeType)
 	}
 
@@ -397,7 +389,11 @@ func (m *Manager) trimLengthInTx(b *bolt.Bucket) error {
 	}
 	c := b.Cursor()
 	var count int
-	for k, _ := c.Last(); k != nil; k, _ = c.Prev() {
+	for k, v := c.Last(); k != nil; k, v = c.Prev() {
+		entry, err := decodeEntry(v)
+		if err == nil && entry.Pinned {
+			continue
+		}
 		if count < m.config.MaxHistory {
 			count++
 			continue
@@ -427,6 +423,11 @@ func encodeEntry(e Entry) ([]byte, error) {
 		buf.WriteByte(0)
 	}
 	binary.Write(buf, binary.BigEndian, e.Hash)
+	if e.Pinned {
+		buf.WriteByte(1)
+	} else {
+		buf.WriteByte(0)
+	}
 
 	return buf.Bytes(), nil
 }
@@ -470,6 +471,12 @@ func decodeEntry(data []byte) (Entry, error) {
 		binary.Read(buf, binary.BigEndian, &e.Hash)
 	}
 
+	if buf.Len() >= 1 {
+		var pinnedByte byte
+		binary.Read(buf, binary.BigEndian, &pinnedByte)
+		e.Pinned = pinnedByte == 1
+	}
+
 	return e, nil
 }
 
@@ -492,6 +499,12 @@ 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",
@@ -737,19 +750,54 @@ func (m *Manager) ClearHistory() {
 		return
 	}
 
+	// Delete only non-pinned entries
 	if err := m.db.Update(func(tx *bolt.Tx) error {
-		if err := tx.DeleteBucket([]byte("clipboard")); err != nil {
-			return err
+		b := tx.Bucket([]byte("clipboard"))
+		if b == nil {
+			return nil
 		}
-		_, err := tx.CreateBucket([]byte("clipboard"))
-		return err
+
+		var toDelete [][]byte
+		c := b.Cursor()
+		for k, v := c.First(); k != nil; k, v = c.Next() {
+			entry, err := decodeEntry(v)
+			if err != nil || !entry.Pinned {
+				toDelete = append(toDelete, k)
+			}
+		}
+
+		for _, k := range toDelete {
+			if err := b.Delete(k); err != nil {
+				return err
+			}
+		}
+		return nil
 	}); err != nil {
 		log.Errorf("Failed to clear clipboard history: %v", err)
 		return
 	}
 
-	if err := m.compactDB(); err != nil {
-		log.Errorf("Failed to compact database: %v", err)
+	pinnedCount := 0
+	if err := m.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		if b != nil {
+			c := b.Cursor()
+			for k, v := c.First(); k != nil; k, v = c.Next() {
+				entry, _ := decodeEntry(v)
+				if entry.Pinned {
+					pinnedCount++
+				}
+			}
+		}
+		return nil
+	}); err != nil {
+		log.Errorf("Failed to count pinned entries: %v", err)
+	}
+
+	if pinnedCount == 0 {
+		if err := m.compactDB(); err != nil {
+			log.Errorf("Failed to compact database: %v", err)
+		}
 	}
 
 	m.updateState()
@@ -962,6 +1010,10 @@ func (m *Manager) clearOldEntries(days int) error {
 			if err != nil {
 				continue
 			}
+			// Skip pinned entries
+			if entry.Pinned {
+				continue
+			}
 			if entry.Timestamp.Before(cutoff) {
 				toDelete = append(toDelete, k)
 			}
@@ -1194,23 +1246,13 @@ func (m *Manager) applyConfigChange(newCfg Config) {
 	m.config = newCfg
 	m.configMutex.Unlock()
 
-	if newCfg.DisableHistory && !oldCfg.DisableHistory && m.db != nil {
-		log.Info("Clipboard history disabled, closing database")
-		m.db.Close()
-		m.db = nil
+	switch {
+	case newCfg.Disabled && !oldCfg.Disabled:
+		log.Info("Clipboard tracking disabled")
+	case !newCfg.Disabled && oldCfg.Disabled:
+		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()
 }
@@ -1218,8 +1260,8 @@ func (m *Manager) applyConfigChange(newCfg Config) {
 func (m *Manager) StoreData(data []byte, mimeType string) error {
 	cfg := m.getConfig()
 
-	if cfg.DisableHistory {
-		return fmt.Errorf("clipboard history disabled")
+	if cfg.Disabled {
+		return fmt.Errorf("clipboard tracking disabled")
 	}
 
 	if m.db == nil {
@@ -1262,3 +1304,153 @@ func (m *Manager) StoreData(data []byte, mimeType string) error {
 
 	return nil
 }
+
+func (m *Manager) PinEntry(id uint64) error {
+	if m.db == nil {
+		return fmt.Errorf("database not available")
+	}
+
+	// Check pinned count
+	cfg := m.getConfig()
+	pinnedCount := 0
+	if err := m.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		if b == nil {
+			return nil
+		}
+		c := b.Cursor()
+		for k, v := c.First(); k != nil; k, v = c.Next() {
+			entry, err := decodeEntry(v)
+			if err == nil && entry.Pinned {
+				pinnedCount++
+			}
+		}
+		return nil
+	}); err != nil {
+		log.Errorf("Failed to count pinned entries: %v", err)
+	}
+
+	if pinnedCount >= cfg.MaxPinned {
+		return fmt.Errorf("maximum pinned entries reached (%d)", cfg.MaxPinned)
+	}
+
+	err := m.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		v := b.Get(itob(id))
+		if v == nil {
+			return fmt.Errorf("entry not found")
+		}
+
+		entry, err := decodeEntry(v)
+		if err != nil {
+			return err
+		}
+
+		entry.Pinned = true
+		encoded, err := encodeEntry(entry)
+		if err != nil {
+			return err
+		}
+
+		return b.Put(itob(id), encoded)
+	})
+
+	if err == nil {
+		m.updateState()
+		m.notifySubscribers()
+	}
+
+	return err
+}
+
+func (m *Manager) UnpinEntry(id uint64) error {
+	if m.db == nil {
+		return fmt.Errorf("database not available")
+	}
+
+	err := m.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		v := b.Get(itob(id))
+		if v == nil {
+			return fmt.Errorf("entry not found")
+		}
+
+		entry, err := decodeEntry(v)
+		if err != nil {
+			return err
+		}
+
+		entry.Pinned = false
+		encoded, err := encodeEntry(entry)
+		if err != nil {
+			return err
+		}
+
+		return b.Put(itob(id), encoded)
+	})
+
+	if err == nil {
+		m.updateState()
+		m.notifySubscribers()
+	}
+
+	return err
+}
+
+func (m *Manager) GetPinnedEntries() []Entry {
+	if m.db == nil {
+		return nil
+	}
+
+	var pinned []Entry
+	if err := m.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		if b == nil {
+			return nil
+		}
+
+		c := b.Cursor()
+		for k, v := c.Last(); k != nil; k, v = c.Prev() {
+			entry, err := decodeEntry(v)
+			if err != nil {
+				continue
+			}
+			if entry.Pinned {
+				entry.Data = nil
+				pinned = append(pinned, entry)
+			}
+		}
+		return nil
+	}); err != nil {
+		log.Errorf("Failed to get pinned entries: %v", err)
+	}
+
+	return pinned
+}
+
+func (m *Manager) GetPinnedCount() int {
+	if m.db == nil {
+		return 0
+	}
+
+	count := 0
+	if err := m.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte("clipboard"))
+		if b == nil {
+			return nil
+		}
+
+		c := b.Cursor()
+		for k, v := c.First(); k != nil; k, v = c.Next() {
+			entry, err := decodeEntry(v)
+			if err == nil && entry.Pinned {
+				count++
+			}
+		}
+		return nil
+	}); err != nil {
+		log.Errorf("Failed to count pinned entries: %v", err)
+	}
+
+	return count
+}

core/internal/server/clipboard/manager_test.go

@@ -457,7 +457,6 @@ 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,9 +18,8 @@ type Config struct {
 	MaxEntrySize   int64 `json:"maxEntrySize"`
 	AutoClearDays  int   `json:"autoClearDays"`
 	ClearAtStartup bool  `json:"clearAtStartup"`
-
-	Disabled       bool `json:"disabled"`
-	DisableHistory bool `json:"disableHistory"`
+	Disabled       bool  `json:"disabled"`
+	MaxPinned      int   `json:"maxPinned"`
 }
 
 func DefaultConfig() Config {
@@ -29,6 +28,7 @@ func DefaultConfig() Config {
 		MaxEntrySize:   5 * 1024 * 1024,
 		AutoClearDays:  0,
 		ClearAtStartup: false,
+		MaxPinned:      25,
 	}
 }
 
@@ -102,6 +102,7 @@ type Entry struct {
 	Timestamp time.Time `json:"timestamp"`
 	IsImage   bool      `json:"isImage"`
 	Hash      uint64    `json:"hash,omitempty"`
+	Pinned    bool      `json:"pinned"`
 }
 
 type State struct {

core/internal/server/dbus/handlers.go

@@ -0,0 +1,237 @@
+package dbus
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
+)
+
+type objectParams struct {
+	bus   string
+	dest  string
+	path  string
+	iface string
+}
+
+func extractObjectParams(p map[string]any, requirePath bool) (objectParams, error) {
+	bus, err := params.String(p, "bus")
+	if err != nil {
+		return objectParams{}, err
+	}
+	dest, err := params.String(p, "dest")
+	if err != nil {
+		return objectParams{}, err
+	}
+
+	var path string
+	if requirePath {
+		path, err = params.String(p, "path")
+		if err != nil {
+			return objectParams{}, err
+		}
+	} else {
+		path = params.StringOpt(p, "path", "/")
+	}
+
+	iface, err := params.String(p, "interface")
+	if err != nil {
+		return objectParams{}, err
+	}
+
+	return objectParams{bus: bus, dest: dest, path: path, iface: iface}, nil
+}
+
+func HandleRequest(conn net.Conn, req models.Request, m *Manager, clientID string) {
+	switch req.Method {
+	case "dbus.call":
+		handleCall(conn, req, m)
+	case "dbus.getProperty":
+		handleGetProperty(conn, req, m)
+	case "dbus.setProperty":
+		handleSetProperty(conn, req, m)
+	case "dbus.getAllProperties":
+		handleGetAllProperties(conn, req, m)
+	case "dbus.introspect":
+		handleIntrospect(conn, req, m)
+	case "dbus.listNames":
+		handleListNames(conn, req, m)
+	case "dbus.subscribe":
+		handleSubscribe(conn, req, m, clientID)
+	case "dbus.unsubscribe":
+		handleUnsubscribe(conn, req, m)
+	default:
+		models.RespondError(conn, req.ID, fmt.Sprintf("unknown method: %s", req.Method))
+	}
+}
+
+func handleCall(conn net.Conn, req models.Request, m *Manager) {
+	op, err := extractObjectParams(req.Params, true)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	method, err := params.String(req.Params, "method")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	var args []any
+	if argsRaw, ok := params.Any(req.Params, "args"); ok {
+		if argsSlice, ok := argsRaw.([]any); ok {
+			args = argsSlice
+		}
+	}
+
+	result, err := m.Call(op.bus, op.dest, op.path, op.iface, method, args)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleGetProperty(conn net.Conn, req models.Request, m *Manager) {
+	op, err := extractObjectParams(req.Params, true)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	property, err := params.String(req.Params, "property")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	result, err := m.GetProperty(op.bus, op.dest, op.path, op.iface, property)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleSetProperty(conn net.Conn, req models.Request, m *Manager) {
+	op, err := extractObjectParams(req.Params, true)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	property, err := params.String(req.Params, "property")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	value, ok := params.Any(req.Params, "value")
+	if !ok {
+		models.RespondError(conn, req.ID, "missing 'value' parameter")
+		return
+	}
+
+	if err := m.SetProperty(op.bus, op.dest, op.path, op.iface, property, value); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true})
+}
+
+func handleGetAllProperties(conn net.Conn, req models.Request, m *Manager) {
+	op, err := extractObjectParams(req.Params, true)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	result, err := m.GetAllProperties(op.bus, op.dest, op.path, op.iface)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleIntrospect(conn net.Conn, req models.Request, m *Manager) {
+	bus, err := params.String(req.Params, "bus")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	dest, err := params.String(req.Params, "dest")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	path := params.StringOpt(req.Params, "path", "/")
+
+	result, err := m.Introspect(bus, dest, path)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleListNames(conn net.Conn, req models.Request, m *Manager) {
+	bus, err := params.String(req.Params, "bus")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	result, err := m.ListNames(bus)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleSubscribe(conn net.Conn, req models.Request, m *Manager, clientID string) {
+	bus, err := params.String(req.Params, "bus")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	sender := params.StringOpt(req.Params, "sender", "")
+	path := params.StringOpt(req.Params, "path", "")
+	iface := params.StringOpt(req.Params, "interface", "")
+	member := params.StringOpt(req.Params, "member", "")
+
+	result, err := m.Subscribe(clientID, bus, sender, path, iface, member)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, result)
+}
+
+func handleUnsubscribe(conn net.Conn, req models.Request, m *Manager) {
+	subID, err := params.String(req.Params, "subscriptionId")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	if err := m.Unsubscribe(subID); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true})
+}

core/internal/server/dbus/manager.go

@@ -0,0 +1,362 @@
+package dbus
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
+	"github.com/godbus/dbus/v5"
+)
+
+func NewManager() (*Manager, error) {
+	systemConn, err := dbus.ConnectSystemBus()
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to system bus: %w", err)
+	}
+
+	sessionConn, err := dbus.ConnectSessionBus()
+	if err != nil {
+		systemConn.Close()
+		return nil, fmt.Errorf("failed to connect to session bus: %w", err)
+	}
+
+	m := &Manager{
+		systemConn:  systemConn,
+		sessionConn: sessionConn,
+	}
+
+	go m.processSystemSignals()
+	go m.processSessionSignals()
+
+	return m, nil
+}
+
+func (m *Manager) getConn(bus string) (*dbus.Conn, error) {
+	switch bus {
+	case "system":
+		if m.systemConn == nil {
+			return nil, fmt.Errorf("system bus not connected")
+		}
+		return m.systemConn, nil
+	case "session":
+		if m.sessionConn == nil {
+			return nil, fmt.Errorf("session bus not connected")
+		}
+		return m.sessionConn, nil
+	default:
+		return nil, fmt.Errorf("invalid bus: %s (must be 'system' or 'session')", bus)
+	}
+}
+
+func (m *Manager) Call(bus, dest, path, iface, method string, args []any) (*CallResult, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	obj := conn.Object(dest, dbus.ObjectPath(path))
+	fullMethod := iface + "." + method
+
+	call := obj.Call(fullMethod, 0, args...)
+	if call.Err != nil {
+		return nil, fmt.Errorf("dbus call failed: %w", call.Err)
+	}
+
+	return &CallResult{Values: call.Body}, nil
+}
+
+func (m *Manager) GetProperty(bus, dest, path, iface, property string) (*PropertyResult, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	obj := conn.Object(dest, dbus.ObjectPath(path))
+
+	var variant dbus.Variant
+	err = obj.Call("org.freedesktop.DBus.Properties.Get", 0, iface, property).Store(&variant)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get property: %w", err)
+	}
+
+	return &PropertyResult{Value: dbusutil.Normalize(variant.Value())}, nil
+}
+
+func (m *Manager) SetProperty(bus, dest, path, iface, property string, value any) error {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return err
+	}
+
+	obj := conn.Object(dest, dbus.ObjectPath(path))
+
+	call := obj.Call("org.freedesktop.DBus.Properties.Set", 0, iface, property, dbus.MakeVariant(value))
+	if call.Err != nil {
+		return fmt.Errorf("failed to set property: %w", call.Err)
+	}
+
+	return nil
+}
+
+func (m *Manager) GetAllProperties(bus, dest, path, iface string) (map[string]any, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	obj := conn.Object(dest, dbus.ObjectPath(path))
+
+	var props map[string]dbus.Variant
+	err = obj.Call("org.freedesktop.DBus.Properties.GetAll", 0, iface).Store(&props)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get properties: %w", err)
+	}
+
+	result := make(map[string]any)
+	for k, v := range props {
+		result[k] = dbusutil.Normalize(v.Value())
+	}
+
+	return result, nil
+}
+
+func (m *Manager) Introspect(bus, dest, path string) (*IntrospectResult, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	obj := conn.Object(dest, dbus.ObjectPath(path))
+
+	var xml string
+	err = obj.Call("org.freedesktop.DBus.Introspectable.Introspect", 0).Store(&xml)
+	if err != nil {
+		return nil, fmt.Errorf("failed to introspect: %w", err)
+	}
+
+	return &IntrospectResult{XML: xml}, nil
+}
+
+func (m *Manager) ListNames(bus string) (*ListNamesResult, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	var names []string
+	err = conn.BusObject().Call("org.freedesktop.DBus.ListNames", 0).Store(&names)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list names: %w", err)
+	}
+
+	return &ListNamesResult{Names: names}, nil
+}
+
+func (m *Manager) Subscribe(clientID, bus, sender, path, iface, member string) (*SubscribeResult, error) {
+	conn, err := m.getConn(bus)
+	if err != nil {
+		return nil, err
+	}
+
+	subID := generateSubscriptionID()
+
+	parts := []string{"type='signal'"}
+	if sender != "" {
+		parts = append(parts, fmt.Sprintf("sender='%s'", sender))
+	}
+	if path != "" {
+		parts = append(parts, fmt.Sprintf("path='%s'", path))
+	}
+	if iface != "" {
+		parts = append(parts, fmt.Sprintf("interface='%s'", iface))
+	}
+	if member != "" {
+		parts = append(parts, fmt.Sprintf("member='%s'", member))
+	}
+	matchRule := strings.Join(parts, ",")
+
+	call := conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, matchRule)
+	if call.Err != nil {
+		return nil, fmt.Errorf("failed to add match rule: %w", call.Err)
+	}
+
+	sub := &signalSubscription{
+		Bus:       bus,
+		Sender:    sender,
+		Path:      path,
+		Interface: iface,
+		Member:    member,
+		ClientID:  clientID,
+	}
+	m.subscriptions.Store(subID, sub)
+
+	log.Debugf("dbus: subscribed %s to %s", subID, matchRule)
+
+	return &SubscribeResult{SubscriptionID: subID}, nil
+}
+
+func (m *Manager) Unsubscribe(subID string) error {
+	sub, ok := m.subscriptions.LoadAndDelete(subID)
+	if !ok {
+		return fmt.Errorf("subscription not found: %s", subID)
+	}
+
+	conn, err := m.getConn(sub.Bus)
+	if err != nil {
+		return err
+	}
+
+	parts := []string{"type='signal'"}
+	if sub.Sender != "" {
+		parts = append(parts, fmt.Sprintf("sender='%s'", sub.Sender))
+	}
+	if sub.Path != "" {
+		parts = append(parts, fmt.Sprintf("path='%s'", sub.Path))
+	}
+	if sub.Interface != "" {
+		parts = append(parts, fmt.Sprintf("interface='%s'", sub.Interface))
+	}
+	if sub.Member != "" {
+		parts = append(parts, fmt.Sprintf("member='%s'", sub.Member))
+	}
+	matchRule := strings.Join(parts, ",")
+
+	call := conn.BusObject().Call("org.freedesktop.DBus.RemoveMatch", 0, matchRule)
+	if call.Err != nil {
+		log.Warnf("dbus: failed to remove match rule: %v", call.Err)
+	}
+
+	log.Debugf("dbus: unsubscribed %s", subID)
+
+	return nil
+}
+
+func (m *Manager) UnsubscribeClient(clientID string) {
+	var toDelete []string
+	m.subscriptions.Range(func(subID string, sub *signalSubscription) bool {
+		if sub.ClientID == clientID {
+			toDelete = append(toDelete, subID)
+		}
+		return true
+	})
+
+	for _, subID := range toDelete {
+		if err := m.Unsubscribe(subID); err != nil {
+			log.Warnf("dbus: failed to unsubscribe %s: %v", subID, err)
+		}
+	}
+}
+
+func (m *Manager) SubscribeSignals(clientID string) chan SignalEvent {
+	ch := make(chan SignalEvent, 64)
+	existing, loaded := m.signalSubscribers.LoadOrStore(clientID, ch)
+	if loaded {
+		return existing
+	}
+	return ch
+}
+
+func (m *Manager) UnsubscribeSignals(clientID string) {
+	if ch, ok := m.signalSubscribers.LoadAndDelete(clientID); ok {
+		close(ch)
+	}
+	m.UnsubscribeClient(clientID)
+}
+
+func (m *Manager) processSystemSignals() {
+	if m.systemConn == nil {
+		return
+	}
+	ch := make(chan *dbus.Signal, 256)
+	m.systemConn.Signal(ch)
+
+	for sig := range ch {
+		m.dispatchSignal("system", sig)
+	}
+}
+
+func (m *Manager) processSessionSignals() {
+	if m.sessionConn == nil {
+		return
+	}
+	ch := make(chan *dbus.Signal, 256)
+	m.sessionConn.Signal(ch)
+
+	for sig := range ch {
+		m.dispatchSignal("session", sig)
+	}
+}
+
+func (m *Manager) dispatchSignal(bus string, sig *dbus.Signal) {
+	path := string(sig.Path)
+	iface := ""
+	member := sig.Name
+
+	if idx := strings.LastIndex(sig.Name, "."); idx != -1 {
+		iface = sig.Name[:idx]
+		member = sig.Name[idx+1:]
+	}
+
+	m.subscriptions.Range(func(subID string, sub *signalSubscription) bool {
+		if sub.Bus != bus {
+			return true
+		}
+		if sub.Path != "" && sub.Path != path && !strings.HasPrefix(path, sub.Path) {
+			return true
+		}
+		if sub.Interface != "" && sub.Interface != iface {
+			return true
+		}
+		if sub.Member != "" && sub.Member != member {
+			return true
+		}
+
+		event := SignalEvent{
+			SubscriptionID: subID,
+			Sender:         sig.Sender,
+			Path:           path,
+			Interface:      iface,
+			Member:         member,
+			Body:           dbusutil.NormalizeSlice(sig.Body),
+		}
+
+		ch, ok := m.signalSubscribers.Load(sub.ClientID)
+		if !ok {
+			return true
+		}
+
+		select {
+		case ch <- event:
+		default:
+			log.Warnf("dbus: channel full for %s, dropping signal", subID)
+		}
+
+		return true
+	})
+}
+
+func (m *Manager) Close() {
+	m.signalSubscribers.Range(func(clientID string, ch chan SignalEvent) bool {
+		close(ch)
+		m.signalSubscribers.Delete(clientID)
+		return true
+	})
+
+	if m.systemConn != nil {
+		m.systemConn.Close()
+	}
+	if m.sessionConn != nil {
+		m.sessionConn.Close()
+	}
+}
+
+func generateSubscriptionID() string {
+	b := make([]byte, 8)
+	if _, err := rand.Read(b); err != nil {
+		log.Warnf("dbus: failed to generate random subscription ID: %v", err)
+	}
+	return hex.EncodeToString(b)
+}

core/internal/server/dbus/types.go

@@ -0,0 +1,52 @@
+package dbus
+
+import (
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
+	"github.com/godbus/dbus/v5"
+)
+
+type Manager struct {
+	systemConn  *dbus.Conn
+	sessionConn *dbus.Conn
+
+	subscriptions     syncmap.Map[string, *signalSubscription]
+	signalSubscribers syncmap.Map[string, chan SignalEvent]
+}
+
+type signalSubscription struct {
+	Bus       string
+	Sender    string
+	Path      string
+	Interface string
+	Member    string
+	ClientID  string
+}
+
+type SignalEvent struct {
+	SubscriptionID string `json:"subscriptionId"`
+	Sender         string `json:"sender"`
+	Path           string `json:"path"`
+	Interface      string `json:"interface"`
+	Member         string `json:"member"`
+	Body           []any  `json:"body"`
+}
+
+type CallResult struct {
+	Values []any `json:"values"`
+}
+
+type PropertyResult struct {
+	Value any `json:"value"`
+}
+
+type IntrospectResult struct {
+	XML string `json:"xml"`
+}
+
+type ListNamesResult struct {
+	Names []string `json:"names"`
+}
+
+type SubscribeResult struct {
+	SubscriptionID string `json:"subscriptionId"`
+}

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 := req.Params["output"].(string)
+	output, ok := models.Get[string](req, "output")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	tagmask, ok := req.Params["tagmask"].(float64)
+	tagmask, ok := models.Get[float64](req, "tagmask")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'tagmask' parameter")
 		return
 	}
 
-	toggleTagset, ok := req.Params["toggleTagset"].(float64)
+	toggleTagset, ok := models.Get[float64](req, "toggleTagset")
 	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 := req.Params["output"].(string)
+	output, ok := models.Get[string](req, "output")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	andTags, ok := req.Params["andTags"].(float64)
+	andTags, ok := models.Get[float64](req, "andTags")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'andTags' parameter")
 		return
 	}
 
-	xorTags, ok := req.Params["xorTags"].(float64)
+	xorTags, ok := models.Get[float64](req, "xorTags")
 	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 := req.Params["output"].(string)
+	output, ok := models.Get[string](req, "output")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
 		return
 	}
 
-	index, ok := req.Params["index"].(float64)
+	index, ok := models.Get[float64](req, "index")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'index' parameter")
 		return

core/internal/server/extworkspace/handlers.go

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

core/internal/server/freedesktop/manager.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"sync"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
 	"github.com/godbus/dbus/v5"
 )
 
@@ -110,61 +111,17 @@ func (m *Manager) updateAccountsState() error {
 	m.stateMutex.Lock()
 	defer m.stateMutex.Unlock()
 
-	if v, ok := props["IconFile"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.IconFile = val
-		}
-	}
-	if v, ok := props["RealName"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.RealName = val
-		}
-	}
-	if v, ok := props["UserName"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.UserName = val
-		}
-	}
-	if v, ok := props["AccountType"]; ok {
-		if val, ok := v.Value().(int32); ok {
-			m.state.Accounts.AccountType = val
-		}
-	}
-	if v, ok := props["HomeDirectory"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.HomeDirectory = val
-		}
-	}
-	if v, ok := props["Shell"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.Shell = val
-		}
-	}
-	if v, ok := props["Email"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.Email = val
-		}
-	}
-	if v, ok := props["Language"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.Language = val
-		}
-	}
-	if v, ok := props["Location"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Accounts.Location = val
-		}
-	}
-	if v, ok := props["Locked"]; ok {
-		if val, ok := v.Value().(bool); ok {
-			m.state.Accounts.Locked = val
-		}
-	}
-	if v, ok := props["PasswordMode"]; ok {
-		if val, ok := v.Value().(int32); ok {
-			m.state.Accounts.PasswordMode = val
-		}
-	}
+	m.state.Accounts.IconFile = dbusutil.GetOr(props, "IconFile", "")
+	m.state.Accounts.RealName = dbusutil.GetOr(props, "RealName", "")
+	m.state.Accounts.UserName = dbusutil.GetOr(props, "UserName", "")
+	m.state.Accounts.AccountType = dbusutil.GetOr(props, "AccountType", int32(0))
+	m.state.Accounts.HomeDirectory = dbusutil.GetOr(props, "HomeDirectory", "")
+	m.state.Accounts.Shell = dbusutil.GetOr(props, "Shell", "")
+	m.state.Accounts.Email = dbusutil.GetOr(props, "Email", "")
+	m.state.Accounts.Language = dbusutil.GetOr(props, "Language", "")
+	m.state.Accounts.Location = dbusutil.GetOr(props, "Location", "")
+	m.state.Accounts.Locked = dbusutil.GetOr(props, "Locked", false)
+	m.state.Accounts.PasswordMode = dbusutil.GetOr(props, "PasswordMode", int32(0))
 
 	return nil
 }
@@ -180,7 +137,7 @@ func (m *Manager) updateSettingsState() error {
 		return err
 	}
 
-	if colorScheme, ok := variant.Value().(uint32); ok {
+	if colorScheme, ok := dbusutil.As[uint32](variant); ok {
 		m.stateMutex.Lock()
 		m.state.Settings.ColorScheme = colorScheme
 		m.stateMutex.Unlock()

core/internal/server/loginctl/manager.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
 	"github.com/godbus/dbus/v5"
 )
 
@@ -132,37 +133,15 @@ func (m *Manager) updateSessionState() error {
 	m.stateMutex.Lock()
 	defer m.stateMutex.Unlock()
 
-	if v, ok := props["Active"]; ok {
-		if val, ok := v.Value().(bool); ok {
-			m.state.Active = val
-		}
-	}
-	if v, ok := props["IdleHint"]; ok {
-		if val, ok := v.Value().(bool); ok {
-			m.state.IdleHint = val
-		}
-	}
-	if v, ok := props["IdleSinceHint"]; ok {
-		if val, ok := v.Value().(uint64); ok {
-			m.state.IdleSinceHint = val
-		}
-	}
-	if v, ok := props["LockedHint"]; ok {
-		if val, ok := v.Value().(bool); ok {
-			m.state.LockedHint = val
-			m.state.Locked = val
-		}
-	}
-	if v, ok := props["Type"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.SessionType = val
-		}
-	}
-	if v, ok := props["Class"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.SessionClass = val
-		}
+	m.state.Active = dbusutil.GetOr(props, "Active", m.state.Active)
+	m.state.IdleHint = dbusutil.GetOr(props, "IdleHint", m.state.IdleHint)
+	m.state.IdleSinceHint = dbusutil.GetOr(props, "IdleSinceHint", m.state.IdleSinceHint)
+	if lockedHint, ok := dbusutil.Get[bool](props, "LockedHint"); ok {
+		m.state.LockedHint = lockedHint
+		m.state.Locked = lockedHint
 	}
+	m.state.SessionType = dbusutil.GetOr(props, "Type", m.state.SessionType)
+	m.state.SessionClass = dbusutil.GetOr(props, "Class", m.state.SessionClass)
 	if v, ok := props["User"]; ok {
 		if userArr, ok := v.Value().([]any); ok && len(userArr) >= 1 {
 			if uid, ok := userArr[0].(uint32); ok {
@@ -170,36 +149,12 @@ func (m *Manager) updateSessionState() error {
 			}
 		}
 	}
-	if v, ok := props["Name"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.UserName = val
-		}
-	}
-	if v, ok := props["RemoteHost"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.RemoteHost = val
-		}
-	}
-	if v, ok := props["Service"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Service = val
-		}
-	}
-	if v, ok := props["TTY"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.TTY = val
-		}
-	}
-	if v, ok := props["Display"]; ok {
-		if val, ok := v.Value().(string); ok {
-			m.state.Display = val
-		}
-	}
-	if v, ok := props["Remote"]; ok {
-		if val, ok := v.Value().(bool); ok {
-			m.state.Remote = val
-		}
-	}
+	m.state.UserName = dbusutil.GetOr(props, "Name", m.state.UserName)
+	m.state.RemoteHost = dbusutil.GetOr(props, "RemoteHost", m.state.RemoteHost)
+	m.state.Service = dbusutil.GetOr(props, "Service", m.state.Service)
+	m.state.TTY = dbusutil.GetOr(props, "TTY", m.state.TTY)
+	m.state.Display = dbusutil.GetOr(props, "Display", m.state.Display)
+	m.state.Remote = dbusutil.GetOr(props, "Remote", m.state.Remote)
 	if v, ok := props["Seat"]; ok {
 		if seatArr, ok := v.Value().([]any); ok && len(seatArr) >= 1 {
 			if seatID, ok := seatArr[0].(string); ok {
@@ -207,11 +162,7 @@ func (m *Manager) updateSessionState() error {
 			}
 		}
 	}
-	if v, ok := props["VTNr"]; ok {
-		if val, ok := v.Value().(uint32); ok {
-			m.state.VTNr = val
-		}
-	}
+	m.state.VTNr = dbusutil.GetOr(props, "VTNr", m.state.VTNr)
 
 	return nil
 }

core/internal/server/loginctl/monitor.go

@@ -3,6 +3,7 @@ package loginctl
 import (
 	"time"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
 	"github.com/godbus/dbus/v5"
 )
 
@@ -117,31 +118,28 @@ func (m *Manager) handlePropertiesChanged(sig *dbus.Signal) {
 	for key, variant := range changes {
 		switch key {
 		case "Active":
-			if val, ok := variant.Value().(bool); ok {
+			if val, ok := dbusutil.As[bool](variant); ok {
 				m.stateMutex.Lock()
 				m.state.Active = val
 				m.stateMutex.Unlock()
 				needsUpdate = true
 			}
-
 		case "IdleHint":
-			if val, ok := variant.Value().(bool); ok {
+			if val, ok := dbusutil.As[bool](variant); ok {
 				m.stateMutex.Lock()
 				m.state.IdleHint = val
 				m.stateMutex.Unlock()
 				needsUpdate = true
 			}
-
 		case "IdleSinceHint":
-			if val, ok := variant.Value().(uint64); ok {
+			if val, ok := dbusutil.As[uint64](variant); ok {
 				m.stateMutex.Lock()
 				m.state.IdleSinceHint = val
 				m.stateMutex.Unlock()
 				needsUpdate = true
 			}
-
 		case "LockedHint":
-			if val, ok := variant.Value().(bool); ok {
+			if val, ok := dbusutil.As[bool](variant); ok {
 				m.stateMutex.Lock()
 				m.state.LockedHint = val
 				m.state.Locked = val

core/internal/server/matugen_handler.go

@@ -15,37 +15,23 @@ type MatugenQueueResult struct {
 }
 
 func handleMatugenQueue(conn net.Conn, req models.Request) {
-	getString := func(key string) string {
-		if v, ok := req.Params[key].(string); ok {
-			return v
-		}
-		return ""
-	}
-
-	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"),
+		StateDir:            models.GetOr(req, "stateDir", ""),
+		ShellDir:            models.GetOr(req, "shellDir", ""),
+		ConfigDir:           models.GetOr(req, "configDir", ""),
+		Kind:                models.GetOr(req, "kind", ""),
+		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 := getBool("wait", true)
+	wait := models.GetOr(req, "wait", true)
 
 	queue := matugen.GetQueue()
 	resultCh := queue.Submit(opts)

core/internal/server/models/types.go

@@ -5,6 +5,7 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
 type Request struct {
@@ -13,6 +14,15 @@ 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

@@ -0,0 +1,52 @@
+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)
+	}
+}