dankinstall fix plasma session collision

* dankmodal: removed backgroundWindow

removed 'backgroundWindow' but combined it with 'contentWindow'

* made single window behavior specific to hyprland

this should keep other compositor behavior the same and fix double
clicking to exit out of Spotlight/ClipboardHist/Powermenu

.github/workflows/nix-pr-check.yml

@@ -10,21 +10,14 @@ jobs:
   check-flake:
     runs-on: ubuntu-latest
     steps:
-      - 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: Install Nix
         uses: cachix/install-nix-action@v31
 
-      - name: Update vendorHash in flake.nix
+      - name: Check the flake
         run: nix flake check

.github/workflows/release.yml

@@ -1,16 +1,19 @@
 name: Release
 
 on:
-  push:
-    tags:
-      - 'v*'
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to release (e.g., v1.0.1)"
+        required: true
+        type: string
 
 permissions:
   contents: write
   actions: write
 
 concurrency:
-  group: release-${{ github.ref_name }}
+  group: release-${{ inputs.tag }}
   cancel-in-progress: true
 
 jobs:
@@ -24,10 +27,14 @@ jobs:
       run:
         working-directory: core
 
+    env:
+      TAG: ${{ inputs.tag }}
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
+          ref: ${{ inputs.tag }}
           fetch-depth: 0
 
       - name: Set up Go
@@ -54,7 +61,7 @@ jobs:
         run: |
           set -eux
           cd cmd/dankinstall
-          go build -trimpath -ldflags "-s -w -X main.Version=${GITHUB_REF#refs/tags/}" \
+          go build -trimpath -ldflags "-s -w -X main.Version=${TAG}" \
             -o ../../dankinstall-${{ matrix.arch }}
           cd ../..
           gzip -9 -k dankinstall-${{ matrix.arch }}
@@ -68,7 +75,7 @@ jobs:
         run: |
           set -eux
           cd cmd/dms
-          go build -trimpath -ldflags "-s -w -X main.Version=${GITHUB_REF#refs/tags/}" \
+          go build -trimpath -ldflags "-s -w -X main.Version=${TAG}" \
             -o ../../dms-${{ matrix.arch }}
           cd ../..
           gzip -9 -k dms-${{ matrix.arch }}
@@ -91,7 +98,7 @@ jobs:
         run: |
           set -eux
           cd cmd/dms
-          go build -trimpath -tags distro_binary -ldflags "-s -w -X main.Version=${GITHUB_REF#refs/tags/}" \
+          go build -trimpath -tags distro_binary -ldflags "-s -w -X main.Version=${TAG}" \
             -o ../../dms-distropkg-${{ matrix.arch }}
           cd ../..
           gzip -9 -k dms-distropkg-${{ matrix.arch }}
@@ -128,60 +135,61 @@ jobs:
             core/completion.zsh
           if-no-files-found: error
 
-  update-versions:
-    runs-on: ubuntu-latest
-    needs: build-core
-    steps:
-      - 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 }}
+  # update-versions:
+  #   runs-on: ubuntu-latest
+  #   needs: build-core
+  #   steps:
+  #     - 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:
-          token: ${{ steps.app_token.outputs.token }}
-          fetch-depth: 0
+  #     - name: Checkout
+  #       uses: actions/checkout@v4
+  #       with:
+  #         token: ${{ steps.app_token.outputs.token }}
+  #         fetch-depth: 0
 
-      - name: Update VERSION
-        env:
-          GH_TOKEN: ${{ steps.app_token.outputs.token }}
-        run: |
-          set -euo pipefail
-          git config user.name "dms-ci[bot]"
-          git config user.email "dms-ci[bot]@users.noreply.github.com"
+  #     - name: Update VERSION
+  #       env:
+  #         GH_TOKEN: ${{ steps.app_token.outputs.token }}
+  #       run: |
+  #         set -euo pipefail
+  #         git config user.name "dms-ci[bot]"
+  #         git config user.email "dms-ci[bot]@users.noreply.github.com"
 
-          version="${GITHUB_REF#refs/tags/}"
-          echo "Updating to version: $version"
-          echo "${version}" > quickshell/VERSION
-          git add quickshell/VERSION
+  #         version="${GITHUB_REF#refs/tags/}"
+  #         echo "Updating to version: $version"
+  #         echo "${version}" > quickshell/VERSION
+  #         git add quickshell/VERSION
 
-          if ! git diff --cached --quiet; then
-            git commit -m "chore: bump version to $version"
-            git pull --rebase origin master
-            git push https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git HEAD:master
-          fi
+  #         if ! git diff --cached --quiet; then
+  #           git commit -m "chore: bump version to $version"
+  #           git pull --rebase origin master
+  #           git push https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git HEAD:master
+  #         fi
 
-          git tag -f "${version}"
-          git push -f https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git "${version}"
+  #         git tag -f "${version}"
+  #         git push -f https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git "${version}"
 
   release:
     runs-on: ubuntu-24.04
-    needs: [build-core, update-versions]
+    needs: [build-core] #, update-versions]
     env:
-      TAG: ${{ github.ref_name }}
+      TAG: ${{ inputs.tag }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
+          ref: ${{ inputs.tag }}
           fetch-depth: 0
 
       - name: Fetch updated tag after version bump
         run: |
-          git fetch origin --force tag ${{ github.ref_name }}
-          git checkout ${{ github.ref_name }}
+          git fetch origin --force tag ${TAG}
+          git checkout ${TAG}
 
       - name: Download core artifacts
         uses: actions/download-artifact@v4
@@ -388,313 +396,296 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  trigger-obs-update:
-    runs-on: ubuntu-latest
-    needs: release
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      
-      - name: Install OSC
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y osc
-          
-          mkdir -p ~/.config/osc
-          cat > ~/.config/osc/oscrc << EOF
-          [general]
-          apiurl = https://api.opensuse.org
-          
-          [https://api.opensuse.org]
-          user = ${{ secrets.OBS_USERNAME }}
-          pass = ${{ secrets.OBS_PASSWORD }}
-          EOF
-          chmod 600 ~/.config/osc/oscrc
-      
-      - name: Update OBS packages
-        run: |
-          VERSION="${{ github.ref_name }}"
-          cd distro
-          bash scripts/obs-upload.sh dms "Update to $VERSION"
+  # trigger-obs-update:
+  #   runs-on: ubuntu-latest
+  #   needs: release
+  #   env:
+  #     TAG: ${{ inputs.tag }}
+  #   steps:
+  #     - name: Checkout
+  #       uses: actions/checkout@v4
+  #       with:
+  #         ref: ${{ inputs.tag }}
 
-  trigger-ppa-update:
-    runs-on: ubuntu-latest
-    needs: release
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      
-      - name: Install build dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            debhelper \
-            devscripts \
-            dput \
-            lftp \
-            build-essential \
-            fakeroot \
-            dpkg-dev
-      
-      - name: Configure GPG
-        env:
-          GPG_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
-        run: |
-          echo "$GPG_KEY" | gpg --import
-          GPG_KEY_ID=$(gpg --list-secret-keys --keyid-format LONG | grep sec | awk '{print $2}' | cut -d'/' -f2)
-          echo "DEBSIGN_KEYID=$GPG_KEY_ID" >> $GITHUB_ENV
-      
-      - name: Upload to PPA
-        run: |
-          VERSION="${{ github.ref_name }}"
-          cd distro/ubuntu/ppa
-          bash create-and-upload.sh ../dms dms questing
+  #     - name: Install OSC
+  #       run: |
+  #         sudo apt-get update
+  #         sudo apt-get install -y osc
 
-  copr-build:
-    runs-on: ubuntu-latest
-    needs: release
-    env:
-      TAG: ${{ github.ref_name }}
+  #         mkdir -p ~/.config/osc
+  #         cat > ~/.config/osc/oscrc << EOF
+  #         [general]
+  #         apiurl = https://api.opensuse.org
 
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+  #         [https://api.opensuse.org]
+  #         user = ${{ secrets.OBS_USERNAME }}
+  #         pass = ${{ secrets.OBS_PASSWORD }}
+  #         EOF
+  #         chmod 600 ~/.config/osc/oscrc
 
-      - name: Determine version
-        id: version
-        run: |
-          VERSION="${TAG#v}"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Building DMS stable version: $VERSION"
+  #     - name: Update OBS packages
+  #       run: |
+  #         cd distro
+  #         bash scripts/obs-upload.sh dms "Update to ${TAG}"
 
-      - name: Setup build environment
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y rpm wget curl jq gzip
-          mkdir -p ~/rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}
+  # trigger-ppa-update:
+  #   runs-on: ubuntu-latest
+  #   needs: release
+  #   env:
+  #     TAG: ${{ inputs.tag }}
+  #   steps:
+  #     - name: Checkout
+  #       uses: actions/checkout@v4
+  #       with:
+  #         ref: ${{ inputs.tag }}
 
-      - name: Download release assets
-        run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          cd ~/rpmbuild/SOURCES
+  #     - name: Install build dependencies
+  #       run: |
+  #         sudo apt-get update
+  #         sudo apt-get install -y \
+  #           debhelper \
+  #           devscripts \
+  #           dput \
+  #           lftp \
+  #           build-essential \
+  #           fakeroot \
+  #           dpkg-dev
 
-          wget "https://github.com/AvengeMedia/DankMaterialShell/releases/download/v${VERSION}/dms-qml.tar.gz" || {
-            echo "Failed to download dms-qml.tar.gz for v${VERSION}"
-            exit 1
-          }
+  #     - name: Configure GPG
+  #       env:
+  #         GPG_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
+  #       run: |
+  #         echo "$GPG_KEY" | gpg --import
+  #         GPG_KEY_ID=$(gpg --list-secret-keys --keyid-format LONG | grep sec | awk '{print $2}' | cut -d'/' -f2)
+  #         echo "DEBSIGN_KEYID=$GPG_KEY_ID" >> $GITHUB_ENV
 
-      - name: Generate stable spec file
-        run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          CHANGELOG_DATE="$(date '+%a %b %d %Y')"
+  #     - name: Upload to PPA
+  #       run: |
+  #         cd distro/ubuntu/ppa
+  #         bash create-and-upload.sh ../dms dms questing
 
-          cat > ~/rpmbuild/SPECS/dms.spec <<'SPECEOF'
-          # Spec for DMS stable releases - Generated by GitHub Actions
+  # copr-build:
+  #   runs-on: ubuntu-latest
+  #   needs: release
+  #   env:
+  #     TAG: ${{ inputs.tag }}
 
-          %global debug_package %{nil}
-          %global version VERSION_PLACEHOLDER
-          %global pkg_summary DankMaterialShell - Material 3 inspired shell for Wayland compositors
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v4
+  #       with:
+  #         ref: ${{ inputs.tag }}
 
-          Name:           dms
-          Version:        %{version}
-          Release:        1%{?dist}
-          Summary:        %{pkg_summary}
+  #     - name: Determine version
+  #       id: version
+  #       run: |
+  #         VERSION="${TAG#v}"
+  #         echo "version=$VERSION" >> $GITHUB_OUTPUT
+  #         echo "Building DMS stable version: $VERSION"
 
-          License:        MIT
-          URL:            https://github.com/AvengeMedia/DankMaterialShell
+  #     - name: Setup build environment
+  #       run: |
+  #         sudo apt-get update
+  #         sudo apt-get install -y rpm wget curl jq gzip
+  #         mkdir -p ~/rpmbuild/{BUILD,BUILDROOT,RPMS,SOURCES,SPECS,SRPMS}
 
-          Source0:        dms-qml.tar.gz
+  #     - name: Download release assets
+  #       run: |
+  #         VERSION="${{ steps.version.outputs.version }}"
+  #         cd ~/rpmbuild/SOURCES
 
-          BuildRequires:  gzip
-          BuildRequires:  wget
-          BuildRequires:  systemd-rpm-macros
+  #         wget "https://github.com/AvengeMedia/DankMaterialShell/releases/download/v${VERSION}/dms-qml.tar.gz" || {
+  #           echo "Failed to download dms-qml.tar.gz for v${VERSION}"
+  #           exit 1
+  #         }
 
-          Requires:       (quickshell or quickshell-git)
-          Requires:       accountsservice
-          Requires:       dms-cli
-          Requires:       dgop
+  #     - name: Generate stable spec file
+  #       run: |
+  #         VERSION="${{ steps.version.outputs.version }}"
+  #         CHANGELOG_DATE="$(date '+%a %b %d %Y')"
 
-          Recommends:     cava
-          Recommends:     cliphist
-          Recommends:     danksearch
-          Recommends:     matugen
-          Recommends:     wl-clipboard
-          Recommends:     NetworkManager
-          Recommends:     qt6-qtmultimedia
-          Suggests:       qt6ct
+  #         cat > ~/rpmbuild/SPECS/dms.spec <<'SPECEOF'
+  #         # Spec for DMS stable releases - Generated by GitHub Actions
 
-          %description
-          DankMaterialShell (DMS) is a modern Wayland desktop shell built with Quickshell
-          and optimized for the niri and hyprland compositors. Features notifications,
-          app launcher, wallpaper customization, and fully customizable with plugins.
+  #         %global debug_package %{nil}
+  #         %global version VERSION_PLACEHOLDER
+  #         %global pkg_summary DankMaterialShell - Material 3 inspired shell for Wayland compositors
 
-          Includes auto-theming for GTK/Qt apps with matugen, 20+ customizable widgets,
-          process monitoring, notification center, clipboard history, dock, control center,
-          lock screen, and comprehensive plugin system.
+  #         Name:           dms
+  #         Version:        %{version}
+  #         Release:        1%{?dist}
+  #         Summary:        %{pkg_summary}
 
-          %package -n dms-cli
-          Summary:        DankMaterialShell CLI tool
-          License:        MIT
-          URL:            https://github.com/AvengeMedia/DankMaterialShell
+  #         License:        MIT
+  #         URL:            https://github.com/AvengeMedia/DankMaterialShell
 
-          %description -n dms-cli
-          Command-line interface for DankMaterialShell configuration and management.
-          Provides native DBus bindings, NetworkManager integration, and system utilities.
+  #         Source0:        dms-qml.tar.gz
 
-          %package -n dgop
-          Summary:        Stateless CPU/GPU monitor for DankMaterialShell
-          License:        MIT
-          URL:            https://github.com/AvengeMedia/dgop
-          Provides:       dgop
+  #         BuildRequires:  gzip
+  #         BuildRequires:  wget
+  #         BuildRequires:  systemd-rpm-macros
 
-          %description -n dgop
-          DGOP is a stateless system monitoring tool that provides CPU, GPU, memory, and
-          network statistics. Designed for integration with DankMaterialShell but can be
-          used standalone. This package always includes the latest stable dgop release.
+  #         Requires:       (quickshell or quickshell-git)
+  #         Requires:       accountsservice
+  #         Requires:       dms-cli = %{version}-%{release}
+  #         Requires:       dgop
 
-          %prep
-          %setup -q -c -n dms-qml
+  #         Recommends:     cava
+  #         Recommends:     cliphist
+  #         Recommends:     danksearch
+  #         Recommends:     matugen
+  #         Recommends:     wl-clipboard
+  #         Recommends:     NetworkManager
+  #         Recommends:     qt6-qtmultimedia
+  #         Suggests:       qt6ct
 
-          # Download architecture-specific binaries during build
-          case "%{_arch}" in
-            x86_64)
-              ARCH_SUFFIX="amd64"
-              ;;
-            aarch64)
-              ARCH_SUFFIX="arm64"
-              ;;
-            *)
-              echo "Unsupported architecture: %{_arch}"
-              exit 1
-              ;;
-          esac
+  #         %description
+  #         DankMaterialShell (DMS) is a modern Wayland desktop shell built with Quickshell
+  #         and optimized for the niri and hyprland compositors. Features notifications,
+  #         app launcher, wallpaper customization, and fully customizable with plugins.
 
-          wget -O %{_builddir}/dms-cli.gz "https://github.com/AvengeMedia/DankMaterialShell/releases/latest/download/dms-distropkg-${ARCH_SUFFIX}.gz" || {
-            echo "Failed to download dms-cli for architecture %{_arch}"
-            exit 1
-          }
-          gunzip -c %{_builddir}/dms-cli.gz > %{_builddir}/dms-cli
-          chmod +x %{_builddir}/dms-cli
+  #         Includes auto-theming for GTK/Qt apps with matugen, 20+ customizable widgets,
+  #         process monitoring, notification center, clipboard history, dock, control center,
+  #         lock screen, and comprehensive plugin system.
 
-          wget -O %{_builddir}/dgop.gz "https://github.com/AvengeMedia/dgop/releases/latest/download/dgop-linux-${ARCH_SUFFIX}.gz" || {
-            echo "Failed to download dgop for architecture %{_arch}"
-            exit 1
-          }
-          gunzip -c %{_builddir}/dgop.gz > %{_builddir}/dgop
-          chmod +x %{_builddir}/dgop
+  #         %package -n dms-cli
+  #         Summary:        DankMaterialShell CLI tool
+  #         License:        MIT
+  #         URL:            https://github.com/AvengeMedia/DankMaterialShell
 
-          %build
+  #         %description -n dms-cli
+  #         Command-line interface for DankMaterialShell configuration and management.
+  #         Provides native DBus bindings, NetworkManager integration, and system utilities.
 
-          %install
-          install -Dm755 %{_builddir}/dms-cli %{buildroot}%{_bindir}/dms
-          install -Dm755 %{_builddir}/dgop %{buildroot}%{_bindir}/dgop
+  #         %prep
+  #         %setup -q -c -n dms-qml
 
-          install -d %{buildroot}%{_datadir}/bash-completion/completions
-          install -d %{buildroot}%{_datadir}/zsh/site-functions
-          install -d %{buildroot}%{_datadir}/fish/vendor_completions.d
-          %{_builddir}/dms-cli completion bash > %{buildroot}%{_datadir}/bash-completion/completions/dms || :
-          %{_builddir}/dms-cli completion zsh > %{buildroot}%{_datadir}/zsh/site-functions/_dms || :
-          %{_builddir}/dms-cli completion fish > %{buildroot}%{_datadir}/fish/vendor_completions.d/dms.fish || :
+  #         # Download architecture-specific binaries during build
+  #         case "%{_arch}" in
+  #           x86_64)
+  #             ARCH_SUFFIX="amd64"
+  #             ;;
+  #           aarch64)
+  #             ARCH_SUFFIX="arm64"
+  #             ;;
+  #           *)
+  #             echo "Unsupported architecture: %{_arch}"
+  #             exit 1
+  #             ;;
+  #         esac
 
-          install -Dm644 assets/systemd/dms.service %{buildroot}%{_userunitdir}/dms.service
+  #         wget -O %{_builddir}/dms-cli.gz "https://github.com/AvengeMedia/DankMaterialShell/releases/latest/download/dms-distropkg-${ARCH_SUFFIX}.gz" || {
+  #           echo "Failed to download dms-cli for architecture %{_arch}"
+  #           exit 1
+  #         }
+  #         gunzip -c %{_builddir}/dms-cli.gz > %{_builddir}/dms-cli
+  #         chmod +x %{_builddir}/dms-cli
 
-          install -Dm644 assets/dms-open.desktop %{buildroot}%{_datadir}/applications/dms-open.desktop
-          install -Dm644 assets/danklogo.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/apps/danklogo.svg
+  #         %build
 
-          install -dm755 %{buildroot}%{_datadir}/quickshell/dms
-          cp -r %{_builddir}/dms-qml/* %{buildroot}%{_datadir}/quickshell/dms/
+  #         %install
+  #         install -Dm755 %{_builddir}/dms-cli %{buildroot}%{_bindir}/dms
 
-          rm -rf %{buildroot}%{_datadir}/quickshell/dms/.git*
-          rm -f %{buildroot}%{_datadir}/quickshell/dms/.gitignore
-          rm -rf %{buildroot}%{_datadir}/quickshell/dms/.github
-          rm -rf %{buildroot}%{_datadir}/quickshell/dms/distro
+  #         install -d %{buildroot}%{_datadir}/bash-completion/completions
+  #         install -d %{buildroot}%{_datadir}/zsh/site-functions
+  #         install -d %{buildroot}%{_datadir}/fish/vendor_completions.d
+  #         %{_builddir}/dms-cli completion bash > %{buildroot}%{_datadir}/bash-completion/completions/dms || :
+  #         %{_builddir}/dms-cli completion zsh > %{buildroot}%{_datadir}/zsh/site-functions/_dms || :
+  #         %{_builddir}/dms-cli completion fish > %{buildroot}%{_datadir}/fish/vendor_completions.d/dms.fish || :
 
-          echo "%{version}" > %{buildroot}%{_datadir}/quickshell/dms/VERSION
+  #         install -Dm644 assets/systemd/dms.service %{buildroot}%{_userunitdir}/dms.service
 
-          %posttrans
-          if [ -d "%{_sysconfdir}/xdg/quickshell/dms" ]; then
-              rmdir "%{_sysconfdir}/xdg/quickshell/dms" 2>/dev/null || true
-              rmdir "%{_sysconfdir}/xdg/quickshell" 2>/dev/null || true
-              rmdir "%{_sysconfdir}/xdg" 2>/dev/null || true
-          fi
+  #         install -Dm644 assets/dms-open.desktop %{buildroot}%{_datadir}/applications/dms-open.desktop
+  #         install -Dm644 assets/danklogo.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/apps/danklogo.svg
 
-          if [ "$1" -ge 2 ]; then
-            pkill -USR1 -x dms >/dev/null 2>&1 || true
-          fi
+  #         install -dm755 %{buildroot}%{_datadir}/quickshell/dms
+  #         cp -r %{_builddir}/dms-qml/* %{buildroot}%{_datadir}/quickshell/dms/
 
-          %files
-          %license LICENSE
-          %doc README.md CONTRIBUTING.md
-          %{_datadir}/quickshell/dms/
-          %{_userunitdir}/dms.service
-          %{_datadir}/applications/dms-open.desktop
-          %{_datadir}/icons/hicolor/scalable/apps/danklogo.svg
+  #         rm -rf %{buildroot}%{_datadir}/quickshell/dms/.git*
+  #         rm -f %{buildroot}%{_datadir}/quickshell/dms/.gitignore
+  #         rm -rf %{buildroot}%{_datadir}/quickshell/dms/.github
+  #         rm -rf %{buildroot}%{_datadir}/quickshell/dms/distro
 
-          %files -n dms-cli
-          %{_bindir}/dms
-          %{_datadir}/bash-completion/completions/dms
-          %{_datadir}/zsh/site-functions/_dms
-          %{_datadir}/fish/vendor_completions.d/dms.fish
+  #         echo "%{version}" > %{buildroot}%{_datadir}/quickshell/dms/VERSION
 
-          %files -n dgop
-          %{_bindir}/dgop
+  #         %posttrans
+  #         if [ -d "%{_sysconfdir}/xdg/quickshell/dms" ]; then
+  #             rmdir "%{_sysconfdir}/xdg/quickshell/dms" 2>/dev/null || true
+  #             rmdir "%{_sysconfdir}/xdg/quickshell" 2>/dev/null || true
+  #             rmdir "%{_sysconfdir}/xdg" 2>/dev/null || true
+  #         fi
+  #         # Signal running DMS instances to reload
+  #         pkill -USR1 -x dms >/dev/null 2>&1 || :
 
-          %changelog
-          * CHANGELOG_DATE_PLACEHOLDER AvengeMedia <contact@avengemedia.com> - VERSION_PLACEHOLDER-1
-          - Stable release VERSION_PLACEHOLDER
-          - Built from GitHub release
-          - Includes latest dms-cli and dgop binaries
-          SPECEOF
+  #         %files
+  #         %license LICENSE
+  #         %doc README.md CONTRIBUTING.md
+  #         %{_datadir}/quickshell/dms/
+  #         %{_userunitdir}/dms.service
+  #         %{_datadir}/applications/dms-open.desktop
+  #         %{_datadir}/icons/hicolor/scalable/apps/danklogo.svg
 
-          sed -i "s/VERSION_PLACEHOLDER/${VERSION}/g" ~/rpmbuild/SPECS/dms.spec
-          sed -i "s/CHANGELOG_DATE_PLACEHOLDER/${CHANGELOG_DATE}/g" ~/rpmbuild/SPECS/dms.spec
+  #         %files -n dms-cli
+  #         %{_bindir}/dms
+  #         %{_datadir}/bash-completion/completions/dms
+  #         %{_datadir}/zsh/site-functions/_dms
+  #         %{_datadir}/fish/vendor_completions.d/dms.fish
 
-      - name: Build SRPM
-        id: build
-        run: |
-          cd ~/rpmbuild/SPECS
-          rpmbuild -bs dms.spec
+  #         %changelog
+  #         * CHANGELOG_DATE_PLACEHOLDER AvengeMedia <contact@avengemedia.com> - VERSION_PLACEHOLDER-1
+  #         - Stable release VERSION_PLACEHOLDER
+  #         - Built from GitHub release
+  #         SPECEOF
 
-          SRPM=$(ls ~/rpmbuild/SRPMS/*.src.rpm | tail -n 1)
-          SRPM_NAME=$(basename "$SRPM")
+  #         sed -i "s/VERSION_PLACEHOLDER/${VERSION}/g" ~/rpmbuild/SPECS/dms.spec
+  #         sed -i "s/CHANGELOG_DATE_PLACEHOLDER/${CHANGELOG_DATE}/g" ~/rpmbuild/SPECS/dms.spec
 
-          echo "srpm_path=$SRPM" >> $GITHUB_OUTPUT
-          echo "srpm_name=$SRPM_NAME" >> $GITHUB_OUTPUT
-          echo "SRPM built: $SRPM_NAME"
+  #     - name: Build SRPM
+  #       id: build
+  #       run: |
+  #         cd ~/rpmbuild/SPECS
+  #         rpmbuild -bs dms.spec
 
-      - name: Upload SRPM artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: dms-stable-srpm-${{ steps.version.outputs.version }}
-          path: ${{ steps.build.outputs.srpm_path }}
-          retention-days: 90
+  #         SRPM=$(ls ~/rpmbuild/SRPMS/*.src.rpm | tail -n 1)
+  #         SRPM_NAME=$(basename "$SRPM")
 
-      - name: Install Copr CLI
-        run: |
-          sudo apt-get install -y python3-pip
-          pip3 install copr-cli
+  #         echo "srpm_path=$SRPM" >> $GITHUB_OUTPUT
+  #         echo "srpm_name=$SRPM_NAME" >> $GITHUB_OUTPUT
+  #         echo "SRPM built: $SRPM_NAME"
 
-          mkdir -p ~/.config
-          cat > ~/.config/copr << EOF
-          [copr-cli]
-          login = ${{ secrets.COPR_LOGIN }}
-          username = avengemedia
-          token = ${{ secrets.COPR_TOKEN }}
-          copr_url = https://copr.fedorainfracloud.org
-          EOF
-          chmod 600 ~/.config/copr
+  #     - name: Upload SRPM artifact
+  #       uses: actions/upload-artifact@v4
+  #       with:
+  #         name: dms-stable-srpm-${{ steps.version.outputs.version }}
+  #         path: ${{ steps.build.outputs.srpm_path }}
+  #         retention-days: 90
 
-      - name: Upload to Copr
-        run: |
-          SRPM="${{ steps.build.outputs.srpm_path }}"
-          VERSION="${{ steps.version.outputs.version }}"
+  #     - name: Install Copr CLI
+  #       run: |
+  #         sudo apt-get install -y python3-pip
+  #         pip3 install copr-cli
 
-          echo "Uploading SRPM to avengemedia/dms..."
-          BUILD_OUTPUT=$(copr-cli build avengemedia/dms "$SRPM" --nowait 2>&1)
-          echo "$BUILD_OUTPUT"
+  #         mkdir -p ~/.config
+  #         cat > ~/.config/copr << EOF
+  #         [copr-cli]
+  #         login = ${{ secrets.COPR_LOGIN }}
+  #         username = avengemedia
+  #         token = ${{ secrets.COPR_TOKEN }}
+  #         copr_url = https://copr.fedorainfracloud.org
+  #         EOF
+  #         chmod 600 ~/.config/copr
 
-          BUILD_ID=$(echo "$BUILD_OUTPUT" | grep -oP 'Build was added to.*\K[0-9]+' || echo "unknown")
+  #     - name: Upload to Copr
+  #       run: |
+  #         SRPM="${{ steps.build.outputs.srpm_path }}"
+  #         VERSION="${{ steps.version.outputs.version }}"
 
-          if [ "$BUILD_ID" != "unknown" ]; then
-            echo "Build submitted: https://copr.fedorainfracloud.org/coprs/avengemedia/dms/build/$BUILD_ID/"
-          fi
+  #         echo "Uploading SRPM to avengemedia/dms..."
+  #         BUILD_OUTPUT=$(copr-cli build avengemedia/dms "$SRPM" --nowait 2>&1)
+  #         echo "$BUILD_OUTPUT"
+
+  #         BUILD_ID=$(echo "$BUILD_OUTPUT" | grep -oP 'Build was added to.*\K[0-9]+' || echo "unknown")
+
+  #         if [ "$BUILD_ID" != "unknown" ]; then
+  #           echo "Build submitted: https://copr.fedorainfracloud.org/coprs/avengemedia/dms/build/$BUILD_ID/"
+  #         fi

.github/workflows/run-copr.yml

@@ -62,7 +62,7 @@ jobs:
           }
           
           echo "✅ Source downloaded"
-          echo "Note: dms-cli and dgop binaries will be downloaded during build based on target architecture"
+          echo "Note: dms-cli binary will be downloaded during build based on target architecture"
           ls -lh
       
       - name: Generate stable spec file
@@ -94,7 +94,7 @@ jobs:
 
           Requires:       (quickshell or quickshell-git)
           Requires:       accountsservice
-          Requires:       dms-cli
+          Requires:       dms-cli = %{version}-%{release}
           Requires:       dgop
 
           Recommends:     cava
@@ -125,17 +125,6 @@ jobs:
           Command-line interface for DankMaterialShell configuration and management.
           Provides native DBus bindings, NetworkManager integration, and system utilities.
 
-          %package -n dgop
-          Summary:        Stateless CPU/GPU monitor for DankMaterialShell
-          License:        MIT
-          URL:            https://github.com/AvengeMedia/dgop
-          Provides:       dgop
-
-          %description -n dgop
-          DGOP is a stateless system monitoring tool that provides CPU, GPU, memory, and
-          network statistics. Designed for integration with DankMaterialShell but can be
-          used standalone. This package always includes the latest stable dgop release.
-
           %prep
           %setup -q -c -n dms-qml
 
@@ -162,19 +151,10 @@ jobs:
           gunzip -c %{_builddir}/dms-cli.gz > %{_builddir}/dms-cli
           chmod +x %{_builddir}/dms-cli
 
-          # Download dgop for target architecture
-          wget -O %{_builddir}/dgop.gz "https://github.com/AvengeMedia/dgop/releases/latest/download/dgop-linux-${ARCH_SUFFIX}.gz" || {
-            echo "Failed to download dgop for architecture %{_arch}"
-            exit 1
-          }
-          gunzip -c %{_builddir}/dgop.gz > %{_builddir}/dgop
-          chmod +x %{_builddir}/dgop
-
           %build
 
           %install
           install -Dm755 %{_builddir}/dms-cli %{buildroot}%{_bindir}/dms
-          install -Dm755 %{_builddir}/dgop %{buildroot}%{_bindir}/dgop
 
           # Shell completions
           install -d %{buildroot}%{_datadir}/bash-completion/completions
@@ -202,11 +182,8 @@ jobs:
               rmdir "%{_sysconfdir}/xdg/quickshell" 2>/dev/null || true
               rmdir "%{_sysconfdir}/xdg" 2>/dev/null || true
           fi
-
-          # Restart DMS for active users after upgrade
-          if [ "$1" -ge 2 ]; then
-            pkill -USR1 -x dms >/dev/null 2>&1 || true
-          fi
+          # Signal running DMS instances to reload (harmless if none running)
+          pkill -USR1 -x dms >/dev/null 2>&1 || :
 
           %files
           %license LICENSE
@@ -220,14 +197,10 @@ jobs:
           %{_datadir}/zsh/site-functions/_dms
           %{_datadir}/fish/vendor_completions.d/dms.fish
 
-          %files -n dgop
-          %{_bindir}/dgop
-
           %changelog
           * CHANGELOG_DATE_PLACEHOLDER AvengeMedia <contact@avengemedia.com> - VERSION_PLACEHOLDER-RELEASE_PLACEHOLDER
           - Stable release VERSION_PLACEHOLDER
           - Built from GitHub release
-          - Includes latest dms-cli and dgop binaries
           SPECEOF
 
           sed -i "s/VERSION_PLACEHOLDER/${VERSION}/g" ~/rpmbuild/SPECS/dms.spec

README.md

@@ -5,21 +5,21 @@
     <img src="assets/danklogo.svg" alt="DankMaterialShell" width="200">
   </a>
 
-  ### A modern desktop shell for Wayland
+### A modern desktop shell for Wayland
 
-  Built with [Quickshell](https://quickshell.org/) and [Go](https://go.dev/)
+Built with [Quickshell](https://quickshell.org/) and [Go](https://go.dev/)
 
 [![Documentation](https://img.shields.io/badge/docs-danklinux.com-9ccbfb?style=for-the-badge&labelColor=101418)](https://danklinux.com/docs)
 [![GitHub stars](https://img.shields.io/github/stars/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=ffd700)](https://github.com/AvengeMedia/DankMaterialShell/stargazers)
 [![GitHub License](https://img.shields.io/github/license/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=b9c8da)](https://github.com/AvengeMedia/DankMaterialShell/blob/master/LICENSE)
 [![GitHub release](https://img.shields.io/github/v/release/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=9ccbfb)](https://github.com/AvengeMedia/DankMaterialShell/releases)
 [![AUR version](https://img.shields.io/aur/version/dms-shell-bin?style=for-the-badge&labelColor=101418&color=9ccbfb)](https://aur.archlinux.org/packages/dms-shell-bin)
-[![AUR version (git)](https://img.shields.io/aur/version/dms-shell-git?style=for-the-badge&labelColor=101418&color=9ccbfb&label=AUR%20(git))](https://aur.archlinux.org/packages/dms-shell-git)
+[![AUR version (git)](<https://img.shields.io/aur/version/dms-shell-git?style=for-the-badge&labelColor=101418&color=9ccbfb&label=AUR%20(git)>)](https://aur.archlinux.org/packages/dms-shell-git)
 [![Ko-Fi donate](https://img.shields.io/badge/donate-kofi?style=for-the-badge&logo=ko-fi&logoColor=ffffff&label=ko-fi&labelColor=101418&color=f16061&link=https%3A%2F%2Fko-fi.com%2Fdanklinux)](https://ko-fi.com/danklinux)
 
 </div>
 
-DankMaterialShell is a complete desktop shell for [niri](https://github.com/YaLTeR/niri), [Hyprland](https://hyprland.org/), [MangoWC](https://github.com/DreamMaoMao/mangowc), [Sway](https://swaywm.org),  [labwc](https://labwc.github.io/), and other Wayland compositors. It replaces waybar, swaylock, swayidle, mako, fuzzel, polkit, and everything else you'd normally stitch together to make a desktop.
+DankMaterialShell is a complete desktop shell for [niri](https://github.com/YaLTeR/niri), [Hyprland](https://hyprland.org/), [MangoWC](https://github.com/DreamMaoMao/mangowc), [Sway](https://swaywm.org), [labwc](https://labwc.github.io/), [Scroll](https://github.com/dawsers/scroll), and other Wayland compositors. It replaces waybar, swaylock, swayidle, mako, fuzzel, polkit, and everything else you'd normally stitch together to make a desktop.
 
 ## Repository Structure
 
@@ -105,7 +105,7 @@ Extend functionality with the [plugin registry](https://plugins.danklinux.com).
 
 ## Supported Compositors
 
-Works best with [niri](https://github.com/YaLTeR/niri), [Hyprland](https://hyprland.org/), [Sway](https://swaywm.org/), [MangoWC](https://github.com/DreamMaoMao/mangowc), and [labwc](https://labwc.github.io/) with full workspace switching, overview integration, and monitor management. Other Wayland compositors work with reduced features.
+Works best with [niri](https://github.com/YaLTeR/niri), [Hyprland](https://hyprland.org/), [Sway](https://swaywm.org/), [MangoWC](https://github.com/DreamMaoMao/mangowc), [labwc](https://labwc.github.io/), and [Scroll](https://github.com/dawsers/scroll) with full workspace switching, overview integration, and monitor management. Other Wayland compositors work with reduced features.
 
 [Compositor configuration guide](https://danklinux.com/docs/dankmaterialshell/compositors)
 
@@ -127,7 +127,7 @@ dms plugins search   # Browse plugin registry
 ## Documentation
 
 - **Website:** [danklinux.com](https://danklinux.com)
-- **Docs:** [danklinux.com/docs](https://danklinux.com/docs)
+- **Docs:** [danklinux.com/docs](https://danklinux.com/docs/)
 - **Theming:** [Application themes](https://danklinux.com/docs/dankmaterialshell/application-themes) | [Custom themes](https://danklinux.com/docs/dankmaterialshell/custom-themes)
 - **Plugins:** [Development guide](https://danklinux.com/docs/dankmaterialshell/plugins-overview)
 - **Support:** [Ko-fi](https://ko-fi.com/avengemediallc)
@@ -143,6 +143,7 @@ See component-specific documentation:
 ### Building from Source
 
 **Core + Dankinstall:**
+
 ```bash
 cd core
 make              # Build dms CLI
@@ -150,11 +151,13 @@ make dankinstall  # Build installer
 ```
 
 **Shell:**
+
 ```bash
 quickshell -p quickshell/
 ```
 
 **NixOS:**
+
 ```nix
 {
   inputs.dms.url = "github:AvengeMedia/DankMaterialShell";

alejandra.toml

@@ -1 +0,0 @@
-indentation = "FourSpaces"

core/.golangci.yml

@@ -22,6 +22,8 @@ linters:
         - (*os.Process).Signal
         - (*os.Process).Kill
         - syscall.Kill
+        # Seek on memfd (reset position before passing fd)
+        - syscall.Seek
         # DBus cleanup
         - (*github.com/godbus/dbus/v5.Conn).RemoveMatchSignal
         - (*github.com/godbus/dbus/v5.Conn).RemoveSignal

core/cmd/dankinstall/main.go

@@ -12,6 +12,11 @@ import (
 var Version = "dev"
 
 func main() {
+	if os.Getuid() == 0 {
+		fmt.Fprintln(os.Stderr, "Error: dankinstall must not be run as root")
+		os.Exit(1)
+	}
+
 	fileLogger, err := log.NewFileLogger()
 	if err != nil {
 		fmt.Printf("Warning: Failed to create log file: %v\n", err)

core/cmd/dms/commands_brightness.go

@@ -211,45 +211,13 @@ func runBrightnessSet(cmd *cobra.Command, args []string) {
 	exponential, _ := cmd.Flags().GetBool("exponential")
 	exponent, _ := cmd.Flags().GetFloat64("exponent")
 
-	// For backlight/leds devices, try logind backend first (requires D-Bus connection)
 	parts := strings.SplitN(deviceID, ":", 2)
 	if len(parts) == 2 && (parts[0] == "backlight" || parts[0] == "leds") {
-		subsystem := parts[0]
-		name := parts[1]
-
-		// Initialize backends needed for logind approach
-		sysfs, err := brightness.NewSysfsBackend()
-		if err != nil {
-			log.Debugf("NewSysfsBackend failed: %v", err)
-		} else {
-			logind, err := brightness.NewLogindBackend()
-			if err != nil {
-				log.Debugf("NewLogindBackend failed: %v", err)
-			} else {
-				defer logind.Close()
-
-				// Get device info to convert percent to value
-				dev, err := sysfs.GetDevice(deviceID)
-				if err == nil {
-					// Calculate hardware value using the same logic as Manager.setViaSysfsWithLogind
-					value := sysfs.PercentToValueWithExponent(percent, dev, exponential, exponent)
-
-					// Call logind with hardware value
-					if err := logind.SetBrightness(subsystem, name, uint32(value)); err == nil {
-						log.Debugf("set %s to %d%% (%d) via logind", deviceID, percent, value)
-						fmt.Printf("Set %s to %d%%\n", deviceID, percent)
-						return
-					} else {
-						log.Debugf("logind.SetBrightness failed: %v", err)
-					}
-				} else {
-					log.Debugf("sysfs.GetDeviceByID failed: %v", err)
-				}
-			}
+		if ok := tryLogindBrightness(parts[0], parts[1], deviceID, percent, exponential, exponent); ok {
+			return
 		}
 	}
 
-	// Fallback to direct sysfs (requires write permissions)
 	sysfs, err := brightness.NewSysfsBackend()
 	if err == nil {
 		if err := sysfs.SetBrightnessWithExponent(deviceID, percent, exponential, exponent); err == nil {
@@ -280,6 +248,37 @@ func runBrightnessSet(cmd *cobra.Command, args []string) {
 	log.Fatalf("Failed to set brightness for device: %s", deviceID)
 }
 
+func tryLogindBrightness(subsystem, name, deviceID string, percent int, exponential bool, exponent float64) bool {
+	sysfs, err := brightness.NewSysfsBackend()
+	if err != nil {
+		log.Debugf("NewSysfsBackend failed: %v", err)
+		return false
+	}
+
+	logind, err := brightness.NewLogindBackend()
+	if err != nil {
+		log.Debugf("NewLogindBackend failed: %v", err)
+		return false
+	}
+	defer logind.Close()
+
+	dev, err := sysfs.GetDevice(deviceID)
+	if err != nil {
+		log.Debugf("sysfs.GetDeviceByID failed: %v", err)
+		return false
+	}
+
+	value := sysfs.PercentToValueWithExponent(percent, dev, exponential, exponent)
+	if err := logind.SetBrightness(subsystem, name, uint32(value)); err != nil {
+		log.Debugf("logind.SetBrightness failed: %v", err)
+		return false
+	}
+
+	log.Debugf("set %s to %d%% (%d) via logind", deviceID, percent, value)
+	fmt.Printf("Set %s to %d%%\n", deviceID, percent)
+	return true
+}
+
 func getBrightnessDevices(includeDDC bool) []string {
 	allDevices := getAllBrightnessDevices(includeDDC)
 

core/cmd/dms/commands_common.go

@@ -152,6 +152,24 @@ var pluginsUninstallCmd = &cobra.Command{
 	},
 }
 
+var pluginsUpdateCmd = &cobra.Command{
+	Use:   "update <plugin-id>",
+	Short: "Update a plugin by ID",
+	Long:  "Update an installed DMS plugin using its ID (e.g., 'myPlugin'). Plugin names are also supported.",
+	Args:  cobra.ExactArgs(1),
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		return getInstalledPluginIDs(), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := updatePluginCLI(args[0]); err != nil {
+			log.Fatalf("Error updating plugin: %v", err)
+		}
+	},
+}
+
 func runVersion(cmd *cobra.Command, args []string) {
 	printASCII()
 	fmt.Printf("%s\n", formatVersion(Version))
@@ -408,49 +426,70 @@ func uninstallPluginCLI(idOrName string) error {
 		return fmt.Errorf("failed to create registry: %w", err)
 	}
 
-	pluginList, err := registry.List()
-	if err != nil {
-		return fmt.Errorf("failed to list plugins: %w", err)
-	}
+	pluginList, _ := registry.List()
+	plugin := plugins.FindByIDOrName(idOrName, pluginList)
 
-	// First, try to find by ID (preferred method)
-	var plugin *plugins.Plugin
-	for _, p := range pluginList {
-		if p.ID == idOrName {
-			plugin = &p
-			break
+	if plugin != nil {
+		installed, err := manager.IsInstalled(*plugin)
+		if err != nil {
+			return fmt.Errorf("failed to check install status: %w", err)
 		}
-	}
-
-	// Fallback to name for backward compatibility
-	if plugin == nil {
-		for _, p := range pluginList {
-			if p.Name == idOrName {
-				plugin = &p
-				break
-			}
+		if !installed {
+			return fmt.Errorf("plugin not installed: %s", plugin.Name)
 		}
+
+		fmt.Printf("Uninstalling plugin: %s (ID: %s)\n", plugin.Name, plugin.ID)
+		if err := manager.Uninstall(*plugin); err != nil {
+			return fmt.Errorf("failed to uninstall plugin: %w", err)
+		}
+		fmt.Printf("Plugin uninstalled successfully: %s\n", plugin.Name)
+		return nil
 	}
 
-	if plugin == nil {
-		return fmt.Errorf("plugin not found: %s", idOrName)
+	fmt.Printf("Uninstalling plugin: %s\n", idOrName)
+	if err := manager.UninstallByIDOrName(idOrName); err != nil {
+		return err
 	}
+	fmt.Printf("Plugin uninstalled successfully: %s\n", idOrName)
+	return nil
+}
 
-	installed, err := manager.IsInstalled(*plugin)
+func updatePluginCLI(idOrName string) error {
+	manager, err := plugins.NewManager()
 	if err != nil {
-		return fmt.Errorf("failed to check install status: %w", err)
+		return fmt.Errorf("failed to create manager: %w", err)
 	}
 
-	if !installed {
-		return fmt.Errorf("plugin not installed: %s", plugin.Name)
+	registry, err := plugins.NewRegistry()
+	if err != nil {
+		return fmt.Errorf("failed to create registry: %w", err)
 	}
 
-	fmt.Printf("Uninstalling plugin: %s (ID: %s)\n", plugin.Name, plugin.ID)
-	if err := manager.Uninstall(*plugin); err != nil {
-		return fmt.Errorf("failed to uninstall plugin: %w", err)
+	pluginList, _ := registry.List()
+	plugin := plugins.FindByIDOrName(idOrName, pluginList)
+
+	if plugin != nil {
+		installed, err := manager.IsInstalled(*plugin)
+		if err != nil {
+			return fmt.Errorf("failed to check install status: %w", err)
+		}
+		if !installed {
+			return fmt.Errorf("plugin not installed: %s", plugin.Name)
+		}
+
+		fmt.Printf("Updating plugin: %s (ID: %s)\n", plugin.Name, plugin.ID)
+		if err := manager.Update(*plugin); err != nil {
+			return fmt.Errorf("failed to update plugin: %w", err)
+		}
+		fmt.Printf("Plugin updated successfully: %s\n", plugin.Name)
+		return nil
 	}
 
-	fmt.Printf("Plugin uninstalled successfully: %s\n", plugin.Name)
+	fmt.Printf("Updating plugin: %s\n", idOrName)
+	if err := manager.UpdateByIDOrName(idOrName); err != nil {
+		return err
+	}
+	fmt.Printf("Plugin updated successfully: %s\n", idOrName)
 	return nil
 }
 

core/cmd/dms/commands_features.go

@@ -15,6 +15,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/errdefs"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
 	"github.com/spf13/cobra"
 )
@@ -121,10 +122,10 @@ func updateArchLinux() error {
 	var helper string
 	var updateCmd *exec.Cmd
 
-	if commandExists("yay") {
+	if utils.CommandExists("yay") {
 		helper = "yay"
 		updateCmd = exec.Command("yay", "-S", packageName)
-	} else if commandExists("paru") {
+	} else if utils.CommandExists("paru") {
 		helper = "paru"
 		updateCmd = exec.Command("paru", "-S", packageName)
 	} else {

core/cmd/dms/commands_greeter.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/greeter"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/spf13/cobra"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -448,7 +449,7 @@ func enableGreeter() error {
 	fmt.Println("Detecting installed compositors...")
 	compositors := greeter.DetectCompositors()
 
-	if commandExists("sway") {
+	if utils.CommandExists("sway") {
 		compositors = append(compositors, "sway")
 	}
 

core/cmd/dms/commands_keybinds.go

@@ -89,6 +89,11 @@ func initializeProviders() {
 		log.Warnf("Failed to register MangoWC provider: %v", err)
 	}
 
+	scrollProvider := providers.NewSwayProvider("$HOME/.config/scroll")
+	if err := registry.Register(scrollProvider); err != nil {
+		log.Warnf("Failed to register Scroll provider: %v", err)
+	}
+
 	swayProvider := providers.NewSwayProvider("$HOME/.config/sway")
 	if err := registry.Register(swayProvider); err != nil {
 		log.Warnf("Failed to register Sway provider: %v", err)
@@ -125,6 +130,8 @@ func makeProviderWithPath(name, path string) keybinds.Provider {
 		return providers.NewMangoWCProvider(path)
 	case "sway":
 		return providers.NewSwayProvider(path)
+	case "scroll":
+		return providers.NewSwayProvider(path)
 	case "niri":
 		return providers.NewNiriProvider(path)
 	default:

core/cmd/dms/commands_screenshot.go

@@ -295,7 +295,14 @@ func bufferToRGBThumbnail(buf *screenshot.ShmBuffer, maxSize int, pixelFormat ui
 
 	data := buf.Data()
 	rgb := make([]byte, dstW*dstH*3)
-	swapRB := pixelFormat == uint32(screenshot.FormatARGB8888) || pixelFormat == uint32(screenshot.FormatXRGB8888) || pixelFormat == 0
+
+	var swapRB bool
+	switch pixelFormat {
+	case uint32(screenshot.FormatABGR8888), uint32(screenshot.FormatXBGR8888):
+		swapRB = false
+	default:
+		swapRB = true
+	}
 
 	for y := 0; y < dstH; y++ {
 		srcY := int(float64(y) / scale)
@@ -309,16 +316,17 @@ func bufferToRGBThumbnail(buf *screenshot.ShmBuffer, maxSize int, pixelFormat ui
 			}
 			si := srcY*buf.Stride + srcX*4
 			di := (y*dstW + x) * 3
-			if si+2 < len(data) {
-				if swapRB {
-					rgb[di+0] = data[si+2]
-					rgb[di+1] = data[si+1]
-					rgb[di+2] = data[si+0]
-				} else {
-					rgb[di+0] = data[si+0]
-					rgb[di+1] = data[si+1]
-					rgb[di+2] = data[si+2]
-				}
+			if si+3 >= len(data) {
+				continue
+			}
+			if swapRB {
+				rgb[di+0] = data[si+2]
+				rgb[di+1] = data[si+1]
+				rgb[di+2] = data[si+0]
+			} else {
+				rgb[di+0] = data[si+0]
+				rgb[di+1] = data[si+1]
+				rgb[di+2] = data[si+2]
 			}
 		}
 	}
@@ -370,7 +378,37 @@ func runScreenshotList(cmd *cobra.Command, args []string) {
 	}
 
 	for _, o := range outputs {
-		fmt.Printf("%s: %dx%d+%d+%d (scale: %d)\n",
-			o.Name, o.Width, o.Height, o.X, o.Y, o.Scale)
+		scaleStr := fmt.Sprintf("%.2f", o.FractionalScale)
+		if o.FractionalScale == float64(int(o.FractionalScale)) {
+			scaleStr = fmt.Sprintf("%d", int(o.FractionalScale))
+		}
+
+		transformStr := transformName(o.Transform)
+
+		fmt.Printf("%s: %dx%d+%d+%d scale=%s transform=%s\n",
+			o.Name, o.Width, o.Height, o.X, o.Y, scaleStr, transformStr)
+	}
+}
+
+func transformName(t int32) string {
+	switch t {
+	case 0:
+		return "normal"
+	case 1:
+		return "90"
+	case 2:
+		return "180"
+	case 3:
+		return "270"
+	case 4:
+		return "flipped"
+	case 5:
+		return "flipped-90"
+	case 6:
+		return "flipped-180"
+	case 7:
+		return "flipped-270"
+	default:
+		return fmt.Sprintf("%d", t)
 	}
 }

core/cmd/dms/commands_setup.go

@@ -29,6 +29,7 @@ func runSetup() error {
 
 	wm, wmSelected := promptCompositor()
 	terminal, terminalSelected := promptTerminal()
+	useSystemd := promptSystemd()
 
 	if !wmSelected && !terminalSelected {
 		fmt.Println("No configurations selected. Exiting.")
@@ -67,14 +68,14 @@ func runSetup() error {
 	var err error
 
 	if wmSelected && terminalSelected {
-		results, err = deployer.DeployConfigurationsWithTerminal(ctx, wm, terminal)
+		results, err = deployer.DeployConfigurationsWithSystemd(ctx, wm, terminal, useSystemd)
 	} else if wmSelected {
-		results, err = deployer.DeployConfigurationsWithTerminal(ctx, wm, deps.TerminalGhostty)
+		results, err = deployer.DeployConfigurationsWithSystemd(ctx, wm, deps.TerminalGhostty, useSystemd)
 		if len(results) > 1 {
 			results = results[:1]
 		}
 	} else if terminalSelected {
-		results, err = deployer.DeployConfigurationsWithTerminal(ctx, deps.WindowManagerNiri, terminal)
+		results, err = deployer.DeployConfigurationsWithSystemd(ctx, deps.WindowManagerNiri, terminal, useSystemd)
 		if len(results) > 0 && results[0].ConfigType == "Niri" {
 			results = results[1:]
 		}
@@ -144,6 +145,19 @@ func promptTerminal() (deps.Terminal, bool) {
 	}
 }
 
+func promptSystemd() bool {
+	fmt.Println("\nUse systemd for session management?")
+	fmt.Println("1) Yes (recommended for most distros)")
+	fmt.Println("2) No (standalone, no systemd integration)")
+
+	var response string
+	fmt.Print("\nChoice (1-2): ")
+	fmt.Scanln(&response)
+	response = strings.TrimSpace(response)
+
+	return response != "2"
+}
+
 func checkExistingConfigs(wm deps.WindowManager, wmSelected bool, terminal deps.Terminal, terminalSelected bool) bool {
 	homeDir := os.Getenv("HOME")
 	willBackup := false

core/cmd/dms/main.go

@@ -23,7 +23,7 @@ func init() {
 	updateCmd.AddCommand(updateCheckCmd)
 
 	// Add subcommands to plugins
-	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd)
+	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)
 
 	// Add common commands to root
 	rootCmd.AddCommand(getCommonCommands()...)

core/cmd/dms/main_distro.go

@@ -21,7 +21,7 @@ func init() {
 	greeterCmd.AddCommand(greeterSyncCmd, greeterEnableCmd, greeterStatusCmd)
 
 	// Add subcommands to plugins
-	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd)
+	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)
 
 	// Add common commands to root
 	rootCmd.AddCommand(getCommonCommands()...)

core/cmd/dms/shell.go

@@ -104,7 +104,6 @@ func getAllDMSPIDs() []int {
 			continue
 		}
 
-		// Check if the child process is still alive
 		proc, err := os.FindProcess(childPID)
 		if err != nil {
 			os.Remove(pidFile)
@@ -112,18 +111,15 @@ func getAllDMSPIDs() []int {
 		}
 
 		if err := proc.Signal(syscall.Signal(0)); err != nil {
-			// Process is dead, remove stale PID file
 			os.Remove(pidFile)
 			continue
 		}
 
 		pids = append(pids, childPID)
 
-		// Also get the parent PID from the filename
 		parentPIDStr := strings.TrimPrefix(entry.Name(), "danklinux-")
 		parentPIDStr = strings.TrimSuffix(parentPIDStr, ".pid")
 		if parentPID, err := strconv.Atoi(parentPIDStr); err == nil {
-			// Check if parent is still alive
 			if parentProc, err := os.FindProcess(parentPID); err == nil {
 				if err := parentProc.Signal(syscall.Signal(0)); err == nil {
 					pids = append(pids, parentPID)
@@ -159,6 +155,7 @@ func runShellInteractive(session bool) {
 				errChan <- fmt.Errorf("server panic: %v", r)
 			}
 		}()
+		server.CLIVersion = Version
 		if err := server.Start(false); err != nil {
 			errChan <- fmt.Errorf("server error: %w", err)
 		}
@@ -225,7 +222,6 @@ func runShellInteractive(session bool) {
 				return
 			}
 
-			// All other signals: clean shutdown
 			log.Infof("\nReceived signal %v, shutting down...", sig)
 			cancel()
 			cmd.Process.Signal(syscall.SIGTERM)
@@ -282,7 +278,6 @@ func restartShell() {
 }
 
 func killShell() {
-	// Get all tracked DMS PIDs from PID files
 	pids := getAllDMSPIDs()
 
 	if len(pids) == 0 {
@@ -293,14 +288,12 @@ func killShell() {
 	currentPid := os.Getpid()
 	uniquePids := make(map[int]bool)
 
-	// Deduplicate and filter out current process
 	for _, pid := range pids {
 		if pid != currentPid {
 			uniquePids[pid] = true
 		}
 	}
 
-	// Kill all tracked processes
 	for pid := range uniquePids {
 		proc, err := os.FindProcess(pid)
 		if err != nil {
@@ -308,7 +301,6 @@ func killShell() {
 			continue
 		}
 
-		// Check if process is still alive before killing
 		if err := proc.Signal(syscall.Signal(0)); err != nil {
 			continue
 		}
@@ -320,7 +312,6 @@ func killShell() {
 		}
 	}
 
-	// Clean up any remaining PID files
 	dir := getRuntimeDir()
 	entries, err := os.ReadDir(dir)
 	if err != nil {
@@ -337,7 +328,6 @@ func killShell() {
 
 func runShellDaemon(session bool) {
 	isSessionManaged = session
-	// Check if this is the daemon child process by looking for the hidden flag
 	isDaemonChild := false
 	for _, arg := range os.Args {
 		if arg == "--daemon-child" {

core/cmd/dms/utils.go

@@ -6,12 +6,6 @@ import (
 	"strings"
 )
 
-func commandExists(cmd string) bool {
-	_, err := exec.LookPath(cmd)
-	return err == nil
-}
-
-// findCommandPath returns the absolute path to a command in PATH
 func findCommandPath(cmd string) (string, error) {
 	path, err := exec.LookPath(cmd)
 	if err != nil {

core/internal/colorpicker/picker.go

@@ -30,6 +30,7 @@ type Output struct {
 	height          int32
 	scale           int32
 	fractionalScale float64
+	transform       int32
 }
 
 type LayerSurface struct {
@@ -276,6 +277,7 @@ func (p *Picker) setupOutputHandlers(name uint32, output *client.Output) {
 		if o, ok := p.outputs[name]; ok {
 			o.x = e.X
 			o.y = e.Y
+			o.transform = int32(e.Transform)
 		}
 		p.outputsMu.Unlock()
 	})
@@ -485,8 +487,19 @@ func (p *Picker) captureForSurface(ls *LayerSurface) {
 	frame.SetReadyHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1ReadyEvent) {
 		ls.state.OnScreencopyReady()
 
-		logicalW, _ := ls.state.LogicalSize()
 		screenBuf := ls.state.ScreenBuffer()
+		if screenBuf != nil && ls.output.transform != TransformNormal {
+			invTransform := InverseTransform(ls.output.transform)
+			transformed, err := screenBuf.ApplyTransform(invTransform)
+			if err != nil {
+				log.Error("apply transform failed", "err", err)
+			} else if transformed != screenBuf {
+				ls.state.ReplaceScreenBuffer(transformed)
+			}
+		}
+
+		logicalW, _ := ls.state.LogicalSize()
+		screenBuf = ls.state.ScreenBuffer()
 		if logicalW > 0 && screenBuf != nil {
 			ls.output.fractionalScale = float64(screenBuf.Width) / float64(logicalW)
 		}

core/internal/colorpicker/shm.go

@@ -4,10 +4,25 @@ import "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/shm"
 
 type ShmBuffer = shm.Buffer
 
+const (
+	TransformNormal     = shm.TransformNormal
+	Transform90         = shm.Transform90
+	Transform180        = shm.Transform180
+	Transform270        = shm.Transform270
+	TransformFlipped    = shm.TransformFlipped
+	TransformFlipped90  = shm.TransformFlipped90
+	TransformFlipped180 = shm.TransformFlipped180
+	TransformFlipped270 = shm.TransformFlipped270
+)
+
 func CreateShmBuffer(width, height, stride int) (*ShmBuffer, error) {
 	return shm.CreateBuffer(width, height, stride)
 }
 
+func InverseTransform(transform int32) int32 {
+	return shm.InverseTransform(transform)
+}
+
 func GetPixelColor(buf *ShmBuffer, x, y int) Color {
 	return GetPixelColorWithFormat(buf, x, y, FormatARGB8888)
 }

core/internal/colorpicker/state.go

@@ -1,6 +1,7 @@
 package colorpicker
 
 import (
+	"fmt"
 	"math"
 	"strings"
 	"sync"
@@ -15,6 +16,8 @@ const (
 	FormatXRGB8888 = shm.FormatXRGB8888
 	FormatABGR8888 = shm.FormatABGR8888
 	FormatXBGR8888 = shm.FormatXBGR8888
+	FormatRGB888   = shm.FormatRGB888
+	FormatBGR888   = shm.FormatBGR888
 )
 
 type SurfaceState struct {
@@ -79,6 +82,11 @@ func (s *SurfaceState) OnScreencopyBuffer(format PixelFormat, width, height, str
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	bpp := format.BytesPerPixel()
+	if stride < width*bpp {
+		return fmt.Errorf("invalid stride %d for width %d (bpp=%d)", stride, width, bpp)
+	}
+
 	if s.screenBuf != nil {
 		s.screenBuf.Close()
 		s.screenBuf = nil
@@ -90,6 +98,7 @@ func (s *SurfaceState) OnScreencopyBuffer(format PixelFormat, width, height, str
 	}
 
 	s.screenBuf = buf
+	s.screenBuf.Format = format
 	s.screenFormat = format
 	return nil
 }
@@ -106,6 +115,20 @@ func (s *SurfaceState) ScreenFormat() PixelFormat {
 	return s.screenFormat
 }
 
+func (s *SurfaceState) ReplaceScreenBuffer(newBuf *ShmBuffer) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.screenBuf != nil {
+		s.screenBuf.Close()
+	}
+	s.screenBuf = newBuf
+	s.screenFormat = newBuf.Format
+
+	s.recomputeScale()
+	s.ensureRenderBuffers()
+}
+
 func (s *SurfaceState) OnScreencopyFlags(flags uint32) {
 	s.mu.Lock()
 	s.yInverted = (flags & 1) != 0
@@ -120,6 +143,15 @@ func (s *SurfaceState) OnScreencopyReady() {
 		return
 	}
 
+	if s.screenFormat.Is24Bit() {
+		converted, newFormat, err := s.screenBuf.ConvertTo32Bit(s.screenFormat)
+		if err == nil && converted != s.screenBuf {
+			s.screenBuf.Close()
+			s.screenBuf = converted
+			s.screenFormat = newFormat
+		}
+	}
+
 	s.recomputeScale()
 	s.ensureRenderBuffers()
 	s.readyForDisplay = true
@@ -279,10 +311,10 @@ func (s *SurfaceState) Redraw() *ShmBuffer {
 	drawMagnifierWithInversion(
 		dst.Data(), dst.Stride, dst.Width, dst.Height,
 		s.screenBuf.Data(), s.screenBuf.Stride, s.screenBuf.Width, s.screenBuf.Height,
-		px, py, picked, s.yInverted,
+		px, py, picked, s.yInverted, s.screenFormat,
 	)
 
-	drawColorPreview(dst.Data(), dst.Stride, dst.Width, dst.Height, px, py, picked, s.displayFormat, s.lowercase)
+	drawColorPreview(dst.Data(), dst.Stride, dst.Width, dst.Height, px, py, picked, s.displayFormat, s.lowercase, s.screenFormat)
 
 	return dst
 }
@@ -390,6 +422,7 @@ func drawMagnifierWithInversion(
 	cx, cy int,
 	borderColor Color,
 	yInverted bool,
+	format PixelFormat,
 ) {
 	if dstW <= 0 || dstH <= 0 || srcW <= 0 || srcH <= 0 {
 		return
@@ -407,6 +440,14 @@ func drawMagnifierWithInversion(
 	innerRadius := float64(outerRadius - borderThickness)
 	outerRadiusF := float64(outerRadius)
 
+	var rOff, bOff int
+	switch format {
+	case FormatABGR8888, FormatXBGR8888:
+		rOff, bOff = 0, 2
+	default:
+		rOff, bOff = 2, 0
+	}
+
 	for dy := -outerRadius - 2; dy <= outerRadius+2; dy++ {
 		y := cy + dy
 		if y < 0 || y >= dstH {
@@ -431,9 +472,9 @@ func drawMagnifierWithInversion(
 			}
 
 			bgColor := Color{
-				B: dst[dstOff+0],
+				R: dst[dstOff+rOff],
 				G: dst[dstOff+1],
-				R: dst[dstOff+2],
+				B: dst[dstOff+bOff],
 				A: dst[dstOff+3],
 			}
 
@@ -462,7 +503,7 @@ func drawMagnifierWithInversion(
 					}
 					srcOff := sy*srcStride + sx*4
 					if srcOff+4 <= len(src) {
-						magColor := Color{B: src[srcOff+0], G: src[srcOff+1], R: src[srcOff+2], A: 255}
+						magColor := Color{R: src[srcOff+rOff], G: src[srcOff+1], B: src[srcOff+bOff], A: 255}
 						finalColor = blendColors(magColor, borderColor, alpha)
 					} else {
 						finalColor = borderColor
@@ -483,24 +524,25 @@ func drawMagnifierWithInversion(
 				}
 				srcOff := sy*srcStride + sx*4
 				if srcOff+4 <= len(src) {
-					finalColor = Color{B: src[srcOff+0], G: src[srcOff+1], R: src[srcOff+2], A: 255}
+					finalColor = Color{R: src[srcOff+rOff], G: src[srcOff+1], B: src[srcOff+bOff], A: 255}
 				} else {
 					continue
 				}
 			}
 
-			dst[dstOff+0] = finalColor.B
+			dst[dstOff+rOff] = finalColor.R
 			dst[dstOff+1] = finalColor.G
-			dst[dstOff+2] = finalColor.R
+			dst[dstOff+bOff] = finalColor.B
 			dst[dstOff+3] = 255
 		}
 	}
 
-	drawMagnifierCrosshair(dst, dstStride, dstW, dstH, cx, cy, int(innerRadius), crossThickness, crossInnerRadius)
+	drawMagnifierCrosshair(dst, dstStride, dstW, dstH, cx, cy, int(innerRadius), crossThickness, crossInnerRadius, format)
 }
 
 func drawMagnifierCrosshair(
 	data []byte, stride, width, height, cx, cy, radius, thickness, innerRadius int,
+	format PixelFormat,
 ) {
 	if width <= 0 || height <= 0 {
 		return
@@ -998,7 +1040,7 @@ var fontGlyphs = map[rune][fontH]uint8{
 	},
 }
 
-func drawColorPreview(data []byte, stride, width, height int, cx, cy int, c Color, format OutputFormat, lowercase bool) {
+func drawColorPreview(data []byte, stride, width, height int, cx, cy int, c Color, format OutputFormat, lowercase bool, pixelFormat PixelFormat) {
 	text := formatColorForPreview(c, format, lowercase)
 	if len(text) == 0 {
 		return
@@ -1033,9 +1075,8 @@ func drawColorPreview(data []byte, stride, width, height int, cx, cy int, c Colo
 		y = height - boxH
 	}
 
-	drawFilledRect(data, stride, width, height, x, y, boxW, boxH, c)
+	drawFilledRect(data, stride, width, height, x, y, boxW, boxH, c, pixelFormat)
 
-	// Use contrasting text color based on luminance
 	lum := 0.299*float64(c.R) + 0.587*float64(c.G) + 0.114*float64(c.B)
 	var fg Color
 	if lum > 128 {
@@ -1043,7 +1084,7 @@ func drawColorPreview(data []byte, stride, width, height int, cx, cy int, c Colo
 	} else {
 		fg = Color{R: 255, G: 255, B: 255, A: 255}
 	}
-	drawText(data, stride, width, height, x+paddingX, y+paddingY, text, fg)
+	drawText(data, stride, width, height, x+paddingX, y+paddingY, text, fg, pixelFormat)
 }
 
 func formatColorForPreview(c Color, format OutputFormat, lowercase bool) string {
@@ -1064,7 +1105,7 @@ func formatColorForPreview(c Color, format OutputFormat, lowercase bool) string
 	}
 }
 
-func drawFilledRect(data []byte, stride, width, height, x, y, w, h int, col Color) {
+func drawFilledRect(data []byte, stride, width, height, x, y, w, h int, col Color, format PixelFormat) {
 	if w <= 0 || h <= 0 {
 		return
 	}
@@ -1073,6 +1114,14 @@ func drawFilledRect(data []byte, stride, width, height, x, y, w, h int, col Colo
 	x = clamp(x, 0, width)
 	y = clamp(y, 0, height)
 
+	var rOff, bOff int
+	switch format {
+	case FormatABGR8888, FormatXBGR8888:
+		rOff, bOff = 0, 2
+	default:
+		rOff, bOff = 2, 0
+	}
+
 	for yy := y; yy < yEnd; yy++ {
 		rowOff := yy * stride
 		for xx := x; xx < xEnd; xx++ {
@@ -1080,26 +1129,34 @@ func drawFilledRect(data []byte, stride, width, height, x, y, w, h int, col Colo
 			if off+4 > len(data) {
 				continue
 			}
-			data[off+0] = col.B
+			data[off+rOff] = col.R
 			data[off+1] = col.G
-			data[off+2] = col.R
+			data[off+bOff] = col.B
 			data[off+3] = 255
 		}
 	}
 }
 
-func drawText(data []byte, stride, width, height, x, y int, text string, col Color) {
+func drawText(data []byte, stride, width, height, x, y int, text string, col Color, format PixelFormat) {
 	for i, r := range text {
-		drawGlyph(data, stride, width, height, x+i*(fontW+2), y, r, col)
+		drawGlyph(data, stride, width, height, x+i*(fontW+2), y, r, col, format)
 	}
 }
 
-func drawGlyph(data []byte, stride, width, height, x, y int, r rune, col Color) {
+func drawGlyph(data []byte, stride, width, height, x, y int, r rune, col Color, format PixelFormat) {
 	g, ok := fontGlyphs[r]
 	if !ok {
 		return
 	}
 
+	var rOff, bOff int
+	switch format {
+	case FormatABGR8888, FormatXBGR8888:
+		rOff, bOff = 0, 2
+	default:
+		rOff, bOff = 2, 0
+	}
+
 	for row := 0; row < fontH; row++ {
 		yy := y + row
 		if yy < 0 || yy >= height {
@@ -1123,9 +1180,9 @@ func drawGlyph(data []byte, stride, width, height, x, y int, r rune, col Color)
 				continue
 			}
 
-			data[off+0] = col.B
+			data[off+rOff] = col.R
 			data[off+1] = col.G
-			data[off+2] = col.R
+			data[off+bOff] = col.B
 			data[off+3] = 255
 		}
 	}

core/internal/colorpicker/state_test.go

@@ -0,0 +1,314 @@
+package colorpicker
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSurfaceState_ConcurrentPointerMotion(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s.OnPointerMotion(float64(id*10+j), float64(id*10+j))
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ConcurrentScaleAccess(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s.SetScale(int32(id%3 + 1))
+			}
+		}(i)
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				scale := s.Scale()
+				assert.GreaterOrEqual(t, scale, int32(1))
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ConcurrentLogicalSize(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				_ = s.OnLayerConfigure(1920+id, 1080+j)
+			}
+		}(i)
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				w, h := s.LogicalSize()
+				_ = w
+				_ = h
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ConcurrentIsDone(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 100
+
+	for i := 0; i < goroutines/3; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s.OnPointerButton(0x110, 1)
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/3; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s.OnKey(1, 1)
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/3; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				picked, cancelled := s.IsDone()
+				_ = picked
+				_ = cancelled
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ConcurrentIsReady(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+	const iterations = 100
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				_ = s.IsReady()
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ConcurrentSwapBuffers(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+	const iterations = 100
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s.SwapBuffers()
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestSurfaceState_ZeroScale(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	s.SetScale(0)
+	assert.Equal(t, int32(1), s.Scale())
+}
+
+func TestSurfaceState_NegativeScale(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	s.SetScale(-5)
+	assert.Equal(t, int32(1), s.Scale())
+}
+
+func TestSurfaceState_ZeroDimensionConfigure(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+
+	err := s.OnLayerConfigure(0, 100)
+	assert.NoError(t, err)
+
+	err = s.OnLayerConfigure(100, 0)
+	assert.NoError(t, err)
+
+	err = s.OnLayerConfigure(-1, 100)
+	assert.NoError(t, err)
+
+	w, h := s.LogicalSize()
+	assert.Equal(t, 0, w)
+	assert.Equal(t, 0, h)
+}
+
+func TestSurfaceState_PickColorNilBuffer(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	color, ok := s.PickColor()
+	assert.False(t, ok)
+	assert.Equal(t, Color{}, color)
+}
+
+func TestSurfaceState_RedrawNilBuffer(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	buf := s.Redraw()
+	assert.Nil(t, buf)
+}
+
+func TestSurfaceState_RedrawScreenOnlyNilBuffer(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	buf := s.RedrawScreenOnly()
+	assert.Nil(t, buf)
+}
+
+func TestSurfaceState_FrontRenderBufferNil(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	buf := s.FrontRenderBuffer()
+	assert.Nil(t, buf)
+}
+
+func TestSurfaceState_ScreenBufferNil(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	buf := s.ScreenBuffer()
+	assert.Nil(t, buf)
+}
+
+func TestSurfaceState_DestroyMultipleTimes(t *testing.T) {
+	s := NewSurfaceState(FormatHex, false)
+	s.Destroy()
+	s.Destroy()
+}
+
+func TestClamp(t *testing.T) {
+	tests := []struct {
+		v, lo, hi, expected int
+	}{
+		{5, 0, 10, 5},
+		{-5, 0, 10, 0},
+		{15, 0, 10, 10},
+		{0, 0, 10, 0},
+		{10, 0, 10, 10},
+	}
+
+	for _, tt := range tests {
+		result := clamp(tt.v, tt.lo, tt.hi)
+		assert.Equal(t, tt.expected, result)
+	}
+}
+
+func TestClampF(t *testing.T) {
+	tests := []struct {
+		v, lo, hi, expected float64
+	}{
+		{5.0, 0.0, 10.0, 5.0},
+		{-5.0, 0.0, 10.0, 0.0},
+		{15.0, 0.0, 10.0, 10.0},
+		{0.0, 0.0, 10.0, 0.0},
+		{10.0, 0.0, 10.0, 10.0},
+	}
+
+	for _, tt := range tests {
+		result := clampF(tt.v, tt.lo, tt.hi)
+		assert.InDelta(t, tt.expected, result, 0.001)
+	}
+}
+
+func TestAbs(t *testing.T) {
+	tests := []struct {
+		v, expected int
+	}{
+		{5, 5},
+		{-5, 5},
+		{0, 0},
+	}
+
+	for _, tt := range tests {
+		result := abs(tt.v)
+		assert.Equal(t, tt.expected, result)
+	}
+}
+
+func TestBlendColors(t *testing.T) {
+	bg := Color{R: 0, G: 0, B: 0, A: 255}
+	fg := Color{R: 255, G: 255, B: 255, A: 255}
+
+	result := blendColors(bg, fg, 0.0)
+	assert.Equal(t, bg.R, result.R)
+	assert.Equal(t, bg.G, result.G)
+	assert.Equal(t, bg.B, result.B)
+
+	result = blendColors(bg, fg, 1.0)
+	assert.Equal(t, fg.R, result.R)
+	assert.Equal(t, fg.G, result.G)
+	assert.Equal(t, fg.B, result.B)
+
+	result = blendColors(bg, fg, 0.5)
+	assert.InDelta(t, 127, int(result.R), 1)
+	assert.InDelta(t, 127, int(result.G), 1)
+	assert.InDelta(t, 127, int(result.B), 1)
+
+	result = blendColors(bg, fg, -1.0)
+	assert.Equal(t, bg.R, result.R)
+
+	result = blendColors(bg, fg, 2.0)
+	assert.Equal(t, fg.R, result.R)
+}

core/internal/config/deployer.go

@@ -46,11 +46,20 @@ func (cd *ConfigDeployer) DeployConfigurationsWithTerminal(ctx context.Context,
 	return cd.DeployConfigurationsSelective(ctx, wm, terminal, nil, nil)
 }
 
+// DeployConfigurationsWithSystemd deploys configurations with systemd option
+func (cd *ConfigDeployer) DeployConfigurationsWithSystemd(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, useSystemd bool) ([]DeploymentResult, error) {
+	return cd.deployConfigurationsInternal(ctx, wm, terminal, nil, nil, nil, useSystemd)
+}
+
 func (cd *ConfigDeployer) DeployConfigurationsSelective(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool) ([]DeploymentResult, error) {
 	return cd.DeployConfigurationsSelectiveWithReinstalls(ctx, wm, terminal, installedDeps, replaceConfigs, nil)
 }
 
 func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool, reinstallItems map[string]bool) ([]DeploymentResult, error) {
+	return cd.deployConfigurationsInternal(ctx, wm, terminal, installedDeps, replaceConfigs, reinstallItems, true)
+}
+
+func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool, reinstallItems map[string]bool, useSystemd bool) ([]DeploymentResult, error) {
 	var results []DeploymentResult
 
 	shouldReplaceConfig := func(configType string) bool {
@@ -64,7 +73,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 	switch wm {
 	case deps.WindowManagerNiri:
 		if shouldReplaceConfig("Niri") {
-			result, err := cd.deployNiriConfig(terminal)
+			result, err := cd.deployNiriConfig(terminal, useSystemd)
 			results = append(results, result)
 			if err != nil {
 				return results, fmt.Errorf("failed to deploy Niri config: %w", err)
@@ -72,7 +81,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 		}
 	case deps.WindowManagerHyprland:
 		if shouldReplaceConfig("Hyprland") {
-			result, err := cd.deployHyprlandConfig(terminal)
+			result, err := cd.deployHyprlandConfig(terminal, useSystemd)
 			results = append(results, result)
 			if err != nil {
 				return results, fmt.Errorf("failed to deploy Hyprland config: %w", err)
@@ -110,7 +119,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 	return results, nil
 }
 
-func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentResult, error) {
+func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal, useSystemd bool) (DeploymentResult, error) {
 	result := DeploymentResult{
 		ConfigType: "Niri",
 		Path:       filepath.Join(os.Getenv("HOME"), ".config", "niri", "config.kdl"),
@@ -148,12 +157,6 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 		cd.log(fmt.Sprintf("Backed up existing config to %s", result.BackupPath))
 	}
 
-	polkitPath, err := cd.detectPolkitAgent()
-	if err != nil {
-		cd.log(fmt.Sprintf("Warning: Could not detect polkit agent: %v", err))
-		polkitPath = "/usr/lib/mate-polkit/polkit-mate-authentication-agent-1"
-	}
-
 	var terminalCommand string
 	switch terminal {
 	case deps.TerminalGhostty:
@@ -166,8 +169,11 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 		terminalCommand = "ghostty"
 	}
 
-	newConfig := strings.ReplaceAll(NiriConfig, "{{POLKIT_AGENT_PATH}}", polkitPath)
-	newConfig = strings.ReplaceAll(newConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+	newConfig := strings.ReplaceAll(NiriConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+
+	if !useSystemd {
+		newConfig = cd.transformNiriConfigForNonSystemd(newConfig, terminalCommand)
+	}
 
 	if existingConfig != "" {
 		mergedConfig, err := cd.mergeNiriOutputSections(newConfig, existingConfig)
@@ -404,41 +410,6 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 	return results, nil
 }
 
-// detectPolkitAgent tries to find the polkit authentication agent on the system
-// Prioritizes mate-polkit paths since that's what we install
-func (cd *ConfigDeployer) detectPolkitAgent() (string, error) {
-	// Prioritize mate-polkit paths first
-	matePaths := []string{
-		"/usr/libexec/polkit-mate-authentication-agent-1", // Fedora path
-		"/usr/lib/mate-polkit/polkit-mate-authentication-agent-1",
-		"/usr/libexec/mate-polkit/polkit-mate-authentication-agent-1",
-		"/usr/lib/polkit-mate/polkit-mate-authentication-agent-1",
-		"/usr/lib/x86_64-linux-gnu/mate-polkit/polkit-mate-authentication-agent-1",
-	}
-
-	for _, path := range matePaths {
-		if _, err := os.Stat(path); err == nil {
-			cd.log(fmt.Sprintf("Found mate-polkit agent at: %s", path))
-			return path, nil
-		}
-	}
-
-	// Fallback to other polkit agents if mate-polkit is not found
-	fallbackPaths := []string{
-		"/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1",
-		"/usr/libexec/polkit-gnome-authentication-agent-1",
-	}
-
-	for _, path := range fallbackPaths {
-		if _, err := os.Stat(path); err == nil {
-			cd.log(fmt.Sprintf("Found fallback polkit agent at: %s", path))
-			return path, nil
-		}
-	}
-
-	return "", fmt.Errorf("no polkit agent found in common locations")
-}
-
 // 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)
@@ -482,7 +453,7 @@ func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig stri
 }
 
 // deployHyprlandConfig handles Hyprland configuration deployment with backup and merging
-func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal) (DeploymentResult, error) {
+func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystemd bool) (DeploymentResult, error) {
 	result := DeploymentResult{
 		ConfigType: "Hyprland",
 		Path:       filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.conf"),
@@ -514,14 +485,6 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal) (Deployme
 		cd.log(fmt.Sprintf("Backed up existing config to %s", result.BackupPath))
 	}
 
-	// Detect polkit agent path
-	polkitPath, err := cd.detectPolkitAgent()
-	if err != nil {
-		cd.log(fmt.Sprintf("Warning: Could not detect polkit agent: %v", err))
-		polkitPath = "/usr/lib/mate-polkit/polkit-mate-authentication-agent-1" // fallback
-	}
-
-	// Determine terminal command based on choice
 	var terminalCommand string
 	switch terminal {
 	case deps.TerminalGhostty:
@@ -531,13 +494,15 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal) (Deployme
 	case deps.TerminalAlacritty:
 		terminalCommand = "alacritty"
 	default:
-		terminalCommand = "ghostty" // fallback to ghostty
+		terminalCommand = "ghostty"
 	}
 
-	newConfig := strings.ReplaceAll(HyprlandConfig, "{{POLKIT_AGENT_PATH}}", polkitPath)
-	newConfig = strings.ReplaceAll(newConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+	newConfig := strings.ReplaceAll(HyprlandConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+
+	if !useSystemd {
+		newConfig = cd.transformHyprlandConfigForNonSystemd(newConfig, terminalCommand)
+	}
 
-	// If there was an existing config, merge the monitor sections
 	if existingConfig != "" {
 		mergedConfig, err := cd.mergeHyprlandMonitorSections(newConfig, existingConfig)
 		if err != nil {
@@ -560,24 +525,16 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal) (Deployme
 
 // mergeHyprlandMonitorSections extracts monitor sections from existing config and merges them into the new config
 func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig string) (string, error) {
-	// Regular expression to match monitor lines (including commented ones)
-	// Matches: monitor = NAME, RESOLUTION, POSITION, SCALE, etc.
-	// Also matches commented versions: # monitor = ...
 	monitorRegex := regexp.MustCompile(`(?m)^#?\s*monitor\s*=.*$`)
-
-	// Find all monitor lines in the existing config
 	existingMonitors := monitorRegex.FindAllString(existingConfig, -1)
 
 	if len(existingMonitors) == 0 {
-		// No monitor sections to merge
 		return newConfig, nil
 	}
 
-	// Remove the example monitor line from the new config
 	exampleMonitorRegex := regexp.MustCompile(`(?m)^# monitor = eDP-2.*$`)
 	mergedConfig := exampleMonitorRegex.ReplaceAllString(newConfig, "")
 
-	// Find where to insert the monitor sections (after the MONITOR CONFIG header)
 	monitorHeaderRegex := regexp.MustCompile(`(?m)^# MONITOR CONFIG\n# ==================$`)
 	headerMatch := monitorHeaderRegex.FindStringIndex(mergedConfig)
 
@@ -585,8 +542,7 @@ func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig
 		return "", fmt.Errorf("could not find MONITOR CONFIG section")
 	}
 
-	// Insert after the header
-	insertPos := headerMatch[1] + 1 // +1 for the newline
+	insertPos := headerMatch[1] + 1
 
 	var builder strings.Builder
 	builder.WriteString(mergedConfig[:insertPos])
@@ -601,3 +557,69 @@ func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig
 
 	return builder.String(), nil
 }
+
+func (cd *ConfigDeployer) transformHyprlandConfigForNonSystemd(config, terminalCommand string) string {
+	lines := strings.Split(config, "\n")
+	var result []string
+	startupSectionFound := false
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "exec-once = dbus-update-activation-environment") {
+			continue
+		}
+		if strings.HasPrefix(trimmed, "exec-once = systemctl --user start") {
+			startupSectionFound = true
+			result = append(result, "exec-once = dms run")
+			result = append(result, "env = QT_QPA_PLATFORM,wayland")
+			result = append(result, "env = ELECTRON_OZONE_PLATFORM_HINT,auto")
+			result = append(result, "env = QT_QPA_PLATFORMTHEME,gtk3")
+			result = append(result, "env = QT_QPA_PLATFORMTHEME_QT6,gtk3")
+			result = append(result, fmt.Sprintf("env = TERMINAL,%s", terminalCommand))
+			continue
+		}
+		result = append(result, line)
+	}
+
+	if !startupSectionFound {
+		for i, line := range result {
+			if strings.Contains(line, "STARTUP APPS") {
+				insertLines := []string{
+					"exec-once = dms run",
+					"env = QT_QPA_PLATFORM,wayland",
+					"env = ELECTRON_OZONE_PLATFORM_HINT,auto",
+					"env = QT_QPA_PLATFORMTHEME,gtk3",
+					"env = QT_QPA_PLATFORMTHEME_QT6,gtk3",
+					fmt.Sprintf("env = TERMINAL,%s", terminalCommand),
+				}
+				result = append(result[:i+2], append(insertLines, result[i+2:]...)...)
+				break
+			}
+		}
+	}
+
+	return strings.Join(result, "\n")
+}
+
+func (cd *ConfigDeployer) transformNiriConfigForNonSystemd(config, terminalCommand string) string {
+	envVars := fmt.Sprintf(`environment {
+  XDG_CURRENT_DESKTOP "niri"
+  QT_QPA_PLATFORM "wayland"
+  ELECTRON_OZONE_PLATFORM_HINT "auto"
+  QT_QPA_PLATFORMTHEME "gtk3"
+  QT_QPA_PLATFORMTHEME_QT6 "gtk3"
+  TERMINAL "%s"
+}`, terminalCommand)
+
+	config = regexp.MustCompile(`environment \{[^}]*\}`).ReplaceAllString(config, envVars)
+
+	spawnDms := `spawn-at-startup "dms" "run"`
+	if !strings.Contains(config, spawnDms) {
+		config = strings.Replace(config,
+			`spawn-at-startup "bash" "-c" "wl-paste --watch cliphist store &"`,
+			`spawn-at-startup "bash" "-c" "wl-paste --watch cliphist store &"`+"\n"+spawnDms,
+			1)
+	}
+
+	return config
+}

core/internal/config/deployer_test.go

@@ -3,7 +3,6 @@ package config
 import (
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
@@ -11,23 +10,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestDetectPolkitAgent(t *testing.T) {
-	cd := &ConfigDeployer{}
-
-	// This test depends on the system having a polkit agent installed
-	// We'll just test that the function doesn't crash and returns some path or error
-	path, err := cd.detectPolkitAgent()
-
-	if err != nil {
-		// If no polkit agent is found, that's okay for testing
-		assert.Contains(t, err.Error(), "no polkit agent found")
-	} else {
-		// If found, it should be a valid path
-		assert.NotEmpty(t, path)
-		assert.True(t, strings.Contains(path, "polkit"))
-	}
-}
-
 func TestMergeNiriOutputSections(t *testing.T) {
 	cd := &ConfigDeployer{}
 
@@ -272,17 +254,6 @@ func getGhosttyPath() string {
 	return filepath.Join(os.Getenv("HOME"), ".config", "ghostty", "config")
 }
 
-func TestPolkitPathInjection(t *testing.T) {
-
-	testConfig := `spawn-at-startup "{{POLKIT_AGENT_PATH}}"
-other content`
-
-	result := strings.Replace(testConfig, "{{POLKIT_AGENT_PATH}}", "/test/polkit/path", 1)
-
-	assert.Contains(t, result, `spawn-at-startup "/test/polkit/path"`)
-	assert.NotContains(t, result, "{{POLKIT_AGENT_PATH}}")
-}
-
 func TestMergeHyprlandMonitorSections(t *testing.T) {
 	cd := &ConfigDeployer{}
 
@@ -424,7 +395,7 @@ func TestHyprlandConfigDeployment(t *testing.T) {
 	cd := NewConfigDeployer(logChan)
 
 	t.Run("deploy hyprland config to empty directory", func(t *testing.T) {
-		result, err := cd.deployHyprlandConfig(deps.TerminalGhostty)
+		result, err := cd.deployHyprlandConfig(deps.TerminalGhostty, true)
 		require.NoError(t, err)
 
 		assert.Equal(t, "Hyprland", result.ConfigType)
@@ -435,7 +406,7 @@ func TestHyprlandConfigDeployment(t *testing.T) {
 		content, err := os.ReadFile(result.Path)
 		require.NoError(t, err)
 		assert.Contains(t, string(content), "# MONITOR CONFIG")
-		assert.Contains(t, string(content), "bind = $mod, T, exec, $TERMINAL")
+		assert.Contains(t, string(content), "bind = $mod, T, exec, ghostty")
 		assert.Contains(t, string(content), "exec-once = ")
 	})
 
@@ -454,7 +425,7 @@ general {
 		err = os.WriteFile(hyprPath, []byte(existingContent), 0644)
 		require.NoError(t, err)
 
-		result, err := cd.deployHyprlandConfig(deps.TerminalKitty)
+		result, err := cd.deployHyprlandConfig(deps.TerminalKitty, true)
 		require.NoError(t, err)
 
 		assert.Equal(t, "Hyprland", result.ConfigType)
@@ -471,7 +442,7 @@ general {
 		require.NoError(t, err)
 		assert.Contains(t, string(newContent), "monitor = DP-1, 1920x1080@144")
 		assert.Contains(t, string(newContent), "monitor = HDMI-A-1, 3840x2160@60")
-		assert.Contains(t, string(newContent), "bind = $mod, T, exec, $TERMINAL")
+		assert.Contains(t, string(newContent), "bind = $mod, T, exec, kitty")
 		assert.NotContains(t, string(newContent), "monitor = eDP-2")
 	})
 }
@@ -479,7 +450,6 @@ general {
 func TestNiriConfigStructure(t *testing.T) {
 	assert.Contains(t, NiriConfig, "input {")
 	assert.Contains(t, NiriConfig, "layout {")
-	assert.Contains(t, NiriConfig, "{{POLKIT_AGENT_PATH}}")
 
 	assert.Contains(t, NiriBindsConfig, "binds {")
 	assert.Contains(t, NiriBindsConfig, `spawn "{{TERMINAL_COMMAND}}"`)
@@ -490,11 +460,9 @@ func TestHyprlandConfigStructure(t *testing.T) {
 	assert.Contains(t, HyprlandConfig, "# STARTUP APPS")
 	assert.Contains(t, HyprlandConfig, "# INPUT CONFIG")
 	assert.Contains(t, HyprlandConfig, "# KEYBINDINGS")
-	assert.Contains(t, HyprlandConfig, "{{POLKIT_AGENT_PATH}}")
-	assert.Contains(t, HyprlandConfig, "bind = $mod, T, exec, $TERMINAL")
+	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, "windowrule {")
-	assert.Contains(t, HyprlandConfig, "match:class = ^(com\\.mitchellh\\.ghostty)$")
+	assert.Contains(t, HyprlandConfig, "windowrulev2 = noborder, class:^(com\\.mitchellh\\.ghostty)$")
 }
 
 func TestGhosttyConfigStructure(t *testing.T) {

core/internal/config/dms.go

@@ -5,19 +5,14 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
-// LocateDMSConfig searches for DMS installation following XDG Base Directory specification
 func LocateDMSConfig() (string, error) {
 	var primaryPaths []string
 
-	configHome := os.Getenv("XDG_CONFIG_HOME")
-	if configHome == "" {
-		if homeDir, err := os.UserHomeDir(); err == nil {
-			configHome = filepath.Join(homeDir, ".config")
-		}
-	}
-
+	configHome := utils.XDGConfigHome()
 	if configHome != "" {
 		primaryPaths = append(primaryPaths, filepath.Join(configHome, "quickshell", "dms"))
 	}

core/internal/config/embedded/hyprland.conf

@@ -10,8 +10,9 @@ monitor = , preferred,auto,auto
 # ==================
 # STARTUP APPS
 # ==================
+exec-once = dbus-update-activation-environment --systemd --all
+exec-once = systemctl --user start hyprland-session.target
 exec-once = bash -c "wl-paste --watch cliphist store &"
-exec-once = {{POLKIT_AGENT_PATH}}
 
 # ==================
 # INPUT CONFIG
@@ -90,132 +91,36 @@ misc {
 # ==================
 # WINDOW RULES
 # ==================
-windowrule {
-  name = windowrule-1
-  tile = on
-  match:class = ^(org\.wezfurlong\.wezterm)$
-  border_size = 0
-}
+windowrulev2 = tile, class:^(org\.wezfurlong\.wezterm)$
 
+windowrulev2 = rounding 12, class:^(org\.gnome\.)
+windowrulev2 = noborder, class:^(org\.gnome\.)
 
-windowrule {
-  name = windowrule-2
-  rounding = 12
-  match:class = ^(org\.gnome\.)
-  border_size = 0
-}
+windowrulev2 = tile, class:^(gnome-control-center)$
+windowrulev2 = tile, class:^(pavucontrol)$
+windowrulev2 = tile, 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)$
 
+windowrulev2 = noborder, class:^(org\.wezfurlong\.wezterm)$
+windowrulev2 = noborder, class:^(Alacritty)$
+windowrulev2 = noborder, class:^(zen)$
+windowrulev2 = noborder, class:^(com\.mitchellh\.ghostty)$
+windowrulev2 = noborder, class:^(kitty)$
 
-windowrule {
-  name = windowrule-3
-  tile = on
-  match:class = ^(gnome-control-center)$
-}
+windowrulev2 = float, class:^(firefox)$, title:^(Picture-in-Picture)$
+windowrulev2 = float, class:^(zoom)$
 
-windowrule {
-  name = windowrule-4
-  tile = on
-  match:class = ^(pavucontrol)$
-}
+# DMS windows floating by default
+windowrulev2 = float, class:^(org.quickshell)$
+windowrulev2 = opacity 0.9 0.9, floating:0, focus:0
 
-windowrule {
-  name = windowrule-5
-  tile = on
-  match:class = ^(nm-connection-editor)$
-}
-
-
-windowrule {
-  name = windowrule-6
-  float = on
-  match:class = ^(gnome-calculator)$
-}
-
-windowrule {
-  name = windowrule-7
-  float = on
-  match:class = ^(galculator)$
-}
-
-windowrule {
-  name = windowrule-8
-  float = on
-  match:class = ^(blueman-manager)$
-}
-
-windowrule {
-  name = windowrule-9
-  float = on
-  match:class = ^(org\.gnome\.Nautilus)$
-}
-
-windowrule {
-  name = windowrule-10
-  float = on
-  match:class = ^(steam)$
-}
-
-windowrule {
-  name = windowrule-11
-  float = on
-  match:class = ^(xdg-desktop-portal)$
-}
-
-
-
-windowrule {
-  name = windowrule-12
-  border_size = 0
-  match:class = ^(Alacritty)$
-}
-
-windowrule {
-  name = windowrule-13
-  border_size = 0
-  match:class = ^(zen)$
-}
-
-windowrule {
-  name = windowrule-14
-  border_size = 0
-  match:class = ^(com\.mitchellh\.ghostty)$
-}
-
-windowrule {
-  name = windowrule-15
-  border_size = 0
-  match:class = ^(kitty)$
-}
-
-
-windowrule {
-  name = windowrule-16
-  float = on
-  match:class = ^(firefox)$
-  match:title = ^(Picture-in-Picture)$
-}
-
-windowrule {
-  name = windowrule-17
-  float = on
-  match:class = ^(zoom)$
-}
-
-
-windowrule {
-  name = windowrule-18
-  opacity = 0.9 0.9
-  match:float = 0
-  match:focus = 0
-}
-
-
-layerrule {
-  name = layerrule-1
-  no_anim = on
-  match:namespace = ^(quickshell)$
-}
+layerrule = noanim, ^(quickshell)$
 
 # ==================
 # KEYBINDINGS
@@ -223,7 +128,7 @@ layerrule {
 $mod = SUPER
 
 # === Application Launchers ===
-bind = $mod, T, exec, $TERMINAL
+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
@@ -372,4 +277,4 @@ bind = CTRL, Print, exec, dms screenshot full
 bind = ALT, Print, exec, dms screenshot window
 
 # === System Controls ===
-bind = $mod SHIFT, P, dpms, off
+bind = $mod SHIFT, P, dpms, toggle

core/internal/config/embedded/niri.kdl

@@ -44,7 +44,6 @@ input {
 // https://github.com/YaLTeR/niri/wiki/Configuration:-Layout
 layout {
     // Set gaps around windows in logical pixels.
-    gaps 5
     background-color "transparent"
     // When to center a column when changing focus, options are:
     // - "never", default behavior, focusing an off-screen column will keep at the left
@@ -87,11 +86,6 @@ layout {
         inactive-color "#d0d0d0"      // Light gray
         urgent-color   "#cc4444"      // Softer red
     }
-    focus-ring {
-        width 2
-        active-color   "#808080"      // Medium gray
-        inactive-color "#505050"      // Dark gray
-    }
     shadow {
         softness 30
         spread 5
@@ -116,7 +110,6 @@ overview {
 // See the binds section below for more spawn examples.
 // This line starts waybar, a commonly used bar for Wayland compositors.
 spawn-at-startup "bash" "-c" "wl-paste --watch cliphist store &"
-spawn-at-startup "{{POLKIT_AGENT_PATH}}"
 environment {
   XDG_CURRENT_DESKTOP "niri"
 }

core/internal/dank16/dank16.go

@@ -113,13 +113,14 @@ func RGBToHSV(rgb RGB) HSV {
 	delta := max - min
 
 	var h float64
-	if delta == 0 {
+	switch {
+	case delta == 0:
 		h = 0
-	} else if max == rgb.R {
+	case max == rgb.R:
 		h = math.Mod((rgb.G-rgb.B)/delta, 6.0) / 6.0
-	} else if max == rgb.G {
+	case max == rgb.G:
 		h = ((rgb.B-rgb.R)/delta + 2.0) / 6.0
-	} else {
+	default:
 		h = ((rgb.R-rgb.G)/delta + 4.0) / 6.0
 	}
 

core/internal/distros/arch.go

@@ -112,31 +112,11 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 }
 
 func (a *ArchDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if a.packageInstalled("xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
+	return a.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", a.packageInstalled("xdg-desktop-portal-gtk"))
 }
 
 func (a *ArchDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
-	if a.packageInstalled("accountsservice") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "accountsservice",
-		Status:      status,
-		Description: "D-Bus interface for user account query and manipulation",
-		Required:    true,
-	}
+	return a.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", a.packageInstalled("accountsservice"))
 }
 
 func (a *ArchDistribution) packageInstalled(pkg string) bool {
@@ -182,13 +162,11 @@ func (a *ArchDistribution) getQuickshellMapping(variant deps.PackageVariant) Pac
 	if forceQuickshellGit || variant == deps.VariantGit {
 		return PackageMapping{Name: "quickshell-git", Repository: RepoTypeAUR}
 	}
-	return PackageMapping{Name: "quickshell", Repository: RepoTypeSystem}
+	// ! TODO - for now we're only forcing quickshell-git on ARCH, as other distros use DL repos which pin a newer quickshell
+	return PackageMapping{Name: "quickshell-git", Repository: RepoTypeAUR}
 }
 
-func (a *ArchDistribution) getHyprlandMapping(variant deps.PackageVariant) PackageMapping {
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "hyprland-git", Repository: RepoTypeAUR}
-	}
+func (a *ArchDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
 	return PackageMapping{Name: "hyprland", Repository: RepoTypeSystem}
 }
 
@@ -362,7 +340,11 @@ func (a *ArchDistribution) InstallPackages(ctx context.Context, dependencies []d
 		a.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := a.EnableDMSService(ctx); err != nil {
+	if err := a.WriteWindowManagerConfig(wm); err != nil {
+		a.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := a.EnableDMSService(ctx, wm); err != nil {
 		a.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 

core/internal/distros/base.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
 )
 
@@ -76,47 +77,42 @@ func ExecSudoCommand(ctx context.Context, sudoPassword string, command string) *
 	return exec.CommandContext(ctx, "bash", "-c", cmdStr)
 }
 
-// Common dependency detection methods
-func (b *BaseDistribution) detectGit() deps.Dependency {
+func (b *BaseDistribution) detectCommand(name, description string) deps.Dependency {
 	status := deps.StatusMissing
-	if b.commandExists("git") {
+	if b.commandExists(name) {
 		status = deps.StatusInstalled
 	}
-
 	return deps.Dependency{
-		Name:        "git",
+		Name:        name,
 		Status:      status,
-		Description: "Version control system",
+		Description: description,
 		Required:    true,
 	}
 }
 
+func (b *BaseDistribution) detectPackage(name, description string, installed bool) deps.Dependency {
+	status := deps.StatusMissing
+	if installed {
+		status = deps.StatusInstalled
+	}
+	return deps.Dependency{
+		Name:        name,
+		Status:      status,
+		Description: description,
+		Required:    true,
+	}
+}
+
+func (b *BaseDistribution) detectGit() deps.Dependency {
+	return b.detectCommand("git", "Version control system")
+}
+
 func (b *BaseDistribution) detectMatugen() deps.Dependency {
-	status := deps.StatusMissing
-	if b.commandExists("matugen") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "matugen",
-		Status:      status,
-		Description: "Material Design color generation tool",
-		Required:    true,
-	}
+	return b.detectCommand("matugen", "Material Design color generation tool")
 }
 
 func (b *BaseDistribution) detectDgop() deps.Dependency {
-	status := deps.StatusMissing
-	if b.commandExists("dgop") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "dgop",
-		Status:      status,
-		Description: "Desktop portal management tool",
-		Required:    true,
-	}
+	return b.detectCommand("dgop", "Desktop portal management tool")
 }
 
 func (b *BaseDistribution) detectDMS() deps.Dependency {
@@ -586,12 +582,20 @@ func (b *BaseDistribution) WriteEnvironmentConfig(terminal deps.Terminal) error
 		terminalCmd = "ghostty"
 	}
 
-	content := fmt.Sprintf(`QT_QPA_PLATFORM=wayland
+	// ! This deviates from master branch so it doesnt need a hotfix
+	var content string
+	if utils.CommandExists("plasmashell") || utils.CommandExists("plasma-session") || utils.CommandExists("plasma_session") {
+		content = fmt.Sprintf(`ELECTRON_OZONE_PLATFORM_HINT=auto
+TERMINAL=%s
+`, terminalCmd)
+	} else {
+		content = fmt.Sprintf(`QT_QPA_PLATFORM=wayland
 ELECTRON_OZONE_PLATFORM_HINT=auto
 QT_QPA_PLATFORMTHEME=gtk3
 QT_QPA_PLATFORMTHEME_QT6=gtk3
 TERMINAL=%s
 `, terminalCmd)
+	}
 
 	envFile := filepath.Join(envDir, "90-dms.conf")
 	if err := os.WriteFile(envFile, []byte(content), 0644); err != nil {
@@ -602,12 +606,53 @@ TERMINAL=%s
 	return nil
 }
 
-func (b *BaseDistribution) EnableDMSService(ctx context.Context) error {
-	cmd := exec.CommandContext(ctx, "systemctl", "--user", "enable", "--now", "dms")
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("failed to enable dms service: %w", err)
+func (b *BaseDistribution) EnableDMSService(ctx context.Context, wm deps.WindowManager) error {
+	switch wm {
+	case deps.WindowManagerNiri:
+		if err := exec.CommandContext(ctx, "systemctl", "--user", "add-wants", "niri.service", "dms").Run(); err != nil {
+			b.log("Warning: failed to add dms as a want for niri.service")
+		}
+	case deps.WindowManagerHyprland:
+		if err := exec.CommandContext(ctx, "systemctl", "--user", "add-wants", "hyprland-session.target", "dms").Run(); err != nil {
+			b.log("Warning: failed to add dms as a want for hyprland-session.target")
+		}
 	}
-	b.log("Enabled dms systemd user service")
+
+	return nil
+}
+
+func (b *BaseDistribution) WriteWindowManagerConfig(wm deps.WindowManager) error {
+	if wm == deps.WindowManagerHyprland {
+		if err := b.WriteHyprlandSessionTarget(); err != nil {
+			return fmt.Errorf("failed to write hyprland session target: %w", err)
+		}
+	}
+	return nil
+}
+
+func (b *BaseDistribution) WriteHyprlandSessionTarget() error {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	targetDir := filepath.Join(homeDir, ".config", "systemd", "user")
+	if err := os.MkdirAll(targetDir, 0755); err != nil {
+		return fmt.Errorf("failed to create systemd user directory: %w", err)
+	}
+
+	targetPath := filepath.Join(targetDir, "hyprland-session.target")
+	content := `[Unit]
+Description=Hyprland Session Target
+Requires=graphical-session.target
+After=graphical-session.target
+`
+
+	if err := os.WriteFile(targetPath, []byte(content), 0644); err != nil {
+		return fmt.Errorf("failed to write hyprland-session.target: %w", err)
+	}
+
+	b.log(fmt.Sprintf("Wrote hyprland-session.target to %s", targetPath))
 	return nil
 }
 

core/internal/distros/base_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 func TestBaseDistribution_detectDMS_NotInstalled(t *testing.T) {
@@ -36,7 +37,7 @@ func TestBaseDistribution_detectDMS_NotInstalled(t *testing.T) {
 }
 
 func TestBaseDistribution_detectDMS_Installed(t *testing.T) {
-	if !commandExists("git") {
+	if !utils.CommandExists("git") {
 		t.Skip("git not available")
 	}
 
@@ -80,7 +81,7 @@ func TestBaseDistribution_detectDMS_Installed(t *testing.T) {
 }
 
 func TestBaseDistribution_detectDMS_NeedsUpdate(t *testing.T) {
-	if !commandExists("git") {
+	if !utils.CommandExists("git") {
 		t.Skip("git not available")
 	}
 
@@ -164,11 +165,6 @@ func TestBaseDistribution_NewBaseDistribution(t *testing.T) {
 	}
 }
 
-func commandExists(cmd string) bool {
-	_, err := exec.LookPath(cmd)
-	return err == nil
-}
-
 func TestBaseDistribution_versionCompare(t *testing.T) {
 	logChan := make(chan string, 10)
 	defer close(logChan)

core/internal/distros/debian.go

@@ -75,45 +75,15 @@ func (d *DebianDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 }
 
 func (d *DebianDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if d.packageInstalled("xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
+	return d.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", d.packageInstalled("xdg-desktop-portal-gtk"))
 }
 
 func (d *DebianDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
-	if d.commandExists("xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
+	return d.detectCommand("xwayland-satellite", "Xwayland support")
 }
 
 func (d *DebianDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
-	if d.packageInstalled("accountsservice") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "accountsservice",
-		Status:      status,
-		Description: "D-Bus interface for user account query and manipulation",
-		Required:    true,
-	}
+	return d.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", d.packageInstalled("accountsservice"))
 }
 
 func (d *DebianDistribution) packageInstalled(pkg string) bool {
@@ -208,7 +178,7 @@ func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 
 	checkCmd := exec.CommandContext(ctx, "dpkg", "-l", "build-essential")
 	if err := checkCmd.Run(); err != nil {
-		cmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y build-essential")
+		cmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y build-essential")
 		if err := d.runWithProgress(cmd, progressChan, PhasePrerequisites, 0.08, 0.09); err != nil {
 			return fmt.Errorf("failed to install build-essential: %w", err)
 		}
@@ -225,7 +195,7 @@ func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 	}
 
 	devToolsCmd := ExecSudoCommand(ctx, sudoPassword,
-		"apt-get install -y curl wget git cmake ninja-build pkg-config libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev libjpeg-dev libpugixml-dev")
+		"DEBIAN_FRONTEND=noninteractive apt-get install -y curl wget git cmake ninja-build pkg-config libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev libjpeg-dev libpugixml-dev")
 	if err := d.runWithProgress(devToolsCmd, progressChan, PhasePrerequisites, 0.10, 0.12); err != nil {
 		return fmt.Errorf("failed to install development tools: %w", err)
 	}
@@ -338,7 +308,11 @@ func (d *DebianDistribution) InstallPackages(ctx context.Context, dependencies [
 		d.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := d.EnableDMSService(ctx); err != nil {
+	if err := d.WriteWindowManagerConfig(wm); err != nil {
+		d.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := d.EnableDMSService(ctx, wm); err != nil {
 		d.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 
@@ -449,7 +423,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 				CommandInfo: fmt.Sprintf("curl & gpg to add key for %s", pkg.RepoURL),
 			}
 
-			keyCmd := fmt.Sprintf("curl -fsSL %s/Release.key | gpg --dearmor -o %s", baseURL, keyringPath)
+			keyCmd := fmt.Sprintf("bash -c 'rm -f %s && curl -fsSL %s/Release.key | gpg --batch --dearmor -o %s'", keyringPath, baseURL, keyringPath)
 			cmd := ExecSudoCommand(ctx, sudoPassword, keyCmd)
 			if err := d.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.18, 0.20); err != nil {
 				return fmt.Errorf("failed to add OBS GPG key for %s: %w", pkg.RepoURL, err)
@@ -467,7 +441,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 			}
 
 			addRepoCmd := ExecSudoCommand(ctx, sudoPassword,
-				fmt.Sprintf("echo '%s' | tee %s", repoLine, listFile))
+				fmt.Sprintf("bash -c \"echo '%s' | tee %s\"", repoLine, listFile))
 			if err := d.runWithProgress(addRepoCmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
 				return fmt.Errorf("failed to add OBS repo %s: %w", pkg.RepoURL, err)
 			}
@@ -502,7 +476,7 @@ func (d *DebianDistribution) installAPTPackages(ctx context.Context, packages []
 
 	d.log(fmt.Sprintf("Installing APT packages: %s", strings.Join(packages, ", ")))
 
-	args := []string{"apt-get", "install", "-y"}
+	args := []string{"DEBIAN_FRONTEND=noninteractive", "apt-get", "install", "-y"}
 	args = append(args, packages...)
 
 	progressChan <- InstallProgressMsg{
@@ -612,7 +586,7 @@ func (d *DebianDistribution) installRust(ctx context.Context, sudoPassword strin
 		CommandInfo: "sudo apt-get install rustup",
 	}
 
-	rustupInstallCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y rustup")
+	rustupInstallCmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y rustup")
 	if err := d.runWithProgress(rustupInstallCmd, progressChan, PhaseSystemPackages, 0.82, 0.83); err != nil {
 		return fmt.Errorf("failed to install rustup: %w", err)
 	}
@@ -651,7 +625,7 @@ func (d *DebianDistribution) installGo(ctx context.Context, sudoPassword string,
 		CommandInfo: "sudo apt-get install golang-go",
 	}
 
-	installCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y golang-go")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y golang-go")
 	return d.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.87, 0.90)
 }
 

core/internal/distros/fedora.go

@@ -97,17 +97,7 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 }
 
 func (f *FedoraDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if f.packageInstalled("xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
+	return f.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", f.packageInstalled("xdg-desktop-portal-gtk"))
 }
 
 func (f *FedoraDistribution) packageInstalled(pkg string) bool {
@@ -166,10 +156,7 @@ func (f *FedoraDistribution) getDmsMapping(variant deps.PackageVariant) PackageM
 	return PackageMapping{Name: "dms", Repository: RepoTypeCOPR, RepoURL: "avengemedia/dms"}
 }
 
-func (f *FedoraDistribution) getHyprlandMapping(variant deps.PackageVariant) PackageMapping {
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "hyprland-git", Repository: RepoTypeCOPR, RepoURL: "solopasha/hyprland"}
-	}
+func (f *FedoraDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
 	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "solopasha/hyprland"}
 }
 
@@ -177,7 +164,7 @@ func (f *FedoraDistribution) getNiriMapping(variant deps.PackageVariant) Package
 	if variant == deps.VariantGit {
 		return PackageMapping{Name: "niri", Repository: RepoTypeCOPR, RepoURL: "yalter/niri-git"}
 	}
-	return PackageMapping{Name: "niri", Repository: RepoTypeSystem}
+	return PackageMapping{Name: "niri", Repository: RepoTypeCOPR, RepoURL: "yalter/niri"}
 }
 
 func (f *FedoraDistribution) detectXwaylandSatellite() deps.Dependency {
@@ -362,7 +349,11 @@ func (f *FedoraDistribution) InstallPackages(ctx context.Context, dependencies [
 		f.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := f.EnableDMSService(ctx); err != nil {
+	if err := f.WriteWindowManagerConfig(wm); err != nil {
+		f.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := f.EnableDMSService(ctx, wm); err != nil {
 		f.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 

core/internal/distros/gentoo.go

@@ -95,7 +95,6 @@ func (g *GentooDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, g.detectWindowManager(wm))
 	dependencies = append(dependencies, g.detectQuickshell())
 	dependencies = append(dependencies, g.detectXDGPortal())
-	dependencies = append(dependencies, g.detectPolkitAgent())
 	dependencies = append(dependencies, g.detectAccountsService())
 
 	if wm == deps.WindowManagerHyprland {
@@ -114,59 +113,15 @@ func (g *GentooDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 }
 
 func (g *GentooDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if g.packageInstalled("sys-apps/xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
-}
-
-func (g *GentooDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if g.packageInstalled("mate-extra/mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		Required:    true,
-	}
+	return g.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", g.packageInstalled("sys-apps/xdg-desktop-portal-gtk"))
 }
 
 func (g *GentooDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
-	if g.packageInstalled("gui-apps/xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
+	return g.detectPackage("xwayland-satellite", "Xwayland support", g.packageInstalled("gui-apps/xwayland-satellite"))
 }
 
 func (g *GentooDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
-	if g.packageInstalled("sys-apps/accountsservice") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "accountsservice",
-		Status:      status,
-		Description: "D-Bus interface for user account query and manipulation",
-		Required:    true,
-	}
+	return g.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", g.packageInstalled("sys-apps/accountsservice"))
 }
 
 func (g *GentooDistribution) packageInstalled(pkg string) bool {
@@ -187,7 +142,6 @@ func (g *GentooDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"alacritty":              {Name: "x11-terms/alacritty", Repository: RepoTypeSystem, UseFlags: "X wayland"},
 		"wl-clipboard":           {Name: "gui-apps/wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "sys-apps/xdg-desktop-portal-gtk", Repository: RepoTypeSystem, UseFlags: "wayland X"},
-		"mate-polkit":            {Name: "mate-extra/mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":        {Name: "sys-apps/accountsservice", Repository: RepoTypeSystem},
 
 		"qtbase":        {Name: "dev-qt/qtbase", Repository: RepoTypeSystem, UseFlags: "wayland opengl vulkan widgets"},
@@ -223,12 +177,8 @@ func (g *GentooDistribution) getDmsMapping(_ deps.PackageVariant) PackageMapping
 	return PackageMapping{Name: "dms", Repository: RepoTypeManual, BuildFunc: "installDankMaterialShell"}
 }
 
-func (g *GentooDistribution) getHyprlandMapping(variant deps.PackageVariant) PackageMapping {
-	archKeyword := g.getArchKeyword()
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "gui-wm/hyprland", Repository: RepoTypeGURU, UseFlags: "X", AcceptKeywords: archKeyword}
-	}
-	return PackageMapping{Name: "gui-wm/hyprland", Repository: RepoTypeSystem, UseFlags: "X", AcceptKeywords: archKeyword}
+func (g *GentooDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
+	return PackageMapping{Name: "gui-wm/hyprland", Repository: RepoTypeSystem, UseFlags: "X", AcceptKeywords: g.getArchKeyword()}
 }
 
 func (g *GentooDistribution) getNiriMapping(_ deps.PackageVariant) PackageMapping {
@@ -456,7 +406,11 @@ func (g *GentooDistribution) InstallPackages(ctx context.Context, dependencies [
 		g.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := g.EnableDMSService(ctx); err != nil {
+	if err := g.WriteWindowManagerConfig(wm); err != nil {
+		g.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := g.EnableDMSService(ctx, wm); err != nil {
 		g.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 

core/internal/distros/opensuse.go

@@ -87,17 +87,7 @@ func (o *OpenSUSEDistribution) DetectDependenciesWithTerminal(ctx context.Contex
 }
 
 func (o *OpenSUSEDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if o.packageInstalled("xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
+	return o.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", o.packageInstalled("xdg-desktop-portal-gtk"))
 }
 
 func (o *OpenSUSEDistribution) packageInstalled(pkg string) bool {
@@ -377,7 +367,11 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		o.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := o.EnableDMSService(ctx); err != nil {
+	if err := o.WriteWindowManagerConfig(wm); err != nil {
+		o.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := o.EnableDMSService(ctx, wm); err != nil {
 		o.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 
@@ -472,7 +466,7 @@ func (o *OpenSUSEDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Pac
 			cmd := ExecSudoCommand(ctx, sudoPassword,
 				fmt.Sprintf("zypper addrepo -f %s", repoURL))
 			if err := o.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
-				return fmt.Errorf("failed to enable OBS repo %s: %w", pkg.RepoURL, err)
+				o.log(fmt.Sprintf("OBS repo %s add failed (may already exist): %v", pkg.RepoURL, err))
 			}
 
 			enabledRepos[pkg.RepoURL] = true

core/internal/distros/ubuntu.go

@@ -85,45 +85,15 @@ func (u *UbuntuDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 }
 
 func (u *UbuntuDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
-	if u.packageInstalled("xdg-desktop-portal-gtk") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xdg-desktop-portal-gtk",
-		Status:      status,
-		Description: "Desktop integration portal for GTK",
-		Required:    true,
-	}
+	return u.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", u.packageInstalled("xdg-desktop-portal-gtk"))
 }
 
 func (u *UbuntuDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
-	if u.commandExists("xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
+	return u.detectCommand("xwayland-satellite", "Xwayland support")
 }
 
 func (u *UbuntuDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
-	if u.packageInstalled("accountsservice") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "accountsservice",
-		Status:      status,
-		Description: "D-Bus interface for user account query and manipulation",
-		Required:    true,
-	}
+	return u.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", u.packageInstalled("accountsservice"))
 }
 
 func (u *UbuntuDistribution) packageInstalled(pkg string) bool {
@@ -357,7 +327,11 @@ func (u *UbuntuDistribution) InstallPackages(ctx context.Context, dependencies [
 		u.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
 	}
 
-	if err := u.EnableDMSService(ctx); err != nil {
+	if err := u.WriteWindowManagerConfig(wm); err != nil {
+		u.log(fmt.Sprintf("Warning: failed to write window manager config: %v", err))
+	}
+
+	if err := u.EnableDMSService(ctx, wm); err != nil {
 		u.log(fmt.Sprintf("Warning: failed to enable dms service: %v", err))
 	}
 

core/internal/dms/app.go

@@ -286,6 +286,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			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()

core/internal/dms/app_distro.go

@@ -75,14 +75,13 @@ type MenuItem struct {
 
 func NewModel(version string) Model {
 	detector, _ := NewDetector()
-	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
+	var dependencies []DependencyInfo
+	var hyprlandInstalled, niriInstalled bool
+
+	if detector != nil {
+		dependencies = detector.GetInstalledComponents()
+		hyprlandInstalled, niriInstalled, _ = detector.GetWindowManagerStatus()
 	}
 
 	m := Model{
@@ -201,6 +200,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			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()

core/internal/dms/plugins_handlers.go

@@ -227,6 +227,11 @@ func (m Model) updatePluginInstalledDetail(msg tea.KeyMsg) (tea.Model, tea.Cmd)
 			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
 }
@@ -246,6 +251,11 @@ type pluginInstalledMsg struct {
 	err        error
 }
 
+type pluginUpdatedMsg struct {
+	pluginName string
+	err        error
+}
+
 func loadInstalledPlugins() tea.Msg {
 	manager, err := plugins.NewManager()
 	if err != nil {
@@ -337,3 +347,31 @@ func uninstallPlugin(plugin pluginInfo) tea.Cmd {
 		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/greeter/installer.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 // DetectDMSPath checks for DMS installation following XDG Base Directory specification
@@ -22,10 +23,10 @@ func DetectDMSPath() (string, error) {
 func DetectCompositors() []string {
 	var compositors []string
 
-	if commandExists("niri") {
+	if utils.CommandExists("niri") {
 		compositors = append(compositors, "niri")
 	}
-	if commandExists("Hyprland") {
+	if utils.CommandExists("Hyprland") {
 		compositors = append(compositors, "Hyprland")
 	}
 
@@ -62,7 +63,7 @@ func PromptCompositorChoice(compositors []string) (string, error) {
 
 // EnsureGreetdInstalled checks if greetd is installed and installs it if not
 func EnsureGreetdInstalled(logFunc func(string), sudoPassword string) error {
-	if commandExists("greetd") {
+	if utils.CommandExists("greetd") {
 		logFunc("✓ greetd is already installed")
 		return nil
 	}
@@ -144,7 +145,7 @@ func EnsureGreetdInstalled(logFunc func(string), sudoPassword string) error {
 // CopyGreeterFiles installs the dms-greeter wrapper and sets up cache directory
 func CopyGreeterFiles(dmsPath, compositor string, logFunc func(string), sudoPassword string) error {
 	// Check if dms-greeter is already in PATH
-	if commandExists("dms-greeter") {
+	if utils.CommandExists("dms-greeter") {
 		logFunc("✓ dms-greeter wrapper already installed")
 	} else {
 		// Install the wrapper script
@@ -204,7 +205,7 @@ func CopyGreeterFiles(dmsPath, compositor string, logFunc func(string), sudoPass
 
 // SetupParentDirectoryACLs sets ACLs on parent directories to allow traversal
 func SetupParentDirectoryACLs(logFunc func(string), sudoPassword string) error {
-	if !commandExists("setfacl") {
+	if !utils.CommandExists("setfacl") {
 		logFunc("⚠ Warning: setfacl command not found. ACL support may not be available on this filesystem.")
 		logFunc("  If theme sync doesn't work, you may need to install acl package:")
 		logFunc("  - Fedora/RHEL: sudo dnf install acl")
@@ -419,7 +420,7 @@ user = "greeter"
 
 	// Determine wrapper command path
 	wrapperCmd := "dms-greeter"
-	if !commandExists("dms-greeter") {
+	if !utils.CommandExists("dms-greeter") {
 		wrapperCmd = "/usr/local/bin/dms-greeter"
 	}
 
@@ -486,8 +487,3 @@ func runSudoCmd(sudoPassword string, command string, args ...string) error {
 	cmd.Stderr = os.Stderr
 	return cmd.Run()
 }
-
-func commandExists(cmd string) bool {
-	_, err := exec.LookPath(cmd)
-	return err == nil
-}

core/internal/keybinds/discovery.go

@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type DiscoveryConfig struct {
@@ -14,13 +16,7 @@ type DiscoveryConfig struct {
 func DefaultDiscoveryConfig() *DiscoveryConfig {
 	var searchPaths []string
 
-	configHome := os.Getenv("XDG_CONFIG_HOME")
-	if configHome == "" {
-		if homeDir, err := os.UserHomeDir(); err == nil {
-			configHome = filepath.Join(homeDir, ".config")
-		}
-	}
-
+	configHome := utils.XDGConfigHome()
 	if configHome != "" {
 		searchPaths = append(searchPaths, filepath.Join(configHome, "DankMaterialShell", "cheatsheets"))
 	}
@@ -43,7 +39,7 @@ func (d *DiscoveryConfig) FindJSONFiles() ([]string, error) {
 	var files []string
 
 	for _, searchPath := range d.SearchPaths {
-		expandedPath, err := expandPath(searchPath)
+		expandedPath, err := utils.ExpandPath(searchPath)
 		if err != nil {
 			continue
 		}
@@ -74,20 +70,6 @@ func (d *DiscoveryConfig) FindJSONFiles() ([]string, error) {
 	return files, nil
 }
 
-func expandPath(path string) (string, error) {
-	expandedPath := os.ExpandEnv(path)
-
-	if strings.HasPrefix(expandedPath, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
-	}
-
-	return filepath.Clean(expandedPath), nil
-}
-
 type JSONProviderFactory func(filePath string) (Provider, error)
 
 var jsonProviderFactory JSONProviderFactory

core/internal/keybinds/discovery_test.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 func TestDefaultDiscoveryConfig(t *testing.T) {
@@ -272,13 +274,13 @@ func TestExpandPathInDiscovery(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := expandPath(tt.input)
+			result, err := utils.ExpandPath(tt.input)
 			if err != nil {
 				t.Fatalf("expandPath failed: %v", err)
 			}
 
 			if result != tt.expected {
-				t.Errorf("expandPath(%q) = %q, want %q", tt.input, result, tt.expected)
+				t.Errorf("utils.ExpandPath(%q) = %q, want %q", tt.input, result, tt.expected)
 			}
 		})
 	}

core/internal/keybinds/providers/hyprland_parser.go

@@ -5,6 +5,8 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 const (
@@ -42,14 +44,9 @@ func NewHyprlandParser() *HyprlandParser {
 }
 
 func (p *HyprlandParser) ReadContent(directory string) error {
-	expandedDir := os.ExpandEnv(directory)
-	expandedDir = filepath.Clean(expandedDir)
-	if strings.HasPrefix(expandedDir, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedDir = filepath.Join(home, expandedDir[1:])
+	expandedDir, err := utils.ExpandPath(directory)
+	if err != nil {
+		return err
 	}
 
 	info, err := os.Stat(expandedDir)

core/internal/keybinds/providers/jsonfile.go

@@ -5,9 +5,9 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type JSONFileProvider struct {
@@ -20,7 +20,7 @@ func NewJSONFileProvider(filePath string) (*JSONFileProvider, error) {
 		return nil, fmt.Errorf("file path cannot be empty")
 	}
 
-	expandedPath, err := expandPath(filePath)
+	expandedPath, err := utils.ExpandPath(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to expand path: %w", err)
 	}
@@ -117,17 +117,3 @@ func (j *JSONFileProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
 		Binds:    categorizedBinds,
 	}, nil
 }
-
-func expandPath(path string) (string, error) {
-	expandedPath := os.ExpandEnv(path)
-
-	if strings.HasPrefix(expandedPath, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
-	}
-
-	return filepath.Clean(expandedPath), nil
-}

core/internal/keybinds/providers/jsonfile_test.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 func TestNewJSONFileProvider(t *testing.T) {
@@ -266,13 +268,13 @@ func TestExpandPath(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := expandPath(tt.input)
+			result, err := utils.ExpandPath(tt.input)
 			if err != nil {
 				t.Fatalf("expandPath failed: %v", err)
 			}
 
 			if result != tt.expected {
-				t.Errorf("expandPath(%q) = %q, want %q", tt.input, result, tt.expected)
+				t.Errorf("utils.ExpandPath(%q) = %q, want %q", tt.input, result, tt.expected)
 			}
 		})
 	}

core/internal/keybinds/providers/mangowc_parser.go

@@ -5,6 +5,8 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 const (
@@ -34,14 +36,9 @@ func NewMangoWCParser() *MangoWCParser {
 }
 
 func (p *MangoWCParser) ReadContent(path string) error {
-	expandedPath := os.ExpandEnv(path)
-	expandedPath = filepath.Clean(expandedPath)
-	if strings.HasPrefix(expandedPath, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
+	expandedPath, err := utils.ExpandPath(path)
+	if err != nil {
+		return err
 	}
 
 	info, err := os.Stat(expandedPath)

core/internal/keybinds/providers/niri.go

@@ -6,9 +6,11 @@ import (
 	"os/exec"
 	"path/filepath"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/sblinch/kdl-go"
 	"github.com/sblinch/kdl-go/document"
 )
@@ -29,15 +31,7 @@ func NewNiriProvider(configDir string) *NiriProvider {
 }
 
 func defaultNiriConfigDir() string {
-	if configHome := os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
-		return filepath.Join(configHome, "niri")
-	}
-
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(home, ".config", "niri")
+	return filepath.Join(utils.XDGConfigHome(), "niri")
 }
 
 func (n *NiriProvider) Name() string {
@@ -154,11 +148,13 @@ func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string, co
 	}
 
 	bind := keybinds.Keybind{
-		Key:         keyStr,
-		Description: kb.Description,
-		Action:      rawAction,
-		Subcategory: subcategory,
-		Source:      source,
+		Key:           keyStr,
+		Description:   kb.Description,
+		Action:        rawAction,
+		Subcategory:   subcategory,
+		Source:        source,
+		HideOnOverlay: kb.HideOnOverlay,
+		CooldownMs:    kb.CooldownMs,
 	}
 
 	if source == "dms" && conflicts != nil {
@@ -316,7 +312,9 @@ func (n *NiriProvider) extractOptions(node *document.Node) map[string]any {
 		opts["repeat"] = val.String() == "true"
 	}
 	if val, ok := node.Properties.Get("cooldown-ms"); ok {
-		opts["cooldown-ms"] = val.String()
+		if ms, err := strconv.Atoi(val.String()); err == nil {
+			opts["cooldown-ms"] = ms
+		}
 	}
 	if val, ok := node.Properties.Get("allow-when-locked"); ok {
 		opts["allow-when-locked"] = val.String() == "true"
@@ -342,7 +340,14 @@ func (n *NiriProvider) buildBindNode(bind *overrideBind) *document.Node {
 			node.AddProperty("repeat", false, "")
 		}
 		if v, ok := bind.Options["cooldown-ms"]; ok {
-			node.AddProperty("cooldown-ms", v, "")
+			switch val := v.(type) {
+			case int:
+				node.AddProperty("cooldown-ms", val, "")
+			case string:
+				if ms, err := strconv.Atoi(val); err == nil {
+					node.AddProperty("cooldown-ms", ms, "")
+				}
+			}
 		}
 		if v, ok := bind.Options["allow-when-locked"]; ok && v == true {
 			node.AddProperty("allow-when-locked", true, "")

core/internal/keybinds/providers/niri_parser.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/sblinch/kdl-go"
@@ -11,12 +12,14 @@ import (
 )
 
 type NiriKeyBinding struct {
-	Mods        []string
-	Key         string
-	Action      string
-	Args        []string
-	Description string
-	Source      string
+	Mods          []string
+	Key           string
+	Action        string
+	Args          []string
+	Description   string
+	HideOnOverlay bool
+	CooldownMs    int
+	Source        string
 }
 
 type NiriSection struct {
@@ -273,19 +276,31 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBin
 	}
 
 	var description string
+	var hideOnOverlay bool
+	var cooldownMs int
 	if node.Properties != nil {
 		if val, ok := node.Properties.Get("hotkey-overlay-title"); ok {
-			description = val.ValueString()
+			switch val.ValueString() {
+			case "null", "":
+				hideOnOverlay = true
+			default:
+				description = val.ValueString()
+			}
+		}
+		if val, ok := node.Properties.Get("cooldown-ms"); ok {
+			cooldownMs, _ = strconv.Atoi(val.String())
 		}
 	}
 
 	return &NiriKeyBinding{
-		Mods:        mods,
-		Key:         key,
-		Action:      action,
-		Args:        args,
-		Description: description,
-		Source:      p.currentSource,
+		Mods:          mods,
+		Key:           key,
+		Action:        action,
+		Args:          args,
+		Description:   description,
+		HideOnOverlay: hideOnOverlay,
+		CooldownMs:    cooldownMs,
+		Source:        p.currentSource,
 	}
 }
 

core/internal/keybinds/providers/sway.go

@@ -2,6 +2,7 @@ package providers
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
@@ -9,18 +10,42 @@ import (
 
 type SwayProvider struct {
 	configPath string
+	isScroll   bool
 }
 
 func NewSwayProvider(configPath string) *SwayProvider {
+	isScroll := false
+	_, scrollEnvSet := os.LookupEnv("SCROLLSOCK")
+
 	if configPath == "" {
-		configPath = "$HOME/.config/sway"
+		if scrollEnvSet {
+			configPath = "$HOME/.config/scroll"
+			isScroll = true
+		} else {
+			configPath = "$HOME/.config/sway"
+		}
+	} else {
+		// Determine isScroll based on the provided config path
+		isScroll = strings.Contains(configPath, "scroll")
 	}
+
 	return &SwayProvider{
 		configPath: configPath,
+		isScroll:   isScroll,
 	}
 }
 
 func (s *SwayProvider) Name() string {
+	if s != nil && s.isScroll {
+		return "scroll"
+	}
+	if s == nil {
+		_, ok := os.LookupEnv("SCROLLSOCK")
+		if ok {
+			return "scroll"
+		}
+	}
+
 	return "sway"
 }
 
@@ -33,8 +58,13 @@ func (s *SwayProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
 	categorizedBinds := make(map[string][]keybinds.Keybind)
 	s.convertSection(section, "", categorizedBinds)
 
+	cheatSheetTitle := "Sway Keybinds"
+	if s != nil && s.isScroll {
+		cheatSheetTitle = "Scroll Keybinds"
+	}
+
 	return &keybinds.CheatSheet{
-		Title:    "Sway Keybinds",
+		Title:    cheatSheetTitle,
 		Provider: s.Name(),
 		Binds:    categorizedBinds,
 	}, nil

core/internal/keybinds/providers/sway_parser.go

@@ -5,6 +5,8 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 const (
@@ -42,14 +44,9 @@ func NewSwayParser() *SwayParser {
 }
 
 func (p *SwayParser) ReadContent(path string) error {
-	expandedPath := os.ExpandEnv(path)
-	expandedPath = filepath.Clean(expandedPath)
-	if strings.HasPrefix(expandedPath, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
+	expandedPath, err := utils.ExpandPath(path)
+	if err != nil {
+		return err
 	}
 
 	info, err := os.Stat(expandedPath)

core/internal/keybinds/types.go

@@ -1,12 +1,14 @@
 package keybinds
 
 type Keybind struct {
-	Key         string   `json:"key"`
-	Description string   `json:"desc"`
-	Action      string   `json:"action,omitempty"`
-	Subcategory string   `json:"subcat,omitempty"`
-	Source      string   `json:"source,omitempty"`
-	Conflict    *Keybind `json:"conflict,omitempty"`
+	Key           string   `json:"key"`
+	Description   string   `json:"desc"`
+	Action        string   `json:"action,omitempty"`
+	Subcategory   string   `json:"subcat,omitempty"`
+	Source        string   `json:"source,omitempty"`
+	HideOnOverlay bool     `json:"hideOnOverlay,omitempty"`
+	CooldownMs    int      `json:"cooldownMs,omitempty"`
+	Conflict      *Keybind `json:"conflict,omitempty"`
 }
 
 type DMSBindsStatus struct {

core/internal/matugen/matugen.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/dank16"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 var (
@@ -277,7 +278,7 @@ func appendConfig(opts *Options, cfgFile *os.File, checkCmd, fileName string) {
 	if _, err := os.Stat(configPath); err != nil {
 		return
 	}
-	if checkCmd != "skip" && !commandExists(checkCmd) {
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
@@ -293,7 +294,7 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fil
 	if _, err := os.Stat(configPath); err != nil {
 		return
 	}
-	if checkCmd != "skip" && !commandExists(checkCmd) {
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
 		return
 	}
 	data, err := os.ReadFile(configPath)
@@ -390,11 +391,6 @@ func extractTOMLSection(content, startMarker, endMarker string) string {
 	return content[startIdx : startIdx+endIdx]
 }
 
-func commandExists(name string) bool {
-	_, err := exec.LookPath(name)
-	return err == nil
-}
-
 func checkMatugenVersion() {
 	matugenVersionOnce.Do(func() {
 		cmd := exec.Command("matugen", "--version")

core/internal/plugins/manager.go

@@ -9,6 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/spf13/afero"
 )
 
@@ -32,33 +33,70 @@ func NewManagerWithFs(fs afero.Fs) (*Manager, error) {
 }
 
 func getPluginsDir() string {
-	configHome := os.Getenv("XDG_CONFIG_HOME")
-	if configHome == "" {
-		homeDir, err := os.UserHomeDir()
-		if err != nil {
-			return filepath.Join(os.TempDir(), "DankMaterialShell", "plugins")
-		}
-		configHome = filepath.Join(homeDir, ".config")
-	}
-	return filepath.Join(configHome, "DankMaterialShell", "plugins")
+	return filepath.Join(utils.XDGConfigHome(), "DankMaterialShell", "plugins")
 }
 
 func (m *Manager) IsInstalled(plugin Plugin) (bool, error) {
-	pluginPath := filepath.Join(m.pluginsDir, plugin.ID)
-	exists, err := afero.DirExists(m.fs, pluginPath)
+	path, err := m.findInstalledPath(plugin.ID)
 	if err != nil {
 		return false, err
 	}
-	if exists {
-		return true, nil
+	return path != "", nil
+}
+
+func (m *Manager) findInstalledPath(pluginID string) (string, error) {
+	// Check user plugins directory
+	path, err := m.findInDir(m.pluginsDir, pluginID)
+	if err != nil {
+		return "", err
+	}
+	if path != "" {
+		return path, nil
 	}
 
-	systemPluginPath := filepath.Join("/etc/xdg/quickshell/dms-plugins", plugin.ID)
-	systemExists, err := afero.DirExists(m.fs, systemPluginPath)
-	if err != nil {
-		return false, err
+	// Check system plugins directory
+	systemDir := "/etc/xdg/quickshell/dms-plugins"
+	return m.findInDir(systemDir, pluginID)
+}
+
+func (m *Manager) findInDir(dir, pluginID string) (string, error) {
+	// First, check if folder with exact ID name exists
+	exactPath := filepath.Join(dir, pluginID)
+	if exists, _ := afero.DirExists(m.fs, exactPath); exists {
+		return exactPath, nil
 	}
-	return systemExists, nil
+
+	// Scan all folders and check plugin.json for matching ID
+	exists, err := afero.DirExists(m.fs, dir)
+	if err != nil || !exists {
+		return "", nil
+	}
+
+	entries, err := afero.ReadDir(m.fs, dir)
+	if err != nil {
+		return "", nil
+	}
+
+	for _, entry := range entries {
+		name := entry.Name()
+		if name == ".repos" || strings.HasSuffix(name, ".meta") {
+			continue
+		}
+
+		fullPath := filepath.Join(dir, name)
+		isPlugin := entry.IsDir() || entry.Mode()&os.ModeSymlink != 0
+		if !isPlugin {
+			if info, err := m.fs.Stat(fullPath); err == nil && info.IsDir() {
+				isPlugin = true
+			}
+		}
+
+		if isPlugin && m.getPluginID(fullPath) == pluginID {
+			return fullPath, nil
+		}
+	}
+
+	return "", nil
 }
 
 func (m *Manager) Install(plugin Plugin) error {
@@ -151,25 +189,19 @@ func (m *Manager) createSymlink(source, dest string) error {
 }
 
 func (m *Manager) Update(plugin Plugin) error {
-	pluginPath := filepath.Join(m.pluginsDir, plugin.ID)
-
-	exists, err := afero.DirExists(m.fs, pluginPath)
+	pluginPath, err := m.findInstalledPath(plugin.ID)
 	if err != nil {
-		return fmt.Errorf("failed to check if plugin exists: %w", err)
+		return fmt.Errorf("failed to find plugin: %w", err)
 	}
 
-	if !exists {
-		systemPluginPath := filepath.Join("/etc/xdg/quickshell/dms-plugins", plugin.ID)
-		systemExists, err := afero.DirExists(m.fs, systemPluginPath)
-		if err != nil {
-			return fmt.Errorf("failed to check if plugin exists: %w", err)
-		}
-		if systemExists {
-			return fmt.Errorf("cannot update system plugin: %s", plugin.Name)
-		}
+	if pluginPath == "" {
 		return fmt.Errorf("plugin not installed: %s", plugin.Name)
 	}
 
+	if strings.HasPrefix(pluginPath, "/etc/xdg/quickshell/dms-plugins") {
+		return fmt.Errorf("cannot update system plugin: %s", plugin.Name)
+	}
+
 	metaPath := pluginPath + ".meta"
 	metaExists, err := afero.Exists(m.fs, metaPath)
 	if err != nil {
@@ -209,25 +241,19 @@ func (m *Manager) Update(plugin Plugin) error {
 }
 
 func (m *Manager) Uninstall(plugin Plugin) error {
-	pluginPath := filepath.Join(m.pluginsDir, plugin.ID)
-
-	exists, err := afero.DirExists(m.fs, pluginPath)
+	pluginPath, err := m.findInstalledPath(plugin.ID)
 	if err != nil {
-		return fmt.Errorf("failed to check if plugin exists: %w", err)
+		return fmt.Errorf("failed to find plugin: %w", err)
 	}
 
-	if !exists {
-		systemPluginPath := filepath.Join("/etc/xdg/quickshell/dms-plugins", plugin.ID)
-		systemExists, err := afero.DirExists(m.fs, systemPluginPath)
-		if err != nil {
-			return fmt.Errorf("failed to check if plugin exists: %w", err)
-		}
-		if systemExists {
-			return fmt.Errorf("cannot uninstall system plugin: %s", plugin.Name)
-		}
+	if pluginPath == "" {
 		return fmt.Errorf("plugin not installed: %s", plugin.Name)
 	}
 
+	if strings.HasPrefix(pluginPath, "/etc/xdg/quickshell/dms-plugins") {
+		return fmt.Errorf("cannot uninstall system plugin: %s", plugin.Name)
+	}
+
 	metaPath := pluginPath + ".meta"
 	metaExists, err := afero.Exists(m.fs, metaPath)
 	if err != nil {
@@ -369,47 +395,174 @@ func (m *Manager) ListInstalled() ([]string, error) {
 
 // getPluginID reads the plugin.json file and returns the plugin ID
 func (m *Manager) getPluginID(pluginPath string) string {
+	manifest := m.getPluginManifest(pluginPath)
+	if manifest == nil {
+		return ""
+	}
+	return manifest.ID
+}
+
+func (m *Manager) getPluginManifest(pluginPath string) *pluginManifest {
 	manifestPath := filepath.Join(pluginPath, "plugin.json")
 	data, err := afero.ReadFile(m.fs, manifestPath)
 	if err != nil {
-		return ""
+		return nil
 	}
 
-	var manifest struct {
-		ID string `json:"id"`
-	}
+	var manifest pluginManifest
 	if err := json.Unmarshal(data, &manifest); err != nil {
-		return ""
+		return nil
 	}
 
-	return manifest.ID
+	return &manifest
+}
+
+type pluginManifest struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
 }
 
 func (m *Manager) GetPluginsDir() string {
 	return m.pluginsDir
 }
 
-func (m *Manager) HasUpdates(pluginID string, plugin Plugin) (bool, error) {
-	pluginPath := filepath.Join(m.pluginsDir, pluginID)
-
-	exists, err := afero.DirExists(m.fs, pluginPath)
+func (m *Manager) UninstallByIDOrName(idOrName string) error {
+	pluginPath, err := m.findInstalledPathByIDOrName(idOrName)
 	if err != nil {
-		return false, fmt.Errorf("failed to check if plugin exists: %w", err)
+		return err
+	}
+	if pluginPath == "" {
+		return fmt.Errorf("plugin not found: %s", idOrName)
 	}
 
-	if !exists {
-		systemPluginPath := filepath.Join("/etc/xdg/quickshell/dms-plugins", pluginID)
-		systemExists, err := afero.DirExists(m.fs, systemPluginPath)
-		if err != nil {
-			return false, fmt.Errorf("failed to check system plugin: %w", err)
+	if strings.HasPrefix(pluginPath, "/etc/xdg/quickshell/dms-plugins") {
+		return fmt.Errorf("cannot uninstall system plugin: %s", idOrName)
+	}
+
+	metaPath := pluginPath + ".meta"
+	metaExists, _ := afero.Exists(m.fs, metaPath)
+
+	if metaExists {
+		if err := m.fs.Remove(pluginPath); err != nil {
+			return fmt.Errorf("failed to remove symlink: %w", err)
 		}
-		if systemExists {
-			return false, nil
+		if err := m.fs.Remove(metaPath); err != nil {
+			return fmt.Errorf("failed to remove metadata: %w", err)
 		}
+	} else {
+		if err := m.fs.RemoveAll(pluginPath); err != nil {
+			return fmt.Errorf("failed to remove plugin: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) UpdateByIDOrName(idOrName string) error {
+	pluginPath, err := m.findInstalledPathByIDOrName(idOrName)
+	if err != nil {
+		return err
+	}
+	if pluginPath == "" {
+		return fmt.Errorf("plugin not found: %s", idOrName)
+	}
+
+	if strings.HasPrefix(pluginPath, "/etc/xdg/quickshell/dms-plugins") {
+		return fmt.Errorf("cannot update system plugin: %s", idOrName)
+	}
+
+	metaPath := pluginPath + ".meta"
+	metaExists, _ := afero.Exists(m.fs, metaPath)
+
+	if metaExists {
+		// Plugin is from monorepo, but we don't know the repo URL without registry
+		// Just try to pull from existing .git in the symlink target
+		return fmt.Errorf("cannot update monorepo plugin without registry info: %s", idOrName)
+	}
+
+	// Standalone plugin - just pull
+	if err := m.gitClient.Pull(pluginPath); err != nil {
+		return fmt.Errorf("failed to update plugin: %w", err)
+	}
+
+	return nil
+}
+
+func (m *Manager) findInstalledPathByIDOrName(idOrName string) (string, error) {
+	path, err := m.findInDirByIDOrName(m.pluginsDir, idOrName)
+	if err != nil {
+		return "", err
+	}
+	if path != "" {
+		return path, nil
+	}
+
+	systemDir := "/etc/xdg/quickshell/dms-plugins"
+	return m.findInDirByIDOrName(systemDir, idOrName)
+}
+
+func (m *Manager) findInDirByIDOrName(dir, idOrName string) (string, error) {
+	// Check exact folder name match first
+	exactPath := filepath.Join(dir, idOrName)
+	if exists, _ := afero.DirExists(m.fs, exactPath); exists {
+		return exactPath, nil
+	}
+
+	exists, err := afero.DirExists(m.fs, dir)
+	if err != nil || !exists {
+		return "", nil
+	}
+
+	entries, err := afero.ReadDir(m.fs, dir)
+	if err != nil {
+		return "", nil
+	}
+
+	for _, entry := range entries {
+		name := entry.Name()
+		if name == ".repos" || strings.HasSuffix(name, ".meta") {
+			continue
+		}
+
+		fullPath := filepath.Join(dir, name)
+		isPlugin := entry.IsDir() || entry.Mode()&os.ModeSymlink != 0
+		if !isPlugin {
+			if info, err := m.fs.Stat(fullPath); err == nil && info.IsDir() {
+				isPlugin = true
+			}
+		}
+
+		if !isPlugin {
+			continue
+		}
+
+		manifest := m.getPluginManifest(fullPath)
+		if manifest == nil {
+			continue
+		}
+
+		if manifest.ID == idOrName || manifest.Name == idOrName {
+			return fullPath, nil
+		}
+	}
+
+	return "", nil
+}
+
+func (m *Manager) HasUpdates(pluginID string, plugin Plugin) (bool, error) {
+	pluginPath, err := m.findInstalledPath(pluginID)
+	if err != nil {
+		return false, fmt.Errorf("failed to find plugin: %w", err)
+	}
+
+	if pluginPath == "" {
 		return false, fmt.Errorf("plugin not installed: %s", pluginID)
 	}
 
-	// Check if there's a .meta file (plugin installed from a monorepo)
+	if strings.HasPrefix(pluginPath, "/etc/xdg/quickshell/dms-plugins") {
+		return false, nil
+	}
+
 	metaPath := pluginPath + ".meta"
 	metaExists, err := afero.Exists(m.fs, metaPath)
 	if err != nil {

core/internal/plugins/search.go

@@ -3,6 +3,8 @@ package plugins
 import (
 	"sort"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 func FuzzySearch(query string, plugins []Plugin) []Plugin {
@@ -11,18 +13,12 @@ func FuzzySearch(query string, plugins []Plugin) []Plugin {
 	}
 
 	queryLower := strings.ToLower(query)
-	var results []Plugin
-
-	for _, plugin := range plugins {
-		if fuzzyMatch(queryLower, strings.ToLower(plugin.Name)) ||
-			fuzzyMatch(queryLower, strings.ToLower(plugin.Category)) ||
-			fuzzyMatch(queryLower, strings.ToLower(plugin.Description)) ||
-			fuzzyMatch(queryLower, strings.ToLower(plugin.Author)) {
-			results = append(results, plugin)
-		}
-	}
-
-	return results
+	return utils.Filter(plugins, func(p Plugin) bool {
+		return fuzzyMatch(queryLower, strings.ToLower(p.Name)) ||
+			fuzzyMatch(queryLower, strings.ToLower(p.Category)) ||
+			fuzzyMatch(queryLower, strings.ToLower(p.Description)) ||
+			fuzzyMatch(queryLower, strings.ToLower(p.Author))
+	})
 }
 
 func fuzzyMatch(query, text string) bool {
@@ -39,57 +35,34 @@ func FilterByCategory(category string, plugins []Plugin) []Plugin {
 	if category == "" {
 		return plugins
 	}
-
-	var results []Plugin
 	categoryLower := strings.ToLower(category)
-
-	for _, plugin := range plugins {
-		if strings.ToLower(plugin.Category) == categoryLower {
-			results = append(results, plugin)
-		}
-	}
-
-	return results
+	return utils.Filter(plugins, func(p Plugin) bool {
+		return strings.ToLower(p.Category) == categoryLower
+	})
 }
 
 func FilterByCompositor(compositor string, plugins []Plugin) []Plugin {
 	if compositor == "" {
 		return plugins
 	}
-
-	var results []Plugin
 	compositorLower := strings.ToLower(compositor)
-
-	for _, plugin := range plugins {
-		for _, comp := range plugin.Compositors {
-			if strings.ToLower(comp) == compositorLower {
-				results = append(results, plugin)
-				break
-			}
-		}
-	}
-
-	return results
+	return utils.Filter(plugins, func(p Plugin) bool {
+		return utils.Any(p.Compositors, func(c string) bool {
+			return strings.ToLower(c) == compositorLower
+		})
+	})
 }
 
 func FilterByCapability(capability string, plugins []Plugin) []Plugin {
 	if capability == "" {
 		return plugins
 	}
-
-	var results []Plugin
 	capabilityLower := strings.ToLower(capability)
-
-	for _, plugin := range plugins {
-		for _, cap := range plugin.Capabilities {
-			if strings.ToLower(cap) == capabilityLower {
-				results = append(results, plugin)
-				break
-			}
-		}
-	}
-
-	return results
+	return utils.Filter(plugins, func(p Plugin) bool {
+		return utils.Any(p.Capabilities, func(c string) bool {
+			return strings.ToLower(c) == capabilityLower
+		})
+	})
 }
 
 func SortByFirstParty(plugins []Plugin) []Plugin {
@@ -103,3 +76,13 @@ func SortByFirstParty(plugins []Plugin) []Plugin {
 	})
 	return plugins
 }
+
+func FindByIDOrName(idOrName string, plugins []Plugin) *Plugin {
+	if p, found := utils.Find(plugins, func(p Plugin) bool { return p.ID == idOrName }); found {
+		return &p
+	}
+	if p, found := utils.Find(plugins, func(p Plugin) bool { return p.Name == idOrName }); found {
+		return &p
+	}
+	return nil
+}

core/internal/proto/wlr_output_management/output_management.go

@@ -238,9 +238,17 @@ func (i *ZwlrOutputManagerV1) Dispatch(opcode uint32, fd int, data []byte) {
 		l := 0
 		objectID := client.Uint32(data[l : l+4])
 		proxy := i.Context().GetProxy(objectID)
-		if proxy != nil {
-			e.Head = proxy.(*ZwlrOutputHeadV1)
+		if proxy == nil {
+			head := &ZwlrOutputHeadV1{}
+			head.SetContext(i.Context())
+			head.SetID(objectID)
+			registerServerProxy(i.Context(), head, objectID)
+			e.Head = head
+		} else if head, ok := proxy.(*ZwlrOutputHeadV1); ok {
+			e.Head = head
 		} else {
+			// Stale proxy of wrong type (can happen after suspend/resume)
+			// Replace it with the correct type
 			head := &ZwlrOutputHeadV1{}
 			head.SetContext(i.Context())
 			head.SetID(objectID)
@@ -715,9 +723,17 @@ func (i *ZwlrOutputHeadV1) Dispatch(opcode uint32, fd int, data []byte) {
 		l := 0
 		objectID := client.Uint32(data[l : l+4])
 		proxy := i.Context().GetProxy(objectID)
-		if proxy != nil {
-			e.Mode = proxy.(*ZwlrOutputModeV1)
+		if proxy == nil {
+			mode := &ZwlrOutputModeV1{}
+			mode.SetContext(i.Context())
+			mode.SetID(objectID)
+			registerServerProxy(i.Context(), mode, objectID)
+			e.Mode = mode
+		} else if mode, ok := proxy.(*ZwlrOutputModeV1); ok {
+			e.Mode = mode
 		} else {
+			// Stale proxy of wrong type (can happen after suspend/resume)
+			// Replace it with the correct type
 			mode := &ZwlrOutputModeV1{}
 			mode.SetContext(i.Context())
 			mode.SetID(objectID)
@@ -743,7 +759,26 @@ func (i *ZwlrOutputHeadV1) Dispatch(opcode uint32, fd int, data []byte) {
 		}
 		var e ZwlrOutputHeadV1CurrentModeEvent
 		l := 0
-		e.Mode = i.Context().GetProxy(client.Uint32(data[l : l+4])).(*ZwlrOutputModeV1)
+		objectID := client.Uint32(data[l : l+4])
+		proxy := i.Context().GetProxy(objectID)
+		if proxy == nil {
+			// Mode not yet registered, create it
+			mode := &ZwlrOutputModeV1{}
+			mode.SetContext(i.Context())
+			mode.SetID(objectID)
+			registerServerProxy(i.Context(), mode, objectID)
+			e.Mode = mode
+		} else if mode, ok := proxy.(*ZwlrOutputModeV1); ok {
+			e.Mode = mode
+		} else {
+			// Stale proxy of wrong type (can happen after suspend/resume)
+			// Replace it with the correct type
+			mode := &ZwlrOutputModeV1{}
+			mode.SetContext(i.Context())
+			mode.SetID(objectID)
+			registerServerProxy(i.Context(), mode, objectID)
+			e.Mode = mode
+		}
 		l += 4
 
 		i.currentModeHandler(e)

core/internal/screenshot/compositor.go

@@ -7,6 +7,7 @@ import (
 	"os/exec"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/dwl_ipc"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_output_management"
 	wlhelpers "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/client"
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 )
@@ -19,6 +20,7 @@ const (
 	CompositorSway
 	CompositorNiri
 	CompositorDWL
+	CompositorScroll
 )
 
 var detectedCompositor Compositor = -1
@@ -31,6 +33,7 @@ func DetectCompositor() Compositor {
 	hyprlandSig := os.Getenv("HYPRLAND_INSTANCE_SIGNATURE")
 	niriSocket := os.Getenv("NIRI_SOCKET")
 	swaySocket := os.Getenv("SWAYSOCK")
+	scrollSocket := os.Getenv("SCROLLSOCK")
 
 	switch {
 	case niriSocket != "":
@@ -38,6 +41,12 @@ func DetectCompositor() Compositor {
 			detectedCompositor = CompositorNiri
 			return detectedCompositor
 		}
+	case scrollSocket != "":
+		if _, err := os.Stat(scrollSocket); err == nil {
+			detectedCompositor = CompositorScroll
+			return detectedCompositor
+		}
+
 	case swaySocket != "":
 		if _, err := os.Stat(swaySocket); err == nil {
 			detectedCompositor = CompositorSway
@@ -89,12 +98,15 @@ func SetCompositorDWL() {
 }
 
 type WindowGeometry struct {
-	X      int32
-	Y      int32
-	Width  int32
-	Height int32
-	Output string
-	Scale  float64
+	X               int32
+	Y               int32
+	Width           int32
+	Height          int32
+	Output          string
+	Scale           float64
+	OutputX         int32
+	OutputY         int32
+	OutputTransform int32
 }
 
 func GetActiveWindow() (*WindowGeometry, error) {
@@ -229,6 +241,25 @@ func getSwayFocusedMonitor() string {
 	return ""
 }
 
+func getScrollFocusedMonitor() string {
+	output, err := exec.Command("scrollmsg", "-t", "get_workspaces").Output()
+	if err != nil {
+		return ""
+	}
+
+	var workspaces []swayWorkspace
+	if err := json.Unmarshal(output, &workspaces); err != nil {
+		return ""
+	}
+
+	for _, ws := range workspaces {
+		if ws.Focused {
+			return ws.Output
+		}
+	}
+	return ""
+}
+
 type niriWorkspace struct {
 	Output    string `json:"output"`
 	IsFocused bool   `json:"is_focused"`
@@ -374,6 +405,8 @@ func GetFocusedMonitor() string {
 		return getHyprlandFocusedMonitor()
 	case CompositorSway:
 		return getSwayFocusedMonitor()
+	case CompositorScroll:
+		return getScrollFocusedMonitor()
 	case CompositorNiri:
 		return getNiriFocusedMonitor()
 	case CompositorDWL:
@@ -382,6 +415,92 @@ func GetFocusedMonitor() string {
 	return ""
 }
 
+type outputInfo struct {
+	x, y      int32
+	transform int32
+}
+
+func getOutputInfo(outputName string) (*outputInfo, bool) {
+	display, err := client.Connect("")
+	if err != nil {
+		return nil, false
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return nil, false
+	}
+
+	var outputManager *wlr_output_management.ZwlrOutputManagerV1
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		if e.Interface == wlr_output_management.ZwlrOutputManagerV1InterfaceName {
+			mgr := wlr_output_management.NewZwlrOutputManagerV1(ctx)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, mgr); err == nil {
+				outputManager = mgr
+			}
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return nil, false
+	}
+
+	if outputManager == nil {
+		return nil, false
+	}
+
+	type headState struct {
+		name      string
+		x, y      int32
+		transform int32
+	}
+	heads := make(map[*wlr_output_management.ZwlrOutputHeadV1]*headState)
+	done := false
+
+	outputManager.SetHeadHandler(func(e wlr_output_management.ZwlrOutputManagerV1HeadEvent) {
+		state := &headState{}
+		heads[e.Head] = state
+		e.Head.SetNameHandler(func(ne wlr_output_management.ZwlrOutputHeadV1NameEvent) {
+			state.name = ne.Name
+		})
+		e.Head.SetPositionHandler(func(pe wlr_output_management.ZwlrOutputHeadV1PositionEvent) {
+			state.x = pe.X
+			state.y = pe.Y
+		})
+		e.Head.SetTransformHandler(func(te wlr_output_management.ZwlrOutputHeadV1TransformEvent) {
+			state.transform = te.Transform
+		})
+	})
+	outputManager.SetDoneHandler(func(e wlr_output_management.ZwlrOutputManagerV1DoneEvent) {
+		done = true
+	})
+
+	for !done {
+		if err := ctx.Dispatch(); err != nil {
+			return nil, false
+		}
+	}
+
+	for _, state := range heads {
+		if state.name == outputName {
+			return &outputInfo{
+				x:         state.x,
+				y:         state.y,
+				transform: state.transform,
+			}, true
+		}
+	}
+
+	return nil, false
+}
+
 func getDWLActiveWindow() (*WindowGeometry, error) {
 	display, err := client.Connect("")
 	if err != nil {
@@ -509,14 +628,23 @@ func getDWLActiveWindow() (*WindowGeometry, error) {
 		if scale <= 0 {
 			scale = 1.0
 		}
-		return &WindowGeometry{
+
+		geom := &WindowGeometry{
 			X:      state.x,
 			Y:      state.y,
 			Width:  state.w,
 			Height: state.h,
 			Output: state.name,
 			Scale:  scale,
-		}, nil
+		}
+
+		if info, ok := getOutputInfo(state.name); ok {
+			geom.OutputX = info.x
+			geom.OutputY = info.y
+			geom.OutputTransform = info.transform
+		}
+
+		return geom, nil
 	}
 
 	return nil, fmt.Errorf("no active output found")

core/internal/screenshot/encode.go

@@ -9,7 +9,10 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 func BufferToImage(buf *ShmBuffer) *image.RGBA {
@@ -20,7 +23,13 @@ func BufferToImageWithFormat(buf *ShmBuffer, format uint32) *image.RGBA {
 	img := image.NewRGBA(image.Rect(0, 0, buf.Width, buf.Height))
 	data := buf.Data()
 
-	swapRB := format == uint32(FormatARGB8888) || format == uint32(FormatXRGB8888) || format == 0
+	var swapRB bool
+	switch format {
+	case uint32(FormatABGR8888), uint32(FormatXBGR8888):
+		swapRB = false
+	default:
+		swapRB = true
+	}
 
 	for y := 0; y < buf.Height; y++ {
 		srcOff := y * buf.Stride
@@ -110,70 +119,30 @@ func GetOutputDir() string {
 }
 
 func getXDGPicturesDir() string {
-	configDir := os.Getenv("XDG_CONFIG_HOME")
-	if configDir == "" {
-		home := os.Getenv("HOME")
-		if home == "" {
-			return ""
-		}
-		configDir = filepath.Join(home, ".config")
-	}
-
-	userDirsFile := filepath.Join(configDir, "user-dirs.dirs")
+	userDirsFile := filepath.Join(utils.XDGConfigHome(), "user-dirs.dirs")
 	data, err := os.ReadFile(userDirsFile)
 	if err != nil {
 		return ""
 	}
 
-	for _, line := range splitLines(string(data)) {
+	for _, line := range strings.Split(string(data), "\n") {
 		if len(line) == 0 || line[0] == '#' {
 			continue
 		}
 		const prefix = "XDG_PICTURES_DIR="
-		if len(line) > len(prefix) && line[:len(prefix)] == prefix {
-			path := line[len(prefix):]
-			path = trimQuotes(path)
-			path = expandHome(path)
-			return path
+		if !strings.HasPrefix(line, prefix) {
+			continue
 		}
+		path := strings.Trim(line[len(prefix):], "\"")
+		expanded, err := utils.ExpandPath(path)
+		if err != nil {
+			return ""
+		}
+		return expanded
 	}
 	return ""
 }
 
-func splitLines(s string) []string {
-	var lines []string
-	start := 0
-	for i := 0; i < len(s); i++ {
-		if s[i] == '\n' {
-			lines = append(lines, s[start:i])
-			start = i + 1
-		}
-	}
-	if start < len(s) {
-		lines = append(lines, s[start:])
-	}
-	return lines
-}
-
-func trimQuotes(s string) string {
-	if len(s) >= 2 && s[0] == '"' && s[len(s)-1] == '"' {
-		return s[1 : len(s)-1]
-	}
-	return s
-}
-
-func expandHome(path string) string {
-	if len(path) >= 5 && path[:5] == "$HOME" {
-		home := os.Getenv("HOME")
-		return home + path[5:]
-	}
-	if len(path) >= 1 && path[0] == '~' {
-		home := os.Getenv("HOME")
-		return home + path[1:]
-	}
-	return path
-}
-
 func WriteToFile(buf *ShmBuffer, path string, format Format, quality int) error {
 	return WriteToFileWithFormat(buf, path, format, quality, uint32(FormatARGB8888))
 }

core/internal/screenshot/region.go

@@ -380,19 +380,24 @@ func (r *RegionSelector) preCaptureOutput(output *WaylandOutput, pc *PreCapture,
 		return
 	}
 
+	var capturedBuf *ShmBuffer
+
+	var capturedFormat PixelFormat
 	frame.SetBufferHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1BufferEvent) {
+		capturedFormat = PixelFormat(e.Format)
+		bpp := capturedFormat.BytesPerPixel()
+		if int(e.Stride) < int(e.Width)*bpp {
+			log.Error("invalid stride from compositor", "stride", e.Stride, "width", e.Width, "bpp", bpp)
+			return
+		}
 		buf, err := CreateShmBuffer(int(e.Width), int(e.Height), int(e.Stride))
 		if err != nil {
 			log.Error("create screen buffer failed", "err", err)
 			return
 		}
 
-		if withCursor {
-			pc.screenBuf = buf
-			pc.format = e.Format
-		} else {
-			pc.screenBufNoCursor = buf
-		}
+		capturedBuf = buf
+		buf.Format = capturedFormat
 
 		pool, err := r.shm.CreatePool(buf.Fd(), int32(buf.Size()))
 		if err != nil {
@@ -421,6 +426,47 @@ func (r *RegionSelector) preCaptureOutput(output *WaylandOutput, pc *PreCapture,
 
 	frame.SetReadyHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1ReadyEvent) {
 		frame.Destroy()
+
+		if capturedBuf == nil {
+			onReady()
+			return
+		}
+
+		if capturedFormat.Is24Bit() {
+			converted, newFormat, err := capturedBuf.ConvertTo32Bit(capturedFormat)
+			if err != nil {
+				log.Error("convert 24-bit to 32-bit failed", "err", err)
+			} else if converted != capturedBuf {
+				capturedBuf.Close()
+				capturedBuf = converted
+				capturedFormat = newFormat
+			}
+		}
+
+		pc.format = uint32(capturedFormat)
+
+		if pc.yInverted {
+			capturedBuf.FlipVertical()
+			pc.yInverted = false
+		}
+
+		if output.transform != TransformNormal {
+			invTransform := InverseTransform(output.transform)
+			transformed, err := capturedBuf.ApplyTransform(invTransform)
+			if err != nil {
+				log.Error("apply transform failed", "err", err)
+			} else if transformed != capturedBuf {
+				capturedBuf.Close()
+				capturedBuf = transformed
+			}
+		}
+
+		if withCursor {
+			pc.screenBuf = capturedBuf
+		} else {
+			pc.screenBufNoCursor = capturedBuf
+		}
+
 		onReady()
 	})
 

core/internal/screenshot/screenshot.go

@@ -150,51 +150,33 @@ func (s *Screenshoter) captureWindow() (*CaptureResult, error) {
 	case CompositorHyprland:
 		return s.captureAndCrop(output, region)
 	case CompositorDWL:
-		return s.captureDWLWindow(output, region, geom.Scale)
+		return s.captureDWLWindow(output, region, geom)
 	default:
 		return s.captureRegionOnOutput(output, region)
 	}
 }
 
-func (s *Screenshoter) captureDWLWindow(output *WaylandOutput, region Region, dwlScale float64) (*CaptureResult, error) {
+func (s *Screenshoter) captureDWLWindow(output *WaylandOutput, region Region, geom *WindowGeometry) (*CaptureResult, error) {
 	result, err := s.captureWholeOutput(output)
 	if err != nil {
 		return nil, err
 	}
 
-	scale := dwlScale
-	if scale <= 0 {
-		scale = float64(result.Buffer.Width) / float64(output.width)
+	scale := geom.Scale
+	if scale <= 0 || scale == 1.0 {
+		if output.fractionalScale > 1.0 {
+			scale = output.fractionalScale
+		}
 	}
 	if scale <= 0 {
 		scale = 1.0
 	}
 
-	localX := int(float64(region.X) * scale)
-	localY := int(float64(region.Y) * scale)
-	if localX >= result.Buffer.Width {
-		localX = localX % result.Buffer.Width
-	}
-	if localY >= result.Buffer.Height {
-		localY = localY % result.Buffer.Height
-	}
-
+	localX := int(float64(region.X-geom.OutputX) * scale)
+	localY := int(float64(region.Y-geom.OutputY) * scale)
 	w := int(float64(region.Width) * scale)
 	h := int(float64(region.Height) * scale)
 
-	if localY+h > result.Buffer.Height && h <= result.Buffer.Height {
-		localY = result.Buffer.Height - h
-		if localY < 0 {
-			localY = 0
-		}
-	}
-	if localX+w > result.Buffer.Width && w <= result.Buffer.Width {
-		localX = result.Buffer.Width - w
-		if localX < 0 {
-			localX = 0
-		}
-	}
-
 	if localX < 0 {
 		w += localX
 		localX = 0
@@ -342,13 +324,18 @@ func (s *Screenshoter) captureAllScreens() (*CaptureResult, error) {
 
 		outX, outY := output.x, output.y
 		scale := float64(output.scale)
-		if DetectCompositor() == CompositorHyprland {
+		switch DetectCompositor() {
+		case CompositorHyprland:
 			if hx, hy, _, _, ok := GetHyprlandMonitorGeometry(output.name); ok {
 				outX, outY = hx, hy
 			}
 			if s := GetHyprlandMonitorScale(output.name); s > 0 {
 				scale = s
 			}
+		case CompositorDWL:
+			if info, ok := getOutputInfo(output.name); ok {
+				outX, outY = info.x, info.y
+			}
 		}
 		if scale <= 0 {
 			scale = 1.0
@@ -476,13 +463,42 @@ func (s *Screenshoter) captureWholeOutput(output *WaylandOutput) (*CaptureResult
 		return nil, fmt.Errorf("capture output: %w", err)
 	}
 
-	return s.processFrame(frame, Region{
+	result, err := s.processFrame(frame, Region{
 		X:      output.x,
 		Y:      output.y,
 		Width:  output.width,
 		Height: output.height,
 		Output: output.name,
 	})
+	if err != nil {
+		return nil, err
+	}
+
+	if result.YInverted {
+		result.Buffer.FlipVertical()
+		result.YInverted = false
+	}
+
+	if output.transform == TransformNormal {
+		return result, nil
+	}
+
+	invTransform := InverseTransform(output.transform)
+	transformed, err := result.Buffer.ApplyTransform(invTransform)
+	if err != nil {
+		result.Buffer.Close()
+		return nil, fmt.Errorf("apply transform: %w", err)
+	}
+
+	if transformed != result.Buffer {
+		result.Buffer.Close()
+		result.Buffer = transformed
+	}
+
+	result.Region.Width = int32(transformed.Width)
+	result.Region.Height = int32(transformed.Height)
+
+	return result, nil
 }
 
 func (s *Screenshoter) captureAndCrop(output *WaylandOutput, region Region) (*CaptureResult, error) {
@@ -563,6 +579,10 @@ func (s *Screenshoter) captureAndCrop(output *WaylandOutput, region Region) (*Ca
 }
 
 func (s *Screenshoter) captureRegionOnOutput(output *WaylandOutput, region Region) (*CaptureResult, error) {
+	if output.transform != TransformNormal {
+		return s.captureRegionOnTransformedOutput(output, region)
+	}
+
 	scale := output.fractionalScale
 	if scale <= 0 && DetectCompositor() == CompositorHyprland {
 		scale = GetHyprlandMonitorScale(output.name)
@@ -617,6 +637,76 @@ func (s *Screenshoter) captureRegionOnOutput(output *WaylandOutput, region Regio
 	return s.processFrame(frame, region)
 }
 
+func (s *Screenshoter) captureRegionOnTransformedOutput(output *WaylandOutput, region Region) (*CaptureResult, error) {
+	result, err := s.captureWholeOutput(output)
+	if err != nil {
+		return nil, err
+	}
+
+	scale := output.fractionalScale
+	if scale <= 0 && DetectCompositor() == CompositorHyprland {
+		scale = GetHyprlandMonitorScale(output.name)
+	}
+	if scale <= 0 {
+		scale = float64(output.scale)
+	}
+	if scale <= 0 {
+		scale = 1.0
+	}
+
+	localX := int(float64(region.X-output.x) * scale)
+	localY := int(float64(region.Y-output.y) * scale)
+	w := int(float64(region.Width) * scale)
+	h := int(float64(region.Height) * scale)
+
+	if localX < 0 {
+		w += localX
+		localX = 0
+	}
+	if localY < 0 {
+		h += localY
+		localY = 0
+	}
+	if localX+w > result.Buffer.Width {
+		w = result.Buffer.Width - localX
+	}
+	if localY+h > result.Buffer.Height {
+		h = result.Buffer.Height - localY
+	}
+
+	if w <= 0 || h <= 0 {
+		result.Buffer.Close()
+		return nil, fmt.Errorf("region not visible on output")
+	}
+
+	cropped, err := CreateShmBuffer(w, h, w*4)
+	if err != nil {
+		result.Buffer.Close()
+		return nil, fmt.Errorf("create crop buffer: %w", err)
+	}
+
+	srcData := result.Buffer.Data()
+	dstData := cropped.Data()
+
+	for y := 0; y < h; y++ {
+		srcOff := (localY+y)*result.Buffer.Stride + localX*4
+		dstOff := y * cropped.Stride
+		if srcOff+w*4 <= len(srcData) && dstOff+w*4 <= len(dstData) {
+			copy(dstData[dstOff:dstOff+w*4], srcData[srcOff:srcOff+w*4])
+		}
+	}
+
+	result.Buffer.Close()
+	cropped.Format = PixelFormat(result.Format)
+
+	return &CaptureResult{
+		Buffer:    cropped,
+		Region:    region,
+		YInverted: false,
+		Format:    result.Format,
+	}, nil
+}
+
 func (s *Screenshoter) processFrame(frame *wlr_screencopy.ZwlrScreencopyFrameV1, region Region) (*CaptureResult, error) {
 	var buf *ShmBuffer
 	var pool *client.ShmPool
@@ -627,13 +717,18 @@ func (s *Screenshoter) processFrame(frame *wlr_screencopy.ZwlrScreencopyFrameV1,
 	failed := false
 
 	frame.SetBufferHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1BufferEvent) {
+		format = PixelFormat(e.Format)
+		bpp := format.BytesPerPixel()
+		if int(e.Stride) < int(e.Width)*bpp {
+			log.Error("invalid stride from compositor", "stride", e.Stride, "width", e.Width, "bpp", bpp)
+			return
+		}
 		var err error
 		buf, err = CreateShmBuffer(int(e.Width), int(e.Height), int(e.Stride))
 		if err != nil {
 			log.Error("failed to create buffer", "err", err)
 			return
 		}
-		format = PixelFormat(e.Format)
 		buf.Format = format
 	})
 
@@ -696,6 +791,19 @@ func (s *Screenshoter) processFrame(frame *wlr_screencopy.ZwlrScreencopyFrameV1,
 		return nil, fmt.Errorf("frame capture failed")
 	}
 
+	if format.Is24Bit() {
+		converted, newFormat, err := buf.ConvertTo32Bit(format)
+		if err != nil {
+			buf.Close()
+			return nil, fmt.Errorf("convert 24-bit to 32-bit: %w", err)
+		}
+		if converted != buf {
+			buf.Close()
+			buf = converted
+		}
+		format = newFormat
+	}
+
 	return &CaptureResult{
 		Buffer:    buf,
 		Region:    region,
@@ -924,16 +1032,32 @@ func ListOutputs() ([]Output, error) {
 	sc.outputsMu.Lock()
 	defer sc.outputsMu.Unlock()
 
+	compositor := DetectCompositor()
 	result := make([]Output, 0, len(sc.outputs))
 	for _, o := range sc.outputs {
-		result = append(result, Output{
-			Name:   o.name,
-			X:      o.x,
-			Y:      o.y,
-			Width:  o.width,
-			Height: o.height,
-			Scale:  o.scale,
-		})
+		out := Output{
+			Name:            o.name,
+			X:               o.x,
+			Y:               o.y,
+			Width:           o.width,
+			Height:          o.height,
+			Scale:           o.scale,
+			FractionalScale: o.fractionalScale,
+			Transform:       o.transform,
+		}
+
+		switch compositor {
+		case CompositorHyprland:
+			if hx, hy, hw, hh, ok := GetHyprlandMonitorGeometry(o.name); ok {
+				out.X, out.Y = hx, hy
+				out.Width, out.Height = hw, hh
+			}
+			if s := GetHyprlandMonitorScale(o.name); s > 0 {
+				out.FractionalScale = s
+			}
+		}
+
+		result = append(result, out)
 	}
 	return result, nil
 }

core/internal/screenshot/shm.go

@@ -9,6 +9,19 @@ const (
 	FormatXRGB8888 = shm.FormatXRGB8888
 	FormatABGR8888 = shm.FormatABGR8888
 	FormatXBGR8888 = shm.FormatXBGR8888
+	FormatRGB888   = shm.FormatRGB888
+	FormatBGR888   = shm.FormatBGR888
+)
+
+const (
+	TransformNormal     = shm.TransformNormal
+	Transform90         = shm.Transform90
+	Transform180        = shm.Transform180
+	Transform270        = shm.Transform270
+	TransformFlipped    = shm.TransformFlipped
+	TransformFlipped90  = shm.TransformFlipped90
+	TransformFlipped180 = shm.TransformFlipped180
+	TransformFlipped270 = shm.TransformFlipped270
 )
 
 type ShmBuffer = shm.Buffer
@@ -16,3 +29,7 @@ type ShmBuffer = shm.Buffer
 func CreateShmBuffer(width, height, stride int) (*ShmBuffer, error) {
 	return shm.CreateBuffer(width, height, stride)
 }
+
+func InverseTransform(transform int32) int32 {
+	return shm.InverseTransform(transform)
+}

core/internal/screenshot/theme.go

@@ -6,6 +6,8 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type ThemeColors struct {
@@ -72,15 +74,7 @@ func loadColorsFile() *ColorScheme {
 }
 
 func getColorsFilePath() string {
-	cacheDir := os.Getenv("XDG_CACHE_HOME")
-	if cacheDir == "" {
-		home := os.Getenv("HOME")
-		if home == "" {
-			return ""
-		}
-		cacheDir = filepath.Join(home, ".cache")
-	}
-	return filepath.Join(cacheDir, "DankMaterialShell", "dms-colors.json")
+	return filepath.Join(utils.XDGCacheHome(), "DankMaterialShell", "dms-colors.json")
 }
 
 func isLightMode() bool {

core/internal/screenshot/types.go

@@ -32,11 +32,13 @@ func (r Region) IsEmpty() bool {
 }
 
 type Output struct {
-	Name   string
-	X, Y   int32
-	Width  int32
-	Height int32
-	Scale  int32
+	Name            string
+	X, Y            int32
+	Width           int32
+	Height          int32
+	Scale           int32
+	FractionalScale float64
+	Transform       int32
 }
 
 type Config struct {

core/internal/server/apppicker/handlers.go

@@ -7,13 +7,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "apppicker.open", "browser.open":
 		handleOpen(conn, req, manager)
@@ -22,7 +16,7 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleOpen(conn net.Conn, req 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)

core/internal/server/bluez/handlers.go

@@ -6,25 +6,15 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type BluetoothEvent struct {
 	Type string         `json:"type"`
 	Data BluetoothState `json:"data"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "bluetooth.getState":
 		handleGetState(conn, req, manager)
@@ -57,31 +47,30 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleStartDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStartDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StartDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery started"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery started"})
 }
 
-func handleStopDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStopDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StopDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery stopped"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery stopped"})
 }
 
-func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
-	powered, ok := req.Params["powered"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'powered' parameter")
+func handleSetPowered(conn net.Conn, req models.Request, manager *Manager) {
+	powered, err := params.Bool(req.Params, "powered")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -90,13 +79,13 @@ func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "powered state updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "powered state updated"})
 }
 
-func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handlePairDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -105,13 +94,13 @@ func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing initiated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing initiated"})
 }
 
-func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleConnectDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -120,13 +109,13 @@ func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleDisconnectDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -135,13 +124,13 @@ func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleRemoveDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -150,13 +139,13 @@ func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device removed"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device removed"})
 }
 
-func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleTrustDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -165,13 +154,13 @@ func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device trusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device trusted"})
 }
 
-func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleUntrustDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -180,43 +169,31 @@ func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device untrusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device untrusted"})
 }
 
-func handlePairingSubmit(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+func handlePairingSubmit(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secretsRaw, ok := req.Params["secrets"].(map[string]any)
-	secrets := make(map[string]string)
-	if ok {
-		for k, v := range secretsRaw {
-			if str, ok := v.(string); ok {
-				secrets[k] = str
-			}
-		}
-	}
-
-	accept := false
-	if acceptParam, ok := req.Params["accept"].(bool); ok {
-		accept = acceptParam
-	}
+	secrets := params.StringMapOpt(req.Params, "secrets")
+	accept := params.BoolOpt(req.Params, "accept", false)
 
 	if err := manager.SubmitPairing(token, secrets, accept); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing response submitted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing response submitted"})
 }
 
-func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+func handlePairingCancel(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -225,10 +202,10 @@ func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing cancelled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing cancelled"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/brightness/handlers.go

@@ -2,12 +2,14 @@ package brightness
 
 import (
 	"encoding/json"
+	"fmt"
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-func HandleRequest(conn net.Conn, req Request, m *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, m *Manager) {
 	switch req.Method {
 	case "brightness.getState":
 		handleGetState(conn, req, m)
@@ -22,131 +24,90 @@ func HandleRequest(conn net.Conn, req Request, m *Manager) {
 	case "brightness.subscribe":
 		handleSubscribe(conn, req, m)
 	default:
-		models.RespondError(conn, req.ID.(int), "unknown method: "+req.Method)
+		models.RespondError(conn, req.ID, "unknown method: "+req.Method)
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, m *Manager) {
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+func handleGetState(conn net.Conn, req models.Request, m *Manager) {
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleSetBrightness(conn net.Conn, req Request, m *Manager) {
-	var params SetBrightnessParams
-
-	device, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
-		return
-	}
-	params.Device = device
-
-	percentFloat, ok := req.Params["percent"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid percent parameter")
-		return
-	}
-	params.Percent = int(percentFloat)
-
-	if exponential, ok := req.Params["exponential"].(bool); ok {
-		params.Exponential = exponential
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		params.Exponent = exponentFloat
-		exponent = exponentFloat
-	}
-
-	if err := m.SetBrightnessWithExponent(params.Device, params.Percent, params.Exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
+func handleSetBrightness(conn net.Conn, req models.Request, m *Manager) {
+	device, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+	percent, err := params.Int(req.Params, "percent")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	exponential := params.BoolOpt(req.Params, "exponential", false)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
+
+	if err := m.SetBrightnessWithExponent(device, percent, exponential, exponent); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleIncrement(conn net.Conn, req Request, m *Manager) {
-	device, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
+func handleIncrement(conn net.Conn, req models.Request, m *Manager) {
+	device, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	step := 10
-	if stepFloat, ok := req.Params["step"].(float64); ok {
-		step = int(stepFloat)
-	}
-
-	exponential := false
-	if expBool, ok := req.Params["exponential"].(bool); ok {
-		exponential = expBool
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		exponent = exponentFloat
-	}
+	step := params.IntOpt(req.Params, "step", 10)
+	exponential := params.BoolOpt(req.Params, "exponential", false)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
 
 	if err := m.IncrementBrightnessWithExponent(device, step, exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleDecrement(conn net.Conn, req Request, m *Manager) {
-	device, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID.(int), "missing or invalid device parameter")
+func handleDecrement(conn net.Conn, req models.Request, m *Manager) {
+	device, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	step := 10
-	if stepFloat, ok := req.Params["step"].(float64); ok {
-		step = int(stepFloat)
-	}
-
-	exponential := false
-	if expBool, ok := req.Params["exponential"].(bool); ok {
-		exponential = expBool
-	}
-
-	exponent := 1.2
-	if exponentFloat, ok := req.Params["exponent"].(float64); ok {
-		exponent = exponentFloat
-	}
+	step := params.IntOpt(req.Params, "step", 10)
+	exponential := params.BoolOpt(req.Params, "exponential", false)
+	exponent := params.FloatOpt(req.Params, "exponent", 1.2)
 
 	if err := m.IncrementBrightnessWithExponent(device, -step, exponential, exponent); err != nil {
-		models.RespondError(conn, req.ID.(int), err.Error())
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleRescan(conn net.Conn, req Request, m *Manager) {
+func handleRescan(conn net.Conn, req models.Request, m *Manager) {
 	m.Rescan()
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+	models.Respond(conn, req.ID, m.GetState())
 }
 
-func handleSubscribe(conn net.Conn, req Request, m *Manager) {
-	clientID := "brightness-subscriber"
-	if idStr, ok := req.ID.(string); ok && idStr != "" {
-		clientID = idStr
-	}
+func handleSubscribe(conn net.Conn, req models.Request, m *Manager) {
+	clientID := fmt.Sprintf("brightness-%d", req.ID)
 
 	ch := m.Subscribe(clientID)
 	defer m.Unsubscribe(clientID)
 
 	initialState := m.GetState()
 	if err := json.NewEncoder(conn).Encode(models.Response[State]{
-		ID:     req.ID.(int),
+		ID:     req.ID,
 		Result: &initialState,
 	}); err != nil {
 		return
@@ -154,7 +115,7 @@ func handleSubscribe(conn net.Conn, req Request, m *Manager) {
 
 	for state := range ch {
 		if err := json.NewEncoder(conn).Encode(models.Response[State]{
-			ID:     req.ID.(int),
+			ID:     req.ID,
 			Result: &state,
 		}); err != nil {
 			return

core/internal/server/brightness/types.go

@@ -33,12 +33,6 @@ type DeviceUpdate struct {
 	Device Device `json:"device"`
 }
 
-type Request struct {
-	ID     any            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
 type Manager struct {
 	logindBackend *LogindBackend
 	sysfsBackend  *SysfsBackend
@@ -112,13 +106,6 @@ type ddcCapability struct {
 	current int
 }
 
-type SetBrightnessParams struct {
-	Device      string  `json:"device"`
-	Percent     int     `json:"percent"`
-	Exponential bool    `json:"exponential,omitempty"`
-	Exponent    float64 `json:"exponent,omitempty"`
-}
-
 func (m *Manager) Subscribe(id string) chan State {
 	ch := make(chan State, 16)
 

core/internal/server/browser/handlers.go

@@ -6,13 +6,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "browser.open":
 		url, ok := req.Params["url"].(string)

core/internal/server/cups/handlers.go

@@ -6,25 +6,21 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type CUPSEvent struct {
 	Type string    `json:"type"`
 	Data CUPSState `json:"data"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+type TestPageResult struct {
+	Success bool   `json:"success"`
+	JobID   int    `json:"jobId"`
+	Message string `json:"message"`
+}
+
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "cups.subscribe":
 		handleSubscribe(conn, req, manager)
@@ -79,20 +75,19 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetPrinters(conn net.Conn, req Request, manager *Manager) {
+func handleGetPrinters(conn net.Conn, req models.Request, manager *Manager) {
 	printers, err := manager.GetPrinters()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-
 	models.Respond(conn, req.ID, printers)
 }
 
-func handleGetJobs(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleGetJobs(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.String(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -101,14 +96,13 @@ func handleGetJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-
 	models.Respond(conn, req.ID, jobs)
 }
 
-func handlePausePrinter(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handlePausePrinter(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.String(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -116,13 +110,13 @@ func handlePausePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "paused"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "paused"})
 }
 
-func handleResumePrinter(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleResumePrinter(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.String(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -130,28 +124,27 @@ func handleResumePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "resumed"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "resumed"})
 }
 
-func handleCancelJob(conn net.Conn, req Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobid' parameter")
+func handleCancelJob(conn net.Conn, req models.Request, manager *Manager) {
+	jobID, err := params.Int(req.Params, "jobID")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	jobID := int(jobIDFloat)
 
 	if err := manager.CancelJob(jobID); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job canceled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job canceled"})
 }
 
-func handlePurgeJobs(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handlePurgeJobs(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.String(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -159,10 +152,10 @@ func handlePurgeJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "jobs canceled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "jobs canceled"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)
@@ -193,7 +186,7 @@ func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetDevices(conn net.Conn, req Request, manager *Manager) {
+func handleGetDevices(conn net.Conn, req models.Request, manager *Manager) {
 	devices, err := manager.GetDevices()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -202,7 +195,7 @@ func handleGetDevices(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, devices)
 }
 
-func handleGetPPDs(conn net.Conn, req Request, manager *Manager) {
+func handleGetPPDs(conn net.Conn, req models.Request, manager *Manager) {
 	ppds, err := manager.GetPPDs()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -211,7 +204,7 @@ func handleGetPPDs(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, ppds)
 }
 
-func handleGetClasses(conn net.Conn, req Request, manager *Manager) {
+func handleGetClasses(conn net.Conn, req models.Request, manager *Manager) {
 	classes, err := manager.GetClasses()
 	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
@@ -220,41 +213,41 @@ func handleGetClasses(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, classes)
 }
 
-func handleCreatePrinter(conn net.Conn, req Request, manager *Manager) {
-	name, ok := req.Params["name"].(string)
-	if !ok || name == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
+func handleCreatePrinter(conn net.Conn, req models.Request, manager *Manager) {
+	name, err := params.StringNonEmpty(req.Params, "name")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	deviceURI, ok := req.Params["deviceURI"].(string)
-	if !ok || deviceURI == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'deviceURI' parameter")
+	deviceURI, err := params.StringNonEmpty(req.Params, "deviceURI")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	ppd, ok := req.Params["ppd"].(string)
-	if !ok || ppd == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'ppd' parameter")
+	ppd, err := params.StringNonEmpty(req.Params, "ppd")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	shared, _ := req.Params["shared"].(bool)
-	errorPolicy, _ := req.Params["errorPolicy"].(string)
-	information, _ := req.Params["information"].(string)
-	location, _ := req.Params["location"].(string)
+	shared := params.BoolOpt(req.Params, "shared", false)
+	errorPolicy := params.StringOpt(req.Params, "errorPolicy", "")
+	information := params.StringOpt(req.Params, "information", "")
+	location := params.StringOpt(req.Params, "location", "")
 
 	if err := manager.CreatePrinter(name, deviceURI, ppd, shared, errorPolicy, information, location); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer created"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer created"})
 }
 
-func handleDeletePrinter(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleDeletePrinter(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -262,13 +255,13 @@ func handleDeletePrinter(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer deleted"})
 }
 
-func handleAcceptJobs(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleAcceptJobs(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -276,13 +269,13 @@ func handleAcceptJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "accepting jobs"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "accepting jobs"})
 }
 
-func handleRejectJobs(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleRejectJobs(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -290,19 +283,19 @@ func handleRejectJobs(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "rejecting jobs"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "rejecting jobs"})
 }
 
-func handleSetPrinterShared(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleSetPrinterShared(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	shared, ok := req.Params["shared"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'shared' parameter")
+	shared, err := params.Bool(req.Params, "shared")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -310,19 +303,19 @@ func handleSetPrinterShared(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "sharing updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "sharing updated"})
 }
 
-func handleSetPrinterLocation(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleSetPrinterLocation(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	location, ok := req.Params["location"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'location' parameter")
+	location, err := params.String(req.Params, "location")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -330,19 +323,19 @@ func handleSetPrinterLocation(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location updated"})
 }
 
-func handleSetPrinterInfo(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handleSetPrinterInfo(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	info, ok := req.Params["info"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'info' parameter")
+	info, err := params.String(req.Params, "info")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -350,39 +343,33 @@ func handleSetPrinterInfo(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "info updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "info updated"})
 }
 
-func handleMoveJob(conn net.Conn, req Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	destPrinter, ok := req.Params["destPrinter"].(string)
-	if !ok || destPrinter == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'destPrinter' parameter")
-		return
-	}
-
-	if err := manager.MoveJob(int(jobIDFloat), destPrinter); err != nil {
+func handleMoveJob(conn net.Conn, req models.Request, manager *Manager) {
+	jobID, err := params.Int(req.Params, "jobID")
+	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job moved"})
+
+	destPrinter, err := params.StringNonEmpty(req.Params, "destPrinter")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	if err := manager.MoveJob(jobID, destPrinter); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job moved"})
 }
 
-type TestPageResult struct {
-	Success bool   `json:"success"`
-	JobID   int    `json:"jobId"`
-	Message string `json:"message"`
-}
-
-func handlePrintTestPage(conn net.Conn, req Request, manager *Manager) {
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+func handlePrintTestPage(conn net.Conn, req models.Request, manager *Manager) {
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -394,16 +381,16 @@ func handlePrintTestPage(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, TestPageResult{Success: true, JobID: jobID, Message: "test page queued"})
 }
 
-func handleAddPrinterToClass(conn net.Conn, req Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
-	if !ok || className == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+func handleAddPrinterToClass(conn net.Conn, req models.Request, manager *Manager) {
+	className, err := params.StringNonEmpty(req.Params, "className")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -411,19 +398,19 @@ func handleAddPrinterToClass(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer added to class"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer added to class"})
 }
 
-func handleRemovePrinterFromClass(conn net.Conn, req Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
-	if !ok || className == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+func handleRemovePrinterFromClass(conn net.Conn, req models.Request, manager *Manager) {
+	className, err := params.StringNonEmpty(req.Params, "className")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	printerName, ok := req.Params["printerName"].(string)
-	if !ok || printerName == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'printerName' parameter")
+	printerName, err := params.StringNonEmpty(req.Params, "printerName")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -431,13 +418,13 @@ func handleRemovePrinterFromClass(conn net.Conn, req Request, manager *Manager)
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "printer removed from class"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "printer removed from class"})
 }
 
-func handleDeleteClass(conn net.Conn, req Request, manager *Manager) {
-	className, ok := req.Params["className"].(string)
-	if !ok || className == "" {
-		models.RespondError(conn, req.ID, "missing or invalid 'className' parameter")
+func handleDeleteClass(conn net.Conn, req models.Request, manager *Manager) {
+	className, err := params.StringNonEmpty(req.Params, "className")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -445,38 +432,35 @@ func handleDeleteClass(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "class deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "class deleted"})
 }
 
-func handleRestartJob(conn net.Conn, req Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	if err := manager.RestartJob(int(jobIDFloat)); err != nil {
+func handleRestartJob(conn net.Conn, req models.Request, manager *Manager) {
+	jobID, err := params.Int(req.Params, "jobID")
+	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job restarted"})
-}
 
-func handleHoldJob(conn net.Conn, req Request, manager *Manager) {
-	jobIDFloat, ok := req.Params["jobID"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'jobID' parameter")
-		return
-	}
-
-	holdUntil, _ := req.Params["holdUntil"].(string)
-	if holdUntil == "" {
-		holdUntil = "indefinite"
-	}
-
-	if err := manager.HoldJob(int(jobIDFloat), holdUntil); err != nil {
+	if err := manager.RestartJob(jobID); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "job held"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job restarted"})
+}
+
+func handleHoldJob(conn net.Conn, req models.Request, manager *Manager) {
+	jobID, err := params.Int(req.Params, "jobID")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	holdUntil := params.StringOpt(req.Params, "holdUntil", "indefinite")
+
+	if err := manager.HoldJob(jobID, holdUntil); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "job held"})
 }

core/internal/server/cups/handlers_test.go

@@ -43,7 +43,7 @@ func TestHandleGetPrinters(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getPrinters",
 	}
@@ -68,7 +68,7 @@ func TestHandleGetPrinters_Error(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getPrinters",
 	}
@@ -100,7 +100,7 @@ func TestHandleGetJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getJobs",
 		Params: map[string]any{
@@ -127,7 +127,7 @@ func TestHandleGetJobs_MissingParam(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.getJobs",
 		Params: map[string]any{},
@@ -152,7 +152,7 @@ func TestHandlePausePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.pausePrinter",
 		Params: map[string]any{
@@ -162,7 +162,7 @@ func TestHandlePausePrinter(t *testing.T) {
 
 	handlePausePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -179,7 +179,7 @@ func TestHandleResumePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.resumePrinter",
 		Params: map[string]any{
@@ -189,7 +189,7 @@ func TestHandleResumePrinter(t *testing.T) {
 
 	handleResumePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -206,7 +206,7 @@ func TestHandleCancelJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.cancelJob",
 		Params: map[string]any{
@@ -216,7 +216,7 @@ func TestHandleCancelJob(t *testing.T) {
 
 	handleCancelJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -233,7 +233,7 @@ func TestHandlePurgeJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.purgeJobs",
 		Params: map[string]any{
@@ -243,7 +243,7 @@ func TestHandlePurgeJobs(t *testing.T) {
 
 	handlePurgeJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -260,7 +260,7 @@ func TestHandleRequest_UnknownMethod(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.unknownMethod",
 	}
@@ -287,7 +287,7 @@ func TestHandleGetDevices(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getDevices"}
+	req := models.Request{ID: 1, Method: "cups.getDevices"}
 	handleGetDevices(conn, req, m)
 
 	var resp models.Response[[]Device]
@@ -309,7 +309,7 @@ func TestHandleGetPPDs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getPPDs"}
+	req := models.Request{ID: 1, Method: "cups.getPPDs"}
 	handleGetPPDs(conn, req, m)
 
 	var resp models.Response[[]PPD]
@@ -332,7 +332,7 @@ func TestHandleGetClasses(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.getClasses"}
+	req := models.Request{ID: 1, Method: "cups.getClasses"}
 	handleGetClasses(conn, req, m)
 
 	var resp models.Response[[]PrinterClass]
@@ -353,7 +353,7 @@ func TestHandleCreatePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.createPrinter",
 		Params: map[string]any{
@@ -364,7 +364,7 @@ func TestHandleCreatePrinter(t *testing.T) {
 	}
 	handleCreatePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -377,7 +377,7 @@ func TestHandleCreatePrinter_MissingParams(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.createPrinter", Params: map[string]any{}}
+	req := models.Request{ID: 1, Method: "cups.createPrinter", Params: map[string]any{}}
 	handleCreatePrinter(conn, req, m)
 
 	var resp models.Response[any]
@@ -396,14 +396,14 @@ func TestHandleDeletePrinter(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.deletePrinter",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleDeletePrinter(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -419,14 +419,14 @@ func TestHandleAcceptJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.acceptJobs",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleAcceptJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -442,14 +442,14 @@ func TestHandleRejectJobs(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.rejectJobs",
 		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleRejectJobs(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -465,14 +465,14 @@ func TestHandleSetPrinterShared(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterShared",
 		Params: map[string]any{"printerName": "printer1", "shared": true},
 	}
 	handleSetPrinterShared(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -488,14 +488,14 @@ func TestHandleSetPrinterLocation(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterLocation",
 		Params: map[string]any{"printerName": "printer1", "location": "Office"},
 	}
 	handleSetPrinterLocation(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -511,14 +511,14 @@ func TestHandleSetPrinterInfo(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.setPrinterInfo",
 		Params: map[string]any{"printerName": "printer1", "info": "Main Printer"},
 	}
 	handleSetPrinterInfo(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -534,14 +534,14 @@ func TestHandleMoveJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.moveJob",
 		Params: map[string]any{"jobID": float64(1), "destPrinter": "printer2"},
 	}
 	handleMoveJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -557,7 +557,7 @@ func TestHandlePrintTestPage(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.printTestPage",
 		Params: map[string]any{"printerName": "printer1"},
@@ -581,14 +581,14 @@ func TestHandleAddPrinterToClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.addPrinterToClass",
 		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleAddPrinterToClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -604,14 +604,14 @@ func TestHandleRemovePrinterFromClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.removePrinterFromClass",
 		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleRemovePrinterFromClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -627,14 +627,14 @@ func TestHandleDeleteClass(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.deleteClass",
 		Params: map[string]any{"className": "office"},
 	}
 	handleDeleteClass(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -650,14 +650,14 @@ func TestHandleRestartJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.restartJob",
 		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleRestartJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -673,14 +673,14 @@ func TestHandleHoldJob(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.holdJob",
 		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleHoldJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)
@@ -696,14 +696,14 @@ func TestHandleHoldJob_WithHoldUntil(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{
+	req := models.Request{
 		ID:     1,
 		Method: "cups.holdJob",
 		Params: map[string]any{"jobID": float64(1), "holdUntil": "no-hold"},
 	}
 	handleHoldJob(conn, req, m)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.NotNil(t, resp.Result)

core/internal/server/dwl/handlers.go

@@ -8,18 +8,12 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
 type SuccessResult struct {
 	Success bool   `json:"success"`
 	Message string `json:"message"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "dwl manager not initialized")
 		return
@@ -41,12 +35,12 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 	state := manager.GetState()
 	models.Respond(conn, req.ID, state)
 }
 
-func handleSetTags(conn net.Conn, req Request, manager *Manager) {
+func handleSetTags(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -73,7 +67,7 @@ func handleSetTags(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "tags set"})
 }
 
-func handleSetClientTags(conn net.Conn, req Request, manager *Manager) {
+func handleSetClientTags(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -100,7 +94,7 @@ func handleSetClientTags(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "client tags set"})
 }
 
-func handleSetLayout(conn net.Conn, req Request, manager *Manager) {
+func handleSetLayout(conn net.Conn, req models.Request, manager *Manager) {
 	output, ok := req.Params["output"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'output' parameter")
@@ -121,7 +115,7 @@ func handleSetLayout(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "layout set"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/dwl/manager_test.go

@@ -0,0 +1,352 @@
+package dwl
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStateChanged_BothNil(t *testing.T) {
+	assert.True(t, stateChanged(nil, nil))
+}
+
+func TestStateChanged_OneNil(t *testing.T) {
+	s := &State{TagCount: 9}
+	assert.True(t, stateChanged(s, nil))
+	assert.True(t, stateChanged(nil, s))
+}
+
+func TestStateChanged_TagCountDiffers(t *testing.T) {
+	a := &State{TagCount: 9, Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	b := &State{TagCount: 10, Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_LayoutLengthDiffers(t *testing.T) {
+	a := &State{TagCount: 9, Layouts: []string{"tile"}, Outputs: make(map[string]*OutputState)}
+	b := &State{TagCount: 9, Layouts: []string{"tile", "monocle"}, Outputs: make(map[string]*OutputState)}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_ActiveOutputDiffers(t *testing.T) {
+	a := &State{TagCount: 9, ActiveOutput: "eDP-1", Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	b := &State{TagCount: 9, ActiveOutput: "HDMI-A-1", Outputs: make(map[string]*OutputState), Layouts: []string{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputCountDiffers(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Outputs:  map[string]*OutputState{"eDP-1": {}},
+		Layouts:  []string{},
+	}
+	b := &State{
+		TagCount: 9,
+		Outputs:  map[string]*OutputState{},
+		Layouts:  []string{},
+	}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputFieldsDiffer(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Active: 1, Layout: 0, Title: "Firefox"},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Active: 0, Layout: 0, Title: "Firefox"},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Active = 1
+	b.Outputs["eDP-1"].Layout = 1
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Layout = 0
+	b.Outputs["eDP-1"].Title = "Code"
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_TagsDiffer(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}}},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1, State: 2, Clients: 2, Focused: 1}}},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs["eDP-1"].Tags[0].State = 1
+	b.Outputs["eDP-1"].Tags[0].Clients = 3
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_Equal(t *testing.T) {
+	a := &State{
+		TagCount:     9,
+		ActiveOutput: "eDP-1",
+		Layouts:      []string{"tile", "monocle"},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {
+				Name:         "eDP-1",
+				Active:       1,
+				Layout:       0,
+				LayoutSymbol: "[]=",
+				Title:        "Firefox",
+				AppID:        "firefox",
+				KbLayout:     "us",
+				Keymode:      "",
+				Tags:         []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}},
+			},
+		},
+	}
+	b := &State{
+		TagCount:     9,
+		ActiveOutput: "eDP-1",
+		Layouts:      []string{"tile", "monocle"},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {
+				Name:         "eDP-1",
+				Active:       1,
+				Layout:       0,
+				LayoutSymbol: "[]=",
+				Title:        "Firefox",
+				AppID:        "firefox",
+				KbLayout:     "us",
+				Keymode:      "",
+				Tags:         []TagState{{Tag: 1, State: 1, Clients: 2, Focused: 1}},
+			},
+		},
+	}
+	assert.False(t, stateChanged(a, b))
+}
+
+func TestManager_ConcurrentGetState(t *testing.T) {
+	m := &Manager{
+		state: &State{
+			TagCount: 9,
+			Layouts:  []string{"tile"},
+			Outputs:  map[string]*OutputState{"eDP-1": {Name: "eDP-1"}},
+		},
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s := m.GetState()
+				_ = s.TagCount
+				_ = s.Outputs
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.stateMutex.Lock()
+				m.state = &State{
+					TagCount: uint32(j % 10),
+					Layouts:  []string{"tile", "monocle"},
+					Outputs:  map[string]*OutputState{"eDP-1": {Active: uint32(j % 2)}},
+				}
+				m.stateMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
+	m := &Manager{
+		stopChan: make(chan struct{}),
+		dirty:    make(chan struct{}, 1),
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			subID := string(rune('a' + id))
+			ch := m.Subscribe(subID)
+			assert.NotNil(t, ch)
+			time.Sleep(time.Millisecond)
+			m.Unsubscribe(subID)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_SyncmapOutputsConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 50
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := uint32(id)
+
+			for j := 0; j < iterations; j++ {
+				state := &outputState{
+					id:     key,
+					name:   "test-output",
+					active: uint32(j % 2),
+					tags:   []TagState{{Tag: uint32(j), State: 1}},
+				}
+				m.outputs.Store(key, state)
+
+				if loaded, ok := m.outputs.Load(key); ok {
+					assert.Equal(t, key, loaded.id)
+				}
+
+				m.outputs.Range(func(k uint32, v *outputState) bool {
+					_ = v.name
+					_ = v.active
+					return true
+				})
+			}
+
+			m.outputs.Delete(key)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_NotifySubscribersNonBlocking(t *testing.T) {
+	m := &Manager{
+		dirty: make(chan struct{}, 1),
+	}
+
+	for i := 0; i < 10; i++ {
+		m.notifySubscribers()
+	}
+
+	assert.Len(t, m.dirty, 1)
+}
+
+func TestManager_PostQueueFull(t *testing.T) {
+	m := &Manager{
+		cmdq:     make(chan cmd, 2),
+		stopChan: make(chan struct{}),
+	}
+
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+
+	assert.Len(t, m.cmdq, 2)
+}
+
+func TestManager_GetStateNilState(t *testing.T) {
+	m := &Manager{}
+
+	s := m.GetState()
+	assert.NotNil(t, s.Outputs)
+	assert.NotNil(t, s.Layouts)
+	assert.Equal(t, uint32(0), s.TagCount)
+}
+
+func TestTagState_Fields(t *testing.T) {
+	tag := TagState{
+		Tag:     1,
+		State:   2,
+		Clients: 3,
+		Focused: 1,
+	}
+
+	assert.Equal(t, uint32(1), tag.Tag)
+	assert.Equal(t, uint32(2), tag.State)
+	assert.Equal(t, uint32(3), tag.Clients)
+	assert.Equal(t, uint32(1), tag.Focused)
+}
+
+func TestOutputState_Fields(t *testing.T) {
+	out := OutputState{
+		Name:         "eDP-1",
+		Active:       1,
+		Tags:         []TagState{{Tag: 1}},
+		Layout:       0,
+		LayoutSymbol: "[]=",
+		Title:        "Firefox",
+		AppID:        "firefox",
+		KbLayout:     "us",
+		Keymode:      "",
+	}
+
+	assert.Equal(t, "eDP-1", out.Name)
+	assert.Equal(t, uint32(1), out.Active)
+	assert.Len(t, out.Tags, 1)
+	assert.Equal(t, "[]=", out.LayoutSymbol)
+}
+
+func TestStateChanged_NewOutputAppears(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Name: "eDP-1"},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1":    {Name: "eDP-1"},
+			"HDMI-A-1": {Name: "HDMI-A-1"},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_TagsLengthDiffers(t *testing.T) {
+	a := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1}}},
+		},
+	}
+	b := &State{
+		TagCount: 9,
+		Layouts:  []string{},
+		Outputs: map[string]*OutputState{
+			"eDP-1": {Tags: []TagState{{Tag: 1}, {Tag: 2}}},
+		},
+	}
+	assert.True(t, stateChanged(a, b))
+}

core/internal/server/evdev/handlers.go

@@ -6,22 +6,15 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     any            `json:"id"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params"`
-}
-
-func HandleRequest(conn net.Conn, req Request, m *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, m *Manager) {
 	switch req.Method {
 	case "evdev.getState":
 		handleGetState(conn, req, m)
 	default:
-		models.RespondError(conn, req.ID.(int), "unknown method: "+req.Method)
+		models.RespondError(conn, req.ID, "unknown method: "+req.Method)
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, m *Manager) {
-	state := m.GetState()
-	models.Respond(conn, req.ID.(int), state)
+func handleGetState(conn net.Conn, req models.Request, m *Manager) {
+	models.Respond(conn, req.ID, m.GetState())
 }

core/internal/server/evdev/handlers_test.go

@@ -53,7 +53,7 @@ func TestHandleRequest(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "evdev.getState",
 			Params: map[string]any{},
@@ -82,7 +82,7 @@ func TestHandleRequest(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     456,
 			Method: "evdev.unknownMethod",
 			Params: map[string]any{},
@@ -111,7 +111,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{
+	req := models.Request{
 		ID:     789,
 		Method: "evdev.getState",
 		Params: map[string]any{},

core/internal/server/evdev/manager.go

@@ -306,6 +306,15 @@ func (m *Manager) readAndUpdateCapsLockState(deviceIndex int) {
 		return
 	}
 
+	if len(ledStates) == 0 {
+		log.Debug("No LED state available (empty map)")
+
+		// This means the device either:
+		// - doesn't support LED reporting at all, or
+		// - the kernel returned an empty state
+		return
+	}
+
 	capsLockState := ledStates[ledCapslockKey]
 	m.updateCapsLockStateDirect(capsLockState)
 }

core/internal/server/extworkspace/handlers.go

@@ -8,18 +8,12 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
 type SuccessResult struct {
 	Success bool   `json:"success"`
 	Message string `json:"message"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "extworkspace manager not initialized")
 		return
@@ -43,12 +37,12 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
 	state := manager.GetState()
 	models.Respond(conn, req.ID, state)
 }
 
-func handleActivateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleActivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -68,7 +62,7 @@ func handleActivateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace activated"})
 }
 
-func handleDeactivateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleDeactivateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -88,7 +82,7 @@ func handleDeactivateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace deactivated"})
 }
 
-func handleRemoveWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleRemoveWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		groupID = ""
@@ -108,7 +102,7 @@ func handleRemoveWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace removed"})
 }
 
-func handleCreateWorkspace(conn net.Conn, req Request, manager *Manager) {
+func handleCreateWorkspace(conn net.Conn, req models.Request, manager *Manager) {
 	groupID, ok := req.Params["groupID"].(string)
 	if !ok {
 		models.RespondError(conn, req.ID, "missing or invalid 'groupID' parameter")
@@ -129,7 +123,7 @@ func handleCreateWorkspace(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "workspace create requested"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/freedesktop/handlers.go

@@ -5,21 +5,10 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-	Value   string `json:"value,omitempty"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "freedesktop.getState":
 		handleGetState(conn, req, manager)
@@ -44,15 +33,14 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleSetIconFile(conn net.Conn, req Request, manager *Manager) {
-	iconPath, ok := req.Params["path"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'path' parameter")
+func handleSetIconFile(conn net.Conn, req models.Request, manager *Manager) {
+	iconPath, err := params.String(req.Params, "path")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -61,13 +49,13 @@ func handleSetIconFile(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "icon file set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "icon file set"})
 }
 
-func handleSetRealName(conn net.Conn, req Request, manager *Manager) {
-	name, ok := req.Params["name"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'name' parameter")
+func handleSetRealName(conn net.Conn, req models.Request, manager *Manager) {
+	name, err := params.String(req.Params, "name")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -76,13 +64,13 @@ func handleSetRealName(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "real name set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "real name set"})
 }
 
-func handleSetEmail(conn net.Conn, req Request, manager *Manager) {
-	email, ok := req.Params["email"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'email' parameter")
+func handleSetEmail(conn net.Conn, req models.Request, manager *Manager) {
+	email, err := params.String(req.Params, "email")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -91,13 +79,13 @@ func handleSetEmail(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "email set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "email set"})
 }
 
-func handleSetLanguage(conn net.Conn, req Request, manager *Manager) {
-	language, ok := req.Params["language"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'language' parameter")
+func handleSetLanguage(conn net.Conn, req models.Request, manager *Manager) {
+	language, err := params.String(req.Params, "language")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -106,13 +94,13 @@ func handleSetLanguage(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "language set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "language set"})
 }
 
-func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
-	location, ok := req.Params["location"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'location' parameter")
+func handleSetLocation(conn net.Conn, req models.Request, manager *Manager) {
+	location, err := params.String(req.Params, "location")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -121,13 +109,13 @@ func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location set"})
 }
 
-func handleGetUserIconFile(conn net.Conn, req Request, manager *Manager) {
-	username, ok := req.Params["username"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'username' parameter")
+func handleGetUserIconFile(conn net.Conn, req models.Request, manager *Manager) {
+	username, err := params.String(req.Params, "username")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -137,10 +125,10 @@ func handleGetUserIconFile(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Value: iconFile})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Value: iconFile})
 }
 
-func handleGetColorScheme(conn net.Conn, req Request, manager *Manager) {
+func handleGetColorScheme(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.updateSettingsState(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -150,10 +138,10 @@ func handleGetColorScheme(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]uint32{"colorScheme": state.Settings.ColorScheme})
 }
 
-func handleSetIconTheme(conn net.Conn, req Request, manager *Manager) {
-	iconTheme, ok := req.Params["iconTheme"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'iconTheme' parameter")
+func handleSetIconTheme(conn net.Conn, req models.Request, manager *Manager) {
+	iconTheme, err := params.String(req.Params, "iconTheme")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -162,5 +150,5 @@ func handleSetIconTheme(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "icon theme set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "icon theme set"})
 }

core/internal/server/freedesktop/handlers_test.go

@@ -74,10 +74,10 @@ func TestRespondError_Freedesktop(t *testing.T) {
 
 func TestRespond_Freedesktop(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -106,7 +106,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "freedesktop.getState"}
+	req := models.Request{ID: 123, Method: "freedesktop.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -131,7 +131,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{},
@@ -164,7 +164,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{
@@ -174,7 +174,7 @@ func TestHandleSetIconFile(t *testing.T) {
 
 		handleSetIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -196,7 +196,7 @@ func TestHandleSetIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setIconFile",
 			Params: map[string]any{
@@ -206,7 +206,7 @@ func TestHandleSetIconFile(t *testing.T) {
 
 		handleSetIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -223,7 +223,7 @@ func TestHandleSetRealName(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setRealName",
 			Params: map[string]any{},
@@ -256,7 +256,7 @@ func TestHandleSetRealName(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setRealName",
 			Params: map[string]any{
@@ -266,7 +266,7 @@ func TestHandleSetRealName(t *testing.T) {
 
 		handleSetRealName(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -286,7 +286,7 @@ func TestHandleSetEmail(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setEmail",
 			Params: map[string]any{},
@@ -319,7 +319,7 @@ func TestHandleSetEmail(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setEmail",
 			Params: map[string]any{
@@ -329,7 +329,7 @@ func TestHandleSetEmail(t *testing.T) {
 
 		handleSetEmail(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -349,7 +349,7 @@ func TestHandleSetLanguage(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setLanguage",
 			Params: map[string]any{},
@@ -374,7 +374,7 @@ func TestHandleSetLocation(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.setLocation",
 			Params: map[string]any{},
@@ -399,7 +399,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.getUserIconFile",
 			Params: map[string]any{},
@@ -426,7 +426,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.accounts.getUserIconFile",
 			Params: map[string]any{
@@ -436,7 +436,7 @@ func TestHandleGetUserIconFile(t *testing.T) {
 
 		handleGetUserIconFile(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -457,7 +457,7 @@ func TestHandleGetColorScheme(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
+		req := models.Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
 
 		handleGetColorScheme(conn, req, manager)
 
@@ -488,7 +488,7 @@ func TestHandleGetColorScheme(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
+		req := models.Request{ID: 123, Method: "freedesktop.settings.getColorScheme"}
 
 		handleGetColorScheme(conn, req, manager)
 
@@ -516,7 +516,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.unknown",
 		}
@@ -533,7 +533,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "freedesktop.getState",
 		}
@@ -561,7 +561,7 @@ func TestHandleRequest(t *testing.T) {
 
 		for _, method := range tests {
 			conn := newMockNetConn()
-			req := Request{
+			req := models.Request{
 				ID:     123,
 				Method: method,
 				Params: map[string]any{},

core/internal/server/loginctl/handlers.go

@@ -6,20 +6,10 @@ import (
 	"net"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "loginctl.getState":
 		handleGetState(conn, req, manager)
@@ -46,39 +36,38 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleLock(conn net.Conn, req Request, manager *Manager) {
+func handleLock(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Lock(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "locked"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "locked"})
 }
 
-func handleUnlock(conn net.Conn, req Request, manager *Manager) {
+func handleUnlock(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Unlock(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "unlocked"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "unlocked"})
 }
 
-func handleActivate(conn net.Conn, req Request, manager *Manager) {
+func handleActivate(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Activate(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "activated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "activated"})
 }
 
-func handleSetIdleHint(conn net.Conn, req Request, manager *Manager) {
-	idle, ok := req.Params["idle"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'idle' parameter")
+func handleSetIdleHint(conn net.Conn, req models.Request, manager *Manager) {
+	idle, err := params.Bool(req.Params, "idle")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -86,32 +75,32 @@ func handleSetIdleHint(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "idle hint set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "idle hint set"})
 }
 
-func handleSetLockBeforeSuspend(conn net.Conn, req Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+func handleSetLockBeforeSuspend(conn net.Conn, req models.Request, manager *Manager) {
+	enabled, err := params.Bool(req.Params, "enabled")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetLockBeforeSuspend(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "lock before suspend set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "lock before suspend set"})
 }
 
-func handleSetSleepInhibitorEnabled(conn net.Conn, req Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+func handleSetSleepInhibitorEnabled(conn net.Conn, req models.Request, manager *Manager) {
+	enabled, err := params.Bool(req.Params, "enabled")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetSleepInhibitorEnabled(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "sleep inhibitor setting updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "sleep inhibitor setting updated"})
 }
 
-func handleLockerReady(conn net.Conn, req Request, manager *Manager) {
+func handleLockerReady(conn net.Conn, req models.Request, manager *Manager) {
 	manager.lockTimerMu.Lock()
 	if manager.lockTimer != nil {
 		manager.lockTimer.Stop()
@@ -125,18 +114,18 @@ func handleLockerReady(conn net.Conn, req Request, manager *Manager) {
 	if manager.inSleepCycle.Load() {
 		manager.signalLockerReady()
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "ok"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "ok"})
 }
 
-func handleTerminate(conn net.Conn, req Request, manager *Manager) {
+func handleTerminate(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.Terminate(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "terminated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "terminated"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/loginctl/handlers_test.go

@@ -58,10 +58,10 @@ func TestRespondError_Loginctl(t *testing.T) {
 
 func TestRespond_Loginctl(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -86,7 +86,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "loginctl.getState"}
+	req := models.Request{ID: 123, Method: "loginctl.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -115,10 +115,10 @@ func TestHandleLock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.lock"}
+		req := models.Request{ID: 123, Method: "loginctl.lock"}
 		handleLock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -141,10 +141,10 @@ func TestHandleLock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.lock"}
+		req := models.Request{ID: 123, Method: "loginctl.lock"}
 		handleLock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -166,10 +166,10 @@ func TestHandleUnlock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.unlock"}
+		req := models.Request{ID: 123, Method: "loginctl.unlock"}
 		handleUnlock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -192,10 +192,10 @@ func TestHandleUnlock(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.unlock"}
+		req := models.Request{ID: 123, Method: "loginctl.unlock"}
 		handleUnlock(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -217,10 +217,10 @@ func TestHandleActivate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.activate"}
+		req := models.Request{ID: 123, Method: "loginctl.activate"}
 		handleActivate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -243,10 +243,10 @@ func TestHandleActivate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.activate"}
+		req := models.Request{ID: 123, Method: "loginctl.activate"}
 		handleActivate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -263,7 +263,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{},
@@ -291,7 +291,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{
@@ -301,7 +301,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 
 		handleSetIdleHint(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -324,7 +324,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.setIdleHint",
 			Params: map[string]any{
@@ -334,7 +334,7 @@ func TestHandleSetIdleHint(t *testing.T) {
 
 		handleSetIdleHint(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -356,10 +356,10 @@ func TestHandleTerminate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.terminate"}
+		req := models.Request{ID: 123, Method: "loginctl.terminate"}
 		handleTerminate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -382,10 +382,10 @@ func TestHandleTerminate(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{ID: 123, Method: "loginctl.terminate"}
+		req := models.Request{ID: 123, Method: "loginctl.terminate"}
 		handleTerminate(conn, req, manager)
 
-		var resp models.Response[SuccessResult]
+		var resp models.Response[models.SuccessResult]
 		err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 		require.NoError(t, err)
 
@@ -405,7 +405,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.unknown",
 		}
@@ -422,7 +422,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.getState",
 		}
@@ -445,7 +445,7 @@ func TestHandleRequest(t *testing.T) {
 		manager.sessionObj = mockSessionObj
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "loginctl.lock",
 		}
@@ -470,7 +470,7 @@ func TestHandleSubscribe(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "loginctl.subscribe"}
+	req := models.Request{ID: 123, Method: "loginctl.subscribe"}
 
 	done := make(chan bool)
 	go func() {

core/internal/server/models/types.go

@@ -29,3 +29,9 @@ func Respond[T any](conn net.Conn, id int, result T) {
 	resp := Response[T]{ID: id, Result: &result}
 	json.NewEncoder(conn).Encode(resp)
 }
+
+type SuccessResult struct {
+	Success bool   `json:"success"`
+	Message string `json:"message,omitempty"`
+	Value   string `json:"value,omitempty"`
+}

core/internal/server/network/backend_networkmanager_vpn.go

@@ -880,29 +880,24 @@ func (b *NetworkManagerBackend) ImportVPN(filePath string, name string) (*VPNImp
 }
 
 func (b *NetworkManagerBackend) importVPNWithNmcli(filePath string, name string) (*VPNImportResult, error) {
-	args := []string{"connection", "import", "type", "openvpn", "file", filePath}
-	cmd := exec.Command("nmcli", args...)
-	output, err := cmd.CombinedOutput()
+	vpnTypes := []string{"openvpn", "wireguard", "vpnc", "pptp", "l2tp", "openconnect", "strongswan"}
+
+	var output []byte
+	var err error
+	for _, vpnType := range vpnTypes {
+		args := []string{"connection", "import", "type", vpnType, "file", filePath}
+		cmd := exec.Command("nmcli", args...)
+		output, err = cmd.CombinedOutput()
+		if err == nil {
+			break
+		}
+	}
 
 	if err != nil {
-		outputStr := string(output)
-		if strings.Contains(outputStr, "vpnc") || strings.Contains(outputStr, "unknown connection type") {
-			for _, vpnType := range []string{"vpnc", "pptp", "l2tp", "openconnect", "strongswan", "wireguard"} {
-				args = []string{"connection", "import", "type", vpnType, "file", filePath}
-				cmd = exec.Command("nmcli", args...)
-				output, err = cmd.CombinedOutput()
-				if err == nil {
-					break
-				}
-			}
-		}
-
-		if err != nil {
-			return &VPNImportResult{
-				Success: false,
-				Error:   fmt.Sprintf("import failed: %s", strings.TrimSpace(string(output))),
-			}, nil
-		}
+		return &VPNImportResult{
+			Success: false,
+			Error:   fmt.Sprintf("import failed: %s", strings.TrimSpace(string(output))),
+		}, nil
 	}
 
 	outputStr := string(output)

core/internal/server/network/handlers.go

@@ -7,20 +7,10 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "network.getState":
 		handleGetState(conn, req, manager)
@@ -89,32 +79,22 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleCredentialsSubmit(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
+func handleCredentialsSubmit(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
 		log.Warnf("handleCredentialsSubmit: missing or invalid token parameter")
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secretsRaw, ok := req.Params["secrets"].(map[string]any)
-	if !ok {
+	secrets, err := params.StringMap(req.Params, "secrets")
+	if err != nil {
 		log.Warnf("handleCredentialsSubmit: missing or invalid secrets parameter")
-		models.RespondError(conn, req.ID, "missing or invalid 'secrets' parameter")
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	secrets := make(map[string]string)
-	for k, v := range secretsRaw {
-		if str, ok := v.(string); ok {
-			secrets[k] = str
-		}
-	}
-
-	save := true
-	if saveParam, ok := req.Params["save"].(bool); ok {
-		save = saveParam
-	}
+	save := params.BoolOpt(req.Params, "save", true)
 
 	if err := manager.SubmitCredentials(token, secrets, save); err != nil {
 		log.Warnf("handleCredentialsSubmit: failed to submit credentials: %v", err)
@@ -123,13 +103,13 @@ func handleCredentialsSubmit(conn net.Conn, req Request, manager *Manager) {
 	}
 
 	log.Infof("handleCredentialsSubmit: credentials submitted successfully")
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "credentials submitted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "credentials submitted"})
 }
 
-func handleCredentialsCancel(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+func handleCredentialsCancel(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -138,16 +118,15 @@ func handleCredentialsCancel(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "credentials cancelled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "credentials cancelled"})
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleScanWiFi(conn net.Conn, req Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+func handleScanWiFi(conn net.Conn, req models.Request, manager *Manager) {
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.ScanWiFiDevice(device)
@@ -158,33 +137,25 @@ func handleScanWiFi(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "scanning"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "scanning"})
 }
 
-func handleGetWiFiNetworks(conn net.Conn, req Request, manager *Manager) {
-	networks := manager.GetWiFiNetworks()
-	models.Respond(conn, req.ID, networks)
+func handleGetWiFiNetworks(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetWiFiNetworks())
 }
 
-func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+func handleConnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
+	ssid, err := params.String(req.Params, "ssid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	var connReq ConnectionRequest
 	connReq.SSID = ssid
-
-	if password, ok := req.Params["password"].(string); ok {
-		connReq.Password = password
-	}
-	if username, ok := req.Params["username"].(string); ok {
-		connReq.Username = username
-	}
-	if device, ok := req.Params["device"].(string); ok {
-		connReq.Device = device
-	}
+	connReq.Password = params.StringOpt(req.Params, "password", "")
+	connReq.Username = params.StringOpt(req.Params, "username", "")
+	connReq.Device = params.StringOpt(req.Params, "device", "")
 
 	if interactive, ok := req.Params["interactive"].(bool); ok {
 		connReq.Interactive = interactive
@@ -206,27 +177,14 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		}
 	}
 
-	if anonymousIdentity, ok := req.Params["anonymousIdentity"].(string); ok {
-		connReq.AnonymousIdentity = anonymousIdentity
-	}
-	if domainSuffixMatch, ok := req.Params["domainSuffixMatch"].(string); ok {
-		connReq.DomainSuffixMatch = domainSuffixMatch
-	}
-	if eapMethod, ok := req.Params["eapMethod"].(string); ok {
-		connReq.EAPMethod = eapMethod
-	}
-	if phase2Auth, ok := req.Params["phase2Auth"].(string); ok {
-		connReq.Phase2Auth = phase2Auth
-	}
-	if caCertPath, ok := req.Params["caCertPath"].(string); ok {
-		connReq.CACertPath = caCertPath
-	}
-	if clientCertPath, ok := req.Params["clientCertPath"].(string); ok {
-		connReq.ClientCertPath = clientCertPath
-	}
-	if privateKeyPath, ok := req.Params["privateKeyPath"].(string); ok {
-		connReq.PrivateKeyPath = privateKeyPath
-	}
+	connReq.AnonymousIdentity = params.StringOpt(req.Params, "anonymousIdentity", "")
+	connReq.DomainSuffixMatch = params.StringOpt(req.Params, "domainSuffixMatch", "")
+	connReq.EAPMethod = params.StringOpt(req.Params, "eapMethod", "")
+	connReq.Phase2Auth = params.StringOpt(req.Params, "phase2Auth", "")
+	connReq.CACertPath = params.StringOpt(req.Params, "caCertPath", "")
+	connReq.ClientCertPath = params.StringOpt(req.Params, "clientCertPath", "")
+	connReq.PrivateKeyPath = params.StringOpt(req.Params, "privateKeyPath", "")
+
 	if useSystemCACerts, ok := req.Params["useSystemCACerts"].(bool); ok {
 		connReq.UseSystemCACerts = &useSystemCACerts
 	}
@@ -236,11 +194,11 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectWiFi(conn net.Conn, req Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+func handleDisconnectWiFi(conn net.Conn, req models.Request, manager *Manager) {
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.DisconnectWiFiDevice(device)
@@ -251,13 +209,13 @@ func handleDisconnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleForgetWiFi(conn net.Conn, req Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+func handleForgetWiFi(conn net.Conn, req models.Request, manager *Manager) {
+	ssid, err := params.String(req.Params, "ssid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -266,10 +224,10 @@ func handleForgetWiFi(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "forgotten"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "forgotten"})
 }
 
-func handleToggleWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleToggleWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.ToggleWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -279,7 +237,7 @@ func handleToggleWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": state.WiFiEnabled})
 }
 
-func handleEnableWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleEnableWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.EnableWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -287,7 +245,7 @@ func handleEnableWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": true})
 }
 
-func handleDisableWiFi(conn net.Conn, req Request, manager *Manager) {
+func handleDisableWiFi(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.DisableWiFi(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
@@ -295,29 +253,29 @@ func handleDisableWiFi(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]bool{"enabled": false})
 }
 
-func handleConnectEthernetSpecificConfig(conn net.Conn, req Request, manager *Manager) {
-	uuid, ok := req.Params["uuid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'uuid' parameter")
+func handleConnectEthernetSpecificConfig(conn net.Conn, req models.Request, manager *Manager) {
+	uuid, err := params.String(req.Params, "uuid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 	if err := manager.activateConnection(uuid); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleConnectEthernet(conn net.Conn, req Request, manager *Manager) {
+func handleConnectEthernet(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.ConnectEthernet(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }
 
-func handleDisconnectEthernet(conn net.Conn, req Request, manager *Manager) {
-	device, _ := req.Params["device"].(string)
+func handleDisconnectEthernet(conn net.Conn, req models.Request, manager *Manager) {
+	device := params.StringOpt(req.Params, "device", "")
 	var err error
 	if device != "" {
 		err = manager.DisconnectEthernetDevice(device)
@@ -328,13 +286,13 @@ func handleDisconnectEthernet(conn net.Conn, req Request, manager *Manager) {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }
 
-func handleSetPreference(conn net.Conn, req Request, manager *Manager) {
-	preference, ok := req.Params["preference"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'preference' parameter")
+func handleSetPreference(conn net.Conn, req models.Request, manager *Manager) {
+	preference, err := params.String(req.Params, "preference")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -346,10 +304,10 @@ func handleSetPreference(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, map[string]string{"preference": preference})
 }
 
-func handleGetNetworkInfo(conn net.Conn, req Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+func handleGetNetworkInfo(conn net.Conn, req models.Request, manager *Manager) {
+	ssid, err := params.String(req.Params, "ssid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -362,10 +320,10 @@ func handleGetNetworkInfo(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, network)
 }
 
-func handleGetWiredNetworkInfo(conn net.Conn, req Request, manager *Manager) {
-	uuid, ok := req.Params["uuid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'uuid' parameter")
+func handleGetWiredNetworkInfo(conn net.Conn, req models.Request, manager *Manager) {
+	uuid, err := params.String(req.Params, "uuid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -378,7 +336,7 @@ func handleGetWiredNetworkInfo(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, network)
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)
@@ -408,7 +366,7 @@ func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleListVPNProfiles(conn net.Conn, req Request, manager *Manager) {
+func handleListVPNProfiles(conn net.Conn, req models.Request, manager *Manager) {
 	profiles, err := manager.ListVPNProfiles()
 	if err != nil {
 		log.Warnf("handleListVPNProfiles: failed to list profiles: %v", err)
@@ -419,7 +377,7 @@ func handleListVPNProfiles(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, profiles)
 }
 
-func handleListActiveVPN(conn net.Conn, req Request, manager *Manager) {
+func handleListActiveVPN(conn net.Conn, req models.Request, manager *Manager) {
 	active, err := manager.ListActiveVPN()
 	if err != nil {
 		log.Warnf("handleListActiveVPN: failed to list active VPNs: %v", err)
@@ -430,27 +388,15 @@ func handleListActiveVPN(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, active)
 }
 
-func handleConnectVPN(conn net.Conn, req Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuidOrName"].(string)
+func handleConnectVPN(conn net.Conn, req models.Request, manager *Manager) {
+	uuidOrName, ok := params.StringAlt(req.Params, "uuidOrName", "name", "uuid")
 	if !ok {
-		name, nameOk := req.Params["name"].(string)
-		uuid, uuidOk := req.Params["uuid"].(string)
-		if nameOk {
-			uuidOrName = name
-		} else if uuidOk {
-			uuidOrName = uuid
-		} else {
-			log.Warnf("handleConnectVPN: missing uuidOrName/name/uuid parameter")
-			models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-			return
-		}
+		log.Warnf("handleConnectVPN: missing uuidOrName/name/uuid parameter")
+		models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
+		return
 	}
 
-	// Default to true - only allow one VPN connection at a time
-	singleActive := true
-	if sa, ok := req.Params["singleActive"].(bool); ok {
-		singleActive = sa
-	}
+	singleActive := params.BoolOpt(req.Params, "singleActive", true)
 
 	if err := manager.ConnectVPN(uuidOrName, singleActive); err != nil {
 		log.Warnf("handleConnectVPN: failed to connect: %v", err)
@@ -458,23 +404,15 @@ func handleConnectVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN connection initiated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN connection initiated"})
 }
 
-func handleDisconnectVPN(conn net.Conn, req Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuidOrName"].(string)
+func handleDisconnectVPN(conn net.Conn, req models.Request, manager *Manager) {
+	uuidOrName, ok := params.StringAlt(req.Params, "uuidOrName", "name", "uuid")
 	if !ok {
-		name, nameOk := req.Params["name"].(string)
-		uuid, uuidOk := req.Params["uuid"].(string)
-		if nameOk {
-			uuidOrName = name
-		} else if uuidOk {
-			uuidOrName = uuid
-		} else {
-			log.Warnf("handleDisconnectVPN: missing uuidOrName/name/uuid parameter")
-			models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
-			return
-		}
+		log.Warnf("handleDisconnectVPN: missing uuidOrName/name/uuid parameter")
+		models.RespondError(conn, req.ID, "missing 'uuidOrName', 'name', or 'uuid' parameter")
+		return
 	}
 
 	if err := manager.DisconnectVPN(uuidOrName); err != nil {
@@ -483,27 +421,21 @@ func handleDisconnectVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN disconnected"})
 }
 
-func handleDisconnectAllVPN(conn net.Conn, req Request, manager *Manager) {
+func handleDisconnectAllVPN(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.DisconnectAllVPN(); err != nil {
 		log.Warnf("handleDisconnectAllVPN: failed: %v", err)
 		models.RespondError(conn, req.ID, fmt.Sprintf("failed to disconnect all VPNs: %v", err))
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "All VPNs disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "All VPNs disconnected"})
 }
 
-func handleClearVPNCredentials(conn net.Conn, req Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
+func handleClearVPNCredentials(conn net.Conn, req models.Request, manager *Manager) {
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
 	if !ok {
 		log.Warnf("handleClearVPNCredentials: missing uuidOrName/name/uuid parameter")
 		models.RespondError(conn, req.ID, "missing uuidOrName/name/uuid parameter")
@@ -516,19 +448,19 @@ func handleClearVPNCredentials(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN credentials cleared"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN credentials cleared"})
 }
 
-func handleSetWiFiAutoconnect(conn net.Conn, req Request, manager *Manager) {
-	ssid, ok := req.Params["ssid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'ssid' parameter")
+func handleSetWiFiAutoconnect(conn net.Conn, req models.Request, manager *Manager) {
+	ssid, err := params.String(req.Params, "ssid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	autoconnect, ok := req.Params["autoconnect"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'autoconnect' parameter")
+	autoconnect, err := params.Bool(req.Params, "autoconnect")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -537,10 +469,10 @@ func handleSetWiFiAutoconnect(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "autoconnect updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "autoconnect updated"})
 }
 
-func handleListVPNPlugins(conn net.Conn, req Request, manager *Manager) {
+func handleListVPNPlugins(conn net.Conn, req models.Request, manager *Manager) {
 	plugins, err := manager.ListVPNPlugins()
 	if err != nil {
 		log.Warnf("handleListVPNPlugins: failed to list plugins: %v", err)
@@ -551,17 +483,14 @@ func handleListVPNPlugins(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, plugins)
 }
 
-func handleImportVPN(conn net.Conn, req Request, manager *Manager) {
-	filePath, ok := req.Params["file"].(string)
-	if !ok {
-		filePath, ok = req.Params["path"].(string)
-	}
+func handleImportVPN(conn net.Conn, req models.Request, manager *Manager) {
+	filePath, ok := params.StringAlt(req.Params, "file", "path")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'file' or 'path' parameter")
 		return
 	}
 
-	name, _ := req.Params["name"].(string)
+	name := params.StringOpt(req.Params, "name", "")
 
 	result, err := manager.ImportVPN(filePath, name)
 	if err != nil {
@@ -573,14 +502,8 @@ func handleImportVPN(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, result)
 }
 
-func handleGetVPNConfig(conn net.Conn, req Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
+func handleGetVPNConfig(conn net.Conn, req models.Request, manager *Manager) {
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'uuid', 'name', or 'uuidOrName' parameter")
 		return
@@ -596,10 +519,10 @@ func handleGetVPNConfig(conn net.Conn, req Request, manager *Manager) {
 	models.Respond(conn, req.ID, config)
 }
 
-func handleUpdateVPNConfig(conn net.Conn, req Request, manager *Manager) {
-	connUUID, ok := req.Params["uuid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing 'uuid' parameter")
+func handleUpdateVPNConfig(conn net.Conn, req models.Request, manager *Manager) {
+	connUUID, err := params.String(req.Params, "uuid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -626,17 +549,11 @@ func handleUpdateVPNConfig(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN config updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN config updated"})
 }
 
-func handleDeleteVPN(conn net.Conn, req Request, manager *Manager) {
-	uuidOrName, ok := req.Params["uuid"].(string)
-	if !ok {
-		uuidOrName, ok = req.Params["name"].(string)
-	}
-	if !ok {
-		uuidOrName, ok = req.Params["uuidOrName"].(string)
-	}
+func handleDeleteVPN(conn net.Conn, req models.Request, manager *Manager) {
+	uuidOrName, ok := params.StringAlt(req.Params, "uuid", "name", "uuidOrName")
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'uuid', 'name', or 'uuidOrName' parameter")
 		return
@@ -648,23 +565,19 @@ func handleDeleteVPN(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN deleted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN deleted"})
 }
 
-func handleSetVPNCredentials(conn net.Conn, req Request, manager *Manager) {
-	connUUID, ok := req.Params["uuid"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing 'uuid' parameter")
+func handleSetVPNCredentials(conn net.Conn, req models.Request, manager *Manager) {
+	connUUID, err := params.String(req.Params, "uuid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	username, _ := req.Params["username"].(string)
-	password, _ := req.Params["password"].(string)
-
-	save := true
-	if saveParam, ok := req.Params["save"].(bool); ok {
-		save = saveParam
-	}
+	username := params.StringOpt(req.Params, "username", "")
+	password := params.StringOpt(req.Params, "password", "")
+	save := params.BoolOpt(req.Params, "save", true)
 
 	if err := manager.SetVPNCredentials(connUUID, username, password, save); err != nil {
 		log.Warnf("handleSetVPNCredentials: failed to set credentials: %v", err)
@@ -672,5 +585,5 @@ func handleSetVPNCredentials(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "VPN credentials set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "VPN credentials set"})
 }

core/internal/server/network/handlers_test.go

@@ -53,10 +53,10 @@ func TestRespondError_Network(t *testing.T) {
 
 func TestRespond_Network(t *testing.T) {
 	conn := newMockNetConn()
-	result := SuccessResult{Success: true, Message: "test"}
+	result := models.SuccessResult{Success: true, Message: "test"}
 	models.Respond(conn, 123, result)
 
-	var resp models.Response[SuccessResult]
+	var resp models.Response[models.SuccessResult]
 	err := json.NewDecoder(conn.writeBuf).Decode(&resp)
 	require.NoError(t, err)
 
@@ -77,7 +77,7 @@ func TestHandleGetState(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "network.getState"}
+	req := models.Request{ID: 123, Method: "network.getState"}
 
 	handleGetState(conn, req, manager)
 
@@ -103,7 +103,7 @@ func TestHandleGetWiFiNetworks(t *testing.T) {
 	}
 
 	conn := newMockNetConn()
-	req := Request{ID: 123, Method: "network.wifi.networks"}
+	req := models.Request{ID: 123, Method: "network.wifi.networks"}
 
 	handleGetWiFiNetworks(conn, req, manager)
 
@@ -125,7 +125,7 @@ func TestHandleConnectWiFi(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.wifi.connect",
 			Params: map[string]any{},
@@ -149,7 +149,7 @@ func TestHandleSetPreference(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.preference.set",
 			Params: map[string]any{},
@@ -173,7 +173,7 @@ func TestHandleGetNetworkInfo(t *testing.T) {
 		}
 
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.info",
 			Params: map[string]any{},
@@ -199,7 +199,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("unknown method", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.unknown",
 		}
@@ -216,7 +216,7 @@ func TestHandleRequest(t *testing.T) {
 
 	t.Run("valid method - getState", func(t *testing.T) {
 		conn := newMockNetConn()
-		req := Request{
+		req := models.Request{
 			ID:     123,
 			Method: "network.getState",
 		}

core/internal/server/params/params.go

@@ -0,0 +1,113 @@
+package params
+
+import "fmt"
+
+func Get[T any](params map[string]any, key string) (T, error) {
+	val, ok := params[key].(T)
+	if !ok {
+		var zero T
+		return zero, fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func GetOpt[T any](params map[string]any, key string, def T) T {
+	if val, ok := params[key].(T); ok {
+		return val
+	}
+	return def
+}
+
+func String(params map[string]any, key string) (string, error) {
+	return Get[string](params, key)
+}
+
+func StringNonEmpty(params map[string]any, key string) (string, error) {
+	val, err := Get[string](params, key)
+	if err != nil || val == "" {
+		return "", fmt.Errorf("missing or invalid '%s' parameter", key)
+	}
+	return val, nil
+}
+
+func StringOpt(params map[string]any, key string, def string) string {
+	return GetOpt(params, key, def)
+}
+
+func Int(params map[string]any, key string) (int, error) {
+	val, err := Get[float64](params, key)
+	if err != nil {
+		return 0, err
+	}
+	return int(val), nil
+}
+
+func IntOpt(params map[string]any, key string, def int) int {
+	if val, ok := params[key].(float64); ok {
+		return int(val)
+	}
+	return def
+}
+
+func Float(params map[string]any, key string) (float64, error) {
+	return Get[float64](params, key)
+}
+
+func FloatOpt(params map[string]any, key string, def float64) float64 {
+	return GetOpt(params, key, def)
+}
+
+func Bool(params map[string]any, key string) (bool, error) {
+	return Get[bool](params, key)
+}
+
+func BoolOpt(params map[string]any, key string, def bool) bool {
+	return GetOpt(params, key, def)
+}
+
+func StringMap(params map[string]any, key string) (map[string]string, error) {
+	rawMap, err := Get[map[string]any](params, key)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result, nil
+}
+
+func StringMapOpt(params map[string]any, key string) map[string]string {
+	rawMap, ok := params[key].(map[string]any)
+	if !ok {
+		return nil
+	}
+	result := make(map[string]string)
+	for k, v := range rawMap {
+		if str, ok := v.(string); ok {
+			result[k] = str
+		}
+	}
+	return result
+}
+
+func Any(params map[string]any, key string) (any, bool) {
+	val, ok := params[key]
+	return val, ok
+}
+
+func AnyMap(params map[string]any, key string) (map[string]any, bool) {
+	val, ok := params[key].(map[string]any)
+	return val, ok
+}
+
+func StringAlt(params map[string]any, keys ...string) (string, bool) {
+	for _, key := range keys {
+		if val, ok := params[key].(string); ok {
+			return val, true
+		}
+	}
+	return "", false
+}

core/internal/server/params/params_test.go

@@ -0,0 +1,154 @@
+package params
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGet(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	val, err := Get[string](p, "key")
+	assert.NoError(t, err)
+	assert.Equal(t, "value", val)
+
+	_, err = Get[string](p, "missing")
+	assert.Error(t, err)
+
+	_, err = Get[int](p, "key")
+	assert.Error(t, err)
+}
+
+func TestGetOpt(t *testing.T) {
+	p := map[string]any{"key": "value"}
+	assert.Equal(t, "value", GetOpt(p, "key", "default"))
+	assert.Equal(t, "default", GetOpt(p, "missing", "default"))
+}
+
+func TestString(t *testing.T) {
+	p := map[string]any{"s": "hello", "n": 123}
+	val, err := String(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = String(p, "n")
+	assert.Error(t, err)
+}
+
+func TestStringNonEmpty(t *testing.T) {
+	p := map[string]any{"s": "hello", "empty": ""}
+	val, err := StringNonEmpty(p, "s")
+	assert.NoError(t, err)
+	assert.Equal(t, "hello", val)
+
+	_, err = StringNonEmpty(p, "empty")
+	assert.Error(t, err)
+
+	_, err = StringNonEmpty(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringOpt(t *testing.T) {
+	p := map[string]any{"s": "hello"}
+	assert.Equal(t, "hello", StringOpt(p, "s", "default"))
+	assert.Equal(t, "default", StringOpt(p, "missing", "default"))
+}
+
+func TestInt(t *testing.T) {
+	p := map[string]any{"n": float64(42), "s": "str"}
+	val, err := Int(p, "n")
+	assert.NoError(t, err)
+	assert.Equal(t, 42, val)
+
+	_, err = Int(p, "s")
+	assert.Error(t, err)
+}
+
+func TestIntOpt(t *testing.T) {
+	p := map[string]any{"n": float64(42)}
+	assert.Equal(t, 42, IntOpt(p, "n", 0))
+	assert.Equal(t, 99, IntOpt(p, "missing", 99))
+}
+
+func TestFloat(t *testing.T) {
+	p := map[string]any{"f": 3.14, "s": "str"}
+	val, err := Float(p, "f")
+	assert.NoError(t, err)
+	assert.Equal(t, 3.14, val)
+
+	_, err = Float(p, "s")
+	assert.Error(t, err)
+}
+
+func TestFloatOpt(t *testing.T) {
+	p := map[string]any{"f": 3.14}
+	assert.Equal(t, 3.14, FloatOpt(p, "f", 0))
+	assert.Equal(t, 1.0, FloatOpt(p, "missing", 1.0))
+}
+
+func TestBool(t *testing.T) {
+	p := map[string]any{"b": true, "s": "str"}
+	val, err := Bool(p, "b")
+	assert.NoError(t, err)
+	assert.True(t, val)
+
+	_, err = Bool(p, "s")
+	assert.Error(t, err)
+}
+
+func TestBoolOpt(t *testing.T) {
+	p := map[string]any{"b": true}
+	assert.True(t, BoolOpt(p, "b", false))
+	assert.True(t, BoolOpt(p, "missing", true))
+}
+
+func TestStringMap(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1", "b": "2", "c": 3},
+	}
+	val, err := StringMap(p, "m")
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]string{"a": "1", "b": "2"}, val)
+
+	_, err = StringMap(p, "missing")
+	assert.Error(t, err)
+}
+
+func TestStringMapOpt(t *testing.T) {
+	p := map[string]any{
+		"m": map[string]any{"a": "1"},
+	}
+	assert.Equal(t, map[string]string{"a": "1"}, StringMapOpt(p, "m"))
+	assert.Nil(t, StringMapOpt(p, "missing"))
+}
+
+func TestAny(t *testing.T) {
+	p := map[string]any{"k": 123}
+	val, ok := Any(p, "k")
+	assert.True(t, ok)
+	assert.Equal(t, 123, val)
+
+	_, ok = Any(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestAnyMap(t *testing.T) {
+	inner := map[string]any{"nested": true}
+	p := map[string]any{"m": inner}
+	val, ok := AnyMap(p, "m")
+	assert.True(t, ok)
+	assert.Equal(t, inner, val)
+
+	_, ok = AnyMap(p, "missing")
+	assert.False(t, ok)
+}
+
+func TestStringAlt(t *testing.T) {
+	p := map[string]any{"b": "found"}
+	val, ok := StringAlt(p, "a", "b", "c")
+	assert.True(t, ok)
+	assert.Equal(t, "found", val)
+
+	_, ok = StringAlt(p, "x", "y")
+	assert.False(t, ok)
+}

core/internal/server/plugins/uninstall.go

@@ -15,50 +15,47 @@ func HandleUninstall(conn net.Conn, req models.Request) {
 		return
 	}
 
-	registry, err := plugins.NewRegistry()
-	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create registry: %v", err))
-		return
-	}
-
-	pluginList, err := registry.List()
-	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to list plugins: %v", err))
-		return
-	}
-
-	var plugin *plugins.Plugin
-	for _, p := range pluginList {
-		if p.Name == name {
-			plugin = &p
-			break
-		}
-	}
-
-	if plugin == nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not found: %s", name))
-		return
-	}
-
 	manager, err := plugins.NewManager()
 	if err != nil {
 		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create manager: %v", err))
 		return
 	}
 
-	installed, err := manager.IsInstalled(*plugin)
+	// First try to find in registry (by name or ID)
+	registry, err := plugins.NewRegistry()
 	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to check if plugin is installed: %v", err))
+		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create registry: %v", err))
 		return
 	}
 
-	if !installed {
-		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not installed: %s", name))
+	pluginList, _ := registry.List()
+	plugin := plugins.FindByIDOrName(name, pluginList)
+
+	// If found in registry, use that
+	if plugin != nil {
+		installed, err := manager.IsInstalled(*plugin)
+		if err != nil {
+			models.RespondError(conn, req.ID, fmt.Sprintf("failed to check if plugin is installed: %v", err))
+			return
+		}
+		if !installed {
+			models.RespondError(conn, req.ID, fmt.Sprintf("plugin not installed: %s", name))
+			return
+		}
+		if err := manager.Uninstall(*plugin); err != nil {
+			models.RespondError(conn, req.ID, fmt.Sprintf("failed to uninstall plugin: %v", err))
+			return
+		}
+		models.Respond(conn, req.ID, SuccessResult{
+			Success: true,
+			Message: fmt.Sprintf("plugin uninstalled: %s", plugin.Name),
+		})
 		return
 	}
 
-	if err := manager.Uninstall(*plugin); err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to uninstall plugin: %v", err))
+	// Not in registry - try to find and uninstall from installed plugins directly
+	if err := manager.UninstallByIDOrName(name); err != nil {
+		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not found: %s", name))
 		return
 	}
 

core/internal/server/plugins/update.go

@@ -15,50 +15,45 @@ func HandleUpdate(conn net.Conn, req models.Request) {
 		return
 	}
 
-	registry, err := plugins.NewRegistry()
-	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create registry: %v", err))
-		return
-	}
-
-	pluginList, err := registry.List()
-	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to list plugins: %v", err))
-		return
-	}
-
-	var plugin *plugins.Plugin
-	for _, p := range pluginList {
-		if p.Name == name {
-			plugin = &p
-			break
-		}
-	}
-
-	if plugin == nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not found: %s", name))
-		return
-	}
-
 	manager, err := plugins.NewManager()
 	if err != nil {
 		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create manager: %v", err))
 		return
 	}
 
-	installed, err := manager.IsInstalled(*plugin)
+	registry, err := plugins.NewRegistry()
 	if err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to check if plugin is installed: %v", err))
+		models.RespondError(conn, req.ID, fmt.Sprintf("failed to create registry: %v", err))
 		return
 	}
 
-	if !installed {
-		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not installed: %s", name))
+	pluginList, _ := registry.List()
+	plugin := plugins.FindByIDOrName(name, pluginList)
+
+	if plugin != nil {
+		installed, err := manager.IsInstalled(*plugin)
+		if err != nil {
+			models.RespondError(conn, req.ID, fmt.Sprintf("failed to check if plugin is installed: %v", err))
+			return
+		}
+		if !installed {
+			models.RespondError(conn, req.ID, fmt.Sprintf("plugin not installed: %s", name))
+			return
+		}
+		if err := manager.Update(*plugin); err != nil {
+			models.RespondError(conn, req.ID, fmt.Sprintf("failed to update plugin: %v", err))
+			return
+		}
+		models.Respond(conn, req.ID, SuccessResult{
+			Success: true,
+			Message: fmt.Sprintf("plugin updated: %s", plugin.Name),
+		})
 		return
 	}
 
-	if err := manager.Update(*plugin); err != nil {
-		models.RespondError(conn, req.ID, fmt.Sprintf("failed to update plugin: %v", err))
+	// Not in registry - try to update from installed plugins directly
+	if err := manager.UpdateByIDOrName(name); err != nil {
+		models.RespondError(conn, req.ID, fmt.Sprintf("plugin not found: %s", name))
 		return
 	}
 

core/internal/server/router.go

@@ -27,12 +27,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "network manager not initialized")
 			return
 		}
-		netReq := network.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		network.HandleRequest(conn, netReq, networkManager)
+		network.HandleRequest(conn, req, networkManager)
 		return
 	}
 
@@ -46,12 +41,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "loginctl manager not initialized")
 			return
 		}
-		loginReq := loginctl.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		loginctl.HandleRequest(conn, loginReq, loginctlManager)
+		loginctl.HandleRequest(conn, req, loginctlManager)
 		return
 	}
 
@@ -60,12 +50,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "freedesktop manager not initialized")
 			return
 		}
-		freedeskReq := freedesktop.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		freedesktop.HandleRequest(conn, freedeskReq, freedesktopManager)
+		freedesktop.HandleRequest(conn, req, freedesktopManager)
 		return
 	}
 
@@ -74,12 +59,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "wayland manager not initialized")
 			return
 		}
-		waylandReq := wayland.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		wayland.HandleRequest(conn, waylandReq, waylandManager)
+		wayland.HandleRequest(conn, req, waylandManager)
 		return
 	}
 
@@ -88,12 +68,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "bluetooth manager not initialized")
 			return
 		}
-		bluezReq := bluez.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		bluez.HandleRequest(conn, bluezReq, bluezManager)
+		bluez.HandleRequest(conn, req, bluezManager)
 		return
 	}
 
@@ -102,12 +77,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "apppicker manager not initialized")
 			return
 		}
-		appPickerReq := apppicker.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		apppicker.HandleRequest(conn, appPickerReq, appPickerManager)
+		apppicker.HandleRequest(conn, req, appPickerManager)
 		return
 	}
 
@@ -116,12 +86,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "CUPS manager not initialized")
 			return
 		}
-		cupsReq := cups.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		cups.HandleRequest(conn, cupsReq, cupsManager)
+		cups.HandleRequest(conn, req, cupsManager)
 		return
 	}
 
@@ -130,12 +95,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "dwl manager not initialized")
 			return
 		}
-		dwlReq := dwl.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		dwl.HandleRequest(conn, dwlReq, dwlManager)
+		dwl.HandleRequest(conn, req, dwlManager)
 		return
 	}
 
@@ -144,12 +104,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "brightness manager not initialized")
 			return
 		}
-		brightnessReq := brightness.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		brightness.HandleRequest(conn, brightnessReq, brightnessManager)
+		brightness.HandleRequest(conn, req, brightnessManager)
 		return
 	}
 
@@ -170,12 +125,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 				return
 			}
 		}
-		extWorkspaceReq := extworkspace.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		extworkspace.HandleRequest(conn, extWorkspaceReq, extWorkspaceManager)
+		extworkspace.HandleRequest(conn, req, extWorkspaceManager)
 		return
 	}
 
@@ -184,12 +134,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "wlroutput manager not initialized")
 			return
 		}
-		wlrOutputReq := wlroutput.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		wlroutput.HandleRequest(conn, wlrOutputReq, wlrOutputManager)
+		wlroutput.HandleRequest(conn, req, wlrOutputManager)
 		return
 	}
 
@@ -198,12 +143,7 @@ func RouteRequest(conn net.Conn, req models.Request) {
 			models.RespondError(conn, req.ID, "evdev manager not initialized")
 			return
 		}
-		evdevReq := evdev.Request{
-			ID:     req.ID,
-			Method: req.Method,
-			Params: req.Params,
-		}
-		evdev.HandleRequest(conn, evdevReq, evdevManager)
+		evdev.HandleRequest(conn, req, evdevManager)
 		return
 	}
 

core/internal/server/wayland/gamma.go

@@ -2,8 +2,6 @@ package wayland
 
 import (
 	"math"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type GammaRamp struct {
@@ -12,6 +10,126 @@ type GammaRamp struct {
 	Blue  []uint16
 }
 
+type rgb struct {
+	r, g, b float64
+}
+
+type xyz struct {
+	x, y, z float64
+}
+
+func illuminantD(temp int) (float64, float64, bool) {
+	var x float64
+	switch {
+	case temp >= 2500 && temp <= 7000:
+		t := float64(temp)
+		x = 0.244063 + 0.09911e3/t + 2.9678e6/(t*t) - 4.6070e9/(t*t*t)
+	case temp > 7000 && temp <= 25000:
+		t := float64(temp)
+		x = 0.237040 + 0.24748e3/t + 1.9018e6/(t*t) - 2.0064e9/(t*t*t)
+	default:
+		return 0, 0, false
+	}
+	y := -3*(x*x) + 2.870*x - 0.275
+	return x, y, true
+}
+
+func planckianLocus(temp int) (float64, float64, bool) {
+	var x, y float64
+	switch {
+	case temp >= 1667 && temp <= 4000:
+		t := float64(temp)
+		x = -0.2661239e9/(t*t*t) - 0.2343589e6/(t*t) + 0.8776956e3/t + 0.179910
+		if temp <= 2222 {
+			y = -1.1064814*(x*x*x) - 1.34811020*(x*x) + 2.18555832*x - 0.20219683
+		} else {
+			y = -0.9549476*(x*x*x) - 1.37418593*(x*x) + 2.09137015*x - 0.16748867
+		}
+	case temp > 4000 && temp < 25000:
+		t := float64(temp)
+		x = -3.0258469e9/(t*t*t) + 2.1070379e6/(t*t) + 0.2226347e3/t + 0.240390
+		y = 3.0817580*(x*x*x) - 5.87338670*(x*x) + 3.75112997*x - 0.37001483
+	default:
+		return 0, 0, false
+	}
+	return x, y, true
+}
+
+func srgbGamma(value, gamma float64) float64 {
+	if value <= 0.0031308 {
+		return 12.92 * value
+	}
+	return math.Pow(1.055*value, 1.0/gamma) - 0.055
+}
+
+func clamp01(v float64) float64 {
+	switch {
+	case v > 1.0:
+		return 1.0
+	case v < 0.0:
+		return 0.0
+	default:
+		return v
+	}
+}
+
+func xyzToSRGB(c xyz) rgb {
+	return rgb{
+		r: srgbGamma(clamp01(3.2404542*c.x-1.5371385*c.y-0.4985314*c.z), 2.2),
+		g: srgbGamma(clamp01(-0.9692660*c.x+1.8760108*c.y+0.0415560*c.z), 2.2),
+		b: srgbGamma(clamp01(0.0556434*c.x-0.2040259*c.y+1.0572252*c.z), 2.2),
+	}
+}
+
+func normalizeRGB(c *rgb) {
+	maxw := math.Max(c.r, math.Max(c.g, c.b))
+	if maxw > 0 {
+		c.r /= maxw
+		c.g /= maxw
+		c.b /= maxw
+	}
+}
+
+func calcWhitepoint(temp int) rgb {
+	if temp == 6500 {
+		return rgb{r: 1.0, g: 1.0, b: 1.0}
+	}
+
+	var wp xyz
+
+	switch {
+	case temp >= 25000:
+		x, y, _ := illuminantD(25000)
+		wp.x = x
+		wp.y = y
+	case temp >= 4000:
+		x, y, _ := illuminantD(temp)
+		wp.x = x
+		wp.y = y
+	case temp >= 2500:
+		x1, y1, _ := illuminantD(temp)
+		x2, y2, _ := planckianLocus(temp)
+		factor := float64(4000-temp) / 1500.0
+		sineFactor := (math.Cos(math.Pi*factor) + 1.0) / 2.0
+		wp.x = x1*sineFactor + x2*(1.0-sineFactor)
+		wp.y = y1*sineFactor + y2*(1.0-sineFactor)
+	default:
+		t := temp
+		if t < 1667 {
+			t = 1667
+		}
+		x, y, _ := planckianLocus(t)
+		wp.x = x
+		wp.y = y
+	}
+
+	wp.z = 1.0 - wp.x - wp.y
+
+	wpRGB := xyzToSRGB(wp)
+	normalizeRGB(&wpRGB)
+	return wpRGB
+}
+
 func GenerateGammaRamp(size uint32, temp int, gamma float64) GammaRamp {
 	ramp := GammaRamp{
 		Red:   make([]uint16, size),
@@ -19,16 +137,13 @@ func GenerateGammaRamp(size uint32, temp int, gamma float64) GammaRamp {
 		Blue:  make([]uint16, size),
 	}
 
+	wp := calcWhitepoint(temp)
+
 	for i := uint32(0); i < size; i++ {
 		val := float64(i) / float64(size-1)
-
-		valGamma := math.Pow(val, 1.0/gamma)
-
-		r, g, b := temperatureToRGB(temp)
-
-		ramp.Red[i] = uint16(utils.Clamp(valGamma*r*65535.0, 0, 65535))
-		ramp.Green[i] = uint16(utils.Clamp(valGamma*g*65535.0, 0, 65535))
-		ramp.Blue[i] = uint16(utils.Clamp(valGamma*b*65535.0, 0, 65535))
+		ramp.Red[i] = uint16(clamp01(math.Pow(val*wp.r, 1.0/gamma)) * 65535.0)
+		ramp.Green[i] = uint16(clamp01(math.Pow(val*wp.g, 1.0/gamma)) * 65535.0)
+		ramp.Blue[i] = uint16(clamp01(math.Pow(val*wp.b, 1.0/gamma)) * 65535.0)
 	}
 
 	return ramp
@@ -50,39 +165,3 @@ func GenerateIdentityRamp(size uint32) GammaRamp {
 
 	return ramp
 }
-
-func temperatureToRGB(temp int) (float64, float64, float64) {
-	tempK := float64(temp) / 100.0
-
-	var r, g, b float64
-
-	if tempK <= 66 {
-		r = 1.0
-	} else {
-		r = tempK - 60
-		r = 329.698727446 * math.Pow(r, -0.1332047592)
-		r = utils.Clamp(r, 0, 255) / 255.0
-	}
-
-	if tempK <= 66 {
-		g = tempK
-		g = 99.4708025861*math.Log(g) - 161.1195681661
-		g = utils.Clamp(g, 0, 255) / 255.0
-	} else {
-		g = tempK - 60
-		g = 288.1221695283 * math.Pow(g, -0.0755148492)
-		g = utils.Clamp(g, 0, 255) / 255.0
-	}
-
-	if tempK >= 66 {
-		b = 1.0
-	} else if tempK <= 19 {
-		b = 0.0
-	} else {
-		b = tempK - 10
-		b = 138.5177312231*math.Log(b) - 305.0447927307
-		b = utils.Clamp(b, 0, 255) / 255.0
-	}
-
-	return r, g, b
-}

core/internal/server/wayland/gamma_test.go

@@ -54,7 +54,7 @@ func TestGenerateGammaRamp(t *testing.T) {
 	}
 }
 
-func TestTemperatureToRGB(t *testing.T) {
+func TestCalcWhitepoint(t *testing.T) {
 	tests := []struct {
 		name string
 		temp int
@@ -67,32 +67,32 @@ func TestTemperatureToRGB(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			r, g, b := temperatureToRGB(tt.temp)
+			wp := calcWhitepoint(tt.temp)
 
-			if r < 0 || r > 1 {
-				t.Errorf("red out of range: %f", r)
+			if wp.r < 0 || wp.r > 1 {
+				t.Errorf("red out of range: %f", wp.r)
 			}
-			if g < 0 || g > 1 {
-				t.Errorf("green out of range: %f", g)
+			if wp.g < 0 || wp.g > 1 {
+				t.Errorf("green out of range: %f", wp.g)
 			}
-			if b < 0 || b > 1 {
-				t.Errorf("blue out of range: %f", b)
+			if wp.b < 0 || wp.b > 1 {
+				t.Errorf("blue out of range: %f", wp.b)
 			}
 		})
 	}
 }
 
-func TestTemperatureProgression(t *testing.T) {
+func TestWhitepointProgression(t *testing.T) {
 	temps := []int{3000, 4000, 5000, 6000, 6500}
 
 	var prevBlue float64
 	for i, temp := range temps {
-		_, _, b := temperatureToRGB(temp)
-		if i > 0 && b < prevBlue {
+		wp := calcWhitepoint(temp)
+		if i > 0 && wp.b < prevBlue {
 			t.Errorf("blue should increase with temperature, %d->%d: %f->%f",
-				temps[i-1], temp, prevBlue, b)
+				temps[i-1], temp, prevBlue, wp.b)
 		}
-		prevBlue = b
+		prevBlue = wp.b
 	}
 }
 

core/internal/server/wayland/handlers.go

@@ -7,20 +7,10 @@ import (
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "wayland manager not initialized")
 		return
@@ -48,26 +38,27 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleSetTemperature(conn net.Conn, req Request, manager *Manager) {
+func handleSetTemperature(conn net.Conn, req models.Request, manager *Manager) {
 	var lowTemp, highTemp int
 
 	if temp, ok := req.Params["temp"].(float64); ok {
 		lowTemp = int(temp)
 		highTemp = int(temp)
 	} else {
-		low, okLow := req.Params["low"].(float64)
-		high, okHigh := req.Params["high"].(float64)
-
-		if !okLow || !okHigh {
+		low, err := params.Float(req.Params, "low")
+		if err != nil {
+			models.RespondError(conn, req.ID, "missing temperature parameters (provide 'temp' or both 'low' and 'high')")
+			return
+		}
+		high, err := params.Float(req.Params, "high")
+		if err != nil {
 			models.RespondError(conn, req.ID, "missing temperature parameters (provide 'temp' or both 'low' and 'high')")
 			return
 		}
-
 		lowTemp = int(low)
 		highTemp = int(high)
 	}
@@ -77,19 +68,19 @@ func handleSetTemperature(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "temperature set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "temperature set"})
 }
 
-func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
-	lat, ok := req.Params["latitude"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'latitude' parameter")
+func handleSetLocation(conn net.Conn, req models.Request, manager *Manager) {
+	lat, err := params.Float(req.Params, "latitude")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
-	lon, ok := req.Params["longitude"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'longitude' parameter")
+	lon, err := params.Float(req.Params, "longitude")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -98,30 +89,30 @@ func handleSetLocation(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "location set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "location set"})
 }
 
-func handleSetManualTimes(conn net.Conn, req Request, manager *Manager) {
+func handleSetManualTimes(conn net.Conn, req models.Request, manager *Manager) {
 	sunriseParam := req.Params["sunrise"]
 	sunsetParam := req.Params["sunset"]
 
 	if sunriseParam == nil || sunsetParam == nil {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
 	sunriseStr, ok := sunriseParam.(string)
 	if !ok || sunriseStr == "" {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
 	sunsetStr, ok := sunsetParam.(string)
 	if !ok || sunsetStr == "" {
 		manager.ClearManualTimes()
-		models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times cleared"})
+		models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times cleared"})
 		return
 	}
 
@@ -142,24 +133,24 @@ func handleSetManualTimes(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "manual times set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "manual times set"})
 }
 
-func handleSetUseIPLocation(conn net.Conn, req Request, manager *Manager) {
-	use, ok := req.Params["use"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'use' parameter")
+func handleSetUseIPLocation(conn net.Conn, req models.Request, manager *Manager) {
+	use, err := params.Bool(req.Params, "use")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetUseIPLocation(use)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "IP location preference set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "IP location preference set"})
 }
 
-func handleSetGamma(conn net.Conn, req Request, manager *Manager) {
-	gamma, ok := req.Params["gamma"].(float64)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'gamma' parameter")
+func handleSetGamma(conn net.Conn, req models.Request, manager *Manager) {
+	gamma, err := params.Float(req.Params, "gamma")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
@@ -168,21 +159,21 @@ func handleSetGamma(conn net.Conn, req Request, manager *Manager) {
 		return
 	}
 
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "gamma set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "gamma set"})
 }
 
-func handleSetEnabled(conn net.Conn, req Request, manager *Manager) {
-	enabled, ok := req.Params["enabled"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'enabled' parameter")
+func handleSetEnabled(conn net.Conn, req models.Request, manager *Manager) {
+	enabled, err := params.Bool(req.Params, "enabled")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
 
 	manager.SetEnabled(enabled)
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "enabled state set"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "enabled state set"})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/wayland/manager_test.go

@@ -0,0 +1,386 @@
+package wayland
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestManager_ActorSerializesOutputStateAccess(t *testing.T) {
+	m := &Manager{
+		cmdq:     make(chan cmd, 128),
+		stopChan: make(chan struct{}),
+	}
+
+	m.wg.Add(1)
+	go m.waylandActor()
+
+	state := &outputState{
+		id:           1,
+		registryName: 100,
+		rampSize:     256,
+	}
+	m.outputs.Store(state.id, state)
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.post(func() {
+					if out, ok := m.outputs.Load(state.id); ok {
+						out.rampSize = uint32(j)
+						out.failed = j%2 == 0
+						out.retryCount = j
+						out.lastFailTime = time.Now()
+					}
+				})
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	done := make(chan struct{})
+	m.post(func() { close(done) })
+	<-done
+
+	close(m.stopChan)
+	m.wg.Wait()
+}
+
+func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
+	m := &Manager{
+		stopChan:      make(chan struct{}),
+		dirty:         make(chan struct{}, 1),
+		updateTrigger: make(chan struct{}, 1),
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			subID := string(rune('a' + id))
+			ch := m.Subscribe(subID)
+			assert.NotNil(t, ch)
+			time.Sleep(time.Millisecond)
+			m.Unsubscribe(subID)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ConcurrentGetState(t *testing.T) {
+	m := &Manager{
+		state: &State{
+			CurrentTemp: 5000,
+			IsDay:       true,
+		},
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s := m.GetState()
+				assert.GreaterOrEqual(t, s.CurrentTemp, 0)
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.stateMutex.Lock()
+				m.state = &State{
+					CurrentTemp: 4000 + i*100,
+					IsDay:       j%2 == 0,
+				}
+				m.stateMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ConcurrentConfigAccess(t *testing.T) {
+	m := &Manager{
+		config: DefaultConfig(),
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.configMutex.RLock()
+				_ = m.config.LowTemp
+				_ = m.config.HighTemp
+				_ = m.config.Enabled
+				m.configMutex.RUnlock()
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.configMutex.Lock()
+				m.config.LowTemp = 3000 + j
+				m.config.HighTemp = 7000 - j
+				m.config.Enabled = j%2 == 0
+				m.configMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_SyncmapOutputsConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 50
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := uint32(id)
+
+			for j := 0; j < iterations; j++ {
+				state := &outputState{
+					id:       key,
+					rampSize: uint32(j),
+					failed:   j%2 == 0,
+				}
+				m.outputs.Store(key, state)
+
+				if loaded, ok := m.outputs.Load(key); ok {
+					assert.Equal(t, key, loaded.id)
+				}
+
+				m.outputs.Range(func(k uint32, v *outputState) bool {
+					_ = v.rampSize
+					_ = v.failed
+					return true
+				})
+			}
+
+			m.outputs.Delete(key)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_LocationCacheConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.locationMutex.RLock()
+				_ = m.cachedIPLat
+				_ = m.cachedIPLon
+				m.locationMutex.RUnlock()
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				lat := float64(40 + i)
+				lon := float64(-74 + j)
+				m.locationMutex.Lock()
+				m.cachedIPLat = &lat
+				m.cachedIPLon = &lon
+				m.locationMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ScheduleConcurrentAccess(t *testing.T) {
+	now := time.Now()
+	m := &Manager{
+		schedule: sunSchedule{
+			times: SunTimes{
+				Dawn:    now,
+				Sunrise: now.Add(time.Hour),
+				Sunset:  now.Add(12 * time.Hour),
+				Night:   now.Add(13 * time.Hour),
+			},
+		},
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.scheduleMutex.RLock()
+				_ = m.schedule.times.Dawn
+				_ = m.schedule.times.Sunrise
+				_ = m.schedule.times.Sunset
+				_ = m.schedule.condition
+				m.scheduleMutex.RUnlock()
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.scheduleMutex.Lock()
+				m.schedule.times.Dawn = time.Now()
+				m.schedule.times.Sunrise = time.Now().Add(time.Hour)
+				m.schedule.condition = SunNormal
+				m.scheduleMutex.Unlock()
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestInterpolate_EdgeCases(t *testing.T) {
+	now := time.Now()
+
+	tests := []struct {
+		name     string
+		now      time.Time
+		start    time.Time
+		stop     time.Time
+		expected float64
+	}{
+		{
+			name:     "same start and stop",
+			now:      now,
+			start:    now,
+			stop:     now,
+			expected: 1.0,
+		},
+		{
+			name:     "now before start",
+			now:      now,
+			start:    now.Add(time.Hour),
+			stop:     now.Add(2 * time.Hour),
+			expected: 0.0,
+		},
+		{
+			name:     "now after stop",
+			now:      now.Add(3 * time.Hour),
+			start:    now,
+			stop:     now.Add(time.Hour),
+			expected: 1.0,
+		},
+		{
+			name:     "now at midpoint",
+			now:      now.Add(30 * time.Minute),
+			start:    now,
+			stop:     now.Add(time.Hour),
+			expected: 0.5,
+		},
+		{
+			name:     "now equals start",
+			now:      now,
+			start:    now,
+			stop:     now.Add(time.Hour),
+			expected: 0.0,
+		},
+		{
+			name:     "now equals stop",
+			now:      now.Add(time.Hour),
+			start:    now,
+			stop:     now.Add(time.Hour),
+			expected: 1.0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := interpolate(tt.now, tt.start, tt.stop)
+			assert.InDelta(t, tt.expected, result, 0.01)
+		})
+	}
+}
+
+func TestGenerateGammaRamp_ZeroSize(t *testing.T) {
+	ramp := GenerateGammaRamp(0, 5000, 1.0)
+	assert.Empty(t, ramp.Red)
+	assert.Empty(t, ramp.Green)
+	assert.Empty(t, ramp.Blue)
+}
+
+func TestGenerateGammaRamp_ValidSizes(t *testing.T) {
+	sizes := []uint32{1, 256, 1024}
+	temps := []int{1000, 4000, 6500, 10000}
+	gammas := []float64{0.5, 1.0, 2.0}
+
+	for _, size := range sizes {
+		for _, temp := range temps {
+			for _, gamma := range gammas {
+				ramp := GenerateGammaRamp(size, temp, gamma)
+				assert.Len(t, ramp.Red, int(size))
+				assert.Len(t, ramp.Green, int(size))
+				assert.Len(t, ramp.Blue, int(size))
+			}
+		}
+	}
+}
+
+func TestNotifySubscribers_NonBlocking(t *testing.T) {
+	m := &Manager{
+		dirty: make(chan struct{}, 1),
+	}
+
+	for i := 0; i < 10; i++ {
+		m.notifySubscribers()
+	}
+
+	assert.Len(t, m.dirty, 1)
+}

core/internal/server/wayland/suncalc.go

@@ -6,81 +6,117 @@ import (
 )
 
 const (
-	degToRad     = math.Pi / 180.0
-	radToDeg     = 180.0 / math.Pi
-	solarNoon    = 12.0
-	sunriseAngle = -0.833
+	degToRad = math.Pi / 180.0
+	radToDeg = 180.0 / math.Pi
 )
 
-func CalculateSunTimes(lat, lon float64, date time.Time) SunTimes {
-	utcDate := date.UTC()
-	year, month, day := utcDate.Date()
-	loc := date.Location()
+type SunCondition int
 
-	dayOfYear := utcDate.YearDay()
+const (
+	SunNormal SunCondition = iota
+	SunMidnightSun
+	SunPolarNight
+)
 
-	gamma := 2 * math.Pi / 365 * float64(dayOfYear-1)
+type SunTimes struct {
+	Dawn    time.Time
+	Sunrise time.Time
+	Sunset  time.Time
+	Night   time.Time
+}
 
-	eqTime := 229.18 * (0.000075 +
-		0.001868*math.Cos(gamma) -
-		0.032077*math.Sin(gamma) -
-		0.014615*math.Cos(2*gamma) -
-		0.040849*math.Sin(2*gamma))
+func daysInYear(year int) int {
+	if (year%4 == 0 && year%100 != 0) || year%400 == 0 {
+		return 366
+	}
+	return 365
+}
 
-	decl := 0.006918 -
-		0.399912*math.Cos(gamma) +
-		0.070257*math.Sin(gamma) -
-		0.006758*math.Cos(2*gamma) +
-		0.000907*math.Sin(2*gamma) -
-		0.002697*math.Cos(3*gamma) +
-		0.00148*math.Sin(3*gamma)
+func dateOrbitAngle(t time.Time) float64 {
+	return 2 * math.Pi / float64(daysInYear(t.Year())) * float64(t.YearDay()-1)
+}
 
+func equationOfTime(orbitAngle float64) float64 {
+	return 4 * (0.000075 +
+		0.001868*math.Cos(orbitAngle) -
+		0.032077*math.Sin(orbitAngle) -
+		0.014615*math.Cos(2*orbitAngle) -
+		0.040849*math.Sin(2*orbitAngle))
+}
+
+func sunDeclination(orbitAngle float64) float64 {
+	return 0.006918 -
+		0.399912*math.Cos(orbitAngle) +
+		0.070257*math.Sin(orbitAngle) -
+		0.006758*math.Cos(2*orbitAngle) +
+		0.000907*math.Sin(2*orbitAngle) -
+		0.002697*math.Cos(3*orbitAngle) +
+		0.00148*math.Sin(3*orbitAngle)
+}
+
+func sunHourAngle(latRad, declination, targetSunRad float64) float64 {
+	return math.Acos(math.Cos(targetSunRad)/
+		math.Cos(latRad)*math.Cos(declination) -
+		math.Tan(latRad)*math.Tan(declination))
+}
+
+func hourAngleToSeconds(hourAngle, eqtime float64) float64 {
+	return radToDeg * (4.0*math.Pi - 4*hourAngle - eqtime) * 60
+}
+
+func sunCondition(latRad, declination float64) SunCondition {
+	signLat := latRad >= 0
+	signDecl := declination >= 0
+	if signLat == signDecl {
+		return SunMidnightSun
+	}
+	return SunPolarNight
+}
+
+func CalculateSunTimesWithTwilight(lat, lon float64, date time.Time, elevTwilight, elevDaylight float64) (SunTimes, SunCondition) {
 	latRad := lat * degToRad
+	elevTwilightRad := (90.833 - elevTwilight) * degToRad
+	elevDaylightRad := (90.833 - elevDaylight) * degToRad
 
-	cosHourAngle := (math.Sin(sunriseAngle*degToRad) -
-		math.Sin(latRad)*math.Sin(decl)) /
-		(math.Cos(latRad) * math.Cos(decl))
+	utc := date.UTC()
+	orbitAngle := dateOrbitAngle(utc)
+	decl := sunDeclination(orbitAngle)
+	eqtime := equationOfTime(orbitAngle)
 
-	if cosHourAngle > 1 {
-		return SunTimes{
-			Sunrise: time.Date(year, month, day, 0, 0, 0, 0, time.UTC).In(loc),
-			Sunset:  time.Date(year, month, day, 0, 0, 0, 0, time.UTC).In(loc),
-		}
-	}
-	if cosHourAngle < -1 {
-		return SunTimes{
-			Sunrise: time.Date(year, month, day, 0, 0, 0, 0, time.UTC).In(loc),
-			Sunset:  time.Date(year, month, day, 23, 59, 59, 0, time.UTC).In(loc),
-		}
+	haTwilight := sunHourAngle(latRad, decl, elevTwilightRad)
+	haDaylight := sunHourAngle(latRad, decl, elevDaylightRad)
+
+	if math.IsNaN(haTwilight) || math.IsNaN(haDaylight) {
+		cond := sunCondition(latRad, decl)
+		return SunTimes{}, cond
 	}
 
-	hourAngle := math.Acos(cosHourAngle) * radToDeg
+	dayStart := time.Date(utc.Year(), utc.Month(), utc.Day(), 0, 0, 0, 0, time.UTC)
+	lonOffset := time.Duration(-lon*4) * time.Minute
 
-	sunriseTime := solarNoon - hourAngle/15.0 - lon/15.0 - eqTime/60.0
-	sunsetTime := solarNoon + hourAngle/15.0 - lon/15.0 - eqTime/60.0
-
-	sunrise := timeOfDayToTime(sunriseTime, year, month, day, time.UTC).In(loc)
-	sunset := timeOfDayToTime(sunsetTime, year, month, day, time.UTC).In(loc)
+	dawnSecs := hourAngleToSeconds(math.Abs(haTwilight), eqtime)
+	sunriseSecs := hourAngleToSeconds(math.Abs(haDaylight), eqtime)
+	sunsetSecs := hourAngleToSeconds(-math.Abs(haDaylight), eqtime)
+	nightSecs := hourAngleToSeconds(-math.Abs(haTwilight), eqtime)
 
 	return SunTimes{
-		Sunrise: sunrise,
-		Sunset:  sunset,
-	}
+		Dawn:    dayStart.Add(time.Duration(dawnSecs)*time.Second + lonOffset).In(date.Location()),
+		Sunrise: dayStart.Add(time.Duration(sunriseSecs)*time.Second + lonOffset).In(date.Location()),
+		Sunset:  dayStart.Add(time.Duration(sunsetSecs)*time.Second + lonOffset).In(date.Location()),
+		Night:   dayStart.Add(time.Duration(nightSecs)*time.Second + lonOffset).In(date.Location()),
+	}, SunNormal
 }
 
-func timeOfDayToTime(hours float64, year int, month time.Month, day int, loc *time.Location) time.Time {
-	h := int(hours)
-	m := int((hours - float64(h)) * 60)
-	s := int(((hours-float64(h))*60 - float64(m)) * 60)
-
-	if h < 0 {
-		h += 24
-		day--
+func CalculateSunTimes(lat, lon float64, date time.Time) SunTimes {
+	times, cond := CalculateSunTimesWithTwilight(lat, lon, date, -6.0, 3.0)
+	switch cond {
+	case SunMidnightSun:
+		dayStart := time.Date(date.Year(), date.Month(), date.Day(), 0, 0, 0, 0, date.Location())
+		dayEnd := dayStart.Add(24*time.Hour - time.Second)
+		return SunTimes{Dawn: dayStart, Sunrise: dayStart, Sunset: dayEnd, Night: dayEnd}
+	case SunPolarNight:
+		dayStart := time.Date(date.Year(), date.Month(), date.Day(), 0, 0, 0, 0, date.Location())
+		return SunTimes{Dawn: dayStart, Sunrise: dayStart, Sunset: dayStart, Night: dayStart}
 	}
-	if h >= 24 {
-		h -= 24
-		day++
-	}
-
-	return time.Date(year, month, day, h, m, s, 0, loc)
+	return times
 }

core/internal/server/wayland/suncalc_test.go

@@ -340,38 +340,47 @@ func TestCalculateNextTransition(t *testing.T) {
 	}
 }
 
-func TestTimeOfDayToTime(t *testing.T) {
+func TestSunTimesWithTwilight(t *testing.T) {
+	lat := 40.7128
+	lon := -74.0060
+	date := time.Date(2024, 6, 21, 12, 0, 0, 0, time.Local)
+
+	times, cond := CalculateSunTimesWithTwilight(lat, lon, date, -6.0, 3.0)
+
+	if cond != SunNormal {
+		t.Errorf("expected SunNormal, got %v", cond)
+	}
+	if !times.Dawn.Before(times.Sunrise) {
+		t.Error("dawn should be before sunrise")
+	}
+	if !times.Sunrise.Before(times.Sunset) {
+		t.Error("sunrise should be before sunset")
+	}
+	if !times.Sunset.Before(times.Night) {
+		t.Error("sunset should be before night")
+	}
+}
+
+func TestSunConditions(t *testing.T) {
 	tests := []struct {
 		name     string
-		hours    float64
-		expected time.Time
+		lat      float64
+		date     time.Time
+		expected SunCondition
 	}{
 		{
-			name:     "noon",
-			hours:    12.0,
-			expected: time.Date(2024, 6, 21, 12, 0, 0, 0, time.Local),
-		},
-		{
-			name:     "half_past",
-			hours:    12.5,
-			expected: time.Date(2024, 6, 21, 12, 30, 0, 0, time.Local),
-		},
-		{
-			name:     "early_morning",
-			hours:    6.25,
-			expected: time.Date(2024, 6, 21, 6, 15, 0, 0, time.Local),
+			name:     "normal_conditions",
+			lat:      40.0,
+			date:     time.Date(2024, 6, 21, 12, 0, 0, 0, time.UTC),
+			expected: SunNormal,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := timeOfDayToTime(tt.hours, 2024, 6, 21, time.Local)
-
-			if result.Hour() != tt.expected.Hour() {
-				t.Errorf("hour = %d, want %d", result.Hour(), tt.expected.Hour())
-			}
-			if result.Minute() != tt.expected.Minute() {
-				t.Errorf("minute = %d, want %d", result.Minute(), tt.expected.Minute())
+			_, cond := CalculateSunTimesWithTwilight(tt.lat, 0, tt.date, -6.0, 3.0)
+			if cond != tt.expected {
+				t.Errorf("expected condition %v, got %v", tt.expected, cond)
 			}
 		})
 	}

core/internal/server/wayland/types.go

@@ -11,18 +11,28 @@ import (
 	"github.com/godbus/dbus/v5"
 )
 
+type GammaState int
+
+const (
+	StateNormal GammaState = iota
+	StateTransition
+	StateStatic
+)
+
 type Config struct {
-	Outputs        []string
-	LowTemp        int
-	HighTemp       int
-	Latitude       *float64
-	Longitude      *float64
-	UseIPLocation  bool
-	ManualSunrise  *time.Time
-	ManualSunset   *time.Time
-	ManualDuration *time.Duration
-	Gamma          float64
-	Enabled        bool
+	Outputs           []string
+	LowTemp           int
+	HighTemp          int
+	Latitude          *float64
+	Longitude         *float64
+	UseIPLocation     bool
+	ManualSunrise     *time.Time
+	ManualSunset      *time.Time
+	ManualDuration    *time.Duration
+	Gamma             float64
+	Enabled           bool
+	ElevationTwilight float64
+	ElevationDaylight float64
 }
 
 type State struct {
@@ -31,13 +41,24 @@ type State struct {
 	NextTransition time.Time `json:"nextTransition"`
 	SunriseTime    time.Time `json:"sunriseTime"`
 	SunsetTime     time.Time `json:"sunsetTime"`
+	DawnTime       time.Time `json:"dawnTime"`
+	NightTime      time.Time `json:"nightTime"`
 	IsDay          bool      `json:"isDay"`
+	SunPosition    float64   `json:"sunPosition"`
 }
 
 type cmd struct {
 	fn func()
 }
 
+type sunSchedule struct {
+	times         SunTimes
+	condition     SunCondition
+	dawnStepTime  time.Duration
+	nightStepTime time.Duration
+	calcDay       time.Time
+}
+
 type Manager struct {
 	config      Config
 	configMutex sync.RWMutex
@@ -60,10 +81,9 @@ type Manager struct {
 	updateTrigger chan struct{}
 	wg            sync.WaitGroup
 
-	currentTemp     int
-	targetTemp      int
-	transitionMutex sync.RWMutex
-	transitionChan  chan int
+	schedule      sunSchedule
+	scheduleMutex sync.RWMutex
+	gammaState    GammaState
 
 	cachedIPLat   *float64
 	cachedIPLon   *float64
@@ -76,11 +96,13 @@ type Manager struct {
 
 	dbusConn   *dbus.Conn
 	dbusSignal chan *dbus.Signal
+
+	lastAppliedTemp  int
+	lastAppliedGamma float64
 }
 
 type outputState struct {
 	id           uint32
-	name         string
 	registryName uint32
 	output       *wlclient.Output
 	gammaControl any
@@ -91,18 +113,15 @@ type outputState struct {
 	lastFailTime time.Time
 }
 
-type SunTimes struct {
-	Sunrise time.Time
-	Sunset  time.Time
-}
-
 func DefaultConfig() Config {
 	return Config{
-		Outputs:  []string{},
-		LowTemp:  4000,
-		HighTemp: 6500,
-		Gamma:    1.0,
-		Enabled:  false,
+		Outputs:           []string{},
+		LowTemp:           4000,
+		HighTemp:          6500,
+		Gamma:             1.0,
+		Enabled:           false,
+		ElevationTwilight: -6.0,
+		ElevationDaylight: 3.0,
 	}
 }
 
@@ -140,8 +159,7 @@ func (m *Manager) GetState() State {
 	if m.state == nil {
 		return State{}
 	}
-	stateCopy := *m.state
-	return stateCopy
+	return *m.state
 }
 
 func (m *Manager) Subscribe(id string) chan State {
@@ -185,5 +203,8 @@ func stateChanged(old, new *State) bool {
 	if old.Config.Enabled != new.Config.Enabled {
 		return true
 	}
+	if old.SunPosition != new.SunPosition {
+		return true
+	}
 	return false
 }

core/internal/server/wlroutput/handlers.go

@@ -11,17 +11,6 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type HeadConfig struct {
 	Name       string  `json:"name"`
 	Enabled    bool    `json:"enabled"`
@@ -42,7 +31,7 @@ type ConfigurationRequest struct {
 	Test  bool         `json:"test"`
 }
 
-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	if manager == nil {
 		models.RespondError(conn, req.ID, "wlroutput manager not initialized")
 		return
@@ -62,12 +51,11 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }
 
-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }
 
-func handleApplyConfiguration(conn net.Conn, req Request, manager *Manager, test bool) {
+func handleApplyConfiguration(conn net.Conn, req models.Request, manager *Manager, test bool) {
 	headsParam, ok := req.Params["heads"]
 	if !ok {
 		models.RespondError(conn, req.ID, "missing 'heads' parameter")
@@ -95,10 +83,10 @@ func handleApplyConfiguration(conn net.Conn, req Request, manager *Manager, test
 	if test {
 		msg = "configuration test succeeded"
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: msg})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: msg})
 }
 
-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)

core/internal/server/wlroutput/manager_test.go

@@ -0,0 +1,400 @@
+package wlroutput
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStateChanged_BothNil(t *testing.T) {
+	assert.True(t, stateChanged(nil, nil))
+}
+
+func TestStateChanged_OneNil(t *testing.T) {
+	s := &State{Serial: 1}
+	assert.True(t, stateChanged(s, nil))
+	assert.True(t, stateChanged(nil, s))
+}
+
+func TestStateChanged_SerialDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{}}
+	b := &State{Serial: 2, Outputs: []Output{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputCountDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1"}}}
+	b := &State{Serial: 1, Outputs: []Output{}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputNameDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Enabled: true}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "HDMI-A-1", Enabled: true}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputEnabledDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Enabled: true}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Enabled: false}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputPositionDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", X: 0, Y: 0}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", X: 1920, Y: 0}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputTransformDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Transform: 0}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Transform: 1}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputScaleDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Scale: 1.0}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Scale: 2.0}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_OutputAdaptiveSyncDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", AdaptiveSync: 0}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", AdaptiveSync: 1}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_CurrentModeNilVsNonNil(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", CurrentMode: nil}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", CurrentMode: &OutputMode{Width: 1920}}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_CurrentModeDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{
+		Name:        "eDP-1",
+		CurrentMode: &OutputMode{Width: 1920, Height: 1080, Refresh: 60000},
+	}}}
+	b := &State{Serial: 1, Outputs: []Output{{
+		Name:        "eDP-1",
+		CurrentMode: &OutputMode{Width: 2560, Height: 1440, Refresh: 60000},
+	}}}
+	assert.True(t, stateChanged(a, b))
+
+	b.Outputs[0].CurrentMode.Width = 1920
+	b.Outputs[0].CurrentMode.Height = 1080
+	b.Outputs[0].CurrentMode.Refresh = 144000
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_ModesLengthDiffers(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Modes: []OutputMode{{Width: 1920}}}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", Modes: []OutputMode{{Width: 1920}, {Width: 1280}}}}}
+	assert.True(t, stateChanged(a, b))
+}
+
+func TestStateChanged_Equal(t *testing.T) {
+	mode := OutputMode{Width: 1920, Height: 1080, Refresh: 60000, Preferred: true}
+	a := &State{
+		Serial: 5,
+		Outputs: []Output{{
+			Name:           "eDP-1",
+			Description:    "Built-in display",
+			Make:           "BOE",
+			Model:          "0x0ABC",
+			SerialNumber:   "12345",
+			PhysicalWidth:  309,
+			PhysicalHeight: 174,
+			Enabled:        true,
+			X:              0,
+			Y:              0,
+			Transform:      0,
+			Scale:          1.0,
+			CurrentMode:    &mode,
+			Modes:          []OutputMode{mode},
+			AdaptiveSync:   0,
+		}},
+	}
+	b := &State{
+		Serial: 5,
+		Outputs: []Output{{
+			Name:           "eDP-1",
+			Description:    "Built-in display",
+			Make:           "BOE",
+			Model:          "0x0ABC",
+			SerialNumber:   "12345",
+			PhysicalWidth:  309,
+			PhysicalHeight: 174,
+			Enabled:        true,
+			X:              0,
+			Y:              0,
+			Transform:      0,
+			Scale:          1.0,
+			CurrentMode:    &mode,
+			Modes:          []OutputMode{mode},
+			AdaptiveSync:   0,
+		}},
+	}
+	assert.False(t, stateChanged(a, b))
+}
+
+func TestManager_ConcurrentGetState(t *testing.T) {
+	m := &Manager{
+		state: &State{
+			Serial:  1,
+			Outputs: []Output{{Name: "eDP-1", Enabled: true}},
+		},
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 50
+	const iterations = 100
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				s := m.GetState()
+				_ = s.Serial
+				_ = s.Outputs
+			}
+		}()
+	}
+
+	for i := 0; i < goroutines/2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			for j := 0; j < iterations; j++ {
+				m.stateMutex.Lock()
+				m.state = &State{
+					Serial:  uint32(j),
+					Outputs: []Output{{Name: "eDP-1", Scale: float64(j % 3)}},
+				}
+				m.stateMutex.Unlock()
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
+	m := &Manager{
+		stopChan: make(chan struct{}),
+		dirty:    make(chan struct{}, 1),
+	}
+
+	var wg sync.WaitGroup
+	const goroutines = 20
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			subID := string(rune('a' + id))
+			ch := m.Subscribe(subID)
+			assert.NotNil(t, ch)
+			time.Sleep(time.Millisecond)
+			m.Unsubscribe(subID)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_SyncmapHeadsConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 50
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := uint32(id)
+
+			for j := 0; j < iterations; j++ {
+				state := &headState{
+					id:      key,
+					name:    "test-head",
+					enabled: j%2 == 0,
+					scale:   float64(j % 3),
+					modeIDs: []uint32{uint32(j)},
+				}
+				m.heads.Store(key, state)
+
+				if loaded, ok := m.heads.Load(key); ok {
+					assert.Equal(t, key, loaded.id)
+				}
+
+				m.heads.Range(func(k uint32, v *headState) bool {
+					_ = v.name
+					_ = v.enabled
+					return true
+				})
+			}
+
+			m.heads.Delete(key)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_SyncmapModesConcurrentAccess(t *testing.T) {
+	m := &Manager{}
+
+	var wg sync.WaitGroup
+	const goroutines = 30
+	const iterations = 50
+
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			key := uint32(id)
+
+			for j := 0; j < iterations; j++ {
+				state := &modeState{
+					id:        key,
+					width:     int32(1920 + j),
+					height:    int32(1080 + j),
+					refresh:   60000,
+					preferred: j == 0,
+				}
+				m.modes.Store(key, state)
+
+				if loaded, ok := m.modes.Load(key); ok {
+					assert.Equal(t, key, loaded.id)
+				}
+
+				m.modes.Range(func(k uint32, v *modeState) bool {
+					_ = v.width
+					_ = v.height
+					return true
+				})
+			}
+
+			m.modes.Delete(key)
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestManager_NotifySubscribersNonBlocking(t *testing.T) {
+	m := &Manager{
+		dirty: make(chan struct{}, 1),
+	}
+
+	for i := 0; i < 10; i++ {
+		m.notifySubscribers()
+	}
+
+	assert.Len(t, m.dirty, 1)
+}
+
+func TestManager_PostQueueFull(t *testing.T) {
+	m := &Manager{
+		cmdq:     make(chan cmd, 2),
+		stopChan: make(chan struct{}),
+	}
+
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+	m.post(func() {})
+
+	assert.Len(t, m.cmdq, 2)
+}
+
+func TestManager_GetStateNilState(t *testing.T) {
+	m := &Manager{}
+
+	s := m.GetState()
+	assert.NotNil(t, s.Outputs)
+	assert.Equal(t, uint32(0), s.Serial)
+}
+
+func TestManager_FatalErrorChannel(t *testing.T) {
+	m := &Manager{
+		fatalError: make(chan error, 1),
+	}
+
+	ch := m.FatalError()
+	assert.NotNil(t, ch)
+
+	m.fatalError <- assert.AnError
+	err := <-ch
+	assert.Error(t, err)
+}
+
+func TestOutputMode_Fields(t *testing.T) {
+	mode := OutputMode{
+		Width:     1920,
+		Height:    1080,
+		Refresh:   60000,
+		Preferred: true,
+		ID:        42,
+	}
+
+	assert.Equal(t, int32(1920), mode.Width)
+	assert.Equal(t, int32(1080), mode.Height)
+	assert.Equal(t, int32(60000), mode.Refresh)
+	assert.True(t, mode.Preferred)
+	assert.Equal(t, uint32(42), mode.ID)
+}
+
+func TestOutput_Fields(t *testing.T) {
+	out := Output{
+		Name:           "eDP-1",
+		Description:    "Built-in display",
+		Make:           "BOE",
+		Model:          "0x0ABC",
+		SerialNumber:   "12345",
+		PhysicalWidth:  309,
+		PhysicalHeight: 174,
+		Enabled:        true,
+		X:              0,
+		Y:              0,
+		Transform:      0,
+		Scale:          1.5,
+		AdaptiveSync:   1,
+		ID:             1,
+	}
+
+	assert.Equal(t, "eDP-1", out.Name)
+	assert.Equal(t, "Built-in display", out.Description)
+	assert.True(t, out.Enabled)
+	assert.Equal(t, float64(1.5), out.Scale)
+	assert.Equal(t, uint32(1), out.AdaptiveSync)
+}
+
+func TestHeadState_ModeIDsSlice(t *testing.T) {
+	head := &headState{
+		id:      1,
+		modeIDs: make([]uint32, 0),
+	}
+
+	head.modeIDs = append(head.modeIDs, 1, 2, 3)
+	assert.Len(t, head.modeIDs, 3)
+	assert.Equal(t, uint32(1), head.modeIDs[0])
+}
+
+func TestStateChanged_BothCurrentModeNil(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", CurrentMode: nil}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1", CurrentMode: nil}}}
+	assert.False(t, stateChanged(a, b))
+}
+
+func TestStateChanged_IndexOutOfBounds(t *testing.T) {
+	a := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1"}}}
+	b := &State{Serial: 1, Outputs: []Output{{Name: "eDP-1"}, {Name: "HDMI-A-1"}}}
+	assert.True(t, stateChanged(a, b))
+}

core/internal/tui/views_install.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 )
@@ -118,6 +120,59 @@ func (m Model) viewInstallingPackages() string {
 	return b.String()
 }
 
+func dmsPackageName(distroID string, dependencies []deps.Dependency) string {
+	config, ok := distros.Registry[distroID]
+	if !ok {
+		return "dms"
+	}
+
+	var isGit bool
+	for _, dep := range dependencies {
+		if dep.Name == "dms (DankMaterialShell)" {
+			isGit = dep.Variant == deps.VariantGit
+			break
+		}
+	}
+
+	switch config.Family {
+	case distros.FamilyArch:
+		if isGit {
+			return "dms-shell-git"
+		}
+		return "dms-shell-bin"
+	case distros.FamilyFedora, distros.FamilyUbuntu, distros.FamilyDebian, distros.FamilySUSE:
+		if isGit {
+			return "dms-git"
+		}
+		return "dms"
+	default:
+		return "dms"
+	}
+}
+
+func uninstallCommand(distroID string, dependencies []deps.Dependency) string {
+	config, ok := distros.Registry[distroID]
+	if !ok {
+		return ""
+	}
+	if config.Family == distros.FamilyGentoo {
+		return "rm -rf ~/.config/quickshell/dms && sudo rm /usr/local/bin/dms"
+	}
+	pkg := dmsPackageName(distroID, dependencies)
+	switch config.Family {
+	case distros.FamilyArch:
+		return "sudo pacman -Rs " + pkg
+	case distros.FamilyFedora:
+		return "sudo dnf remove " + pkg
+	case distros.FamilyUbuntu, distros.FamilyDebian:
+		return "sudo apt remove " + pkg
+	case distros.FamilySUSE:
+		return "sudo zypper remove " + pkg
+	default:
+		return ""
+	}
+}
+
 func (m Model) viewInstallComplete() string {
 	var b strings.Builder
 
@@ -132,7 +187,6 @@ func (m Model) viewInstallComplete() string {
 	b.WriteString(success)
 	b.WriteString("\n\n")
 
-	// Show what was accomplished
 	accomplishments := []string{
 		"• Window manager and dependencies installed",
 		"• Terminal and development tools configured",
@@ -146,8 +200,26 @@ func (m Model) viewInstallComplete() string {
 	}
 
 	b.WriteString("\n")
-	info := m.styles.Normal.Render("Your system is ready! Log out and log back in to start using\nyour new desktop environment.\nIf you do not have a greeter, login with \"niri-session\" or \"Hyprland\" \n\nPress Enter to exit.")
+	info := m.styles.Normal.Render("Your system is ready! Log out and log back in to start using\nyour new desktop environment.\nIf you do not have a greeter, login with \"niri-session\" or \"Hyprland\"")
 	b.WriteString(info)
+	b.WriteString("\n\n")
+
+	theme := TerminalTheme()
+	cmdStyle := lipgloss.NewStyle().Foreground(lipgloss.Color(theme.Accent))
+	labelStyle := lipgloss.NewStyle().Foreground(lipgloss.Color(theme.Subtle))
+
+	b.WriteString(labelStyle.Render("Troubleshooting:") + "\n")
+	b.WriteString(labelStyle.Render("  Disable autostart: ") + cmdStyle.Render("systemctl --user disable dms") + "\n")
+	b.WriteString(labelStyle.Render("  View logs:         ") + cmdStyle.Render("journalctl --user -u dms") + "\n")
+
+	if m.osInfo != nil {
+		if cmd := uninstallCommand(m.osInfo.Distribution.ID, m.dependencies); cmd != "" {
+			b.WriteString(labelStyle.Render("  Uninstall:         ") + cmdStyle.Render(cmd) + "\n")
+		}
+	}
+
+	b.WriteString("\n")
+	b.WriteString(m.styles.Normal.Render("Press Enter to exit."))
 
 	if m.logFilePath != "" {
 		b.WriteString("\n\n")

core/internal/tui/views_welcome.go

@@ -40,7 +40,7 @@ func (m Model) viewWelcome() string {
 	subtitle := lipgloss.NewStyle().
 		Foreground(lipgloss.Color(theme.Subtle)).
 		Italic(true).
-		Render("Quickstart for a Dank™ Desktop")
+		Render("Quickstart for a Dank Desktop")
 
 	b.WriteString(decorator)
 	b.WriteString("\n")