v1.0.2

fixes #958

.githooks/pre-commit

@@ -37,7 +37,10 @@ if [[ -n "$STAGED_CORE_FILES" ]]; then
 
   # Tests
   echo "  Running tests..."
-  go test ./... >/dev/null
+  if ! go test ./... >/dev/null 2>&1; then
+    echo "Tests failed! Run 'go test ./...' for details."
+    exit 1
+  fi
 
   # Build checks
   echo "  Building..."

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

@@ -0,0 +1,23 @@
+name: Check nix flake
+
+on:
+  pull_request:
+    branches: [master, main]
+    paths:
+      - "flake.*"
+      - "distro/nix/**"
+jobs:
+  check-flake:
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install Nix
+        uses: cachix/install-nix-action@v31
+
+      - 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

.gitignore

@@ -102,39 +102,6 @@ go.work.sum
 # .idea/
 # .vscode/
 
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Code coverage profiles and other test artifacts
-*.out
-coverage.*
-*.coverprofile
-profile.cov
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-go.work.sum
-
-# env file
-.env
-
-# Editor/IDE
-# .idea/
-# .vscode/
-
 bin/
 
 # Extracted source trees in Ubuntu package directories  
@@ -142,3 +109,7 @@ distro/ubuntu/*/dms-git-repo/
 distro/ubuntu/*/DankMaterialShell-*/
 distro/ubuntu/danklinux/*/dsearch-*/
 distro/ubuntu/danklinux/*/dgop-*/
+
+# direnv
+.envrc
+.direnv/

CONTRIBUTING.md

@@ -12,6 +12,21 @@ Enable pre-commit hooks to catch CI failures before pushing:
 git config core.hooksPath .githooks
 ```
 
+### Nix Development Shell
+
+If you have Nix installed with flakes enabled, you can use the provided development shell which includes all necessary dependencies:
+
+```bash
+nix develop
+```
+
+This will provide:
+- Go 1.24 toolchain (go, gopls, delve, go-tools) and GNU Make
+- Quickshell and required QML packages
+- Properly configured QML2_IMPORT_PATH
+
+The dev shell automatically creates the `.qmlls.ini` file in the `quickshell/` directory.
+
 ## VSCode Setup
 
 This is a monorepo, the easiest thing to do is to open an editor in either `quickshell`, `core`, or both depending on which part of the project you are working on.

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"

assets/dms-open.desktop

@@ -6,5 +6,5 @@ Exec=dms open %u
 Icon=danklogo
 Terminal=false
 NoDisplay=true
-MimeType=x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/file;text/html;
+MimeType=x-scheme-handler/http;x-scheme-handler/https;text/html;application/xhtml+xml;
 Categories=Utility;

core/.golangci.yml

@@ -21,6 +21,9 @@ linters:
         # Signal handling
         - (*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,53 +426,73 @@ 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
 	}
-
-	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("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)
+	fmt.Printf("Plugin uninstalled successfully: %s\n", idOrName)
+	return nil
+}
+
+func updatePluginCLI(idOrName string) error {
+	manager, err := plugins.NewManager()
+	if err != nil {
+		return fmt.Errorf("failed to create manager: %w", err)
+	}
+
+	registry, err := plugins.NewRegistry()
+	if err != nil {
+		return fmt.Errorf("failed to create registry: %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("Updating plugin: %s\n", idOrName)
+	if err := manager.UpdateByIDOrName(idOrName); err != nil {
+		return err
+	}
+	fmt.Printf("Plugin updated successfully: %s\n", idOrName)
 	return nil
 }
 
-// getCommonCommands returns the commands available in all builds
 func getCommonCommands() []*cobra.Command {
 	return []*cobra.Command{
 		versionCmd,
@@ -472,5 +510,8 @@ func getCommonCommands() []*cobra.Command {
 		greeterCmd,
 		setupCmd,
 		colorCmd,
+		screenshotCmd,
+		notifyActionCmd,
+		matugenCmd,
 	}
 }

core/cmd/dms/commands_dank16.go

@@ -10,15 +10,15 @@ import (
 )
 
 var dank16Cmd = &cobra.Command{
-	Use:   "dank16 <hex_color>",
+	Use:   "dank16 [hex_color]",
 	Short: "Generate Base16 color palettes",
 	Long:  "Generate Base16 color palettes from a color with support for various output formats",
-	Args:  cobra.ExactArgs(1),
+	Args:  cobra.MaximumNArgs(1),
 	Run:   runDank16,
 }
 
 func init() {
-	dank16Cmd.Flags().Bool("light", false, "Generate light theme variant")
+	dank16Cmd.Flags().Bool("light", false, "Generate light theme variant (sets default to light)")
 	dank16Cmd.Flags().Bool("json", false, "Output in JSON format")
 	dank16Cmd.Flags().Bool("kitty", false, "Output in Kitty terminal format")
 	dank16Cmd.Flags().Bool("foot", false, "Output in Foot terminal format")
@@ -27,17 +27,15 @@ func init() {
 	dank16Cmd.Flags().Bool("wezterm", false, "Output in Wezterm terminal format")
 	dank16Cmd.Flags().String("background", "", "Custom background color")
 	dank16Cmd.Flags().String("contrast", "dps", "Contrast algorithm: dps (Delta Phi Star, default) or wcag")
+	dank16Cmd.Flags().Bool("variants", false, "Output all variants (dark/light/default) in JSON")
+	dank16Cmd.Flags().String("primary-dark", "", "Primary color for dark mode (use with --variants)")
+	dank16Cmd.Flags().String("primary-light", "", "Primary color for light mode (use with --variants)")
 	_ = dank16Cmd.RegisterFlagCompletionFunc("contrast", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		return []string{"dps", "wcag"}, cobra.ShellCompDirectiveNoFileComp
 	})
 }
 
 func runDank16(cmd *cobra.Command, args []string) {
-	primaryColor := args[0]
-	if !strings.HasPrefix(primaryColor, "#") {
-		primaryColor = "#" + primaryColor
-	}
-
 	isLight, _ := cmd.Flags().GetBool("light")
 	isJson, _ := cmd.Flags().GetBool("json")
 	isKitty, _ := cmd.Flags().GetBool("kitty")
@@ -47,16 +45,57 @@ func runDank16(cmd *cobra.Command, args []string) {
 	isWezterm, _ := cmd.Flags().GetBool("wezterm")
 	background, _ := cmd.Flags().GetString("background")
 	contrastAlgo, _ := cmd.Flags().GetString("contrast")
+	useVariants, _ := cmd.Flags().GetBool("variants")
+	primaryDark, _ := cmd.Flags().GetString("primary-dark")
+	primaryLight, _ := cmd.Flags().GetString("primary-light")
 
 	if background != "" && !strings.HasPrefix(background, "#") {
 		background = "#" + background
 	}
+	if primaryDark != "" && !strings.HasPrefix(primaryDark, "#") {
+		primaryDark = "#" + primaryDark
+	}
+	if primaryLight != "" && !strings.HasPrefix(primaryLight, "#") {
+		primaryLight = "#" + primaryLight
+	}
 
 	contrastAlgo = strings.ToLower(contrastAlgo)
 	if contrastAlgo != "dps" && contrastAlgo != "wcag" {
 		log.Fatalf("Invalid contrast algorithm: %s (must be 'dps' or 'wcag')", contrastAlgo)
 	}
 
+	if useVariants {
+		if primaryDark == "" || primaryLight == "" {
+			if len(args) == 0 {
+				log.Fatalf("--variants requires either a positional color argument or both --primary-dark and --primary-light")
+			}
+			primaryColor := args[0]
+			if !strings.HasPrefix(primaryColor, "#") {
+				primaryColor = "#" + primaryColor
+			}
+			primaryDark = primaryColor
+			primaryLight = primaryColor
+		}
+		variantOpts := dank16.VariantOptions{
+			PrimaryDark:  primaryDark,
+			PrimaryLight: primaryLight,
+			Background:   background,
+			UseDPS:       contrastAlgo == "dps",
+			IsLightMode:  isLight,
+		}
+		variantColors := dank16.GenerateVariantPalette(variantOpts)
+		fmt.Print(dank16.GenerateVariantJSON(variantColors))
+		return
+	}
+
+	if len(args) == 0 {
+		log.Fatalf("A color argument is required (or use --variants with --primary-dark and --primary-light)")
+	}
+	primaryColor := args[0]
+	if !strings.HasPrefix(primaryColor, "#") {
+		primaryColor = "#" + primaryColor
+	}
+
 	opts := dank16.PaletteOptions{
 		IsLight:    isLight,
 		Background: background,

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_matugen.go

@@ -0,0 +1,182 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/matugen"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
+	"github.com/spf13/cobra"
+)
+
+var matugenCmd = &cobra.Command{
+	Use:   "matugen",
+	Short: "Generate Material Design themes",
+	Long:  "Generate Material Design themes using matugen with dank16 color integration",
+}
+
+var matugenGenerateCmd = &cobra.Command{
+	Use:   "generate",
+	Short: "Generate theme synchronously",
+	Run:   runMatugenGenerate,
+}
+
+var matugenQueueCmd = &cobra.Command{
+	Use:   "queue",
+	Short: "Queue theme generation (uses socket if available)",
+	Run:   runMatugenQueue,
+}
+
+func init() {
+	matugenCmd.AddCommand(matugenGenerateCmd)
+	matugenCmd.AddCommand(matugenQueueCmd)
+
+	for _, cmd := range []*cobra.Command{matugenGenerateCmd, matugenQueueCmd} {
+		cmd.Flags().String("state-dir", "", "State directory for cache files")
+		cmd.Flags().String("shell-dir", "", "DMS shell installation directory")
+		cmd.Flags().String("config-dir", "", "User config directory")
+		cmd.Flags().String("kind", "image", "Source type: image or hex")
+		cmd.Flags().String("value", "", "Wallpaper path or hex color")
+		cmd.Flags().String("mode", "dark", "Color mode: dark or light")
+		cmd.Flags().String("icon-theme", "System Default", "Icon theme name")
+		cmd.Flags().String("matugen-type", "scheme-tonal-spot", "Matugen scheme type")
+		cmd.Flags().Bool("run-user-templates", true, "Run user matugen templates")
+		cmd.Flags().String("stock-colors", "", "Stock theme colors JSON")
+		cmd.Flags().Bool("sync-mode-with-portal", false, "Sync color scheme with GNOME portal")
+		cmd.Flags().Bool("terminals-always-dark", false, "Force terminal themes to dark variant")
+	}
+
+	matugenQueueCmd.Flags().Bool("wait", true, "Wait for completion")
+	matugenQueueCmd.Flags().Duration("timeout", 30*time.Second, "Timeout for waiting")
+}
+
+func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
+	stateDir, _ := cmd.Flags().GetString("state-dir")
+	shellDir, _ := cmd.Flags().GetString("shell-dir")
+	configDir, _ := cmd.Flags().GetString("config-dir")
+	kind, _ := cmd.Flags().GetString("kind")
+	value, _ := cmd.Flags().GetString("value")
+	mode, _ := cmd.Flags().GetString("mode")
+	iconTheme, _ := cmd.Flags().GetString("icon-theme")
+	matugenType, _ := cmd.Flags().GetString("matugen-type")
+	runUserTemplates, _ := cmd.Flags().GetBool("run-user-templates")
+	stockColors, _ := cmd.Flags().GetString("stock-colors")
+	syncModeWithPortal, _ := cmd.Flags().GetBool("sync-mode-with-portal")
+	terminalsAlwaysDark, _ := cmd.Flags().GetBool("terminals-always-dark")
+
+	return matugen.Options{
+		StateDir:            stateDir,
+		ShellDir:            shellDir,
+		ConfigDir:           configDir,
+		Kind:                kind,
+		Value:               value,
+		Mode:                mode,
+		IconTheme:           iconTheme,
+		MatugenType:         matugenType,
+		RunUserTemplates:    runUserTemplates,
+		StockColors:         stockColors,
+		SyncModeWithPortal:  syncModeWithPortal,
+		TerminalsAlwaysDark: terminalsAlwaysDark,
+	}
+}
+
+func runMatugenGenerate(cmd *cobra.Command, args []string) {
+	opts := buildMatugenOptions(cmd)
+	if err := matugen.Run(opts); err != nil {
+		log.Fatalf("Theme generation failed: %v", err)
+	}
+}
+
+func runMatugenQueue(cmd *cobra.Command, args []string) {
+	opts := buildMatugenOptions(cmd)
+	wait, _ := cmd.Flags().GetBool("wait")
+	timeout, _ := cmd.Flags().GetDuration("timeout")
+
+	socketPath := os.Getenv("DMS_SOCKET")
+	if socketPath == "" {
+		var err error
+		socketPath, err = server.FindSocket()
+		if err != nil {
+			log.Info("No socket available, running synchronously")
+			if err := matugen.Run(opts); err != nil {
+				log.Fatalf("Theme generation failed: %v", err)
+			}
+			return
+		}
+	}
+
+	conn, err := net.Dial("unix", socketPath)
+	if err != nil {
+		log.Info("Socket connection failed, running synchronously")
+		if err := matugen.Run(opts); err != nil {
+			log.Fatalf("Theme generation failed: %v", err)
+		}
+		return
+	}
+	defer conn.Close()
+
+	request := map[string]any{
+		"id":     1,
+		"method": "matugen.queue",
+		"params": map[string]any{
+			"stateDir":            opts.StateDir,
+			"shellDir":            opts.ShellDir,
+			"configDir":           opts.ConfigDir,
+			"kind":                opts.Kind,
+			"value":               opts.Value,
+			"mode":                opts.Mode,
+			"iconTheme":           opts.IconTheme,
+			"matugenType":         opts.MatugenType,
+			"runUserTemplates":    opts.RunUserTemplates,
+			"stockColors":         opts.StockColors,
+			"syncModeWithPortal":  opts.SyncModeWithPortal,
+			"terminalsAlwaysDark": opts.TerminalsAlwaysDark,
+			"wait":                wait,
+		},
+	}
+
+	if err := json.NewEncoder(conn).Encode(request); err != nil {
+		log.Fatalf("Failed to send request: %v", err)
+	}
+
+	if !wait {
+		fmt.Println("Theme generation queued")
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	resultCh := make(chan error, 1)
+	go func() {
+		var response struct {
+			ID     int    `json:"id"`
+			Result any    `json:"result"`
+			Error  string `json:"error"`
+		}
+		if err := json.NewDecoder(conn).Decode(&response); err != nil {
+			resultCh <- fmt.Errorf("failed to read response: %w", err)
+			return
+		}
+		if response.Error != "" {
+			resultCh <- fmt.Errorf("server error: %s", response.Error)
+			return
+		}
+		resultCh <- nil
+	}()
+
+	select {
+	case err := <-resultCh:
+		if err != nil {
+			log.Fatalf("Theme generation failed: %v", err)
+		}
+		fmt.Println("Theme generation completed")
+	case <-ctx.Done():
+		log.Fatalf("Timeout waiting for theme generation")
+	}
+}

core/cmd/dms/commands_screenshot.go

@@ -0,0 +1,414 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/screenshot"
+	"github.com/spf13/cobra"
+)
+
+var (
+	ssOutputName    string
+	ssIncludeCursor bool
+	ssFormat        string
+	ssQuality       int
+	ssOutputDir     string
+	ssFilename      string
+	ssNoClipboard   bool
+	ssNoFile        bool
+	ssNoNotify      bool
+	ssStdout        bool
+)
+
+var screenshotCmd = &cobra.Command{
+	Use:   "screenshot",
+	Short: "Capture screenshots",
+	Long: `Capture screenshots from Wayland displays.
+
+Modes:
+  region      - Select a region interactively (default)
+  full        - Capture the focused output
+  all         - Capture all outputs combined
+  output      - Capture a specific output by name
+  window      - Capture the focused window (Hyprland/DWL)
+  last        - Capture the last selected region
+
+Output format (--format):
+  png         - PNG format (default)
+  jpg/jpeg    - JPEG format
+  ppm         - PPM format
+
+Examples:
+  dms screenshot                     # Region select, save file + clipboard
+  dms screenshot full                # Full screen of focused output
+  dms screenshot all                 # All screens combined
+  dms screenshot output -o DP-1      # Specific output
+  dms screenshot window              # Focused window (Hyprland)
+  dms screenshot last                # Last region (pre-selected)
+  dms screenshot --no-clipboard      # Save file only
+  dms screenshot --no-file           # Clipboard only
+  dms screenshot --cursor            # Include cursor
+  dms screenshot -f jpg -q 85        # JPEG with quality 85`,
+}
+
+var ssRegionCmd = &cobra.Command{
+	Use:   "region",
+	Short: "Select a region interactively",
+	Run:   runScreenshotRegion,
+}
+
+var ssFullCmd = &cobra.Command{
+	Use:   "full",
+	Short: "Capture the focused output",
+	Run:   runScreenshotFull,
+}
+
+var ssAllCmd = &cobra.Command{
+	Use:   "all",
+	Short: "Capture all outputs combined",
+	Run:   runScreenshotAll,
+}
+
+var ssOutputCmd = &cobra.Command{
+	Use:   "output",
+	Short: "Capture a specific output",
+	Run:   runScreenshotOutput,
+}
+
+var ssLastCmd = &cobra.Command{
+	Use:   "last",
+	Short: "Capture the last selected region",
+	Long: `Capture the previously selected region without interactive selection.
+If no previous region exists, falls back to interactive selection.`,
+	Run: runScreenshotLast,
+}
+
+var ssWindowCmd = &cobra.Command{
+	Use:   "window",
+	Short: "Capture the focused window",
+	Long:  `Capture the currently focused window. Supported on Hyprland and DWL.`,
+	Run:   runScreenshotWindow,
+}
+
+var ssListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List available outputs",
+	Run:   runScreenshotList,
+}
+
+var notifyActionCmd = &cobra.Command{
+	Use:    "notify-action",
+	Hidden: true,
+	Run: func(cmd *cobra.Command, args []string) {
+		screenshot.RunNotifyActionListener(args)
+	},
+}
+
+func init() {
+	screenshotCmd.PersistentFlags().StringVarP(&ssOutputName, "output", "o", "", "Output name for 'output' mode")
+	screenshotCmd.PersistentFlags().BoolVar(&ssIncludeCursor, "cursor", false, "Include cursor in screenshot")
+	screenshotCmd.PersistentFlags().StringVarP(&ssFormat, "format", "f", "png", "Output format (png, jpg, ppm)")
+	screenshotCmd.PersistentFlags().IntVarP(&ssQuality, "quality", "q", 90, "JPEG quality (1-100)")
+	screenshotCmd.PersistentFlags().StringVarP(&ssOutputDir, "dir", "d", "", "Output directory")
+	screenshotCmd.PersistentFlags().StringVar(&ssFilename, "filename", "", "Output filename (auto-generated if empty)")
+	screenshotCmd.PersistentFlags().BoolVar(&ssNoClipboard, "no-clipboard", false, "Don't copy to clipboard")
+	screenshotCmd.PersistentFlags().BoolVar(&ssNoFile, "no-file", false, "Don't save to file")
+	screenshotCmd.PersistentFlags().BoolVar(&ssNoNotify, "no-notify", false, "Don't show notification")
+	screenshotCmd.PersistentFlags().BoolVar(&ssStdout, "stdout", false, "Output image to stdout (for piping to swappy, etc.)")
+
+	screenshotCmd.AddCommand(ssRegionCmd)
+	screenshotCmd.AddCommand(ssFullCmd)
+	screenshotCmd.AddCommand(ssAllCmd)
+	screenshotCmd.AddCommand(ssOutputCmd)
+	screenshotCmd.AddCommand(ssLastCmd)
+	screenshotCmd.AddCommand(ssWindowCmd)
+	screenshotCmd.AddCommand(ssListCmd)
+
+	screenshotCmd.Run = runScreenshotRegion
+}
+
+func getScreenshotConfig(mode screenshot.Mode) screenshot.Config {
+	config := screenshot.DefaultConfig()
+	config.Mode = mode
+	config.OutputName = ssOutputName
+	config.IncludeCursor = ssIncludeCursor
+	config.Clipboard = !ssNoClipboard
+	config.SaveFile = !ssNoFile
+	config.Notify = !ssNoNotify
+	config.Stdout = ssStdout
+
+	if ssOutputDir != "" {
+		config.OutputDir = ssOutputDir
+	}
+	if ssFilename != "" {
+		config.Filename = ssFilename
+	}
+
+	switch strings.ToLower(ssFormat) {
+	case "jpg", "jpeg":
+		config.Format = screenshot.FormatJPEG
+	case "ppm":
+		config.Format = screenshot.FormatPPM
+	default:
+		config.Format = screenshot.FormatPNG
+	}
+
+	if ssQuality < 1 {
+		ssQuality = 1
+	}
+	if ssQuality > 100 {
+		ssQuality = 100
+	}
+	config.Quality = ssQuality
+
+	return config
+}
+
+func runScreenshot(config screenshot.Config) {
+	sc := screenshot.New(config)
+	result, err := sc.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	if result == nil {
+		os.Exit(0)
+	}
+
+	defer result.Buffer.Close()
+
+	if result.YInverted {
+		result.Buffer.FlipVertical()
+	}
+
+	if config.Stdout {
+		if err := writeImageToStdout(result.Buffer, config.Format, config.Quality, result.Format); err != nil {
+			fmt.Fprintf(os.Stderr, "Error writing to stdout: %v\n", err)
+			os.Exit(1)
+		}
+		return
+	}
+
+	var filePath string
+
+	if config.SaveFile {
+		outputDir := config.OutputDir
+		if outputDir == "" {
+			outputDir = screenshot.GetOutputDir()
+		}
+
+		filename := config.Filename
+		if filename == "" {
+			filename = screenshot.GenerateFilename(config.Format)
+		}
+
+		filePath = filepath.Join(outputDir, filename)
+		if err := screenshot.WriteToFileWithFormat(result.Buffer, filePath, config.Format, config.Quality, result.Format); err != nil {
+			fmt.Fprintf(os.Stderr, "Error writing file: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Println(filePath)
+	}
+
+	if config.Clipboard {
+		if err := copyImageToClipboard(result.Buffer, config.Format, config.Quality, result.Format); err != nil {
+			fmt.Fprintf(os.Stderr, "Error copying to clipboard: %v\n", err)
+			os.Exit(1)
+		}
+		if !config.SaveFile {
+			fmt.Println("Copied to clipboard")
+		}
+	}
+
+	if config.Notify {
+		thumbData, thumbW, thumbH := bufferToRGBThumbnail(result.Buffer, 256, result.Format)
+		screenshot.SendNotification(screenshot.NotifyResult{
+			FilePath:  filePath,
+			Clipboard: config.Clipboard,
+			ImageData: thumbData,
+			Width:     thumbW,
+			Height:    thumbH,
+		})
+	}
+}
+
+func copyImageToClipboard(buf *screenshot.ShmBuffer, format screenshot.Format, quality int, pixelFormat uint32) error {
+	var mimeType string
+	var data bytes.Buffer
+
+	img := screenshot.BufferToImageWithFormat(buf, pixelFormat)
+
+	switch format {
+	case screenshot.FormatJPEG:
+		mimeType = "image/jpeg"
+		if err := screenshot.EncodeJPEG(&data, img, quality); err != nil {
+			return err
+		}
+	default:
+		mimeType = "image/png"
+		if err := screenshot.EncodePNG(&data, img); err != nil {
+			return err
+		}
+	}
+
+	cmd := exec.Command("wl-copy", "--type", mimeType)
+	cmd.Stdin = &data
+	return cmd.Run()
+}
+
+func writeImageToStdout(buf *screenshot.ShmBuffer, format screenshot.Format, quality int, pixelFormat uint32) error {
+	img := screenshot.BufferToImageWithFormat(buf, pixelFormat)
+
+	switch format {
+	case screenshot.FormatJPEG:
+		return screenshot.EncodeJPEG(os.Stdout, img, quality)
+	default:
+		return screenshot.EncodePNG(os.Stdout, img)
+	}
+}
+
+func bufferToRGBThumbnail(buf *screenshot.ShmBuffer, maxSize int, pixelFormat uint32) ([]byte, int, int) {
+	srcW, srcH := buf.Width, buf.Height
+	scale := 1.0
+	if srcW > maxSize || srcH > maxSize {
+		if srcW > srcH {
+			scale = float64(maxSize) / float64(srcW)
+		} else {
+			scale = float64(maxSize) / float64(srcH)
+		}
+	}
+
+	dstW := int(float64(srcW) * scale)
+	dstH := int(float64(srcH) * scale)
+	if dstW < 1 {
+		dstW = 1
+	}
+	if dstH < 1 {
+		dstH = 1
+	}
+
+	data := buf.Data()
+	rgb := make([]byte, dstW*dstH*3)
+
+	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)
+		if srcY >= srcH {
+			srcY = srcH - 1
+		}
+		for x := 0; x < dstW; x++ {
+			srcX := int(float64(x) / scale)
+			if srcX >= srcW {
+				srcX = srcW - 1
+			}
+			si := srcY*buf.Stride + srcX*4
+			di := (y*dstW + x) * 3
+			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]
+			}
+		}
+	}
+	return rgb, dstW, dstH
+}
+
+func runScreenshotRegion(cmd *cobra.Command, args []string) {
+	config := getScreenshotConfig(screenshot.ModeRegion)
+	runScreenshot(config)
+}
+
+func runScreenshotFull(cmd *cobra.Command, args []string) {
+	config := getScreenshotConfig(screenshot.ModeFullScreen)
+	runScreenshot(config)
+}
+
+func runScreenshotAll(cmd *cobra.Command, args []string) {
+	config := getScreenshotConfig(screenshot.ModeAllScreens)
+	runScreenshot(config)
+}
+
+func runScreenshotOutput(cmd *cobra.Command, args []string) {
+	if ssOutputName == "" && len(args) > 0 {
+		ssOutputName = args[0]
+	}
+	if ssOutputName == "" {
+		fmt.Fprintln(os.Stderr, "Error: output name required (use -o or provide as argument)")
+		os.Exit(1)
+	}
+	config := getScreenshotConfig(screenshot.ModeOutput)
+	runScreenshot(config)
+}
+
+func runScreenshotLast(cmd *cobra.Command, args []string) {
+	config := getScreenshotConfig(screenshot.ModeLastRegion)
+	runScreenshot(config)
+}
+
+func runScreenshotWindow(cmd *cobra.Command, args []string) {
+	config := getScreenshotConfig(screenshot.ModeWindow)
+	runScreenshot(config)
+}
+
+func runScreenshotList(cmd *cobra.Command, args []string) {
+	outputs, err := screenshot.ListOutputs()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	for _, o := range outputs {
+		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

@@ -16,7 +16,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
 )
 
-type ipcTargets map[string][]string
+type ipcTargets map[string]map[string][]string
 
 var isSessionManaged bool
 
@@ -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" {
@@ -476,28 +466,40 @@ func runShellDaemon(session bool) {
 }
 
 func parseTargetsFromIPCShowOutput(output string) ipcTargets {
-	targets := map[string][]string{}
+	targets := make(ipcTargets)
 	var currentTarget string
 	for _, line := range strings.Split(output, "\n") {
 		if strings.HasPrefix(line, "target ") {
 			currentTarget = strings.TrimSpace(strings.TrimPrefix(line, "target "))
+			targets[currentTarget] = make(map[string][]string)
 		}
 		if strings.HasPrefix(line, "  function") && currentTarget != "" {
+			argsList := []string{}
 			currentFunc := strings.TrimPrefix(line, "  function ")
-			currentFunc = strings.SplitN(currentFunc, "(", 2)[0]
-			targets[currentTarget] = append(targets[currentTarget], currentFunc)
+			funcDef := strings.SplitN(currentFunc, "(", 2)
+			argList := strings.SplitN(funcDef[1], ")", 2)[0]
+			args := strings.Split(argList, ",")
+			if len(args) > 0 && strings.TrimSpace(args[0]) != "" {
+				argsList = append(argsList, funcDef[0])
+				for _, arg := range args {
+					argName := strings.SplitN(strings.TrimSpace(arg), ":", 2)[0]
+					argsList = append(argsList, argName)
+				}
+				targets[currentTarget][funcDef[0]] = argsList
+			} else {
+				targets[currentTarget][funcDef[0]] = make([]string, 0)
+			}
 		}
 	}
 	return targets
 }
 
-func getShellIPCCompletions(args []string, toComplete string) []string {
+func getShellIPCCompletions(args []string, _ string) []string {
 	cmdArgs := []string{"-p", configPath, "ipc", "show"}
 	cmd := exec.Command("qs", cmdArgs...)
 	var targets ipcTargets
 
 	if output, err := cmd.Output(); err == nil {
-		log.Debugf("IPC show output: %s", string(output))
 		targets = parseTargetsFromIPCShowOutput(string(output))
 	} else {
 		log.Debugf("Error getting IPC show output for completions: %v", err)
@@ -516,8 +518,24 @@ func getShellIPCCompletions(args []string, toComplete string) []string {
 		}
 		return targetNames
 	}
+	if len(args) == 1 {
+		if targetFuncs, ok := targets[args[0]]; ok {
+			funcNames := make([]string, 0)
+			for k := range targetFuncs {
+				funcNames = append(funcNames, k)
+			}
+			return funcNames
+		}
+		return nil
+	}
+	if len(args) <= len(targets[args[0]]) {
+		funcArgs := targets[args[0]][args[1]]
+		if len(funcArgs) >= len(args) {
+			return []string{fmt.Sprintf("[%s]", funcArgs[len(args)-1])}
+		}
+	}
 
-	return targets[args[0]]
+	return nil
 }
 
 func runShellIPCCommand(args []string) {

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

@@ -2,7 +2,6 @@ package colorpicker
 
 import (
 	"fmt"
-	"math"
 	"sync"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
@@ -10,6 +9,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_layer_shell"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_screencopy"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wp_viewporter"
+	wlhelpers "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/client"
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 )
 
@@ -30,18 +30,23 @@ type Output struct {
 	height          int32
 	scale           int32
 	fractionalScale float64
+	transform       int32
 }
 
 type LayerSurface struct {
-	output     *Output
-	state      *SurfaceState
-	wlSurface  *client.Surface
-	layerSurf  *wlr_layer_shell.ZwlrLayerSurfaceV1
-	viewport   *wp_viewporter.WpViewport
-	wlPool     *client.ShmPool
-	wlBuffer   *client.Buffer
-	configured bool
-	hidden     bool
+	output      *Output
+	state       *SurfaceState
+	wlSurface   *client.Surface
+	layerSurf   *wlr_layer_shell.ZwlrLayerSurfaceV1
+	viewport    *wp_viewporter.WpViewport
+	wlPool      *client.ShmPool
+	wlBuffer    *client.Buffer
+	bufferBusy  bool
+	oldPool     *client.ShmPool
+	oldBuffer   *client.Buffer
+	scopyBuffer *client.Buffer
+	configured  bool
+	hidden      bool
 }
 
 type Picker struct {
@@ -111,6 +116,11 @@ func (p *Picker) Run() (*Color, error) {
 		return nil, fmt.Errorf("roundtrip: %w", err)
 	}
 
+	// Extra roundtrip to ensure pointer/keyboard from seat capabilities are registered
+	if err := p.roundtrip(); err != nil {
+		return nil, fmt.Errorf("roundtrip after seat: %w", err)
+	}
+
 	if err := p.createSurfaces(); err != nil {
 		return nil, fmt.Errorf("create surfaces: %w", err)
 	}
@@ -165,26 +175,7 @@ func (p *Picker) connect() error {
 }
 
 func (p *Picker) roundtrip() error {
-	callback, err := p.display.Sync()
-	if err != nil {
-		return err
-	}
-
-	done := make(chan struct{})
-	callback.SetDoneHandler(func(e client.CallbackDoneEvent) {
-		close(done)
-	})
-
-	for {
-		select {
-		case <-done:
-			return nil
-		default:
-			if err := p.ctx.Dispatch(); err != nil {
-				return err
-			}
-		}
-	}
+	return wlhelpers.Roundtrip(p.display, p.ctx)
 }
 
 func (p *Picker) setupRegistry() error {
@@ -286,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()
 	})
@@ -419,15 +411,10 @@ func (p *Picker) createLayerSurface(output *Output) (*LayerSurface, error) {
 
 func (p *Picker) computeSurfaceScale(ls *LayerSurface) int32 {
 	out := ls.output
-	if out == nil || out.fractionalScale <= 0 {
+	if out == nil || out.scale <= 0 {
 		return 1
 	}
-
-	scale := int32(math.Ceil(out.fractionalScale))
-	if scale <= 0 {
-		scale = 1
-	}
-	return scale
+	return out.scale
 }
 
 func (p *Picker) ensureShortcutsInhibitor(ls *LayerSurface) {
@@ -481,6 +468,12 @@ func (p *Picker) captureForSurface(ls *LayerSurface) {
 			return
 		}
 
+		if ls.scopyBuffer != nil {
+			ls.scopyBuffer.Destroy()
+		}
+		ls.scopyBuffer = wlBuffer
+		wlBuffer.SetReleaseHandler(func(e client.BufferReleaseEvent) {})
+
 		if err := frame.Copy(wlBuffer); err != nil {
 			log.Error("failed to copy frame", "err", err)
 		}
@@ -493,6 +486,24 @@ func (p *Picker) captureForSurface(ls *LayerSurface) {
 
 	frame.SetReadyHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1ReadyEvent) {
 		ls.state.OnScreencopyReady()
+
+		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)
+		}
+
 		scale := p.computeSurfaceScale(ls)
 		ls.state.SetScale(scale)
 		frame.Destroy()
@@ -507,7 +518,6 @@ func (p *Picker) captureForSurface(ls *LayerSurface) {
 func (p *Picker) redrawSurface(ls *LayerSurface) {
 	var renderBuf *ShmBuffer
 	if ls.hidden {
-		// When hidden, just show the screenshot without overlay
 		renderBuf = ls.state.RedrawScreenOnly()
 	} else {
 		renderBuf = ls.state.Redraw()
@@ -516,65 +526,58 @@ func (p *Picker) redrawSurface(ls *LayerSurface) {
 		return
 	}
 
-	if ls.wlPool != nil {
-		ls.wlPool.Destroy()
-		ls.wlPool = nil
+	if ls.oldBuffer != nil {
+		ls.oldBuffer.Destroy()
+		ls.oldBuffer = nil
 	}
-	if ls.wlBuffer != nil {
-		ls.wlBuffer.Destroy()
-		ls.wlBuffer = nil
+	if ls.oldPool != nil {
+		ls.oldPool.Destroy()
+		ls.oldPool = nil
 	}
 
+	ls.oldPool = ls.wlPool
+	ls.oldBuffer = ls.wlBuffer
+	ls.wlPool = nil
+	ls.wlBuffer = nil
+
 	pool, err := p.shm.CreatePool(renderBuf.Fd(), int32(renderBuf.Size()))
 	if err != nil {
 		return
 	}
 	ls.wlPool = pool
 
-	wlBuffer, err := pool.CreateBuffer(0, int32(renderBuf.Width), int32(renderBuf.Height), int32(renderBuf.Stride), uint32(FormatARGB8888))
+	wlBuffer, err := pool.CreateBuffer(0, int32(renderBuf.Width), int32(renderBuf.Height), int32(renderBuf.Stride), uint32(ls.state.ScreenFormat()))
 	if err != nil {
 		return
 	}
 	ls.wlBuffer = wlBuffer
 
+	lsRef := ls
+	wlBuffer.SetReleaseHandler(func(e client.BufferReleaseEvent) {
+		lsRef.bufferBusy = false
+	})
+	ls.bufferBusy = true
+
 	logicalW, logicalH := ls.state.LogicalSize()
 	if logicalW == 0 || logicalH == 0 {
 		logicalW = int(ls.output.width)
 		logicalH = int(ls.output.height)
 	}
 
-	scale := ls.state.Scale()
-	if scale <= 0 {
-		scale = 1
-	}
-
 	if ls.viewport != nil {
-		srcW := float64(renderBuf.Width) / float64(scale)
-		srcH := float64(renderBuf.Height) / float64(scale)
-		if err := ls.viewport.SetSource(0, 0, srcW, srcH); err != nil {
-			log.Warn("failed to set viewport source", "err", err)
-		}
-		if err := ls.viewport.SetDestination(int32(logicalW), int32(logicalH)); err != nil {
-			log.Warn("failed to set viewport destination", "err", err)
-		}
-		if err := ls.wlSurface.SetBufferScale(scale); err != nil {
-			log.Warn("failed to set buffer scale", "err", err)
-		}
+		_ = ls.wlSurface.SetBufferScale(1)
+		_ = ls.viewport.SetSource(0, 0, float64(renderBuf.Width), float64(renderBuf.Height))
+		_ = ls.viewport.SetDestination(int32(logicalW), int32(logicalH))
 	} else {
-		if err := ls.wlSurface.SetBufferScale(scale); err != nil {
-			log.Warn("failed to set buffer scale", "err", err)
+		bufferScale := ls.output.scale
+		if bufferScale <= 0 {
+			bufferScale = 1
 		}
+		_ = ls.wlSurface.SetBufferScale(bufferScale)
 	}
-
-	if err := ls.wlSurface.Attach(wlBuffer, 0, 0); err != nil {
-		log.Warn("failed to attach buffer", "err", err)
-	}
-	if err := ls.wlSurface.Damage(0, 0, int32(logicalW), int32(logicalH)); err != nil {
-		log.Warn("failed to damage surface", "err", err)
-	}
-	if err := ls.wlSurface.Commit(); err != nil {
-		log.Warn("failed to commit surface", "err", err)
-	}
+	_ = ls.wlSurface.Attach(wlBuffer, 0, 0)
+	_ = ls.wlSurface.Damage(0, 0, int32(logicalW), int32(logicalH))
+	_ = ls.wlSurface.Commit()
 
 	ls.state.SwapBuffers()
 }
@@ -596,17 +599,19 @@ func (p *Picker) setupInput() {
 	p.seat.SetCapabilitiesHandler(func(e client.SeatCapabilitiesEvent) {
 		if e.Capabilities&uint32(client.SeatCapabilityPointer) != 0 && p.pointer == nil {
 			pointer, err := p.seat.GetPointer()
-			if err == nil {
-				p.pointer = pointer
-				p.setupPointerHandlers()
+			if err != nil {
+				return
 			}
+			p.pointer = pointer
+			p.setupPointerHandlers()
 		}
 		if e.Capabilities&uint32(client.SeatCapabilityKeyboard) != 0 && p.keyboard == nil {
 			keyboard, err := p.seat.GetKeyboard()
-			if err == nil {
-				p.keyboard = keyboard
-				p.setupKeyboardHandlers()
+			if err != nil {
+				return
 			}
+			p.keyboard = keyboard
+			p.setupKeyboardHandlers()
 		}
 	})
 }
@@ -617,9 +622,14 @@ func (p *Picker) setupPointerHandlers() {
 			log.Debug("failed to hide cursor", "err", err)
 		}
 
+		if e.Surface == nil {
+			return
+		}
+
 		p.activeSurface = nil
+		surfaceID := e.Surface.ID()
 		for _, ls := range p.surfaces {
-			if ls.wlSurface.ID() == e.Surface.ID() {
+			if ls.wlSurface.ID() == surfaceID {
 				p.activeSurface = ls
 				break
 			}
@@ -628,7 +638,6 @@ func (p *Picker) setupPointerHandlers() {
 			return
 		}
 
-		// If surface was hidden, mark it as visible again
 		if p.activeSurface.hidden {
 			p.activeSurface.hidden = false
 		}
@@ -638,8 +647,12 @@ func (p *Picker) setupPointerHandlers() {
 	})
 
 	p.pointer.SetLeaveHandler(func(e client.PointerLeaveEvent) {
+		if e.Surface == nil {
+			return
+		}
+		surfaceID := e.Surface.ID()
 		for _, ls := range p.surfaces {
-			if ls.wlSurface.ID() == e.Surface.ID() {
+			if ls.wlSurface.ID() == surfaceID {
 				p.hideSurface(ls)
 				break
 			}
@@ -672,6 +685,15 @@ func (p *Picker) setupKeyboardHandlers() {
 
 func (p *Picker) cleanup() {
 	for _, ls := range p.surfaces {
+		if ls.scopyBuffer != nil {
+			ls.scopyBuffer.Destroy()
+		}
+		if ls.oldBuffer != nil {
+			ls.oldBuffer.Destroy()
+		}
+		if ls.oldPool != nil {
+			ls.oldPool.Destroy()
+		}
 		if ls.wlBuffer != nil {
 			ls.wlBuffer.Destroy()
 		}

core/internal/colorpicker/shm.go

@@ -1,93 +1,55 @@
 package colorpicker
 
-import (
-	"fmt"
+import "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/shm"
 
-	"golang.org/x/sys/unix"
+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
 )
 
-type ShmBuffer struct {
-	fd     int
-	data   []byte
-	size   int
-	Width  int
-	Height int
-	Stride int
-}
-
 func CreateShmBuffer(width, height, stride int) (*ShmBuffer, error) {
-	size := stride * height
-
-	fd, err := unix.MemfdCreate("dms-colorpicker", 0)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create memfd: %w", err)
-	}
-
-	if err := unix.Ftruncate(fd, int64(size)); err != nil {
-		unix.Close(fd)
-		return nil, fmt.Errorf("ftruncate failed: %w", err)
-	}
-
-	data, err := unix.Mmap(fd, 0, size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED)
-	if err != nil {
-		unix.Close(fd)
-		return nil, fmt.Errorf("mmap failed: %w", err)
-	}
-
-	return &ShmBuffer{
-		fd:     fd,
-		data:   data,
-		size:   size,
-		Width:  width,
-		Height: height,
-		Stride: stride,
-	}, nil
+	return shm.CreateBuffer(width, height, stride)
 }
 
-func (s *ShmBuffer) Fd() int {
-	return s.fd
+func InverseTransform(transform int32) int32 {
+	return shm.InverseTransform(transform)
 }
 
-func (s *ShmBuffer) Size() int {
-	return s.size
+func GetPixelColor(buf *ShmBuffer, x, y int) Color {
+	return GetPixelColorWithFormat(buf, x, y, FormatARGB8888)
 }
 
-func (s *ShmBuffer) Data() []byte {
-	return s.data
-}
-
-func (s *ShmBuffer) GetPixel(x, y int) Color {
-	if x < 0 || x >= s.Width || y < 0 || y >= s.Height {
+func GetPixelColorWithFormat(buf *ShmBuffer, x, y int, format PixelFormat) Color {
+	if x < 0 || x >= buf.Width || y < 0 || y >= buf.Height {
 		return Color{}
 	}
 
-	offset := y*s.Stride + x*4
-
-	if offset+3 >= len(s.data) {
+	data := buf.Data()
+	offset := y*buf.Stride + x*4
+	if offset+3 >= len(data) {
 		return Color{}
 	}
 
+	if format == FormatABGR8888 || format == FormatXBGR8888 {
+		return Color{
+			R: data[offset],
+			G: data[offset+1],
+			B: data[offset+2],
+			A: data[offset+3],
+		}
+	}
 	return Color{
-		B: s.data[offset],
-		G: s.data[offset+1],
-		R: s.data[offset+2],
-		A: s.data[offset+3],
+		B: data[offset],
+		G: data[offset+1],
+		R: data[offset+2],
+		A: data[offset+3],
 	}
 }
-
-func (s *ShmBuffer) Close() error {
-	var firstErr error
-	if s.data != nil {
-		if err := unix.Munmap(s.data); err != nil && firstErr == nil {
-			firstErr = fmt.Errorf("munmap failed: %w", err)
-		}
-		s.data = nil
-	}
-	if s.fd >= 0 {
-		if err := unix.Close(s.fd); err != nil && firstErr == nil {
-			firstErr = fmt.Errorf("close fd failed: %w", err)
-		}
-		s.fd = -1
-	}
-	return firstErr
-}

core/internal/colorpicker/state.go

@@ -1,18 +1,23 @@
 package colorpicker
 
 import (
+	"fmt"
 	"math"
 	"strings"
 	"sync"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/shm"
 )
 
-type PixelFormat uint32
+type PixelFormat = shm.PixelFormat
 
 const (
-	FormatARGB8888 PixelFormat = 0
-	FormatXRGB8888 PixelFormat = 1
-	FormatABGR8888 PixelFormat = 0x34324241
-	FormatXBGR8888 PixelFormat = 0x34324258
+	FormatARGB8888 = shm.FormatARGB8888
+	FormatXRGB8888 = shm.FormatXRGB8888
+	FormatABGR8888 = shm.FormatABGR8888
+	FormatXBGR8888 = shm.FormatXBGR8888
+	FormatRGB888   = shm.FormatRGB888
+	FormatBGR888   = shm.FormatBGR888
 )
 
 type SurfaceState struct {
@@ -77,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
@@ -88,6 +98,7 @@ func (s *SurfaceState) OnScreencopyBuffer(format PixelFormat, width, height, str
 	}
 
 	s.screenBuf = buf
+	s.screenBuf.Format = format
 	s.screenFormat = format
 	return nil
 }
@@ -98,6 +109,26 @@ func (s *SurfaceState) ScreenBuffer() *ShmBuffer {
 	return s.screenBuf
 }
 
+func (s *SurfaceState) ScreenFormat() PixelFormat {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	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
@@ -112,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
@@ -253,7 +293,7 @@ func (s *SurfaceState) Redraw() *ShmBuffer {
 		return nil
 	}
 
-	copy(dst.data, s.screenBuf.data)
+	dst.CopyFrom(s.screenBuf)
 
 	px := int(math.Round(float64(s.pointerX) * s.scaleX))
 	py := int(math.Round(float64(s.pointerY) * s.scaleY))
@@ -261,15 +301,20 @@ func (s *SurfaceState) Redraw() *ShmBuffer {
 	px = clamp(px, 0, dst.Width-1)
 	py = clamp(py, 0, dst.Height-1)
 
-	picked := s.screenBuf.GetPixel(px, py)
+	sampleY := py
+	if s.yInverted {
+		sampleY = s.screenBuf.Height - 1 - py
+	}
 
-	drawMagnifier(
-		dst.data, dst.Stride, dst.Width, dst.Height,
-		s.screenBuf.data, s.screenBuf.Stride, s.screenBuf.Width, s.screenBuf.Height,
-		px, py, picked,
+	picked := GetPixelColorWithFormat(s.screenBuf, px, sampleY, s.screenFormat)
+
+	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, 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
 }
@@ -289,7 +334,7 @@ func (s *SurfaceState) RedrawScreenOnly() *ShmBuffer {
 		return nil
 	}
 
-	copy(dst.data, s.screenBuf.data)
+	dst.CopyFrom(s.screenBuf)
 	return dst
 }
 
@@ -311,7 +356,7 @@ func (s *SurfaceState) PickColor() (Color, bool) {
 		sy = s.screenBuf.Height - 1 - sy
 	}
 
-	return s.screenBuf.GetPixel(sx, sy), true
+	return GetPixelColorWithFormat(s.screenBuf, sx, sy, s.screenFormat), true
 }
 
 func (s *SurfaceState) Destroy() {
@@ -371,11 +416,13 @@ func blendColors(bg, fg Color, alpha float64) Color {
 	}
 }
 
-func drawMagnifier(
+func drawMagnifierWithInversion(
 	dst []byte, dstStride, dstW, dstH int,
 	src []byte, srcStride, srcW, srcH int,
 	cx, cy int,
 	borderColor Color,
+	yInverted bool,
+	format PixelFormat,
 ) {
 	if dstW <= 0 || dstH <= 0 || srcW <= 0 || srcH <= 0 {
 		return
@@ -393,6 +440,14 @@ func drawMagnifier(
 	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 {
@@ -417,9 +472,9 @@ func drawMagnifier(
 			}
 
 			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],
 			}
 
@@ -431,10 +486,11 @@ func drawMagnifier(
 				finalColor = blendColors(bgColor, borderColor, alpha)
 
 			case dist > innerRadius:
-				if dist > outerRadiusF-aaWidth {
+				switch {
+				case dist > outerRadiusF-aaWidth:
 					alpha := clampF((outerRadiusF-dist)/aaWidth, 0, 1)
 					finalColor = blendColors(borderColor, borderColor, alpha)
-				} else if dist < innerRadius+aaWidth {
+				case dist < innerRadius+aaWidth:
 					alpha := clampF((dist-innerRadius)/aaWidth, 0, 1)
 					fx := float64(dx) / zoom
 					fy := float64(dy) / zoom
@@ -442,14 +498,17 @@ func drawMagnifier(
 					sy := cy + int(math.Round(fy))
 					sx = clamp(sx, 0, srcW-1)
 					sy = clamp(sy, 0, srcH-1)
+					if yInverted {
+						sy = srcH - 1 - sy
+					}
 					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
 					}
-				} else {
+				default:
 					finalColor = borderColor
 				}
 
@@ -460,26 +519,30 @@ func drawMagnifier(
 				sy := cy + int(math.Round(fy))
 				sx = clamp(sx, 0, srcW-1)
 				sy = clamp(sy, 0, srcH-1)
+				if yInverted {
+					sy = srcH - 1 - sy
+				}
 				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
@@ -977,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
@@ -1012,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 {
@@ -1022,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 {
@@ -1043,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
 	}
@@ -1052,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++ {
@@ -1059,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 {
@@ -1102,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/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,8 +119,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 	return results, nil
 }
 
-// deployNiriConfig handles Niri configuration deployment with backup and merging
-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"),
@@ -123,6 +131,12 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 		return result, result.Error
 	}
 
+	dmsDir := filepath.Join(configDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0755); err != nil {
+		result.Error = fmt.Errorf("failed to create dms directory: %w", err)
+		return result, result.Error
+	}
+
 	var existingConfig string
 	if _, err := os.Stat(result.Path); err == nil {
 		cd.log("Found existing Niri configuration")
@@ -143,14 +157,6 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 		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:
@@ -160,13 +166,15 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 	case deps.TerminalAlacritty:
 		terminalCommand = "alacritty"
 	default:
-		terminalCommand = "ghostty" // fallback to ghostty
+		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 there was an existing config, merge the output sections
 	if existingConfig != "" {
 		mergedConfig, err := cd.mergeNiriOutputSections(newConfig, existingConfig)
 		if err != nil {
@@ -182,11 +190,38 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (DeploymentRe
 		return result, result.Error
 	}
 
+	if err := cd.deployNiriDmsConfigs(dmsDir, terminalCommand); err != nil {
+		result.Error = fmt.Errorf("failed to deploy dms configs: %w", err)
+		return result, result.Error
+	}
+
 	result.Deployed = true
 	cd.log("Successfully deployed Niri configuration")
 	return result, nil
 }
 
+func (cd *ConfigDeployer) deployNiriDmsConfigs(dmsDir, terminalCommand string) error {
+	configs := []struct {
+		name    string
+		content string
+	}{
+		{"colors.kdl", NiriColorsConfig},
+		{"layout.kdl", NiriLayoutConfig},
+		{"alttab.kdl", NiriAlttabConfig},
+		{"binds.kdl", strings.ReplaceAll(NiriBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
+	}
+
+	for _, cfg := range configs {
+		path := filepath.Join(dmsDir, cfg.name)
+		if err := os.WriteFile(path, []byte(cfg.content), 0644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", cfg.name, err)
+		}
+		cd.log(fmt.Sprintf("Deployed %s", cfg.name))
+	}
+
+	return nil
+}
+
 func (cd *ConfigDeployer) deployGhosttyConfig() ([]DeploymentResult, error) {
 	var results []DeploymentResult
 
@@ -375,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)
@@ -453,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"),
@@ -485,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:
@@ -502,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 {
@@ -531,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)
 
@@ -556,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])
@@ -572,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)
@@ -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)
@@ -479,21 +450,17 @@ general {
 func TestNiriConfigStructure(t *testing.T) {
 	assert.Contains(t, NiriConfig, "input {")
 	assert.Contains(t, NiriConfig, "layout {")
-	assert.Contains(t, NiriConfig, "binds {")
-	assert.Contains(t, NiriConfig, "{{POLKIT_AGENT_PATH}}")
-	assert.Contains(t, NiriConfig, `spawn "{{TERMINAL_COMMAND}}"`)
+
+	assert.Contains(t, NiriBindsConfig, "binds {")
+	assert.Contains(t, NiriBindsConfig, `spawn "{{TERMINAL_COMMAND}}"`)
 }
 
 func TestHyprlandConfigStructure(t *testing.T) {
 	assert.Contains(t, HyprlandConfig, "# MONITOR CONFIG")
-	assert.Contains(t, HyprlandConfig, "# ENVIRONMENT VARS")
 	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, "{{TERMINAL_COMMAND}}")
-	assert.Contains(t, HyprlandConfig, "exec-once = dms run")
-	assert.Contains(t, HyprlandConfig, "bind = $mod, T, exec,")
+	assert.Contains(t, HyprlandConfig, "bind = $mod, T, exec, {{TERMINAL_COMMAND}}")
 	assert.Contains(t, HyprlandConfig, "bind = $mod, space, exec, dms ipc call spotlight toggle")
 	assert.Contains(t, HyprlandConfig, "windowrulev2 = noborder, class:^(com\\.mitchellh\\.ghostty)$")
 }

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

@@ -7,21 +7,12 @@
 # monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
 monitor = , preferred,auto,auto
 
-# ==================
-# ENVIRONMENT VARS
-# ==================
-env = QT_QPA_PLATFORM,wayland
-env = ELECTRON_OZONE_PLATFORM_HINT,auto
-env = QT_QPA_PLATFORMTHEME,gtk3
-env = QT_QPA_PLATFORMTHEME_QT6,gtk3
-env = TERMINAL,{{TERMINAL_COMMAND}}
-
 # ==================
 # 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 = dms run
-exec-once = {{POLKIT_AGENT_PATH}}
 
 # ==================
 # INPUT CONFIG
@@ -281,12 +272,9 @@ binde = $mod SHIFT, minus, resizeactive, 0 -10%
 binde = $mod SHIFT, equal, resizeactive, 0 10%
 
 # === Screenshots ===
-bind = , XF86Launch1, exec, grimblast copy area
-bind = CTRL, XF86Launch1, exec, grimblast copy screen
-bind = ALT, XF86Launch1, exec, grimblast copy active
-bind = , Print, exec, grimblast copy area
-bind = CTRL, Print, exec, grimblast copy screen
-bind = ALT, Print, exec, grimblast copy active
+bind = , Print, exec, dms screenshot
+bind = CTRL, Print, exec, dms screenshot full
+bind = ALT, Print, exec, dms screenshot window
 
 # === System Controls ===
 bind = $mod SHIFT, P, dpms, off

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

@@ -0,0 +1,5 @@
+recent-windows {
+    highlight {
+        corner-radius 12
+    }
+}

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

@@ -0,0 +1,195 @@
+binds {
+    // === System & Overview ===
+    Mod+D repeat=false { toggle-overview; }
+    Mod+Tab repeat=false { toggle-overview; }
+    Mod+Shift+Slash { show-hotkey-overlay; }
+
+    // === Application Launchers ===
+    Mod+T hotkey-overlay-title="Open Terminal" { spawn "{{TERMINAL_COMMAND}}"; }
+    Mod+Space hotkey-overlay-title="Application Launcher" {
+        spawn "dms" "ipc" "call" "spotlight" "toggle";
+    }
+    Mod+V hotkey-overlay-title="Clipboard Manager" {
+        spawn "dms" "ipc" "call" "clipboard" "toggle";
+    }
+    Mod+M hotkey-overlay-title="Task Manager" {
+        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
+    }
+    Mod+Comma hotkey-overlay-title="Settings" {
+        spawn "dms" "ipc" "call" "settings" "focusOrToggle";
+    }
+    Mod+Y hotkey-overlay-title="Browse Wallpapers" {
+        spawn "dms" "ipc" "call" "dankdash" "wallpaper";
+    }
+    Mod+N hotkey-overlay-title="Notification Center" { spawn "dms" "ipc" "call" "notifications" "toggle"; }
+    Mod+Shift+N hotkey-overlay-title="Notepad" { spawn "dms" "ipc" "call" "notepad" "toggle"; }
+
+    // === Security ===
+    Mod+Alt+L hotkey-overlay-title="Lock Screen" {
+        spawn "dms" "ipc" "call" "lock" "lock";
+    }
+    Mod+Shift+E { quit; }
+    Ctrl+Alt+Delete hotkey-overlay-title="Task Manager" {
+        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
+    }
+
+    // === Audio Controls ===
+    XF86AudioRaiseVolume allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "increment" "3";
+    }
+    XF86AudioLowerVolume allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "decrement" "3";
+    }
+    XF86AudioMute allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "mute";
+    }
+    XF86AudioMicMute allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "micmute";
+    }
+
+    // === Brightness Controls ===
+    XF86MonBrightnessUp allow-when-locked=true {
+       spawn "dms" "ipc" "call" "brightness" "increment" "5" "";
+    }
+    XF86MonBrightnessDown allow-when-locked=true {
+       spawn "dms" "ipc" "call" "brightness" "decrement" "5" "";
+    }
+
+    // === Window Management ===
+    Mod+Q repeat=false { close-window; }
+    Mod+F { maximize-column; }
+    Mod+Shift+F { fullscreen-window; }
+    Mod+Shift+T { toggle-window-floating; }
+    Mod+Shift+V { switch-focus-between-floating-and-tiling; }
+    Mod+W { toggle-column-tabbed-display; }
+
+    // === Focus Navigation ===
+    Mod+Left  { focus-column-left; }
+    Mod+Down  { focus-window-down; }
+    Mod+Up    { focus-window-up; }
+    Mod+Right { focus-column-right; }
+    Mod+H     { focus-column-left; }
+    Mod+J     { focus-window-down; }
+    Mod+K     { focus-window-up; }
+    Mod+L     { focus-column-right; }
+
+    // === Window Movement ===
+    Mod+Shift+Left  { move-column-left; }
+    Mod+Shift+Down  { move-window-down; }
+    Mod+Shift+Up    { move-window-up; }
+    Mod+Shift+Right { move-column-right; }
+    Mod+Shift+H     { move-column-left; }
+    Mod+Shift+J     { move-window-down; }
+    Mod+Shift+K     { move-window-up; }
+    Mod+Shift+L     { move-column-right; }
+
+    // === Column Navigation ===
+    Mod+Home { focus-column-first; }
+    Mod+End  { focus-column-last; }
+    Mod+Ctrl+Home { move-column-to-first; }
+    Mod+Ctrl+End  { move-column-to-last; }
+
+    // === Monitor Navigation ===
+    Mod+Ctrl+Left  { focus-monitor-left; }
+    //Mod+Ctrl+Down  { focus-monitor-down; }
+    //Mod+Ctrl+Up    { focus-monitor-up; }
+    Mod+Ctrl+Right { focus-monitor-right; }
+    Mod+Ctrl+H     { focus-monitor-left; }
+    Mod+Ctrl+J     { focus-monitor-down; }
+    Mod+Ctrl+K     { focus-monitor-up; }
+    Mod+Ctrl+L     { focus-monitor-right; }
+
+    // === Move to Monitor ===
+    Mod+Shift+Ctrl+Left  { move-column-to-monitor-left; }
+    Mod+Shift+Ctrl+Down  { move-column-to-monitor-down; }
+    Mod+Shift+Ctrl+Up    { move-column-to-monitor-up; }
+    Mod+Shift+Ctrl+Right { move-column-to-monitor-right; }
+    Mod+Shift+Ctrl+H     { move-column-to-monitor-left; }
+    Mod+Shift+Ctrl+J     { move-column-to-monitor-down; }
+    Mod+Shift+Ctrl+K     { move-column-to-monitor-up; }
+    Mod+Shift+Ctrl+L     { move-column-to-monitor-right; }
+
+    // === Workspace Navigation ===
+    Mod+Page_Down      { focus-workspace-down; }
+    Mod+Page_Up        { focus-workspace-up; }
+    Mod+U              { focus-workspace-down; }
+    Mod+I              { focus-workspace-up; }
+    Mod+Ctrl+Down { move-column-to-workspace-down; }
+    Mod+Ctrl+Up   { move-column-to-workspace-up; }
+    Mod+Ctrl+U         { move-column-to-workspace-down; }
+    Mod+Ctrl+I         { move-column-to-workspace-up; }
+
+    // === Move Workspaces ===
+    Mod+Shift+Page_Down { move-workspace-down; }
+    Mod+Shift+Page_Up   { move-workspace-up; }
+    Mod+Shift+U         { move-workspace-down; }
+    Mod+Shift+I         { move-workspace-up; }
+
+    // === Mouse Wheel Navigation ===
+    Mod+WheelScrollDown      cooldown-ms=150 { focus-workspace-down; }
+    Mod+WheelScrollUp        cooldown-ms=150 { focus-workspace-up; }
+    Mod+Ctrl+WheelScrollDown cooldown-ms=150 { move-column-to-workspace-down; }
+    Mod+Ctrl+WheelScrollUp   cooldown-ms=150 { move-column-to-workspace-up; }
+
+    Mod+WheelScrollRight      { focus-column-right; }
+    Mod+WheelScrollLeft       { focus-column-left; }
+    Mod+Ctrl+WheelScrollRight { move-column-right; }
+    Mod+Ctrl+WheelScrollLeft  { move-column-left; }
+
+    Mod+Shift+WheelScrollDown      { focus-column-right; }
+    Mod+Shift+WheelScrollUp        { focus-column-left; }
+    Mod+Ctrl+Shift+WheelScrollDown { move-column-right; }
+    Mod+Ctrl+Shift+WheelScrollUp   { move-column-left; }
+
+    // === Numbered Workspaces ===
+    Mod+1 { focus-workspace 1; }
+    Mod+2 { focus-workspace 2; }
+    Mod+3 { focus-workspace 3; }
+    Mod+4 { focus-workspace 4; }
+    Mod+5 { focus-workspace 5; }
+    Mod+6 { focus-workspace 6; }
+    Mod+7 { focus-workspace 7; }
+    Mod+8 { focus-workspace 8; }
+    Mod+9 { focus-workspace 9; }
+
+    // === Move to Numbered Workspaces ===
+    Mod+Shift+1 { move-column-to-workspace 1; }
+    Mod+Shift+2 { move-column-to-workspace 2; }
+    Mod+Shift+3 { move-column-to-workspace 3; }
+    Mod+Shift+4 { move-column-to-workspace 4; }
+    Mod+Shift+5 { move-column-to-workspace 5; }
+    Mod+Shift+6 { move-column-to-workspace 6; }
+    Mod+Shift+7 { move-column-to-workspace 7; }
+    Mod+Shift+8 { move-column-to-workspace 8; }
+    Mod+Shift+9 { move-column-to-workspace 9; }
+
+    // === Column Management ===
+    Mod+BracketLeft  { consume-or-expel-window-left; }
+    Mod+BracketRight { consume-or-expel-window-right; }
+    Mod+Period { expel-window-from-column; }
+
+    // === Sizing & Layout ===
+    Mod+R { switch-preset-column-width; }
+    Mod+Shift+R { switch-preset-window-height; }
+    Mod+Ctrl+R { reset-window-height; }
+    Mod+Ctrl+F { expand-column-to-available-width; }
+    Mod+C { center-column; }
+    Mod+Ctrl+C { center-visible-columns; }
+
+    // === Manual Sizing ===
+    Mod+Minus { set-column-width "-10%"; }
+    Mod+Equal { set-column-width "+10%"; }
+    Mod+Shift+Minus { set-window-height "-10%"; }
+    Mod+Shift+Equal { set-window-height "+10%"; }
+
+    // === Screenshots ===
+    XF86Launch1 { screenshot; }
+    Ctrl+XF86Launch1 { screenshot-screen; }
+    Alt+XF86Launch1 { screenshot-window; }
+    Print { screenshot; }
+    Ctrl+Print { screenshot-screen; }
+    Alt+Print { screenshot-window; }
+    // === System Controls ===
+    Mod+Escape allow-inhibiting=false { toggle-keyboard-shortcuts-inhibit; }
+    Mod+Shift+P { power-off-monitors; }
+}

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

@@ -0,0 +1,36 @@
+layout {
+    background-color "transparent"
+
+    focus-ring {
+        active-color   "#9dcbfb"
+        inactive-color "#8c9199"
+        urgent-color   "#ffb4ab"
+    }
+
+    border {
+        active-color   "#9dcbfb"
+        inactive-color "#8c9199"
+        urgent-color   "#ffb4ab"
+    }
+
+    shadow {
+        color "#00000070"
+    }
+
+    tab-indicator {
+        active-color   "#9dcbfb"
+        inactive-color "#8c9199"
+        urgent-color   "#ffb4ab"
+    }
+
+    insert-hint {
+        color "#9dcbfb80"
+    }
+}
+
+recent-windows {
+    highlight {
+        active-color   "#124a73"
+        urgent-color   "#ffb4ab"
+    }
+}

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

@@ -0,0 +1,17 @@
+layout {
+    gaps 4
+
+    border {
+        width 2
+    }
+
+    focus-ring {
+        width 2
+    }
+}
+window-rule {
+    geometry-corner-radius 12
+    clip-to-geometry true
+    tiled-state true
+    draw-border-with-background false
+}

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,15 +110,8 @@ 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 "dms" "run"
-spawn-at-startup "{{POLKIT_AGENT_PATH}}"
 environment {
   XDG_CURRENT_DESKTOP "niri"
-  QT_QPA_PLATFORM "wayland"
-  ELECTRON_OZONE_PLATFORM_HINT "auto"
-  QT_QPA_PLATFORMTHEME "gtk3"
-  QT_QPA_PLATFORMTHEME_QT6 "gtk3"
-  TERMINAL "{{TERMINAL_COMMAND}}"
 }
 hotkey-overlay {
     skip-at-startup
@@ -214,210 +201,27 @@ window-rule {
     match app-id="zoom"
     open-floating true
 }
-window-rule {
-    geometry-corner-radius 12
-    clip-to-geometry true
-}
 // Open dms windows as floating by default
 window-rule {
     match app-id=r#"org.quickshell$"#
     open-floating true
 }
-binds {
-    // === System & Overview ===
-    Mod+D { spawn "niri" "msg" "action" "toggle-overview"; }
-    Mod+Tab repeat=false { toggle-overview; }
-    Mod+Shift+Slash { show-hotkey-overlay; }
-
-    // === Application Launchers ===
-    Mod+T hotkey-overlay-title="Open Terminal" { spawn "{{TERMINAL_COMMAND}}"; }
-    Mod+Space hotkey-overlay-title="Application Launcher" {
-        spawn "dms" "ipc" "call" "spotlight" "toggle";
-    }
-    Mod+V hotkey-overlay-title="Clipboard Manager" {
-        spawn "dms" "ipc" "call" "clipboard" "toggle";
-    }
-    Mod+M hotkey-overlay-title="Task Manager" {
-        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
-    }
-    Mod+Comma hotkey-overlay-title="Settings" {
-        spawn "dms" "ipc" "call" "settings" "focusOrToggle";
-    }
-    Mod+Y hotkey-overlay-title="Browse Wallpapers" {
-        spawn "dms" "ipc" "call" "dankdash" "wallpaper";
-    }
-    Mod+N hotkey-overlay-title="Notification Center" { spawn "dms" "ipc" "call" "notifications" "toggle"; }
-    Mod+Shift+N hotkey-overlay-title="Notepad" { spawn "dms" "ipc" "call" "notepad" "toggle"; }
-
-    // === Security ===
-    Mod+Alt+L hotkey-overlay-title="Lock Screen" {
-        spawn "dms" "ipc" "call" "lock" "lock";
-    }
-    Mod+Shift+E { quit; }
-    Ctrl+Alt+Delete hotkey-overlay-title="Task Manager" {
-        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
-    }
-
-    // === Audio Controls ===
-    XF86AudioRaiseVolume allow-when-locked=true {
-        spawn "dms" "ipc" "call" "audio" "increment" "3";
-    }
-    XF86AudioLowerVolume allow-when-locked=true {
-        spawn "dms" "ipc" "call" "audio" "decrement" "3";
-    }
-    XF86AudioMute allow-when-locked=true {
-        spawn "dms" "ipc" "call" "audio" "mute";
-    }
-    XF86AudioMicMute allow-when-locked=true {
-        spawn "dms" "ipc" "call" "audio" "micmute";
-    }
-
-    // === Brightness Controls ===
-    XF86MonBrightnessUp allow-when-locked=true {
-       spawn "dms" "ipc" "call" "brightness" "increment" "5" "";
-    }
-    XF86MonBrightnessDown allow-when-locked=true {
-       spawn "dms" "ipc" "call" "brightness" "decrement" "5" "";
-    }
-
-    // === Window Management ===
-    Mod+Q repeat=false { close-window; }
-    Mod+F { maximize-column; }
-    Mod+Shift+F { fullscreen-window; }
-    Mod+Shift+T { toggle-window-floating; }
-    Mod+Shift+V { switch-focus-between-floating-and-tiling; }
-    Mod+W { toggle-column-tabbed-display; }
-
-    // === Focus Navigation ===
-    Mod+Left  { focus-column-left; }
-    Mod+Down  { focus-window-down; }
-    Mod+Up    { focus-window-up; }
-    Mod+Right { focus-column-right; }
-    Mod+H     { focus-column-left; }
-    Mod+J     { focus-window-down; }
-    Mod+K     { focus-window-up; }
-    Mod+L     { focus-column-right; }
-
-    // === Window Movement ===
-    Mod+Shift+Left  { move-column-left; }
-    Mod+Shift+Down  { move-window-down; }
-    Mod+Shift+Up    { move-window-up; }
-    Mod+Shift+Right { move-column-right; }
-    Mod+Shift+H     { move-column-left; }
-    Mod+Shift+J     { move-window-down; }
-    Mod+Shift+K     { move-window-up; }
-    Mod+Shift+L     { move-column-right; }
-
-    // === Column Navigation ===
-    Mod+Home { focus-column-first; }
-    Mod+End  { focus-column-last; }
-    Mod+Ctrl+Home { move-column-to-first; }
-    Mod+Ctrl+End  { move-column-to-last; }
-
-    // === Monitor Navigation ===
-    Mod+Ctrl+Left  { focus-monitor-left; }
-    //Mod+Ctrl+Down  { focus-monitor-down; }
-    //Mod+Ctrl+Up    { focus-monitor-up; }
-    Mod+Ctrl+Right { focus-monitor-right; }
-    Mod+Ctrl+H     { focus-monitor-left; }
-    Mod+Ctrl+J     { focus-monitor-down; }
-    Mod+Ctrl+K     { focus-monitor-up; }
-    Mod+Ctrl+L     { focus-monitor-right; }
-
-    // === Move to Monitor ===
-    Mod+Shift+Ctrl+Left  { move-column-to-monitor-left; }
-    Mod+Shift+Ctrl+Down  { move-column-to-monitor-down; }
-    Mod+Shift+Ctrl+Up    { move-column-to-monitor-up; }
-    Mod+Shift+Ctrl+Right { move-column-to-monitor-right; }
-    Mod+Shift+Ctrl+H     { move-column-to-monitor-left; }
-    Mod+Shift+Ctrl+J     { move-column-to-monitor-down; }
-    Mod+Shift+Ctrl+K     { move-column-to-monitor-up; }
-    Mod+Shift+Ctrl+L     { move-column-to-monitor-right; }
-
-    // === Workspace Navigation ===
-    Mod+Page_Down      { focus-workspace-down; }
-    Mod+Page_Up        { focus-workspace-up; }
-    Mod+U              { focus-workspace-down; }
-    Mod+I              { focus-workspace-up; }
-    Mod+Ctrl+Down { move-column-to-workspace-down; }
-    Mod+Ctrl+Up   { move-column-to-workspace-up; }
-    Mod+Ctrl+U         { move-column-to-workspace-down; }
-    Mod+Ctrl+I         { move-column-to-workspace-up; }
-
-    // === Move Workspaces ===
-    Mod+Shift+Page_Down { move-workspace-down; }
-    Mod+Shift+Page_Up   { move-workspace-up; }
-    Mod+Shift+U         { move-workspace-down; }
-    Mod+Shift+I         { move-workspace-up; }
-
-    // === Mouse Wheel Navigation ===
-    Mod+WheelScrollDown      cooldown-ms=150 { focus-workspace-down; }
-    Mod+WheelScrollUp        cooldown-ms=150 { focus-workspace-up; }
-    Mod+Ctrl+WheelScrollDown cooldown-ms=150 { move-column-to-workspace-down; }
-    Mod+Ctrl+WheelScrollUp   cooldown-ms=150 { move-column-to-workspace-up; }
-
-    Mod+WheelScrollRight      { focus-column-right; }
-    Mod+WheelScrollLeft       { focus-column-left; }
-    Mod+Ctrl+WheelScrollRight { move-column-right; }
-    Mod+Ctrl+WheelScrollLeft  { move-column-left; }
-
-    Mod+Shift+WheelScrollDown      { focus-column-right; }
-    Mod+Shift+WheelScrollUp        { focus-column-left; }
-    Mod+Ctrl+Shift+WheelScrollDown { move-column-right; }
-    Mod+Ctrl+Shift+WheelScrollUp   { move-column-left; }
-
-    // === Numbered Workspaces ===
-    Mod+1 { focus-workspace 1; }
-    Mod+2 { focus-workspace 2; }
-    Mod+3 { focus-workspace 3; }
-    Mod+4 { focus-workspace 4; }
-    Mod+5 { focus-workspace 5; }
-    Mod+6 { focus-workspace 6; }
-    Mod+7 { focus-workspace 7; }
-    Mod+8 { focus-workspace 8; }
-    Mod+9 { focus-workspace 9; }
-
-    // === Move to Numbered Workspaces ===
-    Mod+Shift+1 { move-column-to-workspace 1; }
-    Mod+Shift+2 { move-column-to-workspace 2; }
-    Mod+Shift+3 { move-column-to-workspace 3; }
-    Mod+Shift+4 { move-column-to-workspace 4; }
-    Mod+Shift+5 { move-column-to-workspace 5; }
-    Mod+Shift+6 { move-column-to-workspace 6; }
-    Mod+Shift+7 { move-column-to-workspace 7; }
-    Mod+Shift+8 { move-column-to-workspace 8; }
-    Mod+Shift+9 { move-column-to-workspace 9; }
-
-    // === Column Management ===
-    Mod+BracketLeft  { consume-or-expel-window-left; }
-    Mod+BracketRight { consume-or-expel-window-right; }
-    Mod+Period { expel-window-from-column; }
-
-    // === Sizing & Layout ===
-    Mod+R { switch-preset-column-width; }
-    Mod+Shift+R { switch-preset-window-height; }
-    Mod+Ctrl+R { reset-window-height; }
-    Mod+Ctrl+F { expand-column-to-available-width; }
-    Mod+C { center-column; }
-    Mod+Ctrl+C { center-visible-columns; }
-
-    // === Manual Sizing ===
-    Mod+Minus { set-column-width "-10%"; }
-    Mod+Equal { set-column-width "+10%"; }
-    Mod+Shift+Minus { set-window-height "-10%"; }
-    Mod+Shift+Equal { set-window-height "+10%"; }
-
-    // === Screenshots ===
-    XF86Launch1 { screenshot; }
-    Ctrl+XF86Launch1 { screenshot-screen; }
-    Alt+XF86Launch1 { screenshot-window; }
-    Print { screenshot; }
-    Ctrl+Print { screenshot-screen; }
-    Alt+Print { screenshot-window; }
-    // === System Controls ===
-    Mod+Escape allow-inhibiting=false { toggle-keyboard-shortcuts-inhibit; }
-    Mod+Shift+P { power-off-monitors; }
-}
 debug {
     honor-xdg-activation-with-invalid-serial
 }
+
+// Override to disable super+tab
+recent-windows {
+    binds {
+        Alt+Tab         { next-window scope="output"; }
+        Alt+Shift+Tab   { previous-window scope="output"; }
+        Alt+grave       { next-window filter="app-id"; }
+        Alt+Shift+grave { previous-window filter="app-id"; }
+    }
+}
+
+// Include dms files
+include "dms/colors.kdl"
+include "dms/layout.kdl"
+include "dms/alttab.kdl"
+include "dms/binds.kdl"

core/internal/config/niri.go

@@ -4,3 +4,15 @@ import _ "embed"
 
 //go:embed embedded/niri.kdl
 var NiriConfig string
+
+//go:embed embedded/niri-colors.kdl
+var NiriColorsConfig string
+
+//go:embed embedded/niri-layout.kdl
+var NiriLayoutConfig string
+
+//go:embed embedded/niri-alttab.kdl
+var NiriAlttabConfig string
+
+//go:embed embedded/niri-binds.kdl
+var NiriBindsConfig string

core/internal/dank16/dank16.go

@@ -23,6 +23,17 @@ type ColorInfo struct {
 	B           int    `json:"b"`
 }
 
+type VariantColorValue struct {
+	Hex         string `json:"hex"`
+	HexStripped string `json:"hex_stripped"`
+}
+
+type VariantColorInfo struct {
+	Dark    VariantColorValue `json:"dark"`
+	Light   VariantColorValue `json:"light"`
+	Default VariantColorValue `json:"default"`
+}
+
 type Palette struct {
 	Color0  ColorInfo `json:"color0"`
 	Color1  ColorInfo `json:"color1"`
@@ -42,6 +53,25 @@ type Palette struct {
 	Color15 ColorInfo `json:"color15"`
 }
 
+type VariantPalette struct {
+	Color0  VariantColorInfo `json:"color0"`
+	Color1  VariantColorInfo `json:"color1"`
+	Color2  VariantColorInfo `json:"color2"`
+	Color3  VariantColorInfo `json:"color3"`
+	Color4  VariantColorInfo `json:"color4"`
+	Color5  VariantColorInfo `json:"color5"`
+	Color6  VariantColorInfo `json:"color6"`
+	Color7  VariantColorInfo `json:"color7"`
+	Color8  VariantColorInfo `json:"color8"`
+	Color9  VariantColorInfo `json:"color9"`
+	Color10 VariantColorInfo `json:"color10"`
+	Color11 VariantColorInfo `json:"color11"`
+	Color12 VariantColorInfo `json:"color12"`
+	Color13 VariantColorInfo `json:"color13"`
+	Color14 VariantColorInfo `json:"color14"`
+	Color15 VariantColorInfo `json:"color15"`
+}
+
 func NewColorInfo(hex string) ColorInfo {
 	rgb := HexToRGB(hex)
 	stripped := hex
@@ -83,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
 	}
 
@@ -492,3 +523,54 @@ func GeneratePalette(primaryColor string, opts PaletteOptions) Palette {
 
 	return palette
 }
+
+type VariantOptions struct {
+	PrimaryDark  string
+	PrimaryLight string
+	Background   string
+	UseDPS       bool
+	IsLightMode  bool
+}
+
+func mergeColorInfo(dark, light ColorInfo, isLightMode bool) VariantColorInfo {
+	darkVal := VariantColorValue{Hex: dark.Hex, HexStripped: dark.HexStripped}
+	lightVal := VariantColorValue{Hex: light.Hex, HexStripped: light.HexStripped}
+
+	defaultVal := darkVal
+	if isLightMode {
+		defaultVal = lightVal
+	}
+
+	return VariantColorInfo{
+		Dark:    darkVal,
+		Light:   lightVal,
+		Default: defaultVal,
+	}
+}
+
+func GenerateVariantPalette(opts VariantOptions) VariantPalette {
+	darkOpts := PaletteOptions{IsLight: false, Background: opts.Background, UseDPS: opts.UseDPS}
+	lightOpts := PaletteOptions{IsLight: true, Background: opts.Background, UseDPS: opts.UseDPS}
+
+	dark := GeneratePalette(opts.PrimaryDark, darkOpts)
+	light := GeneratePalette(opts.PrimaryLight, lightOpts)
+
+	return VariantPalette{
+		Color0:  mergeColorInfo(dark.Color0, light.Color0, opts.IsLightMode),
+		Color1:  mergeColorInfo(dark.Color1, light.Color1, opts.IsLightMode),
+		Color2:  mergeColorInfo(dark.Color2, light.Color2, opts.IsLightMode),
+		Color3:  mergeColorInfo(dark.Color3, light.Color3, opts.IsLightMode),
+		Color4:  mergeColorInfo(dark.Color4, light.Color4, opts.IsLightMode),
+		Color5:  mergeColorInfo(dark.Color5, light.Color5, opts.IsLightMode),
+		Color6:  mergeColorInfo(dark.Color6, light.Color6, opts.IsLightMode),
+		Color7:  mergeColorInfo(dark.Color7, light.Color7, opts.IsLightMode),
+		Color8:  mergeColorInfo(dark.Color8, light.Color8, opts.IsLightMode),
+		Color9:  mergeColorInfo(dark.Color9, light.Color9, opts.IsLightMode),
+		Color10: mergeColorInfo(dark.Color10, light.Color10, opts.IsLightMode),
+		Color11: mergeColorInfo(dark.Color11, light.Color11, opts.IsLightMode),
+		Color12: mergeColorInfo(dark.Color12, light.Color12, opts.IsLightMode),
+		Color13: mergeColorInfo(dark.Color13, light.Color13, opts.IsLightMode),
+		Color14: mergeColorInfo(dark.Color14, light.Color14, opts.IsLightMode),
+		Color15: mergeColorInfo(dark.Color15, light.Color15, opts.IsLightMode),
+	}
+}

core/internal/dank16/terminals.go

@@ -11,6 +11,11 @@ func GenerateJSON(p Palette) string {
 	return string(marshalled)
 }
 
+func GenerateVariantJSON(p VariantPalette) string {
+	marshalled, _ := json.Marshal(p)
+	return string(marshalled)
+}
+
 func GenerateKittyTheme(p Palette) string {
 	var result strings.Builder
 	fmt.Fprintf(&result, "color0   %s\n", p.Color0.Hex)

core/internal/distros/arch.go

@@ -91,7 +91,6 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 	dependencies = append(dependencies, a.detectWindowManager(wm))
 	dependencies = append(dependencies, a.detectQuickshell())
 	dependencies = append(dependencies, a.detectXDGPortal())
-	dependencies = append(dependencies, a.detectPolkitAgent())
 	dependencies = append(dependencies, a.detectAccountsService())
 
 	// Hyprland-specific tools
@@ -107,52 +106,17 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 	// Base detections (common across distros)
 	dependencies = append(dependencies, a.detectMatugen())
 	dependencies = append(dependencies, a.detectDgop())
-	dependencies = append(dependencies, a.detectHyprpicker())
 	dependencies = append(dependencies, a.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 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,
-	}
-}
-
-func (a *ArchDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if a.packageInstalled("mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		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 {
@@ -178,18 +142,13 @@ func (a *ArchDistribution) GetPackageMappingWithVariants(wm deps.WindowManager,
 		"cliphist":                {Name: "cliphist", Repository: RepoTypeSystem},
 		"wl-clipboard":            {Name: "wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk":  {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
-		"mate-polkit":             {Name: "mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":         {Name: "accountsservice", Repository: RepoTypeSystem},
-		"hyprpicker":              {Name: "hyprpicker", Repository: RepoTypeSystem},
 	}
 
 	switch wm {
 	case deps.WindowManagerHyprland:
 		packages["hyprland"] = a.getHyprlandMapping(variants["hyprland"])
-		packages["grim"] = PackageMapping{Name: "grim", Repository: RepoTypeSystem}
-		packages["slurp"] = PackageMapping{Name: "slurp", Repository: RepoTypeSystem}
 		packages["hyprctl"] = a.getHyprlandMapping(variants["hyprland"])
-		packages["grimblast"] = PackageMapping{Name: "grimblast", Repository: RepoTypeManual, BuildFunc: "installGrimblast"}
 		packages["jq"] = PackageMapping{Name: "jq", Repository: RepoTypeSystem}
 	case deps.WindowManagerNiri:
 		packages["niri"] = a.getNiriMapping(variants["niri"])
@@ -203,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}
 }
 
@@ -378,6 +335,19 @@ func (a *ArchDistribution) InstallPackages(ctx context.Context, dependencies []d
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := a.DetectTerminalFromDeps(dependencies)
+	if err := a.WriteEnvironmentConfig(terminal); err != nil {
+		a.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	// Phase 7: Complete
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,

core/internal/distros/base.go

@@ -17,8 +17,10 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
 )
 
-const forceQuickshellGit = false
-const forceDMSGit = false
+const (
+	forceQuickshellGit = false
+	forceDMSGit        = false
+)
 
 // BaseDistribution provides common functionality for all distributions
 type BaseDistribution struct {
@@ -74,47 +76,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 {
@@ -219,20 +216,6 @@ func (b *BaseDistribution) detectClipboardTools() []deps.Dependency {
 	return dependencies
 }
 
-func (b *BaseDistribution) detectHyprpicker() deps.Dependency {
-	status := deps.StatusMissing
-	if b.commandExists("hyprpicker") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "hyprpicker",
-		Status:      status,
-		Description: "Color picker for Wayland",
-		Required:    true,
-	}
-}
-
 func (b *BaseDistribution) detectHyprlandTools() []deps.Dependency {
 	var dependencies []deps.Dependency
 
@@ -240,10 +223,7 @@ func (b *BaseDistribution) detectHyprlandTools() []deps.Dependency {
 		name        string
 		description string
 	}{
-		{"grim", "Screenshot utility for Wayland"},
-		{"slurp", "Region selection utility for Wayland"},
 		{"hyprctl", "Hyprland control utility"},
-		{"grimblast", "Screenshot script for Hyprland"},
 		{"jq", "JSON processor"},
 	}
 
@@ -564,6 +544,115 @@ func (b *BaseDistribution) runWithProgressStepTimeout(cmd *exec.Cmd, progressCha
 	}
 }
 
+func (b *BaseDistribution) DetectTerminalFromDeps(dependencies []deps.Dependency) deps.Terminal {
+	for _, dep := range dependencies {
+		switch dep.Name {
+		case "ghostty":
+			return deps.TerminalGhostty
+		case "kitty":
+			return deps.TerminalKitty
+		case "alacritty":
+			return deps.TerminalAlacritty
+		}
+	}
+	return deps.TerminalGhostty
+}
+
+func (b *BaseDistribution) WriteEnvironmentConfig(terminal deps.Terminal) error {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	envDir := filepath.Join(homeDir, ".config", "environment.d")
+	if err := os.MkdirAll(envDir, 0755); err != nil {
+		return fmt.Errorf("failed to create environment.d directory: %w", err)
+	}
+
+	var terminalCmd string
+	switch terminal {
+	case deps.TerminalGhostty:
+		terminalCmd = "ghostty"
+	case deps.TerminalKitty:
+		terminalCmd = "kitty"
+	case deps.TerminalAlacritty:
+		terminalCmd = "alacritty"
+	default:
+		terminalCmd = "ghostty"
+	}
+
+	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 {
+		return fmt.Errorf("failed to write environment config: %w", err)
+	}
+
+	b.log(fmt.Sprintf("Wrote environment config to %s", envFile))
+	return nil
+}
+
+func (b *BaseDistribution) EnableDMSService(ctx context.Context, wm deps.WindowManager) 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)
+	}
+	b.log("Enabled dms systemd user service")
+
+	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")
+		}
+	}
+
+	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
+}
+
 // installDMSBinary installs the DMS binary from GitHub releases
 func (b *BaseDistribution) installDMSBinary(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	b.log("Installing/updating DMS binary...")
@@ -602,7 +691,7 @@ func (b *BaseDistribution) installDMSBinary(ctx context.Context, sudoPassword st
 		return fmt.Errorf("failed to get user home directory: %w", err)
 	}
 	tmpDir := filepath.Join(homeDir, ".cache", "dankinstall", "manual-builds")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)

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

@@ -61,7 +61,6 @@ func (d *DebianDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, d.detectWindowManager(wm))
 	dependencies = append(dependencies, d.detectQuickshell())
 	dependencies = append(dependencies, d.detectXDGPortal())
-	dependencies = append(dependencies, d.detectPolkitAgent())
 	dependencies = append(dependencies, d.detectAccountsService())
 
 	if wm == deps.WindowManagerNiri {
@@ -76,59 +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,
-	}
-}
-
-func (d *DebianDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if d.packageInstalled("mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		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 {
@@ -149,7 +104,6 @@ func (d *DebianDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"alacritty":              {Name: "alacritty", Repository: RepoTypeSystem},
 		"wl-clipboard":           {Name: "wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
-		"mate-polkit":            {Name: "mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":        {Name: "accountsservice", Repository: RepoTypeSystem},
 
 		// DMS packages from OBS with variant support
@@ -158,9 +112,7 @@ func (d *DebianDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"cliphist":                {Name: "cliphist", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
-
-		// Keep ghostty as manual (no OBS package yet)
-		"ghostty": {Name: "ghostty", Repository: RepoTypeManual, BuildFunc: "installGhostty"},
+		"ghostty":                 {Name: "ghostty", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 	}
 
 	if wm == deps.WindowManagerNiri {
@@ -226,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)
 		}
@@ -243,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)
 	}
@@ -351,6 +303,19 @@ func (d *DebianDistribution) InstallPackages(ctx context.Context, dependencies [
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := d.DetectTerminalFromDeps(dependencies)
+	if err := d.WriteEnvironmentConfig(terminal); err != nil {
+		d.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,
 		Progress:   1.0,
@@ -458,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)
@@ -476,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)
 			}
@@ -511,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{
@@ -621,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)
 	}
@@ -660,34 +625,10 @@ 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)
 }
 
-func (d *DebianDistribution) installGhosttyDebian(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	d.log("Installing Ghostty using Debian installer script...")
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.1,
-		Step:        "Running Ghostty Debian installer...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: "curl -fsSL https://raw.githubusercontent.com/mkasberg/ghostty-ubuntu/HEAD/install.sh | sudo bash",
-		LogOutput:   "Installing Ghostty using pre-built Debian package",
-	}
-
-	installCmd := ExecSudoCommand(ctx, sudoPassword,
-		"/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/mkasberg/ghostty-ubuntu/HEAD/install.sh)\"")
-
-	if err := d.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.1, 0.9); err != nil {
-		return fmt.Errorf("failed to install Ghostty: %w", err)
-	}
-
-	d.log("Ghostty installed successfully using Debian installer")
-	return nil
-}
-
 func (d *DebianDistribution) InstallManualPackages(ctx context.Context, packages []string, variantMap map[string]deps.PackageVariant, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	if len(packages) == 0 {
 		return nil
@@ -697,10 +638,6 @@ func (d *DebianDistribution) InstallManualPackages(ctx context.Context, packages
 
 	for _, pkg := range packages {
 		switch pkg {
-		case "ghostty":
-			if err := d.installGhosttyDebian(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install ghostty: %w", err)
-			}
 		default:
 			if err := d.ManualPackageInstaller.InstallManualPackages(ctx, []string{pkg}, variantMap, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install %s: %w", pkg, err)

core/internal/distros/fedora.go

@@ -76,7 +76,6 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, f.detectWindowManager(wm))
 	dependencies = append(dependencies, f.detectQuickshell())
 	dependencies = append(dependencies, f.detectXDGPortal())
-	dependencies = append(dependencies, f.detectPolkitAgent())
 	dependencies = append(dependencies, f.detectAccountsService())
 
 	// Hyprland-specific tools
@@ -92,38 +91,13 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	// Base detections (common across distros)
 	dependencies = append(dependencies, f.detectMatugen())
 	dependencies = append(dependencies, f.detectDgop())
-	dependencies = append(dependencies, f.detectHyprpicker())
 	dependencies = append(dependencies, f.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 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,
-	}
-}
-
-func (f *FedoraDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if f.packageInstalled("mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		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 {
@@ -145,9 +119,7 @@ func (f *FedoraDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"alacritty":              {Name: "alacritty", Repository: RepoTypeSystem},
 		"wl-clipboard":           {Name: "wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
-		"mate-polkit":            {Name: "mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":        {Name: "accountsservice", Repository: RepoTypeSystem},
-		"hyprpicker":             f.getHyprpickerMapping(variants["hyprland"]),
 
 		// COPR packages
 		"quickshell":              f.getQuickshellMapping(variants["quickshell"]),
@@ -160,10 +132,7 @@ func (f *FedoraDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 	switch wm {
 	case deps.WindowManagerHyprland:
 		packages["hyprland"] = f.getHyprlandMapping(variants["hyprland"])
-		packages["grim"] = PackageMapping{Name: "grim", Repository: RepoTypeSystem}
-		packages["slurp"] = PackageMapping{Name: "slurp", Repository: RepoTypeSystem}
 		packages["hyprctl"] = f.getHyprlandMapping(variants["hyprland"])
-		packages["grimblast"] = PackageMapping{Name: "grimblast", Repository: RepoTypeManual, BuildFunc: "installGrimblast"}
 		packages["jq"] = PackageMapping{Name: "jq", Repository: RepoTypeSystem}
 	case deps.WindowManagerNiri:
 		packages["niri"] = f.getNiriMapping(variants["niri"])
@@ -187,25 +156,15 @@ 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"}
 }
 
-func (f *FedoraDistribution) getHyprpickerMapping(variant deps.PackageVariant) PackageMapping {
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "hyprpicker-git", Repository: RepoTypeCOPR, RepoURL: "solopasha/hyprland"}
-	}
-	return PackageMapping{Name: "hyprpicker", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"}
-}
-
 func (f *FedoraDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {
 	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 {
@@ -385,6 +344,19 @@ func (f *FedoraDistribution) InstallPackages(ctx context.Context, dependencies [
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := f.DetectTerminalFromDeps(dependencies)
+	if err := f.WriteEnvironmentConfig(terminal); err != nil {
+		f.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	// Phase 7: Complete
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,

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 {
@@ -108,66 +107,21 @@ func (g *GentooDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 
 	dependencies = append(dependencies, g.detectMatugen())
 	dependencies = append(dependencies, g.detectDgop())
-	dependencies = append(dependencies, g.detectHyprpicker())
 	dependencies = append(dependencies, g.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 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 {
@@ -188,9 +142,7 @@ 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},
-		"hyprpicker":             g.getHyprpickerMapping(variants["hyprland"]),
 
 		"qtbase":        {Name: "dev-qt/qtbase", Repository: RepoTypeSystem, UseFlags: "wayland opengl vulkan widgets"},
 		"qtdeclarative": {Name: "dev-qt/qtdeclarative", Repository: RepoTypeSystem, UseFlags: "opengl vulkan"},
@@ -207,10 +159,7 @@ func (g *GentooDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 	switch wm {
 	case deps.WindowManagerHyprland:
 		packages["hyprland"] = g.getHyprlandMapping(variants["hyprland"])
-		packages["grim"] = PackageMapping{Name: "gui-apps/grim", Repository: RepoTypeSystem}
-		packages["slurp"] = PackageMapping{Name: "gui-apps/slurp", Repository: RepoTypeSystem}
 		packages["hyprctl"] = g.getHyprlandMapping(variants["hyprland"])
-		packages["grimblast"] = PackageMapping{Name: "gui-wm/hyprland-contrib", Repository: RepoTypeGURU, AcceptKeywords: archKeyword}
 		packages["jq"] = PackageMapping{Name: "app-misc/jq", Repository: RepoTypeSystem}
 	case deps.WindowManagerNiri:
 		packages["niri"] = g.getNiriMapping(variants["niri"])
@@ -228,16 +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) getHyprpickerMapping(_ deps.PackageVariant) PackageMapping {
-	return PackageMapping{Name: "gui-apps/hyprpicker", Repository: RepoTypeGURU, AcceptKeywords: g.getArchKeyword()}
+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 {
@@ -460,6 +401,19 @@ func (g *GentooDistribution) InstallPackages(ctx context.Context, dependencies [
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := g.DetectTerminalFromDeps(dependencies)
+	if err := g.WriteEnvironmentConfig(terminal); err != nil {
+		g.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,
 		Progress:   1.0,

core/internal/distros/manual_packages.go

@@ -62,10 +62,6 @@ func (m *ManualPackageInstaller) InstallManualPackages(ctx context.Context, pack
 			if err := m.installDgop(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install dgop: %w", err)
 			}
-		case "grimblast":
-			if err := m.installGrimblast(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install grimblast: %w", err)
-			}
 		case "niri":
 			if err := m.installNiri(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install niri: %w", err)
@@ -166,62 +162,6 @@ func (m *ManualPackageInstaller) installDgop(ctx context.Context, sudoPassword s
 	return nil
 }
 
-func (m *ManualPackageInstaller) installGrimblast(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	m.log("Installing grimblast script for Hyprland...")
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.1,
-		Step:        "Downloading grimblast script...",
-		IsComplete:  false,
-		CommandInfo: "curl grimblast script",
-	}
-
-	grimblastURL := "https://raw.githubusercontent.com/hyprwm/contrib/refs/heads/main/grimblast/grimblast"
-	tmpPath := filepath.Join(os.TempDir(), "grimblast")
-
-	downloadCmd := exec.CommandContext(ctx, "curl", "-L", "-o", tmpPath, grimblastURL)
-	if err := downloadCmd.Run(); err != nil {
-		m.logError("failed to download grimblast", err)
-		return fmt.Errorf("failed to download grimblast: %w", err)
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.5,
-		Step:        "Making grimblast executable...",
-		IsComplete:  false,
-		CommandInfo: "chmod +x grimblast",
-	}
-
-	chmodCmd := exec.CommandContext(ctx, "chmod", "+x", tmpPath)
-	if err := chmodCmd.Run(); err != nil {
-		m.logError("failed to make grimblast executable", err)
-		return fmt.Errorf("failed to make grimblast executable: %w", err)
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.8,
-		Step:        "Installing grimblast to /usr/local/bin...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: "sudo cp grimblast /usr/local/bin/",
-	}
-
-	installCmd := ExecSudoCommand(ctx, sudoPassword,
-		fmt.Sprintf("cp %s /usr/local/bin/grimblast", tmpPath))
-	if err := installCmd.Run(); err != nil {
-		m.logError("failed to install grimblast", err)
-		return fmt.Errorf("failed to install grimblast: %w", err)
-	}
-
-	os.Remove(tmpPath)
-
-	m.log("grimblast installed successfully to /usr/local/bin")
-	return nil
-}
-
 func (m *ManualPackageInstaller) installNiri(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	m.log("Installing niri from source...")
 

core/internal/distros/opensuse.go

@@ -66,7 +66,6 @@ func (o *OpenSUSEDistribution) DetectDependenciesWithTerminal(ctx context.Contex
 	dependencies = append(dependencies, o.detectWindowManager(wm))
 	dependencies = append(dependencies, o.detectQuickshell())
 	dependencies = append(dependencies, o.detectXDGPortal())
-	dependencies = append(dependencies, o.detectPolkitAgent())
 	dependencies = append(dependencies, o.detectAccountsService())
 
 	// Hyprland-specific tools
@@ -88,31 +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,
-	}
-}
-
-func (o *OpenSUSEDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if o.packageInstalled("mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		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 {
@@ -134,7 +109,6 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 		"alacritty":              {Name: "alacritty", Repository: RepoTypeSystem},
 		"wl-clipboard":           {Name: "wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
-		"mate-polkit":            {Name: "mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":        {Name: "accountsservice", Repository: RepoTypeSystem},
 		"cliphist":               {Name: "cliphist", Repository: RepoTypeSystem},
 
@@ -148,10 +122,7 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 	switch wm {
 	case deps.WindowManagerHyprland:
 		packages["hyprland"] = PackageMapping{Name: "hyprland", Repository: RepoTypeSystem}
-		packages["grim"] = PackageMapping{Name: "grim", Repository: RepoTypeSystem}
-		packages["slurp"] = PackageMapping{Name: "slurp", Repository: RepoTypeSystem}
 		packages["hyprctl"] = PackageMapping{Name: "hyprland", Repository: RepoTypeSystem}
-		packages["grimblast"] = PackageMapping{Name: "grimblast", Repository: RepoTypeManual, BuildFunc: "installGrimblast"}
 		packages["jq"] = PackageMapping{Name: "jq", Repository: RepoTypeSystem}
 	case deps.WindowManagerNiri:
 		// Niri stable has native package support on openSUSE
@@ -391,6 +362,19 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := o.DetectTerminalFromDeps(dependencies)
+	if err := o.WriteEnvironmentConfig(terminal); err != nil {
+		o.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	// Complete
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,
@@ -482,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

@@ -3,9 +3,7 @@ package distros
 import (
 	"context"
 	"fmt"
-	"os"
 	"os/exec"
-	"path/filepath"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
@@ -66,7 +64,6 @@ func (u *UbuntuDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, u.detectWindowManager(wm))
 	dependencies = append(dependencies, u.detectQuickshell())
 	dependencies = append(dependencies, u.detectXDGPortal())
-	dependencies = append(dependencies, u.detectPolkitAgent())
 	dependencies = append(dependencies, u.detectAccountsService())
 
 	// Hyprland-specific tools
@@ -88,59 +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,
-	}
-}
-
-func (u *UbuntuDistribution) detectPolkitAgent() deps.Dependency {
-	status := deps.StatusMissing
-	if u.packageInstalled("mate-polkit") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "mate-polkit",
-		Status:      status,
-		Description: "PolicyKit authentication agent",
-		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 {
@@ -161,7 +114,6 @@ func (u *UbuntuDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"alacritty":              {Name: "alacritty", Repository: RepoTypeSystem},
 		"wl-clipboard":           {Name: "wl-clipboard", Repository: RepoTypeSystem},
 		"xdg-desktop-portal-gtk": {Name: "xdg-desktop-portal-gtk", Repository: RepoTypeSystem},
-		"mate-polkit":            {Name: "mate-polkit", Repository: RepoTypeSystem},
 		"accountsservice":        {Name: "accountsservice", Repository: RepoTypeSystem},
 
 		// DMS packages from PPAs
@@ -170,19 +122,14 @@ func (u *UbuntuDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"matugen":                 {Name: "matugen", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 		"cliphist":                {Name: "cliphist", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
-
-		// Keep ghostty as manual (no PPA available)
-		"ghostty": {Name: "ghostty", Repository: RepoTypeManual, BuildFunc: "installGhostty"},
+		"ghostty":                 {Name: "ghostty", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 	}
 
 	switch wm {
 	case deps.WindowManagerHyprland:
 		// Use the cppiber PPA for Hyprland
 		packages["hyprland"] = PackageMapping{Name: "hyprland", Repository: RepoTypePPA, RepoURL: "ppa:cppiber/hyprland"}
-		packages["grim"] = PackageMapping{Name: "grim", Repository: RepoTypeSystem}
-		packages["slurp"] = PackageMapping{Name: "slurp", Repository: RepoTypeSystem}
 		packages["hyprctl"] = PackageMapping{Name: "hyprland", Repository: RepoTypePPA, RepoURL: "ppa:cppiber/hyprland"}
-		packages["grimblast"] = PackageMapping{Name: "grimblast", Repository: RepoTypeManual, BuildFunc: "installGrimblast"}
 		packages["jq"] = PackageMapping{Name: "jq", Repository: RepoTypeSystem}
 	case deps.WindowManagerNiri:
 		niriVariant := variants["niri"]
@@ -375,6 +322,19 @@ func (u *UbuntuDistribution) InstallPackages(ctx context.Context, dependencies [
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
+	terminal := u.DetectTerminalFromDeps(dependencies)
+	if err := u.WriteEnvironmentConfig(terminal); err != nil {
+		u.log(fmt.Sprintf("Warning: failed to write environment config: %v", err))
+	}
+
+	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))
+	}
+
 	// Phase 7: Complete
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseComplete,
@@ -577,10 +537,6 @@ func (u *UbuntuDistribution) installBuildDependencies(ctx context.Context, manua
 			buildDeps["libxcb1-dev"] = true
 			buildDeps["libpipewire-0.3-dev"] = true
 			buildDeps["libpam0g-dev"] = true
-		case "ghostty":
-			buildDeps["curl"] = true
-			buildDeps["libgtk-4-dev"] = true
-			buildDeps["libadwaita-1-dev"] = true
 		case "matugen":
 			buildDeps["curl"] = true
 		case "cliphist":
@@ -594,10 +550,6 @@ func (u *UbuntuDistribution) installBuildDependencies(ctx context.Context, manua
 			if err := u.installRust(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install Rust: %w", err)
 			}
-		case "ghostty":
-			if err := u.installZig(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install Zig: %w", err)
-			}
 		case "cliphist", "dgop":
 			if err := u.installGo(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install Go: %w", err)
@@ -661,40 +613,6 @@ func (u *UbuntuDistribution) installRust(ctx context.Context, sudoPassword strin
 	return nil
 }
 
-func (u *UbuntuDistribution) installZig(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	if u.commandExists("zig") {
-		return nil
-	}
-
-	homeDir, err := os.UserHomeDir()
-	if err != nil {
-		return fmt.Errorf("failed to get user home directory: %w", err)
-	}
-
-	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0755); err != nil {
-		return fmt.Errorf("failed to create cache directory: %w", err)
-	}
-
-	zigUrl := "https://ziglang.org/download/0.11.0/zig-linux-x86_64-0.11.0.tar.xz"
-	zigTmp := filepath.Join(cacheDir, "zig.tar.xz")
-
-	downloadCmd := exec.CommandContext(ctx, "curl", "-L", zigUrl, "-o", zigTmp)
-	if err := u.runWithProgress(downloadCmd, progressChan, PhaseSystemPackages, 0.84, 0.85); err != nil {
-		return fmt.Errorf("failed to download Zig: %w", err)
-	}
-
-	extractCmd := ExecSudoCommand(ctx, sudoPassword,
-		fmt.Sprintf("tar -xf %s -C /opt/", zigTmp))
-	if err := u.runWithProgress(extractCmd, progressChan, PhaseSystemPackages, 0.85, 0.86); err != nil {
-		return fmt.Errorf("failed to extract Zig: %w", err)
-	}
-
-	linkCmd := ExecSudoCommand(ctx, sudoPassword,
-		"ln -sf /opt/zig-linux-x86_64-0.11.0/zig /usr/local/bin/zig")
-	return u.runWithProgress(linkCmd, progressChan, PhaseSystemPackages, 0.86, 0.87)
-}
-
 func (u *UbuntuDistribution) installGo(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	if u.commandExists("go") {
 		return nil
@@ -742,30 +660,6 @@ func (u *UbuntuDistribution) installGo(ctx context.Context, sudoPassword string,
 	return u.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.89, 0.90)
 }
 
-func (u *UbuntuDistribution) installGhosttyUbuntu(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	u.log("Installing Ghostty using Ubuntu installer script...")
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.1,
-		Step:        "Running Ghostty Ubuntu installer...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: "curl -fsSL https://raw.githubusercontent.com/mkasberg/ghostty-ubuntu/HEAD/install.sh | sudo bash",
-		LogOutput:   "Installing Ghostty using pre-built Ubuntu package",
-	}
-
-	installCmd := ExecSudoCommand(ctx, sudoPassword,
-		"/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/mkasberg/ghostty-ubuntu/HEAD/install.sh)\"")
-
-	if err := u.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.1, 0.9); err != nil {
-		return fmt.Errorf("failed to install Ghostty: %w", err)
-	}
-
-	u.log("Ghostty installed successfully using Ubuntu installer")
-	return nil
-}
-
 func (u *UbuntuDistribution) InstallManualPackages(ctx context.Context, packages []string, variantMap map[string]deps.PackageVariant, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	if len(packages) == 0 {
 		return nil
@@ -775,10 +669,6 @@ func (u *UbuntuDistribution) InstallManualPackages(ctx context.Context, packages
 
 	for _, pkg := range packages {
 		switch pkg {
-		case "ghostty":
-			if err := u.installGhosttyUbuntu(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install ghostty: %w", err)
-			}
 		default:
 			if err := u.ManualPackageInstaller.InstallManualPackages(ctx, []string{pkg}, variantMap, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install %s: %w", pkg, 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/dms/views_features.go

@@ -514,7 +514,7 @@ func (m Model) categorizeDependencies() map[string][]DependencyInfo {
 		switch dep.Name {
 		case "dms (DankMaterialShell)", "quickshell":
 			categories["Shell"] = append(categories["Shell"], dep)
-		case "hyprland", "grim", "slurp", "hyprctl", "grimblast":
+		case "hyprland", "hyprctl":
 			categories["Hyprland Components"] = append(categories["Hyprland Components"], dep)
 		case "niri":
 			categories["Niri Components"] = append(categories["Niri Components"], dep)

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"
@@ -333,35 +331,6 @@ func (n *NiriProvider) isRecentWindowsAction(action string) bool {
 	}
 }
 
-func (n *NiriProvider) parseSpawnArgs(s string) []string {
-	var args []string
-	var current strings.Builder
-	var inQuote, escaped bool
-
-	for _, r := range s {
-		switch {
-		case escaped:
-			current.WriteRune(r)
-			escaped = false
-		case r == '\\':
-			escaped = true
-		case r == '"':
-			inQuote = !inQuote
-		case r == ' ' && !inQuote:
-			if current.Len() > 0 {
-				args = append(args, current.String())
-				current.Reset()
-			}
-		default:
-			current.WriteRune(r)
-		}
-	}
-	if current.Len() > 0 {
-		args = append(args, current.String())
-	}
-	return args
-}
-
 func (n *NiriProvider) buildBindNode(bind *overrideBind) *document.Node {
 	node := document.NewNode()
 	node.SetName(bind.Key)
@@ -371,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, "")
@@ -392,19 +368,62 @@ func (n *NiriProvider) buildActionNode(action string) *document.Node {
 	action = strings.TrimSpace(action)
 	node := document.NewNode()
 
-	if !strings.HasPrefix(action, "spawn ") {
+	parts := n.parseActionParts(action)
+	if len(parts) == 0 {
 		node.SetName(action)
 		return node
 	}
 
-	node.SetName("spawn")
-	args := n.parseSpawnArgs(strings.TrimPrefix(action, "spawn "))
-	for _, arg := range args {
+	node.SetName(parts[0])
+	for _, arg := range parts[1:] {
+		if strings.Contains(arg, "=") {
+			kv := strings.SplitN(arg, "=", 2)
+			switch kv[1] {
+			case "true":
+				node.AddProperty(kv[0], true, "")
+			case "false":
+				node.AddProperty(kv[0], false, "")
+			default:
+				node.AddProperty(kv[0], kv[1], "")
+			}
+			continue
+		}
 		node.AddArgument(arg, "")
 	}
 	return node
 }
 
+func (n *NiriProvider) parseActionParts(action string) []string {
+	var parts []string
+	var current strings.Builder
+	var inQuote, escaped, wasQuoted bool
+
+	for _, r := range action {
+		switch {
+		case escaped:
+			current.WriteRune(r)
+			escaped = false
+		case r == '\\':
+			escaped = true
+		case r == '"':
+			wasQuoted = true
+			inQuote = !inQuote
+		case r == ' ' && !inQuote:
+			if current.Len() > 0 || wasQuoted {
+				parts = append(parts, current.String())
+				current.Reset()
+				wasQuoted = false
+			}
+		default:
+			current.WriteRune(r)
+		}
+	}
+	if current.Len() > 0 || wasQuoted {
+		parts = append(parts, current.String())
+	}
+	return parts
+}
+
 func (n *NiriProvider) writeOverrideBinds(binds map[string]*overrideBind) error {
 	overridePath := n.GetOverridePath()
 	content := n.generateBindsContent(binds)
@@ -501,21 +520,50 @@ func (n *NiriProvider) writeBindNode(sb *strings.Builder, bind *overrideBind, in
 	sb.WriteString(" { ")
 	if len(node.Children) > 0 {
 		child := node.Children[0]
-		sb.WriteString(child.Name.String())
+		actionName := child.Name.String()
+		sb.WriteString(actionName)
+		forceQuote := actionName == "spawn"
 		for _, arg := range child.Arguments {
 			sb.WriteString(" ")
-			n.writeQuotedArg(sb, arg.ValueString())
+			n.writeArg(sb, arg.ValueString(), forceQuote)
+		}
+		if child.Properties.Exist() {
+			sb.WriteString(" ")
+			sb.WriteString(strings.TrimLeft(child.Properties.String(), " "))
 		}
 	}
 	sb.WriteString("; }\n")
 }
 
-func (n *NiriProvider) writeQuotedArg(sb *strings.Builder, val string) {
+func (n *NiriProvider) writeArg(sb *strings.Builder, val string, forceQuote bool) {
+	if !forceQuote && n.isNumericArg(val) {
+		sb.WriteString(val)
+		return
+	}
 	sb.WriteString("\"")
 	sb.WriteString(strings.ReplaceAll(val, "\"", "\\\""))
 	sb.WriteString("\"")
 }
 
+func (n *NiriProvider) isNumericArg(val string) bool {
+	if val == "" {
+		return false
+	}
+	start := 0
+	if val[0] == '-' || val[0] == '+' {
+		if len(val) == 1 {
+			return false
+		}
+		start = 1
+	}
+	for i := start; i < len(val); i++ {
+		if val[i] < '0' || val[i] > '9' {
+			return false
+		}
+	}
+	return true
+}
+
 func (n *NiriProvider) validateBindsContent(content string) error {
 	tmpFile, err := os.CreateTemp("", "dms-binds-*.kdl")
 	if err != nil {

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 {
@@ -265,22 +268,39 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBin
 		for _, arg := range actionNode.Arguments {
 			args = append(args, arg.ValueString())
 		}
+		if actionNode.Properties != nil {
+			if val, ok := actionNode.Properties.Get("focus"); ok {
+				args = append(args, "focus="+val.String())
+			}
+		}
 	}
 
 	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/niri_parser_test.go

@@ -496,3 +496,135 @@ func TestNiriParseMultipleArgs(t *testing.T) {
 		}
 	}
 }
+
+func TestNiriParseNumericWorkspaceBinds(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	content := `binds {
+    Mod+1 hotkey-overlay-title="Focus Workspace 1" { focus-workspace 1; }
+    Mod+2 hotkey-overlay-title="Focus Workspace 2" { focus-workspace 2; }
+    Mod+0 hotkey-overlay-title="Focus Workspace 10" { focus-workspace 10; }
+    Mod+Shift+1 hotkey-overlay-title="Move to Workspace 1" { move-column-to-workspace 1; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 4 {
+		t.Errorf("Expected 4 keybinds, got %d", len(result.Section.Keybinds))
+	}
+
+	for _, kb := range result.Section.Keybinds {
+		switch kb.Key {
+		case "1":
+			if len(kb.Mods) == 1 && kb.Mods[0] == "Mod" {
+				if kb.Action != "focus-workspace" || len(kb.Args) != 1 || kb.Args[0] != "1" {
+					t.Errorf("Mod+1 action/args mismatch: %+v", kb)
+				}
+				if kb.Description != "Focus Workspace 1" {
+					t.Errorf("Mod+1 description = %q, want 'Focus Workspace 1'", kb.Description)
+				}
+			}
+		case "0":
+			if kb.Action != "focus-workspace" || len(kb.Args) != 1 || kb.Args[0] != "10" {
+				t.Errorf("Mod+0 action/args mismatch: %+v", kb)
+			}
+		}
+	}
+}
+
+func TestNiriParseQuotedStringArgs(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	content := `binds {
+    Super+Minus hotkey-overlay-title="Adjust Column Width -10%" { set-column-width "-10%"; }
+    Super+Equal hotkey-overlay-title="Adjust Column Width +10%" { set-column-width "+10%"; }
+    Super+Shift+Minus hotkey-overlay-title="Adjust Window Height -10%" { set-window-height "-10%"; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 3 {
+		t.Errorf("Expected 3 keybinds, got %d", len(result.Section.Keybinds))
+	}
+
+	for _, kb := range result.Section.Keybinds {
+		if kb.Action == "set-column-width" {
+			if len(kb.Args) != 1 {
+				t.Errorf("set-column-width should have 1 arg, got %d", len(kb.Args))
+				continue
+			}
+			if kb.Args[0] != "-10%" && kb.Args[0] != "+10%" {
+				t.Errorf("set-column-width arg = %q, want -10%% or +10%%", kb.Args[0])
+			}
+		}
+	}
+}
+
+func TestNiriParseActionWithProperties(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	content := `binds {
+    Mod+Shift+1 hotkey-overlay-title="Move to Workspace 1" { move-column-to-workspace 1 focus=false; }
+    Mod+Shift+2 hotkey-overlay-title="Move to Workspace 2" { move-column-to-workspace 2 focus=false; }
+    Alt+Tab { next-window scope="output"; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 3 {
+		t.Errorf("Expected 3 keybinds, got %d", len(result.Section.Keybinds))
+	}
+
+	for _, kb := range result.Section.Keybinds {
+		switch kb.Action {
+		case "move-column-to-workspace":
+			if len(kb.Args) != 2 {
+				t.Errorf("move-column-to-workspace should have 2 args (index + focus), got %d", len(kb.Args))
+			}
+			hasIndex := false
+			hasFocus := false
+			for _, arg := range kb.Args {
+				if arg == "1" || arg == "2" {
+					hasIndex = true
+				}
+				if arg == "focus=false" {
+					hasFocus = true
+				}
+			}
+			if !hasIndex {
+				t.Errorf("move-column-to-workspace missing index arg")
+			}
+			if !hasFocus {
+				t.Errorf("move-column-to-workspace missing focus=false arg")
+			}
+		case "next-window":
+			if kb.Key != "Tab" {
+				t.Errorf("next-window key = %q, want 'Tab'", kb.Key)
+			}
+		}
+	}
+}

core/internal/keybinds/providers/niri_test.go

@@ -397,3 +397,211 @@ recent-windows {
 		t.Errorf("Expected at least 2 Alt-Tab binds, got %d", len(cheatSheet.Binds["Alt-Tab"]))
 	}
 }
+
+func TestNiriGenerateBindsContentNumericArgs(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	tests := []struct {
+		name     string
+		binds    map[string]*overrideBind
+		expected string
+	}{
+		{
+			name: "workspace with numeric arg",
+			binds: map[string]*overrideBind{
+				"Mod+1": {
+					Key:         "Mod+1",
+					Action:      "focus-workspace 1",
+					Description: "Focus Workspace 1",
+				},
+			},
+			expected: `binds {
+    Mod+1 hotkey-overlay-title="Focus Workspace 1" { focus-workspace 1; }
+}
+`,
+		},
+		{
+			name: "workspace with large numeric arg",
+			binds: map[string]*overrideBind{
+				"Mod+0": {
+					Key:         "Mod+0",
+					Action:      "focus-workspace 10",
+					Description: "Focus Workspace 10",
+				},
+			},
+			expected: `binds {
+    Mod+0 hotkey-overlay-title="Focus Workspace 10" { focus-workspace 10; }
+}
+`,
+		},
+		{
+			name: "percentage string arg (should be quoted)",
+			binds: map[string]*overrideBind{
+				"Super+Minus": {
+					Key:         "Super+Minus",
+					Action:      `set-column-width "-10%"`,
+					Description: "Adjust Column Width -10%",
+				},
+			},
+			expected: `binds {
+    Super+Minus hotkey-overlay-title="Adjust Column Width -10%" { set-column-width "-10%"; }
+}
+`,
+		},
+		{
+			name: "positive percentage string arg",
+			binds: map[string]*overrideBind{
+				"Super+Equal": {
+					Key:         "Super+Equal",
+					Action:      `set-column-width "+10%"`,
+					Description: "Adjust Column Width +10%",
+				},
+			},
+			expected: `binds {
+    Super+Equal hotkey-overlay-title="Adjust Column Width +10%" { set-column-width "+10%"; }
+}
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := provider.generateBindsContent(tt.binds)
+			if result != tt.expected {
+				t.Errorf("generateBindsContent() =\n%q\nwant:\n%q", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestNiriGenerateActionWithUnquotedPercentArg(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	binds := map[string]*overrideBind{
+		"Super+Equal": {
+			Key:         "Super+Equal",
+			Action:      "set-window-height +10%",
+			Description: "Adjust Window Height +10%",
+		},
+	}
+
+	content := provider.generateBindsContent(binds)
+	expected := `binds {
+    Super+Equal hotkey-overlay-title="Adjust Window Height +10%" { set-window-height "+10%"; }
+}
+`
+	if content != expected {
+		t.Errorf("Content mismatch.\nGot:\n%s\nWant:\n%s", content, expected)
+	}
+}
+
+func TestNiriGenerateSpawnWithNumericArgs(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	binds := map[string]*overrideBind{
+		"XF86AudioLowerVolume": {
+			Key:     "XF86AudioLowerVolume",
+			Action:  `spawn "dms" "ipc" "call" "audio" "decrement" "3"`,
+			Options: map[string]any{"allow-when-locked": true},
+		},
+	}
+
+	content := provider.generateBindsContent(binds)
+	expected := `binds {
+    XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
+}
+`
+	if content != expected {
+		t.Errorf("Content mismatch.\nGot:\n%s\nWant:\n%s", content, expected)
+	}
+}
+
+func TestNiriGenerateSpawnNumericArgFromCLI(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	binds := map[string]*overrideBind{
+		"XF86AudioLowerVolume": {
+			Key:     "XF86AudioLowerVolume",
+			Action:  "spawn dms ipc call audio decrement 3",
+			Options: map[string]any{"allow-when-locked": true},
+		},
+	}
+
+	content := provider.generateBindsContent(binds)
+	expected := `binds {
+    XF86AudioLowerVolume allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "decrement" "3"; }
+}
+`
+	if content != expected {
+		t.Errorf("Content mismatch.\nGot:\n%s\nWant:\n%s", content, expected)
+	}
+}
+
+func TestNiriGenerateWorkspaceBindsRoundTrip(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	binds := map[string]*overrideBind{
+		"Mod+1": {
+			Key:         "Mod+1",
+			Action:      "focus-workspace 1",
+			Description: "Focus Workspace 1",
+		},
+		"Mod+2": {
+			Key:         "Mod+2",
+			Action:      "focus-workspace 2",
+			Description: "Focus Workspace 2",
+		},
+		"Mod+Shift+1": {
+			Key:         "Mod+Shift+1",
+			Action:      "move-column-to-workspace 1",
+			Description: "Move to Workspace 1",
+		},
+		"Super+Minus": {
+			Key:         "Super+Minus",
+			Action:      "set-column-width -10%",
+			Description: "Adjust Column Width -10%",
+		},
+	}
+
+	content := provider.generateBindsContent(binds)
+
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write temp file: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("Failed to parse generated content: %v\nContent was:\n%s", err, content)
+	}
+
+	if len(result.Section.Keybinds) != 4 {
+		t.Errorf("Expected 4 keybinds after round-trip, got %d", len(result.Section.Keybinds))
+	}
+
+	foundFocusWS1 := false
+	foundMoveWS1 := false
+	foundSetWidth := false
+
+	for _, kb := range result.Section.Keybinds {
+		switch {
+		case kb.Action == "focus-workspace" && len(kb.Args) > 0 && kb.Args[0] == "1":
+			foundFocusWS1 = true
+		case kb.Action == "move-column-to-workspace" && len(kb.Args) > 0 && kb.Args[0] == "1":
+			foundMoveWS1 = true
+		case kb.Action == "set-column-width" && len(kb.Args) > 0 && kb.Args[0] == "-10%":
+			foundSetWidth = true
+		}
+	}
+
+	if !foundFocusWS1 {
+		t.Error("focus-workspace 1 not found after round-trip")
+	}
+	if !foundMoveWS1 {
+		t.Error("move-column-to-workspace 1 not found after round-trip")
+	}
+	if !foundSetWidth {
+		t.Error("set-column-width -10% not found after round-trip")
+	}
+}

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

@@ -0,0 +1,583 @@
+package matugen
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/dank16"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
+)
+
+var (
+	matugenVersionOnce sync.Once
+	matugenSupportsCOE bool
+)
+
+type Options struct {
+	StateDir            string
+	ShellDir            string
+	ConfigDir           string
+	Kind                string
+	Value               string
+	Mode                string
+	IconTheme           string
+	MatugenType         string
+	RunUserTemplates    bool
+	StockColors         string
+	SyncModeWithPortal  bool
+	TerminalsAlwaysDark bool
+}
+
+type ColorsOutput struct {
+	Colors struct {
+		Dark  map[string]string `json:"dark"`
+		Light map[string]string `json:"light"`
+	} `json:"colors"`
+}
+
+func (o *Options) ColorsOutput() string {
+	return filepath.Join(o.StateDir, "dms-colors.json")
+}
+
+func Run(opts Options) error {
+	if opts.StateDir == "" {
+		return fmt.Errorf("state-dir is required")
+	}
+	if opts.ShellDir == "" {
+		return fmt.Errorf("shell-dir is required")
+	}
+	if opts.ConfigDir == "" {
+		return fmt.Errorf("config-dir is required")
+	}
+	if opts.Kind == "" {
+		return fmt.Errorf("kind is required")
+	}
+	if opts.Value == "" {
+		return fmt.Errorf("value is required")
+	}
+	if opts.Mode == "" {
+		opts.Mode = "dark"
+	}
+	if opts.MatugenType == "" {
+		opts.MatugenType = "scheme-tonal-spot"
+	}
+	if opts.IconTheme == "" {
+		opts.IconTheme = "System Default"
+	}
+
+	if err := os.MkdirAll(opts.StateDir, 0755); err != nil {
+		return fmt.Errorf("failed to create state dir: %w", err)
+	}
+
+	log.Infof("Building theme: %s %s (%s)", opts.Kind, opts.Value, opts.Mode)
+
+	if err := buildOnce(&opts); err != nil {
+		return err
+	}
+
+	if opts.SyncModeWithPortal {
+		syncColorScheme(opts.Mode)
+	}
+
+	log.Info("Done")
+	return nil
+}
+
+func buildOnce(opts *Options) error {
+	cfgFile, err := os.CreateTemp("", "matugen-config-*.toml")
+	if err != nil {
+		return fmt.Errorf("failed to create temp config: %w", err)
+	}
+	defer os.Remove(cfgFile.Name())
+	defer cfgFile.Close()
+
+	tmpDir, err := os.MkdirTemp("", "matugen-templates-*")
+	if err != nil {
+		return fmt.Errorf("failed to create temp dir: %w", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	if err := buildMergedConfig(opts, cfgFile, tmpDir); err != nil {
+		return fmt.Errorf("failed to build config: %w", err)
+	}
+	cfgFile.Close()
+
+	var primaryDark, primaryLight, surface string
+	var dank16JSON string
+	var importArgs []string
+
+	if opts.StockColors != "" {
+		log.Info("Using stock/custom theme colors with matugen base")
+		primaryDark = extractNestedColor(opts.StockColors, "primary", "dark")
+		primaryLight = extractNestedColor(opts.StockColors, "primary", "light")
+		surface = extractNestedColor(opts.StockColors, "surface", "dark")
+
+		if primaryDark == "" {
+			return fmt.Errorf("failed to extract primary dark from stock colors")
+		}
+		if primaryLight == "" {
+			primaryLight = primaryDark
+		}
+
+		dank16JSON = generateDank16Variants(primaryDark, primaryLight, surface, opts.Mode)
+		importData := fmt.Sprintf(`{"colors": %s, "dank16": %s}`, opts.StockColors, dank16JSON)
+		importArgs = []string{"--import-json-string", importData}
+
+		log.Info("Running matugen color hex with stock color overrides")
+		args := []string{"color", "hex", primaryDark, "-m", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name()}
+		args = append(args, importArgs...)
+		if err := runMatugen(args); err != nil {
+			return err
+		}
+	} else {
+		log.Infof("Using dynamic theme from %s: %s", opts.Kind, opts.Value)
+
+		matJSON, err := runMatugenDryRun(opts)
+		if err != nil {
+			return fmt.Errorf("matugen dry-run failed: %w", err)
+		}
+
+		primaryDark = extractMatugenColor(matJSON, "primary", "dark")
+		primaryLight = extractMatugenColor(matJSON, "primary", "light")
+		surface = extractMatugenColor(matJSON, "surface", "dark")
+
+		if primaryDark == "" {
+			return fmt.Errorf("failed to extract primary color")
+		}
+		if primaryLight == "" {
+			primaryLight = primaryDark
+		}
+
+		dank16JSON = generateDank16Variants(primaryDark, primaryLight, surface, opts.Mode)
+		importData := fmt.Sprintf(`{"dank16": %s}`, dank16JSON)
+		importArgs = []string{"--import-json-string", importData}
+
+		log.Infof("Running matugen %s with dank16 injection", opts.Kind)
+		var args []string
+		switch opts.Kind {
+		case "hex":
+			args = []string{"color", "hex", opts.Value}
+		default:
+			args = []string{opts.Kind, opts.Value}
+		}
+		args = append(args, "-m", opts.Mode, "-t", opts.MatugenType, "-c", cfgFile.Name())
+		args = append(args, importArgs...)
+		if err := runMatugen(args); err != nil {
+			return err
+		}
+	}
+
+	refreshGTK(opts.ConfigDir, opts.Mode)
+	signalTerminals()
+
+	return nil
+}
+
+func buildMergedConfig(opts *Options, cfgFile *os.File, tmpDir string) error {
+	userConfigPath := filepath.Join(opts.ConfigDir, "matugen", "config.toml")
+
+	wroteConfig := false
+	if opts.RunUserTemplates {
+		if data, err := os.ReadFile(userConfigPath); err == nil {
+			configSection := extractTOMLSection(string(data), "[config]", "[templates]")
+			if configSection != "" {
+				cfgFile.WriteString(configSection)
+				cfgFile.WriteString("\n")
+				wroteConfig = true
+			}
+		}
+	}
+	if !wroteConfig {
+		cfgFile.WriteString("[config]\n\n")
+	}
+
+	baseConfigPath := filepath.Join(opts.ShellDir, "matugen", "configs", "base.toml")
+	if data, err := os.ReadFile(baseConfigPath); err == nil {
+		content := string(data)
+		lines := strings.Split(content, "\n")
+		for _, line := range lines {
+			if strings.TrimSpace(line) == "[config]" {
+				continue
+			}
+			cfgFile.WriteString(substituteShellDir(line, opts.ShellDir) + "\n")
+		}
+		cfgFile.WriteString("\n")
+	}
+
+	fmt.Fprintf(cfgFile, `[templates.dank]
+input_path = '%s/matugen/templates/dank.json'
+output_path = '%s'
+
+`, opts.ShellDir, opts.ColorsOutput())
+
+	switch opts.Mode {
+	case "light":
+		appendConfig(opts, cfgFile, "skip", "gtk3-light.toml")
+	default:
+		appendConfig(opts, cfgFile, "skip", "gtk3-dark.toml")
+	}
+
+	appendConfig(opts, cfgFile, "niri", "niri.toml")
+	appendConfig(opts, cfgFile, "qt5ct", "qt5ct.toml")
+	appendConfig(opts, cfgFile, "qt6ct", "qt6ct.toml")
+	appendConfig(opts, cfgFile, "firefox", "firefox.toml")
+	appendConfig(opts, cfgFile, "pywalfox", "pywalfox.toml")
+	appendConfig(opts, cfgFile, "vesktop", "vesktop.toml")
+
+	appendTerminalConfig(opts, cfgFile, tmpDir, "ghostty", "ghostty.toml")
+	appendTerminalConfig(opts, cfgFile, tmpDir, "kitty", "kitty.toml")
+	appendTerminalConfig(opts, cfgFile, tmpDir, "foot", "foot.toml")
+	appendTerminalConfig(opts, cfgFile, tmpDir, "alacritty", "alacritty.toml")
+	appendTerminalConfig(opts, cfgFile, tmpDir, "wezterm", "wezterm.toml")
+
+	appendConfig(opts, cfgFile, "dgop", "dgop.toml")
+
+	homeDir, _ := os.UserHomeDir()
+	appendVSCodeConfig(cfgFile, "vscode", filepath.Join(homeDir, ".vscode/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	appendVSCodeConfig(cfgFile, "codium", filepath.Join(homeDir, ".vscode-oss/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	appendVSCodeConfig(cfgFile, "codeoss", filepath.Join(homeDir, ".config/Code - OSS/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	appendVSCodeConfig(cfgFile, "cursor", filepath.Join(homeDir, ".cursor/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	appendVSCodeConfig(cfgFile, "windsurf", filepath.Join(homeDir, ".windsurf/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+
+	if opts.RunUserTemplates {
+		if data, err := os.ReadFile(userConfigPath); err == nil {
+			templatesSection := extractTOMLSection(string(data), "[templates]", "")
+			if templatesSection != "" {
+				cfgFile.WriteString(templatesSection)
+				cfgFile.WriteString("\n")
+			}
+		}
+	}
+
+	userPluginConfigDir := filepath.Join(opts.ConfigDir, "matugen", "dms", "configs")
+	if entries, err := os.ReadDir(userPluginConfigDir); err == nil {
+		for _, entry := range entries {
+			if !strings.HasSuffix(entry.Name(), ".toml") {
+				continue
+			}
+			if data, err := os.ReadFile(filepath.Join(userPluginConfigDir, entry.Name())); err == nil {
+				cfgFile.WriteString(string(data))
+				cfgFile.WriteString("\n")
+			}
+		}
+	}
+
+	return nil
+}
+
+func appendConfig(opts *Options, cfgFile *os.File, checkCmd, fileName string) {
+	configPath := filepath.Join(opts.ShellDir, "matugen", "configs", fileName)
+	if _, err := os.Stat(configPath); err != nil {
+		return
+	}
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
+		return
+	}
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return
+	}
+	cfgFile.WriteString(substituteShellDir(string(data), opts.ShellDir))
+	cfgFile.WriteString("\n")
+}
+
+func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir, checkCmd, fileName string) {
+	configPath := filepath.Join(opts.ShellDir, "matugen", "configs", fileName)
+	if _, err := os.Stat(configPath); err != nil {
+		return
+	}
+	if checkCmd != "skip" && !utils.CommandExists(checkCmd) {
+		return
+	}
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return
+	}
+
+	content := string(data)
+
+	if !opts.TerminalsAlwaysDark {
+		cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
+		cfgFile.WriteString("\n")
+		return
+	}
+
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		if !strings.Contains(line, "input_path") || !strings.Contains(line, "SHELL_DIR/matugen/templates/") {
+			continue
+		}
+
+		start := strings.Index(line, "'SHELL_DIR/matugen/templates/")
+		if start == -1 {
+			continue
+		}
+		end := strings.Index(line[start+1:], "'")
+		if end == -1 {
+			continue
+		}
+		templateName := line[start+len("'SHELL_DIR/matugen/templates/") : start+1+end]
+		origPath := filepath.Join(opts.ShellDir, "matugen", "templates", templateName)
+
+		origData, err := os.ReadFile(origPath)
+		if err != nil {
+			continue
+		}
+
+		modified := strings.ReplaceAll(string(origData), ".default.", ".dark.")
+		tmpPath := filepath.Join(tmpDir, templateName)
+		if err := os.WriteFile(tmpPath, []byte(modified), 0644); err != nil {
+			continue
+		}
+
+		content = strings.ReplaceAll(content,
+			fmt.Sprintf("'SHELL_DIR/matugen/templates/%s'", templateName),
+			fmt.Sprintf("'%s'", tmpPath))
+	}
+
+	cfgFile.WriteString(substituteShellDir(content, opts.ShellDir))
+	cfgFile.WriteString("\n")
+}
+
+func appendVSCodeConfig(cfgFile *os.File, name, extDir, shellDir string) {
+	if _, err := os.Stat(extDir); err != nil {
+		return
+	}
+	templateDir := filepath.Join(shellDir, "matugen", "templates")
+	fmt.Fprintf(cfgFile, `[templates.dms%sdefault]
+input_path = '%s/vscode-color-theme-default.json'
+output_path = '%s/themes/dankshell-default.json'
+
+[templates.dms%sdark]
+input_path = '%s/vscode-color-theme-dark.json'
+output_path = '%s/themes/dankshell-dark.json'
+
+[templates.dms%slight]
+input_path = '%s/vscode-color-theme-light.json'
+output_path = '%s/themes/dankshell-light.json'
+
+`, name, templateDir, extDir,
+		name, templateDir, extDir,
+		name, templateDir, extDir)
+	log.Infof("Added %s theme config (extension found at %s)", name, extDir)
+}
+
+func substituteShellDir(content, shellDir string) string {
+	return strings.ReplaceAll(content, "'SHELL_DIR/", "'"+shellDir+"/")
+}
+
+func extractTOMLSection(content, startMarker, endMarker string) string {
+	startIdx := strings.Index(content, startMarker)
+	if startIdx == -1 {
+		return ""
+	}
+
+	if endMarker == "" {
+		return content[startIdx:]
+	}
+
+	endIdx := strings.Index(content[startIdx:], endMarker)
+	if endIdx == -1 {
+		return content[startIdx:]
+	}
+	return content[startIdx : startIdx+endIdx]
+}
+
+func checkMatugenVersion() {
+	matugenVersionOnce.Do(func() {
+		cmd := exec.Command("matugen", "--version")
+		output, err := cmd.Output()
+		if err != nil {
+			return
+		}
+
+		versionStr := strings.TrimSpace(string(output))
+		versionStr = strings.TrimPrefix(versionStr, "matugen ")
+
+		parts := strings.Split(versionStr, ".")
+		if len(parts) < 2 {
+			return
+		}
+
+		major, err := strconv.Atoi(parts[0])
+		if err != nil {
+			return
+		}
+
+		minor, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return
+		}
+
+		matugenSupportsCOE = major > 3 || (major == 3 && minor >= 1)
+		if matugenSupportsCOE {
+			log.Infof("Matugen %s supports --continue-on-error", versionStr)
+		}
+	})
+}
+
+func runMatugen(args []string) error {
+	checkMatugenVersion()
+
+	if matugenSupportsCOE {
+		args = append([]string{"--continue-on-error"}, args...)
+	}
+
+	cmd := exec.Command("matugen", args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func runMatugenDryRun(opts *Options) (string, error) {
+	var args []string
+	switch opts.Kind {
+	case "hex":
+		args = []string{"color", "hex", opts.Value}
+	default:
+		args = []string{opts.Kind, opts.Value}
+	}
+	args = append(args, "-m", "dark", "-t", opts.MatugenType, "--json", "hex", "--dry-run")
+
+	cmd := exec.Command("matugen", args...)
+	output, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.ReplaceAll(string(output), "\n", ""), nil
+}
+
+func extractMatugenColor(jsonStr, colorName, variant string) string {
+	var data map[string]any
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ""
+	}
+
+	colors, ok := data["colors"].(map[string]any)
+	if !ok {
+		return ""
+	}
+
+	colorData, ok := colors[colorName].(map[string]any)
+	if !ok {
+		return ""
+	}
+
+	variantData, ok := colorData[variant].(string)
+	if !ok {
+		return ""
+	}
+
+	return variantData
+}
+
+func extractNestedColor(jsonStr, colorName, variant string) string {
+	var data map[string]any
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ""
+	}
+
+	colorData, ok := data[colorName].(map[string]any)
+	if !ok {
+		return ""
+	}
+
+	variantData, ok := colorData[variant].(map[string]any)
+	if !ok {
+		return ""
+	}
+
+	color, ok := variantData["color"].(string)
+	if !ok {
+		return ""
+	}
+
+	return color
+}
+
+func generateDank16Variants(primaryDark, primaryLight, surface, mode string) string {
+	variantOpts := dank16.VariantOptions{
+		PrimaryDark:  primaryDark,
+		PrimaryLight: primaryLight,
+		Background:   surface,
+		UseDPS:       true,
+		IsLightMode:  mode == "light",
+	}
+	variantColors := dank16.GenerateVariantPalette(variantOpts)
+	return dank16.GenerateVariantJSON(variantColors)
+}
+
+func refreshGTK(configDir, mode string) {
+	gtkCSS := filepath.Join(configDir, "gtk-3.0", "gtk.css")
+
+	info, err := os.Lstat(gtkCSS)
+	if err != nil {
+		return
+	}
+
+	shouldRun := false
+	if info.Mode()&os.ModeSymlink != 0 {
+		target, err := os.Readlink(gtkCSS)
+		if err == nil && strings.Contains(target, "dank-colors.css") {
+			shouldRun = true
+		}
+	} else {
+		data, err := os.ReadFile(gtkCSS)
+		if err == nil && strings.Contains(string(data), "dank-colors.css") {
+			shouldRun = true
+		}
+	}
+
+	if !shouldRun {
+		return
+	}
+
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "").Run()
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "adw-gtk3-"+mode).Run()
+}
+
+func signalTerminals() {
+	signalByName("kitty", syscall.SIGUSR1)
+	signalByName("ghostty", syscall.SIGUSR2)
+	signalByName(".kitty-wrapped", syscall.SIGUSR1)
+	signalByName(".ghostty-wrappe", syscall.SIGUSR2)
+}
+
+func signalByName(name string, sig syscall.Signal) {
+	entries, err := os.ReadDir("/proc")
+	if err != nil {
+		return
+	}
+	for _, entry := range entries {
+		pid, err := strconv.Atoi(entry.Name())
+		if err != nil {
+			continue
+		}
+		comm, err := os.ReadFile(filepath.Join("/proc", entry.Name(), "comm"))
+		if err != nil {
+			continue
+		}
+		if strings.TrimSpace(string(comm)) == name {
+			syscall.Kill(pid, sig)
+		}
+	}
+}
+
+func syncColorScheme(mode string) {
+	scheme := "prefer-dark"
+	if mode == "light" {
+		scheme = "default"
+	}
+
+	if err := exec.Command("gsettings", "set", "org.gnome.desktop.interface", "color-scheme", scheme).Run(); err != nil {
+		exec.Command("dconf", "write", "/org/gnome/desktop/interface/color-scheme", "'"+scheme+"'").Run()
+	}
+}

core/internal/matugen/queue.go

@@ -0,0 +1,139 @@
+package matugen
+
+import (
+	"context"
+	"sync"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+)
+
+type Result struct {
+	Success bool
+	Error   error
+}
+
+type QueuedJob struct {
+	Options Options
+	Done    chan Result
+	Ctx     context.Context
+	Cancel  context.CancelFunc
+}
+
+type Queue struct {
+	mu      sync.Mutex
+	current *QueuedJob
+	pending *QueuedJob
+	jobDone chan struct{}
+}
+
+var globalQueue *Queue
+var queueOnce sync.Once
+
+func GetQueue() *Queue {
+	queueOnce.Do(func() {
+		globalQueue = &Queue{
+			jobDone: make(chan struct{}, 1),
+		}
+	})
+	return globalQueue
+}
+
+func (q *Queue) Submit(opts Options) <-chan Result {
+	result := make(chan Result, 1)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	job := &QueuedJob{
+		Options: opts,
+		Done:    result,
+		Ctx:     ctx,
+		Cancel:  cancel,
+	}
+
+	q.mu.Lock()
+
+	if q.pending != nil {
+		log.Info("Cancelling pending theme request")
+		q.pending.Cancel()
+		q.pending.Done <- Result{Success: false, Error: context.Canceled}
+		close(q.pending.Done)
+	}
+
+	if q.current != nil {
+		q.pending = job
+		q.mu.Unlock()
+		log.Info("Theme request queued (worker running)")
+		return result
+	}
+
+	q.current = job
+	q.mu.Unlock()
+
+	go q.runWorker()
+	return result
+}
+
+func (q *Queue) runWorker() {
+	for {
+		q.mu.Lock()
+		job := q.current
+		if job == nil {
+			q.mu.Unlock()
+			return
+		}
+		q.mu.Unlock()
+
+		select {
+		case <-job.Ctx.Done():
+			q.finishJob(Result{Success: false, Error: context.Canceled})
+			continue
+		default:
+		}
+
+		log.Infof("Processing theme: %s %s (%s)", job.Options.Kind, job.Options.Value, job.Options.Mode)
+		err := Run(job.Options)
+
+		var result Result
+		if err != nil {
+			result = Result{Success: false, Error: err}
+		} else {
+			result = Result{Success: true}
+		}
+
+		q.finishJob(result)
+	}
+}
+
+func (q *Queue) finishJob(result Result) {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+
+	if q.current != nil {
+		select {
+		case q.current.Done <- result:
+		default:
+		}
+		close(q.current.Done)
+	}
+
+	q.current = q.pending
+	q.pending = nil
+
+	if q.current == nil {
+		select {
+		case q.jobDone <- struct{}{}:
+		default:
+		}
+	}
+}
+
+func (q *Queue) IsRunning() bool {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	return q.current != nil
+}
+
+func (q *Queue) HasPending() bool {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	return q.pending != nil
+}

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/dwl_ipc/dwl_ipc.go

@@ -44,7 +44,7 @@ func NewZdwlIpcManagerV2(ctx *client.Context) *ZdwlIpcManagerV2 {
 // Indicates that the client will not the dwl_ipc_manager object anymore.
 // Objects created through this instance are not affected.
 func (i *ZdwlIpcManagerV2) Release() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -188,7 +188,7 @@ func NewZdwlIpcOutputV2(ctx *client.Context) *ZdwlIpcOutputV2 {
 //
 // Indicates to that the client no longer needs this dwl_ipc_output.
 func (i *ZdwlIpcOutputV2) Release() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/ext_workspace/workspace.go

@@ -174,7 +174,7 @@ func (i *ExtWorkspaceManagerV1) Stop() error {
 }
 
 func (i *ExtWorkspaceManagerV1) Destroy() error {
-	i.Context().Unregister(i)
+	i.MarkZombie()
 	return nil
 }
 
@@ -385,7 +385,7 @@ func (i *ExtWorkspaceGroupHandleV1) CreateWorkspace(workspace string) error {
 // use the workspace group object any more or after the removed event to finalize
 // the destruction of the object.
 func (i *ExtWorkspaceGroupHandleV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -655,7 +655,7 @@ func NewExtWorkspaceHandleV1(ctx *client.Context) *ExtWorkspaceHandleV1 {
 // use the workspace object any more or after the remove event to finalize
 // the destruction of the object.
 func (i *ExtWorkspaceHandleV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/keyboard_shortcuts_inhibit/keyboard_shortcuts_inhibit.go

@@ -54,7 +54,7 @@ func NewZwpKeyboardShortcutsInhibitManagerV1(ctx *client.Context) *ZwpKeyboardSh
 //
 // Destroy the keyboard shortcuts inhibitor manager.
 func (i *ZwpKeyboardShortcutsInhibitManagerV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -218,7 +218,7 @@ func NewZwpKeyboardShortcutsInhibitorV1(ctx *client.Context) *ZwpKeyboardShortcu
 //
 // Remove the keyboard shortcuts inhibitor from the associated wl_surface.
 func (i *ZwpKeyboardShortcutsInhibitorV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/wlr_gamma_control/gamma_control.go

@@ -85,7 +85,7 @@ func (i *ZwlrGammaControlManagerV1) GetGammaControl(output *client.Output) (*Zwl
 // All objects created by the manager will still remain valid, until their
 // appropriate destroy request has been called.
 func (i *ZwlrGammaControlManagerV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -169,7 +169,7 @@ func (i *ZwlrGammaControlV1) SetGamma(fd int) error {
 // Destroys the gamma control object. If the object is still valid, this
 // restores the original gamma tables.
 func (i *ZwlrGammaControlV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/wlr_layer_shell/layer_shell.go

@@ -129,7 +129,7 @@ func (i *ZwlrLayerShellV1) GetLayerSurface(surface *client.Surface, output *clie
 // object any more. Objects that have been created through this instance
 // are not affected.
 func (i *ZwlrLayerShellV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -509,7 +509,7 @@ func (i *ZwlrLayerSurfaceV1) AckConfigure(serial uint32) error {
 //
 // This request destroys the layer surface.
 func (i *ZwlrLayerSurfaceV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 7
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/wlr_output_management/output_management.go

@@ -172,7 +172,7 @@ func (i *ZwlrOutputManagerV1) Stop() error {
 }
 
 func (i *ZwlrOutputManagerV1) Destroy() error {
-	i.Context().Unregister(i)
+	i.MarkZombie()
 	return nil
 }
 
@@ -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)
@@ -334,7 +342,7 @@ func NewZwlrOutputHeadV1(ctx *client.Context) *ZwlrOutputHeadV1 {
 // This request indicates that the client will no longer use this head
 // object.
 func (i *ZwlrOutputHeadV1) Release() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -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)
@@ -879,7 +914,7 @@ func NewZwlrOutputModeV1(ctx *client.Context) *ZwlrOutputModeV1 {
 // This request indicates that the client will no longer use this mode
 // object.
 func (i *ZwlrOutputModeV1) Release() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -1132,7 +1167,7 @@ func (i *ZwlrOutputConfigurationV1) Test() error {
 // This request also destroys wlr_output_configuration_head objects created
 // via this object.
 func (i *ZwlrOutputConfigurationV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 4
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -1415,7 +1450,7 @@ func (i *ZwlrOutputConfigurationHeadV1) SetAdaptiveSync(state uint32) error {
 }
 
 func (i *ZwlrOutputConfigurationHeadV1) Destroy() error {
-	i.Context().Unregister(i)
+	i.MarkZombie()
 	return nil
 }
 

core/internal/proto/wlr_output_power/output_power.go

@@ -79,7 +79,7 @@ func (i *ZwlrOutputPowerManagerV1) GetOutputPower(output *client.Output) (*ZwlrO
 // All objects created by the manager will still remain valid, until their
 // appropriate destroy request has been called.
 func (i *ZwlrOutputPowerManagerV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -143,7 +143,7 @@ func (i *ZwlrOutputPowerV1) SetMode(mode uint32) error {
 //
 // Destroys the output power management mode control object.
 func (i *ZwlrOutputPowerV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/wlr_screencopy/screencopy.go

@@ -120,7 +120,7 @@ func (i *ZwlrScreencopyManagerV1) CaptureOutputRegion(overlayCursor int32, outpu
 // All objects created by the manager will still remain valid, until their
 // appropriate destroy request has been called.
 func (i *ZwlrScreencopyManagerV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 2
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -219,7 +219,7 @@ func (i *ZwlrScreencopyFrameV1) Copy(buffer *client.Buffer) error {
 //
 // Destroys the frame. This request can be sent at any time by the client.
 func (i *ZwlrScreencopyFrameV1) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 1
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/proto/wp_viewporter/viewporter.go

@@ -66,7 +66,7 @@ func NewWpViewporter(ctx *client.Context) *WpViewporter {
 // protocol object anymore. This does not affect any other objects,
 // wp_viewport objects included.
 func (i *WpViewporter) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte
@@ -267,7 +267,7 @@ func NewWpViewport(ctx *client.Context) *WpViewport {
 // The associated wl_surface's crop and scale state is removed.
 // The change is applied on the next wl_surface.commit.
 func (i *WpViewport) Destroy() error {
-	defer i.Context().Unregister(i)
+	defer i.MarkZombie()
 	const opcode = 0
 	const _reqBufLen = 8
 	var _reqBuf [_reqBufLen]byte

core/internal/screenshot/compositor.go

@@ -0,0 +1,651 @@
+package screenshot
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"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"
+)
+
+type Compositor int
+
+const (
+	CompositorUnknown Compositor = iota
+	CompositorHyprland
+	CompositorSway
+	CompositorNiri
+	CompositorDWL
+	CompositorScroll
+)
+
+var detectedCompositor Compositor = -1
+
+func DetectCompositor() Compositor {
+	if detectedCompositor >= 0 {
+		return detectedCompositor
+	}
+
+	hyprlandSig := os.Getenv("HYPRLAND_INSTANCE_SIGNATURE")
+	niriSocket := os.Getenv("NIRI_SOCKET")
+	swaySocket := os.Getenv("SWAYSOCK")
+	scrollSocket := os.Getenv("SCROLLSOCK")
+
+	switch {
+	case niriSocket != "":
+		if _, err := os.Stat(niriSocket); err == nil {
+			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
+			return detectedCompositor
+		}
+	case hyprlandSig != "":
+		detectedCompositor = CompositorHyprland
+		return detectedCompositor
+	}
+
+	if detectDWLProtocol() {
+		detectedCompositor = CompositorDWL
+		return detectedCompositor
+	}
+
+	detectedCompositor = CompositorUnknown
+	return detectedCompositor
+}
+
+func detectDWLProtocol() bool {
+	display, err := client.Connect("")
+	if err != nil {
+		return false
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return false
+	}
+
+	found := false
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		if e.Interface == dwl_ipc.ZdwlIpcManagerV2InterfaceName {
+			found = true
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return false
+	}
+
+	return found
+}
+
+func SetCompositorDWL() {
+	detectedCompositor = CompositorDWL
+}
+
+type WindowGeometry struct {
+	X               int32
+	Y               int32
+	Width           int32
+	Height          int32
+	Output          string
+	Scale           float64
+	OutputX         int32
+	OutputY         int32
+	OutputTransform int32
+}
+
+func GetActiveWindow() (*WindowGeometry, error) {
+	switch DetectCompositor() {
+	case CompositorHyprland:
+		return getHyprlandActiveWindow()
+	case CompositorDWL:
+		return getDWLActiveWindow()
+	default:
+		return nil, fmt.Errorf("window capture requires Hyprland or DWL")
+	}
+}
+
+type hyprlandWindow struct {
+	At   [2]int32 `json:"at"`
+	Size [2]int32 `json:"size"`
+}
+
+func getHyprlandActiveWindow() (*WindowGeometry, error) {
+	output, err := exec.Command("hyprctl", "-j", "activewindow").Output()
+	if err != nil {
+		return nil, fmt.Errorf("hyprctl activewindow: %w", err)
+	}
+
+	var win hyprlandWindow
+	if err := json.Unmarshal(output, &win); err != nil {
+		return nil, fmt.Errorf("parse activewindow: %w", err)
+	}
+
+	if win.Size[0] <= 0 || win.Size[1] <= 0 {
+		return nil, fmt.Errorf("no active window")
+	}
+
+	return &WindowGeometry{
+		X:      win.At[0],
+		Y:      win.At[1],
+		Width:  win.Size[0],
+		Height: win.Size[1],
+	}, nil
+}
+
+type hyprlandMonitor struct {
+	Name    string  `json:"name"`
+	X       int32   `json:"x"`
+	Y       int32   `json:"y"`
+	Width   int32   `json:"width"`
+	Height  int32   `json:"height"`
+	Scale   float64 `json:"scale"`
+	Focused bool    `json:"focused"`
+}
+
+func GetHyprlandMonitorScale(name string) float64 {
+	output, err := exec.Command("hyprctl", "-j", "monitors").Output()
+	if err != nil {
+		return 0
+	}
+
+	var monitors []hyprlandMonitor
+	if err := json.Unmarshal(output, &monitors); err != nil {
+		return 0
+	}
+
+	for _, m := range monitors {
+		if m.Name == name {
+			return m.Scale
+		}
+	}
+	return 0
+}
+
+func getHyprlandFocusedMonitor() string {
+	output, err := exec.Command("hyprctl", "-j", "monitors").Output()
+	if err != nil {
+		return ""
+	}
+
+	var monitors []hyprlandMonitor
+	if err := json.Unmarshal(output, &monitors); err != nil {
+		return ""
+	}
+
+	for _, m := range monitors {
+		if m.Focused {
+			return m.Name
+		}
+	}
+	return ""
+}
+
+func GetHyprlandMonitorGeometry(name string) (x, y, w, h int32, ok bool) {
+	output, err := exec.Command("hyprctl", "-j", "monitors").Output()
+	if err != nil {
+		return 0, 0, 0, 0, false
+	}
+
+	var monitors []hyprlandMonitor
+	if err := json.Unmarshal(output, &monitors); err != nil {
+		return 0, 0, 0, 0, false
+	}
+
+	for _, m := range monitors {
+		if m.Name == name {
+			logicalW := int32(float64(m.Width) / m.Scale)
+			logicalH := int32(float64(m.Height) / m.Scale)
+			return m.X, m.Y, logicalW, logicalH, true
+		}
+	}
+	return 0, 0, 0, 0, false
+}
+
+type swayWorkspace struct {
+	Output  string `json:"output"`
+	Focused bool   `json:"focused"`
+}
+
+func getSwayFocusedMonitor() string {
+	output, err := exec.Command("swaymsg", "-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 ""
+}
+
+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"`
+}
+
+func getNiriFocusedMonitor() string {
+	output, err := exec.Command("niri", "msg", "-j", "workspaces").Output()
+	if err != nil {
+		return ""
+	}
+
+	var workspaces []niriWorkspace
+	if err := json.Unmarshal(output, &workspaces); err != nil {
+		return ""
+	}
+
+	for _, ws := range workspaces {
+		if ws.IsFocused {
+			return ws.Output
+		}
+	}
+	return ""
+}
+
+var dwlActiveOutput string
+
+func SetDWLActiveOutput(name string) {
+	dwlActiveOutput = name
+}
+
+func getDWLFocusedMonitor() string {
+	if dwlActiveOutput != "" {
+		return dwlActiveOutput
+	}
+	return queryDWLActiveOutput()
+}
+
+func queryDWLActiveOutput() string {
+	display, err := client.Connect("")
+	if err != nil {
+		return ""
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return ""
+	}
+
+	var dwlManager *dwl_ipc.ZdwlIpcManagerV2
+	outputs := make(map[uint32]*client.Output)
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		switch e.Interface {
+		case dwl_ipc.ZdwlIpcManagerV2InterfaceName:
+			mgr := dwl_ipc.NewZdwlIpcManagerV2(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+				dwlManager = mgr
+			}
+		case client.OutputInterfaceName:
+			out := client.NewOutput(ctx)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, out); err == nil {
+				outputs[e.Name] = out
+			}
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return ""
+	}
+
+	if dwlManager == nil || len(outputs) == 0 {
+		return ""
+	}
+
+	outputNames := make(map[uint32]string)
+	for name, out := range outputs {
+		n := name
+		out.SetNameHandler(func(e client.OutputNameEvent) {
+			outputNames[n] = e.Name
+		})
+	}
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return ""
+	}
+
+	type outputState struct {
+		name     string
+		active   bool
+		gotFrame bool
+	}
+	states := make(map[uint32]*outputState)
+
+	for name, out := range outputs {
+		dwlOut, err := dwlManager.GetOutput(out)
+		if err != nil {
+			continue
+		}
+		state := &outputState{name: outputNames[name]}
+		states[name] = state
+
+		dwlOut.SetActiveHandler(func(e dwl_ipc.ZdwlIpcOutputV2ActiveEvent) {
+			state.active = e.Active != 0
+		})
+		dwlOut.SetFrameHandler(func(e dwl_ipc.ZdwlIpcOutputV2FrameEvent) {
+			state.gotFrame = true
+		})
+	}
+
+	allFramesReceived := func() bool {
+		for _, s := range states {
+			if !s.gotFrame {
+				return false
+			}
+		}
+		return true
+	}
+
+	for !allFramesReceived() {
+		if err := ctx.Dispatch(); err != nil {
+			return ""
+		}
+	}
+
+	for _, state := range states {
+		if state.active {
+			return state.name
+		}
+	}
+
+	return ""
+}
+
+func GetFocusedMonitor() string {
+	switch DetectCompositor() {
+	case CompositorHyprland:
+		return getHyprlandFocusedMonitor()
+	case CompositorSway:
+		return getSwayFocusedMonitor()
+	case CompositorScroll:
+		return getScrollFocusedMonitor()
+	case CompositorNiri:
+		return getNiriFocusedMonitor()
+	case CompositorDWL:
+		return getDWLFocusedMonitor()
+	}
+	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 {
+		return nil, fmt.Errorf("connect: %w", err)
+	}
+	ctx := display.Context()
+	defer ctx.Close()
+
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return nil, fmt.Errorf("get registry: %w", err)
+	}
+
+	var dwlManager *dwl_ipc.ZdwlIpcManagerV2
+	outputs := make(map[uint32]*client.Output)
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		switch e.Interface {
+		case dwl_ipc.ZdwlIpcManagerV2InterfaceName:
+			mgr := dwl_ipc.NewZdwlIpcManagerV2(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+				dwlManager = mgr
+			}
+		case client.OutputInterfaceName:
+			out := client.NewOutput(ctx)
+			version := e.Version
+			if version > 4 {
+				version = 4
+			}
+			if err := registry.Bind(e.Name, e.Interface, version, out); err == nil {
+				outputs[e.Name] = out
+			}
+		}
+	})
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	if dwlManager == nil {
+		return nil, fmt.Errorf("dwl_ipc_manager not available")
+	}
+
+	if len(outputs) == 0 {
+		return nil, fmt.Errorf("no outputs found")
+	}
+
+	outputNames := make(map[uint32]string)
+	for name, out := range outputs {
+		n := name
+		out.SetNameHandler(func(e client.OutputNameEvent) {
+			outputNames[n] = e.Name
+		})
+	}
+
+	if err := wlhelpers.Roundtrip(display, ctx); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	type dwlOutputState struct {
+		output      *dwl_ipc.ZdwlIpcOutputV2
+		name        string
+		active      bool
+		x, y        int32
+		w, h        int32
+		scalefactor uint32
+		gotFrame    bool
+	}
+
+	dwlOutputs := make(map[uint32]*dwlOutputState)
+	for name, out := range outputs {
+		dwlOut, err := dwlManager.GetOutput(out)
+		if err != nil {
+			continue
+		}
+		state := &dwlOutputState{output: dwlOut, name: outputNames[name]}
+		dwlOutputs[name] = state
+
+		dwlOut.SetActiveHandler(func(e dwl_ipc.ZdwlIpcOutputV2ActiveEvent) {
+			state.active = e.Active != 0
+		})
+		dwlOut.SetXHandler(func(e dwl_ipc.ZdwlIpcOutputV2XEvent) {
+			state.x = e.X
+		})
+		dwlOut.SetYHandler(func(e dwl_ipc.ZdwlIpcOutputV2YEvent) {
+			state.y = e.Y
+		})
+		dwlOut.SetWidthHandler(func(e dwl_ipc.ZdwlIpcOutputV2WidthEvent) {
+			state.w = e.Width
+		})
+		dwlOut.SetHeightHandler(func(e dwl_ipc.ZdwlIpcOutputV2HeightEvent) {
+			state.h = e.Height
+		})
+		dwlOut.SetScalefactorHandler(func(e dwl_ipc.ZdwlIpcOutputV2ScalefactorEvent) {
+			state.scalefactor = e.Scalefactor
+		})
+		dwlOut.SetFrameHandler(func(e dwl_ipc.ZdwlIpcOutputV2FrameEvent) {
+			state.gotFrame = true
+		})
+	}
+
+	allFramesReceived := func() bool {
+		for _, s := range dwlOutputs {
+			if !s.gotFrame {
+				return false
+			}
+		}
+		return true
+	}
+
+	for !allFramesReceived() {
+		if err := ctx.Dispatch(); err != nil {
+			return nil, fmt.Errorf("dispatch: %w", err)
+		}
+	}
+
+	for _, state := range dwlOutputs {
+		if !state.active {
+			continue
+		}
+		if state.w <= 0 || state.h <= 0 {
+			return nil, fmt.Errorf("no active window")
+		}
+		scale := float64(state.scalefactor) / 100.0
+		if scale <= 0 {
+			scale = 1.0
+		}
+
+		geom := &WindowGeometry{
+			X:      state.x,
+			Y:      state.y,
+			Width:  state.w,
+			Height: state.h,
+			Output: state.name,
+			Scale:  scale,
+		}
+
+		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

@@ -0,0 +1,166 @@
+package screenshot
+
+import (
+	"bufio"
+	"fmt"
+	"image"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
+)
+
+func BufferToImage(buf *ShmBuffer) *image.RGBA {
+	return BufferToImageWithFormat(buf, uint32(FormatARGB8888))
+}
+
+func BufferToImageWithFormat(buf *ShmBuffer, format uint32) *image.RGBA {
+	img := image.NewRGBA(image.Rect(0, 0, buf.Width, buf.Height))
+	data := buf.Data()
+
+	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
+		dstOff := y * img.Stride
+		for x := 0; x < buf.Width; x++ {
+			si := srcOff + x*4
+			di := dstOff + x*4
+			if si+3 >= len(data) || di+3 >= len(img.Pix) {
+				continue
+			}
+			if swapRB {
+				img.Pix[di+0] = data[si+2]
+				img.Pix[di+1] = data[si+1]
+				img.Pix[di+2] = data[si+0]
+			} else {
+				img.Pix[di+0] = data[si+0]
+				img.Pix[di+1] = data[si+1]
+				img.Pix[di+2] = data[si+2]
+			}
+			img.Pix[di+3] = 255
+		}
+	}
+	return img
+}
+
+func EncodePNG(w io.Writer, img image.Image) error {
+	enc := png.Encoder{CompressionLevel: png.BestSpeed}
+	return enc.Encode(w, img)
+}
+
+func EncodeJPEG(w io.Writer, img image.Image, quality int) error {
+	return jpeg.Encode(w, img, &jpeg.Options{Quality: quality})
+}
+
+func EncodePPM(w io.Writer, img *image.RGBA) error {
+	bw := bufio.NewWriter(w)
+	bounds := img.Bounds()
+	if _, err := fmt.Fprintf(bw, "P6\n%d %d\n255\n", bounds.Dx(), bounds.Dy()); err != nil {
+		return err
+	}
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			off := (y-bounds.Min.Y)*img.Stride + (x-bounds.Min.X)*4
+			if err := bw.WriteByte(img.Pix[off+0]); err != nil {
+				return err
+			}
+			if err := bw.WriteByte(img.Pix[off+1]); err != nil {
+				return err
+			}
+			if err := bw.WriteByte(img.Pix[off+2]); err != nil {
+				return err
+			}
+		}
+	}
+	return bw.Flush()
+}
+
+func GenerateFilename(format Format) string {
+	t := time.Now()
+	ext := "png"
+	switch format {
+	case FormatJPEG:
+		ext = "jpg"
+	case FormatPPM:
+		ext = "ppm"
+	}
+	return fmt.Sprintf("screenshot_%s.%s", t.Format("2006-01-02_15-04-05"), ext)
+}
+
+func GetOutputDir() string {
+	if dir := os.Getenv("DMS_SCREENSHOT_DIR"); dir != "" {
+		return dir
+	}
+
+	if xdgPics := getXDGPicturesDir(); xdgPics != "" {
+		screenshotDir := filepath.Join(xdgPics, "Screenshots")
+		if err := os.MkdirAll(screenshotDir, 0755); err == nil {
+			return screenshotDir
+		}
+		return xdgPics
+	}
+
+	if home := os.Getenv("HOME"); home != "" {
+		return home
+	}
+	return "."
+}
+
+func getXDGPicturesDir() string {
+	userDirsFile := filepath.Join(utils.XDGConfigHome(), "user-dirs.dirs")
+	data, err := os.ReadFile(userDirsFile)
+	if err != nil {
+		return ""
+	}
+
+	for _, line := range strings.Split(string(data), "\n") {
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		const prefix = "XDG_PICTURES_DIR="
+		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 WriteToFile(buf *ShmBuffer, path string, format Format, quality int) error {
+	return WriteToFileWithFormat(buf, path, format, quality, uint32(FormatARGB8888))
+}
+
+func WriteToFileWithFormat(buf *ShmBuffer, path string, format Format, quality int, pixelFormat uint32) error {
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	img := BufferToImageWithFormat(buf, pixelFormat)
+	switch format {
+	case FormatJPEG:
+		return EncodeJPEG(f, img, quality)
+	case FormatPPM:
+		return EncodePPM(f, img)
+	default:
+		return EncodePNG(f, img)
+	}
+}

core/internal/screenshot/notify.go

@@ -0,0 +1,180 @@
+package screenshot
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"syscall"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/godbus/dbus/v5"
+)
+
+const (
+	notifyDest      = "org.freedesktop.Notifications"
+	notifyPath      = "/org/freedesktop/Notifications"
+	notifyInterface = "org.freedesktop.Notifications"
+)
+
+type NotifyResult struct {
+	FilePath  string
+	Clipboard bool
+	ImageData []byte
+	Width     int
+	Height    int
+}
+
+func SendNotification(result NotifyResult) {
+	conn, err := dbus.SessionBus()
+	if err != nil {
+		log.Debug("dbus session failed", "err", err)
+		return
+	}
+
+	var actions []string
+	if result.FilePath != "" {
+		actions = []string{"default", "Open"}
+	}
+
+	hints := map[string]dbus.Variant{}
+	if len(result.ImageData) > 0 && result.Width > 0 && result.Height > 0 {
+		rowstride := result.Width * 3
+		hints["image_data"] = dbus.MakeVariant(struct {
+			Width         int32
+			Height        int32
+			Rowstride     int32
+			HasAlpha      bool
+			BitsPerSample int32
+			Channels      int32
+			Data          []byte
+		}{
+			Width:         int32(result.Width),
+			Height:        int32(result.Height),
+			Rowstride:     int32(rowstride),
+			HasAlpha:      false,
+			BitsPerSample: 8,
+			Channels:      3,
+			Data:          result.ImageData,
+		})
+	} else if result.FilePath != "" {
+		hints["image_path"] = dbus.MakeVariant(result.FilePath)
+	}
+
+	summary := "Screenshot captured"
+	body := ""
+	if result.Clipboard && result.FilePath != "" {
+		body = fmt.Sprintf("Copied to clipboard\n%s", filepath.Base(result.FilePath))
+	} else if result.Clipboard {
+		body = "Copied to clipboard"
+	} else if result.FilePath != "" {
+		body = filepath.Base(result.FilePath)
+	}
+
+	obj := conn.Object(notifyDest, notifyPath)
+	call := obj.Call(
+		notifyInterface+".Notify",
+		0,
+		"DMS",
+		uint32(0),
+		"",
+		summary,
+		body,
+		actions,
+		hints,
+		int32(5000),
+	)
+
+	if call.Err != nil {
+		log.Debug("notify call failed", "err", call.Err)
+		return
+	}
+
+	var notificationID uint32
+	if err := call.Store(&notificationID); err != nil {
+		log.Debug("failed to get notification id", "err", err)
+		return
+	}
+
+	if len(actions) == 0 || result.FilePath == "" {
+		return
+	}
+
+	spawnActionListener(notificationID, result.FilePath)
+}
+
+func spawnActionListener(notificationID uint32, filePath string) {
+	exe, err := os.Executable()
+	if err != nil {
+		log.Debug("failed to get executable", "err", err)
+		return
+	}
+
+	cmd := exec.Command(exe, "notify-action", fmt.Sprintf("%d", notificationID), filePath)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+	cmd.Start()
+}
+
+func RunNotifyActionListener(args []string) {
+	if len(args) < 2 {
+		return
+	}
+
+	notificationID, err := strconv.ParseUint(args[0], 10, 32)
+	if err != nil {
+		return
+	}
+
+	filePath := args[1]
+
+	conn, err := dbus.SessionBus()
+	if err != nil {
+		return
+	}
+
+	if err := conn.AddMatchSignal(
+		dbus.WithMatchObjectPath(notifyPath),
+		dbus.WithMatchInterface(notifyInterface),
+	); err != nil {
+		return
+	}
+
+	signals := make(chan *dbus.Signal, 10)
+	conn.Signal(signals)
+
+	for sig := range signals {
+		switch sig.Name {
+		case notifyInterface + ".ActionInvoked":
+			if len(sig.Body) < 2 {
+				continue
+			}
+			id, ok := sig.Body[0].(uint32)
+			if !ok || id != uint32(notificationID) {
+				continue
+			}
+			openFile(filePath)
+			return
+
+		case notifyInterface + ".NotificationClosed":
+			if len(sig.Body) < 1 {
+				continue
+			}
+			id, ok := sig.Body[0].(uint32)
+			if !ok || id != uint32(notificationID) {
+				continue
+			}
+			return
+		}
+	}
+}
+
+func openFile(filePath string) {
+	cmd := exec.Command("xdg-open", filePath)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+	cmd.Start()
+}

core/internal/screenshot/region.go

@@ -0,0 +1,855 @@
+package screenshot
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/keyboard_shortcuts_inhibit"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_layer_shell"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_screencopy"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wp_viewporter"
+	wlhelpers "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/client"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+)
+
+type SelectionState struct {
+	hasSelection bool           // There's a selection to display (pre-loaded or user-drawn)
+	dragging     bool           // User is actively drawing a new selection
+	surface      *OutputSurface // Surface where selection was made
+	// Surface-local logical coordinates (from pointer events)
+	anchorX  float64
+	anchorY  float64
+	currentX float64
+	currentY float64
+}
+
+type RenderSlot struct {
+	shm   *ShmBuffer
+	pool  *client.ShmPool
+	wlBuf *client.Buffer
+	busy  bool
+}
+
+type OutputSurface struct {
+	output            *WaylandOutput
+	wlSurface         *client.Surface
+	layerSurf         *wlr_layer_shell.ZwlrLayerSurfaceV1
+	viewport          *wp_viewporter.WpViewport
+	screenBuf         *ShmBuffer
+	screenBufNoCursor *ShmBuffer
+	screenFormat      uint32
+	logicalW          int
+	logicalH          int
+	configured        bool
+	yInverted         bool
+
+	// Triple-buffered render slots
+	slots      [3]*RenderSlot
+	slotsReady bool
+}
+
+type PreCapture struct {
+	screenBuf         *ShmBuffer
+	screenBufNoCursor *ShmBuffer
+	format            uint32
+	yInverted         bool
+}
+
+type RegionSelector struct {
+	screenshoter *Screenshoter
+
+	display  *client.Display
+	registry *client.Registry
+	ctx      *client.Context
+
+	compositor *client.Compositor
+	shm        *client.Shm
+	seat       *client.Seat
+	pointer    *client.Pointer
+	keyboard   *client.Keyboard
+	layerShell *wlr_layer_shell.ZwlrLayerShellV1
+	screencopy *wlr_screencopy.ZwlrScreencopyManagerV1
+	viewporter *wp_viewporter.WpViewporter
+
+	shortcutsInhibitMgr *keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitManagerV1
+	shortcutsInhibitor  *keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitorV1
+
+	outputs    map[uint32]*WaylandOutput
+	outputsMu  sync.Mutex
+	preCapture map[*WaylandOutput]*PreCapture
+
+	surfaces      []*OutputSurface
+	activeSurface *OutputSurface
+
+	// Cursor surface for crosshair
+	cursorSurface *client.Surface
+	cursorBuffer  *ShmBuffer
+	cursorWlBuf   *client.Buffer
+	cursorPool    *client.ShmPool
+
+	selection          SelectionState
+	pointerX           float64
+	pointerY           float64
+	preSelect          Region
+	showCapturedCursor bool
+	shiftHeld          bool
+
+	running   bool
+	cancelled bool
+	result    Region
+
+	capturedBuffer *ShmBuffer
+	capturedRegion Region
+}
+
+func NewRegionSelector(s *Screenshoter) *RegionSelector {
+	return &RegionSelector{
+		screenshoter:       s,
+		outputs:            make(map[uint32]*WaylandOutput),
+		preCapture:         make(map[*WaylandOutput]*PreCapture),
+		showCapturedCursor: true,
+	}
+}
+
+func (r *RegionSelector) Run() (*CaptureResult, bool, error) {
+	r.preSelect = GetLastRegion()
+
+	if err := r.connect(); err != nil {
+		return nil, false, fmt.Errorf("wayland connect: %w", err)
+	}
+	defer r.cleanup()
+
+	if err := r.setupRegistry(); err != nil {
+		return nil, false, fmt.Errorf("registry setup: %w", err)
+	}
+
+	if err := r.roundtrip(); err != nil {
+		return nil, false, fmt.Errorf("roundtrip after registry: %w", err)
+	}
+
+	switch {
+	case r.screencopy == nil:
+		return nil, false, fmt.Errorf("compositor does not support wlr-screencopy-unstable-v1")
+	case r.layerShell == nil:
+		return nil, false, fmt.Errorf("compositor does not support wlr-layer-shell-unstable-v1")
+	case r.seat == nil:
+		return nil, false, fmt.Errorf("no seat available")
+	case r.compositor == nil:
+		return nil, false, fmt.Errorf("compositor not available")
+	case r.shm == nil:
+		return nil, false, fmt.Errorf("wl_shm not available")
+	case len(r.outputs) == 0:
+		return nil, false, fmt.Errorf("no outputs available")
+	}
+
+	if err := r.roundtrip(); err != nil {
+		return nil, false, fmt.Errorf("roundtrip after protocol check: %w", err)
+	}
+
+	if err := r.preCaptureAllOutputs(); err != nil {
+		return nil, false, fmt.Errorf("pre-capture: %w", err)
+	}
+
+	if err := r.createSurfaces(); err != nil {
+		return nil, false, fmt.Errorf("create surfaces: %w", err)
+	}
+
+	_ = r.createCursor()
+
+	if err := r.roundtrip(); err != nil {
+		return nil, false, fmt.Errorf("roundtrip after surfaces: %w", err)
+	}
+
+	r.running = true
+	for r.running {
+		if err := r.ctx.Dispatch(); err != nil {
+			return nil, false, fmt.Errorf("dispatch: %w", err)
+		}
+	}
+
+	if r.cancelled || r.capturedBuffer == nil {
+		return nil, r.cancelled, nil
+	}
+
+	yInverted := false
+	var format uint32
+	if r.selection.surface != nil {
+		yInverted = r.selection.surface.yInverted
+		format = r.selection.surface.screenFormat
+	}
+
+	return &CaptureResult{
+		Buffer:    r.capturedBuffer,
+		Region:    r.result,
+		YInverted: yInverted,
+		Format:    format,
+	}, false, nil
+}
+
+func (r *RegionSelector) connect() error {
+	display, err := client.Connect("")
+	if err != nil {
+		return err
+	}
+	r.display = display
+	r.ctx = display.Context()
+	return nil
+}
+
+func (r *RegionSelector) roundtrip() error {
+	return wlhelpers.Roundtrip(r.display, r.ctx)
+}
+
+func (r *RegionSelector) setupRegistry() error {
+	registry, err := r.display.GetRegistry()
+	if err != nil {
+		return err
+	}
+	r.registry = registry
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		r.handleGlobal(e)
+	})
+
+	registry.SetGlobalRemoveHandler(func(e client.RegistryGlobalRemoveEvent) {
+		r.outputsMu.Lock()
+		delete(r.outputs, e.Name)
+		r.outputsMu.Unlock()
+	})
+
+	return nil
+}
+
+func (r *RegionSelector) handleGlobal(e client.RegistryGlobalEvent) {
+	switch e.Interface {
+	case client.CompositorInterfaceName:
+		comp := client.NewCompositor(r.ctx)
+		if err := r.registry.Bind(e.Name, e.Interface, e.Version, comp); err == nil {
+			r.compositor = comp
+		}
+
+	case client.ShmInterfaceName:
+		shm := client.NewShm(r.ctx)
+		if err := r.registry.Bind(e.Name, e.Interface, e.Version, shm); err == nil {
+			r.shm = shm
+		}
+
+	case client.SeatInterfaceName:
+		seat := client.NewSeat(r.ctx)
+		if err := r.registry.Bind(e.Name, e.Interface, e.Version, seat); err == nil {
+			r.seat = seat
+			r.setupInput()
+		}
+
+	case client.OutputInterfaceName:
+		output := client.NewOutput(r.ctx)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
+		if err := r.registry.Bind(e.Name, e.Interface, version, output); err == nil {
+			r.outputsMu.Lock()
+			r.outputs[e.Name] = &WaylandOutput{
+				wlOutput:        output,
+				globalName:      e.Name,
+				scale:           1,
+				fractionalScale: 1.0,
+			}
+			r.outputsMu.Unlock()
+			r.setupOutputHandlers(e.Name, output)
+		}
+
+	case wlr_layer_shell.ZwlrLayerShellV1InterfaceName:
+		ls := wlr_layer_shell.NewZwlrLayerShellV1(r.ctx)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
+		if err := r.registry.Bind(e.Name, e.Interface, version, ls); err == nil {
+			r.layerShell = ls
+		}
+
+	case wlr_screencopy.ZwlrScreencopyManagerV1InterfaceName:
+		sc := wlr_screencopy.NewZwlrScreencopyManagerV1(r.ctx)
+		version := e.Version
+		if version > 3 {
+			version = 3
+		}
+		if err := r.registry.Bind(e.Name, e.Interface, version, sc); err == nil {
+			r.screencopy = sc
+		}
+
+	case wp_viewporter.WpViewporterInterfaceName:
+		vp := wp_viewporter.NewWpViewporter(r.ctx)
+		if err := r.registry.Bind(e.Name, e.Interface, e.Version, vp); err == nil {
+			r.viewporter = vp
+		}
+
+	case keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitManagerV1InterfaceName:
+		mgr := keyboard_shortcuts_inhibit.NewZwpKeyboardShortcutsInhibitManagerV1(r.ctx)
+		if err := r.registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+			r.shortcutsInhibitMgr = mgr
+		}
+	}
+}
+
+func (r *RegionSelector) setupOutputHandlers(name uint32, output *client.Output) {
+	output.SetGeometryHandler(func(e client.OutputGeometryEvent) {
+		r.outputsMu.Lock()
+		if o, ok := r.outputs[name]; ok {
+			o.x = e.X
+			o.y = e.Y
+			o.transform = int32(e.Transform)
+		}
+		r.outputsMu.Unlock()
+	})
+
+	output.SetModeHandler(func(e client.OutputModeEvent) {
+		if e.Flags&uint32(client.OutputModeCurrent) == 0 {
+			return
+		}
+		r.outputsMu.Lock()
+		if o, ok := r.outputs[name]; ok {
+			o.width = e.Width
+			o.height = e.Height
+		}
+		r.outputsMu.Unlock()
+	})
+
+	output.SetScaleHandler(func(e client.OutputScaleEvent) {
+		r.outputsMu.Lock()
+		if o, ok := r.outputs[name]; ok {
+			o.scale = e.Factor
+			o.fractionalScale = float64(e.Factor)
+		}
+		r.outputsMu.Unlock()
+	})
+
+	output.SetNameHandler(func(e client.OutputNameEvent) {
+		r.outputsMu.Lock()
+		if o, ok := r.outputs[name]; ok {
+			o.name = e.Name
+		}
+		r.outputsMu.Unlock()
+	})
+}
+
+func (r *RegionSelector) preCaptureAllOutputs() error {
+	r.outputsMu.Lock()
+	outputs := make([]*WaylandOutput, 0, len(r.outputs))
+	for _, o := range r.outputs {
+		outputs = append(outputs, o)
+	}
+	r.outputsMu.Unlock()
+
+	pending := len(outputs) * 2
+	done := make(chan struct{}, pending)
+
+	for _, output := range outputs {
+		pc := &PreCapture{}
+		r.preCapture[output] = pc
+
+		r.preCaptureOutput(output, pc, true, func() { done <- struct{}{} })
+		r.preCaptureOutput(output, pc, false, func() { done <- struct{}{} })
+	}
+
+	for i := 0; i < pending; i++ {
+		if err := r.ctx.Dispatch(); err != nil {
+			return err
+		}
+		select {
+		case <-done:
+		default:
+			i--
+		}
+	}
+	return nil
+}
+
+func (r *RegionSelector) preCaptureOutput(output *WaylandOutput, pc *PreCapture, withCursor bool, onReady func()) {
+	cursor := int32(0)
+	if withCursor {
+		cursor = 1
+	}
+
+	frame, err := r.screencopy.CaptureOutput(cursor, output.wlOutput)
+	if err != nil {
+		log.Error("screencopy capture failed", "err", err)
+		onReady()
+		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
+		}
+
+		capturedBuf = buf
+		buf.Format = capturedFormat
+
+		pool, err := r.shm.CreatePool(buf.Fd(), int32(buf.Size()))
+		if err != nil {
+			log.Error("create shm pool failed", "err", err)
+			return
+		}
+
+		wlBuf, err := pool.CreateBuffer(0, int32(buf.Width), int32(buf.Height), int32(buf.Stride), e.Format)
+		if err != nil {
+			log.Error("create wl_buffer failed", "err", err)
+			pool.Destroy()
+			return
+		}
+
+		if err := frame.Copy(wlBuf); err != nil {
+			log.Error("frame copy failed", "err", err)
+		}
+		pool.Destroy()
+	})
+
+	frame.SetFlagsHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1FlagsEvent) {
+		if withCursor {
+			pc.yInverted = (e.Flags & 1) != 0
+		}
+	})
+
+	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()
+	})
+
+	frame.SetFailedHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1FailedEvent) {
+		log.Error("screencopy failed")
+		frame.Destroy()
+		onReady()
+	})
+}
+
+func (r *RegionSelector) createSurfaces() error {
+	r.outputsMu.Lock()
+	outputs := make([]*WaylandOutput, 0, len(r.outputs))
+	for _, o := range r.outputs {
+		outputs = append(outputs, o)
+	}
+	r.outputsMu.Unlock()
+
+	for _, output := range outputs {
+		os, err := r.createOutputSurface(output)
+		if err != nil {
+			return fmt.Errorf("output %s: %w", output.name, err)
+		}
+		r.surfaces = append(r.surfaces, os)
+	}
+
+	return nil
+}
+
+func (r *RegionSelector) createCursor() error {
+	const size = 24
+	const hotspot = size / 2
+
+	surface, err := r.compositor.CreateSurface()
+	if err != nil {
+		return fmt.Errorf("create cursor surface: %w", err)
+	}
+	r.cursorSurface = surface
+
+	buf, err := CreateShmBuffer(size, size, size*4)
+	if err != nil {
+		return fmt.Errorf("create cursor buffer: %w", err)
+	}
+	r.cursorBuffer = buf
+
+	// Draw crosshair
+	data := buf.Data()
+	for y := 0; y < size; y++ {
+		for x := 0; x < size; x++ {
+			off := (y*size + x) * 4
+			// Vertical line
+			if x >= hotspot-1 && x <= hotspot && y >= 2 && y < size-2 {
+				data[off+0] = 255 // B
+				data[off+1] = 255 // G
+				data[off+2] = 255 // R
+				data[off+3] = 255 // A
+				continue
+			}
+			// Horizontal line
+			if y >= hotspot-1 && y <= hotspot && x >= 2 && x < size-2 {
+				data[off+0] = 255
+				data[off+1] = 255
+				data[off+2] = 255
+				data[off+3] = 255
+				continue
+			}
+			// Transparent
+			data[off+0] = 0
+			data[off+1] = 0
+			data[off+2] = 0
+			data[off+3] = 0
+		}
+	}
+
+	pool, err := r.shm.CreatePool(buf.Fd(), int32(buf.Size()))
+	if err != nil {
+		return fmt.Errorf("create cursor pool: %w", err)
+	}
+	r.cursorPool = pool
+
+	wlBuf, err := pool.CreateBuffer(0, size, size, size*4, uint32(FormatARGB8888))
+	if err != nil {
+		return fmt.Errorf("create cursor wl_buffer: %w", err)
+	}
+	r.cursorWlBuf = wlBuf
+
+	if err := surface.Attach(wlBuf, 0, 0); err != nil {
+		return fmt.Errorf("attach cursor: %w", err)
+	}
+	if err := surface.Damage(0, 0, size, size); err != nil {
+		return fmt.Errorf("damage cursor: %w", err)
+	}
+	if err := surface.Commit(); err != nil {
+		return fmt.Errorf("commit cursor: %w", err)
+	}
+
+	return nil
+}
+
+func (r *RegionSelector) createOutputSurface(output *WaylandOutput) (*OutputSurface, error) {
+	surface, err := r.compositor.CreateSurface()
+	if err != nil {
+		return nil, fmt.Errorf("create surface: %w", err)
+	}
+
+	layerSurf, err := r.layerShell.GetLayerSurface(
+		surface,
+		output.wlOutput,
+		uint32(wlr_layer_shell.ZwlrLayerShellV1LayerOverlay),
+		"dms-screenshot",
+	)
+	if err != nil {
+		return nil, fmt.Errorf("get layer surface: %w", err)
+	}
+
+	os := &OutputSurface{
+		output:    output,
+		wlSurface: surface,
+		layerSurf: layerSurf,
+	}
+
+	if r.viewporter != nil {
+		vp, err := r.viewporter.GetViewport(surface)
+		if err == nil {
+			os.viewport = vp
+		}
+	}
+
+	if err := layerSurf.SetAnchor(
+		uint32(wlr_layer_shell.ZwlrLayerSurfaceV1AnchorTop) |
+			uint32(wlr_layer_shell.ZwlrLayerSurfaceV1AnchorBottom) |
+			uint32(wlr_layer_shell.ZwlrLayerSurfaceV1AnchorLeft) |
+			uint32(wlr_layer_shell.ZwlrLayerSurfaceV1AnchorRight),
+	); err != nil {
+		return nil, fmt.Errorf("set anchor: %w", err)
+	}
+	if err := layerSurf.SetExclusiveZone(-1); err != nil {
+		return nil, fmt.Errorf("set exclusive zone: %w", err)
+	}
+	if err := layerSurf.SetKeyboardInteractivity(uint32(wlr_layer_shell.ZwlrLayerSurfaceV1KeyboardInteractivityExclusive)); err != nil {
+		return nil, fmt.Errorf("set keyboard interactivity: %w", err)
+	}
+
+	layerSurf.SetConfigureHandler(func(e wlr_layer_shell.ZwlrLayerSurfaceV1ConfigureEvent) {
+		if err := layerSurf.AckConfigure(e.Serial); err != nil {
+			log.Error("ack configure failed", "err", err)
+			return
+		}
+		os.logicalW = int(e.Width)
+		os.logicalH = int(e.Height)
+		os.configured = true
+		r.captureForSurface(os)
+		r.ensureShortcutsInhibitor(os)
+	})
+
+	layerSurf.SetClosedHandler(func(e wlr_layer_shell.ZwlrLayerSurfaceV1ClosedEvent) {
+		r.running = false
+		r.cancelled = true
+	})
+
+	if err := surface.Commit(); err != nil {
+		return nil, fmt.Errorf("surface commit: %w", err)
+	}
+
+	return os, nil
+}
+
+func (r *RegionSelector) ensureShortcutsInhibitor(os *OutputSurface) {
+	if r.shortcutsInhibitMgr == nil || r.seat == nil || r.shortcutsInhibitor != nil {
+		return
+	}
+	inhibitor, err := r.shortcutsInhibitMgr.InhibitShortcuts(os.wlSurface, r.seat)
+	if err == nil {
+		r.shortcutsInhibitor = inhibitor
+	}
+}
+
+func (r *RegionSelector) captureForSurface(os *OutputSurface) {
+	pc := r.preCapture[os.output]
+	if pc == nil {
+		return
+	}
+
+	os.screenBuf = pc.screenBuf
+	os.screenBufNoCursor = pc.screenBufNoCursor
+	os.screenFormat = pc.format
+	os.yInverted = pc.yInverted
+
+	if os.logicalW > 0 && os.screenBuf != nil {
+		os.output.fractionalScale = float64(os.screenBuf.Width) / float64(os.logicalW)
+	}
+
+	r.initRenderBuffer(os)
+	r.applyPreSelection(os)
+	r.redrawSurface(os)
+}
+
+func (r *RegionSelector) initRenderBuffer(os *OutputSurface) {
+	if os.screenBuf == nil {
+		return
+	}
+
+	for i := 0; i < 3; i++ {
+		slot := &RenderSlot{}
+
+		buf, err := CreateShmBuffer(os.screenBuf.Width, os.screenBuf.Height, os.screenBuf.Stride)
+		if err != nil {
+			log.Error("create render slot buffer failed", "err", err)
+			return
+		}
+		slot.shm = buf
+
+		pool, err := r.shm.CreatePool(buf.Fd(), int32(buf.Size()))
+		if err != nil {
+			log.Error("create render slot pool failed", "err", err)
+			buf.Close()
+			return
+		}
+		slot.pool = pool
+
+		wlBuf, err := pool.CreateBuffer(0, int32(buf.Width), int32(buf.Height), int32(buf.Stride), os.screenFormat)
+		if err != nil {
+			log.Error("create render slot wl_buffer failed", "err", err)
+			pool.Destroy()
+			buf.Close()
+			return
+		}
+		slot.wlBuf = wlBuf
+
+		slotRef := slot
+		wlBuf.SetReleaseHandler(func(e client.BufferReleaseEvent) {
+			slotRef.busy = false
+		})
+
+		os.slots[i] = slot
+	}
+	os.slotsReady = true
+}
+
+func (os *OutputSurface) acquireFreeSlot() *RenderSlot {
+	for _, slot := range os.slots {
+		if slot != nil && !slot.busy {
+			return slot
+		}
+	}
+	return nil
+}
+
+func (r *RegionSelector) applyPreSelection(os *OutputSurface) {
+	if r.preSelect.IsEmpty() || os.screenBuf == nil || r.selection.hasSelection {
+		return
+	}
+
+	if r.preSelect.Output != "" && r.preSelect.Output != os.output.name {
+		return
+	}
+
+	scaleX := float64(os.logicalW) / float64(os.screenBuf.Width)
+	scaleY := float64(os.logicalH) / float64(os.screenBuf.Height)
+
+	x1 := float64(r.preSelect.X-os.output.x) * scaleX
+	y1 := float64(r.preSelect.Y-os.output.y) * scaleY
+	x2 := float64(r.preSelect.X-os.output.x+r.preSelect.Width) * scaleX
+	y2 := float64(r.preSelect.Y-os.output.y+r.preSelect.Height) * scaleY
+
+	r.selection.hasSelection = true
+	r.selection.dragging = false
+	r.selection.surface = os
+	r.selection.anchorX = x1
+	r.selection.anchorY = y1
+	r.selection.currentX = x2
+	r.selection.currentY = y2
+	r.activeSurface = os
+}
+
+func (r *RegionSelector) getSourceBuffer(os *OutputSurface) *ShmBuffer {
+	if !r.showCapturedCursor && os.screenBufNoCursor != nil {
+		return os.screenBufNoCursor
+	}
+	return os.screenBuf
+}
+
+func (r *RegionSelector) redrawSurface(os *OutputSurface) {
+	srcBuf := r.getSourceBuffer(os)
+	if srcBuf == nil || !os.slotsReady {
+		return
+	}
+
+	slot := os.acquireFreeSlot()
+	if slot == nil {
+		return
+	}
+
+	slot.shm.CopyFrom(srcBuf)
+
+	// Draw overlay (dimming + selection) into this slot
+	r.drawOverlay(os, slot.shm)
+
+	if os.viewport != nil {
+		_ = os.wlSurface.SetBufferScale(1)
+		_ = os.viewport.SetSource(0, 0, float64(slot.shm.Width), float64(slot.shm.Height))
+		_ = os.viewport.SetDestination(int32(os.logicalW), int32(os.logicalH))
+	} else {
+		bufferScale := os.output.scale
+		if bufferScale <= 0 {
+			bufferScale = 1
+		}
+		_ = os.wlSurface.SetBufferScale(bufferScale)
+	}
+
+	_ = os.wlSurface.Attach(slot.wlBuf, 0, 0)
+	_ = os.wlSurface.Damage(0, 0, int32(os.logicalW), int32(os.logicalH))
+	_ = os.wlSurface.Commit()
+
+	// Mark this slot as busy until compositor releases it
+	slot.busy = true
+}
+
+func (r *RegionSelector) cleanup() {
+	if r.cursorWlBuf != nil {
+		r.cursorWlBuf.Destroy()
+	}
+	if r.cursorPool != nil {
+		r.cursorPool.Destroy()
+	}
+	if r.cursorSurface != nil {
+		r.cursorSurface.Destroy()
+	}
+	if r.cursorBuffer != nil {
+		r.cursorBuffer.Close()
+	}
+
+	for _, os := range r.surfaces {
+		for _, slot := range os.slots {
+			if slot == nil {
+				continue
+			}
+			if slot.wlBuf != nil {
+				slot.wlBuf.Destroy()
+			}
+			if slot.pool != nil {
+				slot.pool.Destroy()
+			}
+			if slot.shm != nil {
+				slot.shm.Close()
+			}
+		}
+		if os.viewport != nil {
+			os.viewport.Destroy()
+		}
+		if os.layerSurf != nil {
+			os.layerSurf.Destroy()
+		}
+		if os.wlSurface != nil {
+			os.wlSurface.Destroy()
+		}
+		if os.screenBuf != nil {
+			os.screenBuf.Close()
+		}
+		if os.screenBufNoCursor != nil {
+			os.screenBufNoCursor.Close()
+		}
+	}
+
+	if r.shortcutsInhibitor != nil {
+		_ = r.shortcutsInhibitor.Destroy()
+	}
+	if r.shortcutsInhibitMgr != nil {
+		_ = r.shortcutsInhibitMgr.Destroy()
+	}
+	if r.viewporter != nil {
+		r.viewporter.Destroy()
+	}
+	if r.screencopy != nil {
+		r.screencopy.Destroy()
+	}
+	if r.pointer != nil {
+		r.pointer.Release()
+	}
+	if r.keyboard != nil {
+		r.keyboard.Release()
+	}
+	if r.display != nil {
+		r.ctx.Close()
+	}
+}

core/internal/screenshot/region_input.go

@@ -0,0 +1,271 @@
+package screenshot
+
+import (
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+)
+
+func (r *RegionSelector) setupInput() {
+	if r.seat == nil {
+		return
+	}
+
+	r.seat.SetCapabilitiesHandler(func(e client.SeatCapabilitiesEvent) {
+		if e.Capabilities&uint32(client.SeatCapabilityPointer) != 0 && r.pointer == nil {
+			if pointer, err := r.seat.GetPointer(); err == nil {
+				r.pointer = pointer
+				r.setupPointerHandlers()
+			}
+		}
+		if e.Capabilities&uint32(client.SeatCapabilityKeyboard) != 0 && r.keyboard == nil {
+			if keyboard, err := r.seat.GetKeyboard(); err == nil {
+				r.keyboard = keyboard
+				r.setupKeyboardHandlers()
+			}
+		}
+	})
+}
+
+func (r *RegionSelector) setupPointerHandlers() {
+	r.pointer.SetEnterHandler(func(e client.PointerEnterEvent) {
+		if r.cursorSurface != nil {
+			_ = r.pointer.SetCursor(e.Serial, r.cursorSurface, 12, 12)
+		}
+
+		r.activeSurface = nil
+		for _, os := range r.surfaces {
+			if os.wlSurface.ID() == e.Surface.ID() {
+				r.activeSurface = os
+				break
+			}
+		}
+
+		r.pointerX = e.SurfaceX
+		r.pointerY = e.SurfaceY
+	})
+
+	r.pointer.SetMotionHandler(func(e client.PointerMotionEvent) {
+		if r.activeSurface == nil {
+			return
+		}
+
+		r.pointerX = e.SurfaceX
+		r.pointerY = e.SurfaceY
+
+		if !r.selection.dragging {
+			return
+		}
+
+		curX, curY := e.SurfaceX, e.SurfaceY
+		if r.shiftHeld {
+			dx := curX - r.selection.anchorX
+			dy := curY - r.selection.anchorY
+			adx, ady := dx, dy
+			if adx < 0 {
+				adx = -adx
+			}
+			if ady < 0 {
+				ady = -ady
+			}
+			size := adx
+			if ady > adx {
+				size = ady
+			}
+			if dx < 0 {
+				curX = r.selection.anchorX - size
+			} else {
+				curX = r.selection.anchorX + size
+			}
+			if dy < 0 {
+				curY = r.selection.anchorY - size
+			} else {
+				curY = r.selection.anchorY + size
+			}
+		}
+
+		r.selection.currentX = curX
+		r.selection.currentY = curY
+		for _, os := range r.surfaces {
+			r.redrawSurface(os)
+		}
+	})
+
+	r.pointer.SetButtonHandler(func(e client.PointerButtonEvent) {
+		if r.activeSurface == nil {
+			return
+		}
+
+		switch e.Button {
+		case 0x110: // BTN_LEFT
+			switch e.State {
+			case 1: // pressed
+				r.preSelect = Region{}
+				r.selection.hasSelection = true
+				r.selection.dragging = true
+				r.selection.surface = r.activeSurface
+				r.selection.anchorX = r.pointerX
+				r.selection.anchorY = r.pointerY
+				r.selection.currentX = r.pointerX
+				r.selection.currentY = r.pointerY
+				for _, os := range r.surfaces {
+					r.redrawSurface(os)
+				}
+			case 0: // released
+				r.selection.dragging = false
+				for _, os := range r.surfaces {
+					r.redrawSurface(os)
+				}
+			}
+		default:
+			r.cancelled = true
+			r.running = false
+		}
+	})
+}
+
+func (r *RegionSelector) setupKeyboardHandlers() {
+	r.keyboard.SetModifiersHandler(func(e client.KeyboardModifiersEvent) {
+		r.shiftHeld = e.ModsDepressed&1 != 0
+	})
+
+	r.keyboard.SetKeyHandler(func(e client.KeyboardKeyEvent) {
+		if e.State != 1 {
+			return
+		}
+
+		switch e.Key {
+		case 1:
+			r.cancelled = true
+			r.running = false
+		case 25:
+			r.showCapturedCursor = !r.showCapturedCursor
+			for _, os := range r.surfaces {
+				r.redrawSurface(os)
+			}
+		case 28, 57:
+			if r.selection.hasSelection {
+				r.finishSelection()
+			}
+		}
+	})
+}
+
+func (r *RegionSelector) finishSelection() {
+	if r.selection.surface == nil {
+		r.running = false
+		return
+	}
+
+	os := r.selection.surface
+	srcBuf := r.getSourceBuffer(os)
+	if srcBuf == nil {
+		r.running = false
+		return
+	}
+
+	x1, y1 := r.selection.anchorX, r.selection.anchorY
+	x2, y2 := r.selection.currentX, r.selection.currentY
+
+	if x1 > x2 {
+		x1, x2 = x2, x1
+	}
+	if y1 > y2 {
+		y1, y2 = y2, y1
+	}
+
+	scaleX, scaleY := 1.0, 1.0
+	if os.logicalW > 0 {
+		scaleX = float64(srcBuf.Width) / float64(os.logicalW)
+		scaleY = float64(srcBuf.Height) / float64(os.logicalH)
+	}
+
+	bx1 := int(x1 * scaleX)
+	by1 := int(y1 * scaleY)
+	bx2 := int(x2 * scaleX)
+	by2 := int(y2 * scaleY)
+
+	// Clamp to buffer bounds
+	if bx1 < 0 {
+		bx1 = 0
+	}
+	if by1 < 0 {
+		by1 = 0
+	}
+	if bx2 > srcBuf.Width {
+		bx2 = srcBuf.Width
+	}
+	if by2 > srcBuf.Height {
+		by2 = srcBuf.Height
+	}
+
+	w, h := bx2-bx1+1, by2-by1+1
+	if r.shiftHeld && w != h {
+		if w < h {
+			h = w
+		} else {
+			w = h
+		}
+	}
+	if w < 1 {
+		w = 1
+	}
+	if h < 1 {
+		h = 1
+	}
+
+	// Create cropped buffer and copy pixels directly
+	cropped, err := CreateShmBuffer(w, h, w*4)
+	if err != nil {
+		r.running = false
+		return
+	}
+
+	srcData := srcBuf.Data()
+	dstData := cropped.Data()
+	for y := 0; y < h; y++ {
+		srcY := by1 + y
+		if os.yInverted {
+			srcY = srcBuf.Height - 1 - (by1 + y)
+		}
+		if srcY < 0 || srcY >= srcBuf.Height {
+			continue
+		}
+		dstY := y
+		if os.yInverted {
+			dstY = h - 1 - y
+		}
+		for x := 0; x < w; x++ {
+			srcX := bx1 + x
+			if srcX < 0 || srcX >= srcBuf.Width {
+				continue
+			}
+			si := srcY*srcBuf.Stride + srcX*4
+			di := dstY*cropped.Stride + x*4
+			if si+3 < len(srcData) && di+3 < len(dstData) {
+				dstData[di+0] = srcData[si+0]
+				dstData[di+1] = srcData[si+1]
+				dstData[di+2] = srcData[si+2]
+				dstData[di+3] = srcData[si+3]
+			}
+		}
+	}
+
+	r.capturedBuffer = cropped
+	r.capturedRegion = Region{
+		X:      int32(bx1),
+		Y:      int32(by1),
+		Width:  int32(w),
+		Height: int32(h),
+		Output: os.output.name,
+	}
+
+	// Also store for "last region" feature with global coords
+	r.result = Region{
+		X:      int32(bx1) + os.output.x,
+		Y:      int32(by1) + os.output.y,
+		Width:  int32(w),
+		Height: int32(h),
+		Output: os.output.name,
+	}
+
+	r.running = false
+}

core/internal/screenshot/region_render.go

@@ -0,0 +1,322 @@
+package screenshot
+
+import "fmt"
+
+var fontGlyphs = map[rune][12]uint8{
+	'0': {0x3C, 0x66, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00},
+	'1': {0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, 0x00},
+	'2': {0x3C, 0x66, 0x66, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x66, 0x7E, 0x00, 0x00},
+	'3': {0x3C, 0x66, 0x06, 0x06, 0x1C, 0x06, 0x06, 0x06, 0x66, 0x3C, 0x00, 0x00},
+	'4': {0x0C, 0x1C, 0x3C, 0x6C, 0xCC, 0xCC, 0xFE, 0x0C, 0x0C, 0x1E, 0x00, 0x00},
+	'5': {0x7E, 0x60, 0x60, 0x60, 0x7C, 0x06, 0x06, 0x06, 0x66, 0x3C, 0x00, 0x00},
+	'6': {0x1C, 0x30, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00},
+	'7': {0x7E, 0x66, 0x06, 0x06, 0x0C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00},
+	'8': {0x3C, 0x66, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00},
+	'9': {0x3C, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x06, 0x0C, 0x38, 0x00, 0x00},
+	'x': {0x00, 0x00, 0x00, 0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00, 0x00},
+	'E': {0x7E, 0x60, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00, 0x00},
+	'P': {0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00},
+	'S': {0x3C, 0x66, 0x60, 0x60, 0x3C, 0x06, 0x06, 0x06, 0x66, 0x3C, 0x00, 0x00},
+	'a': {0x00, 0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x00, 0x00},
+	'c': {0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00, 0x00},
+	'd': {0x00, 0x00, 0x06, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x3E, 0x00, 0x00},
+	'e': {0x00, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x7E, 0x60, 0x60, 0x3C, 0x00, 0x00},
+	'h': {0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00},
+	'i': {0x00, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00},
+	'n': {0x00, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00},
+	'o': {0x00, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00},
+	'p': {0x00, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x00, 0x00},
+	'r': {0x00, 0x00, 0x00, 0x6E, 0x76, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00},
+	's': {0x00, 0x00, 0x00, 0x3E, 0x60, 0x60, 0x3C, 0x06, 0x06, 0x7C, 0x00, 0x00},
+	't': {0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0E, 0x00, 0x00},
+	'u': {0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3E, 0x00, 0x00},
+	'w': {0x00, 0x00, 0x00, 0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00, 0x00},
+	'l': {0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00},
+	' ': {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	':': {0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00},
+	'/': {0x00, 0x02, 0x06, 0x0C, 0x18, 0x18, 0x30, 0x60, 0x40, 0x00, 0x00, 0x00},
+	'[': {0x3C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, 0x00, 0x00},
+	']': {0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x3C, 0x00, 0x00},
+}
+
+type OverlayStyle struct {
+	BackgroundR, BackgroundG, BackgroundB, BackgroundA uint8
+	TextR, TextG, TextB                                uint8
+	AccentR, AccentG, AccentB                          uint8
+}
+
+var DefaultOverlayStyle = OverlayStyle{
+	BackgroundR: 30, BackgroundG: 30, BackgroundB: 30, BackgroundA: 220,
+	TextR: 255, TextG: 255, TextB: 255,
+	AccentR: 100, AccentG: 180, AccentB: 255,
+}
+
+func (r *RegionSelector) drawOverlay(os *OutputSurface, renderBuf *ShmBuffer) {
+	data := renderBuf.Data()
+	stride := renderBuf.Stride
+	w, h := renderBuf.Width, renderBuf.Height
+	format := os.screenFormat
+
+	// Dim the entire buffer
+	for y := 0; y < h; y++ {
+		off := y * stride
+		for x := 0; x < w; x++ {
+			i := off + x*4
+			if i+3 >= len(data) {
+				continue
+			}
+			data[i+0] = uint8(int(data[i+0]) * 3 / 5)
+			data[i+1] = uint8(int(data[i+1]) * 3 / 5)
+			data[i+2] = uint8(int(data[i+2]) * 3 / 5)
+		}
+	}
+
+	r.drawHUD(data, stride, w, h, format)
+
+	if !r.selection.hasSelection || r.selection.surface != os {
+		return
+	}
+
+	scaleX := float64(w) / float64(os.logicalW)
+	scaleY := float64(h) / float64(os.logicalH)
+
+	bx1 := int(r.selection.anchorX * scaleX)
+	by1 := int(r.selection.anchorY * scaleY)
+	bx2 := int(r.selection.currentX * scaleX)
+	by2 := int(r.selection.currentY * scaleY)
+
+	if bx1 > bx2 {
+		bx1, bx2 = bx2, bx1
+	}
+	if by1 > by2 {
+		by1, by2 = by2, by1
+	}
+
+	bx1 = clamp(bx1, 0, w-1)
+	by1 = clamp(by1, 0, h-1)
+	bx2 = clamp(bx2, 0, w-1)
+	by2 = clamp(by2, 0, h-1)
+
+	srcBuf := r.getSourceBuffer(os)
+	srcData := srcBuf.Data()
+	for y := by1; y <= by2; y++ {
+		rowOff := y * stride
+		for x := bx1; x <= bx2; x++ {
+			si := y*srcBuf.Stride + x*4
+			di := rowOff + x*4
+			if si+3 >= len(srcData) || di+3 >= len(data) {
+				continue
+			}
+			data[di+0] = srcData[si+0]
+			data[di+1] = srcData[si+1]
+			data[di+2] = srcData[si+2]
+			data[di+3] = srcData[si+3]
+		}
+	}
+
+	selW, selH := bx2-bx1+1, by2-by1+1
+	if r.shiftHeld && selW != selH {
+		if selW < selH {
+			selH = selW
+		} else {
+			selW = selH
+		}
+	}
+	r.drawBorder(data, stride, w, h, bx1, by1, selW, selH, format)
+	r.drawDimensions(data, stride, w, h, bx1, by1, selW, selH, format)
+}
+
+func (r *RegionSelector) drawHUD(data []byte, stride, bufW, bufH int, format uint32) {
+	if r.selection.dragging {
+		return
+	}
+
+	style := LoadOverlayStyle()
+	const charW, charH, padding, itemSpacing = 8, 12, 12, 24
+
+	cursorLabel := "hide"
+	if !r.showCapturedCursor {
+		cursorLabel = "show"
+	}
+
+	items := []struct{ key, desc string }{
+		{"Space/Enter", "capture"},
+		{"P", cursorLabel + " cursor"},
+		{"Esc", "cancel"},
+	}
+
+	totalW := 0
+	for i, item := range items {
+		totalW += len(item.key)*(charW+1) + 4 + len(item.desc)*(charW+1)
+		if i < len(items)-1 {
+			totalW += itemSpacing
+		}
+	}
+
+	hudW := totalW + padding*2
+	hudH := charH + padding*2
+	hudX := (bufW - hudW) / 2
+	hudY := bufH - hudH - 20
+
+	r.fillRect(data, stride, bufW, bufH, hudX, hudY, hudW, hudH,
+		style.BackgroundR, style.BackgroundG, style.BackgroundB, style.BackgroundA, format)
+
+	tx, ty := hudX+padding, hudY+padding
+	for i, item := range items {
+		r.drawText(data, stride, bufW, bufH, tx, ty, item.key,
+			style.AccentR, style.AccentG, style.AccentB, format)
+		tx += len(item.key) * (charW + 1)
+
+		r.drawText(data, stride, bufW, bufH, tx, ty, " "+item.desc,
+			style.TextR, style.TextG, style.TextB, format)
+		tx += (1 + len(item.desc)) * (charW + 1)
+
+		if i < len(items)-1 {
+			tx += itemSpacing
+		}
+	}
+}
+
+func (r *RegionSelector) drawBorder(data []byte, stride, bufW, bufH, x, y, w, h int, format uint32) {
+	const thickness = 2
+	for i := 0; i < thickness; i++ {
+		r.drawHLine(data, stride, bufW, bufH, x-i, y-i, w+2*i, format)
+		r.drawHLine(data, stride, bufW, bufH, x-i, y+h+i-1, w+2*i, format)
+		r.drawVLine(data, stride, bufW, bufH, x-i, y-i, h+2*i, format)
+		r.drawVLine(data, stride, bufW, bufH, x+w+i-1, y-i, h+2*i, format)
+	}
+}
+
+func (r *RegionSelector) drawHLine(data []byte, stride, bufW, bufH, x, y, length int, _ uint32) {
+	if y < 0 || y >= bufH {
+		return
+	}
+	rowOff := y * stride
+	for i := 0; i < length; i++ {
+		px := x + i
+		if px < 0 || px >= bufW {
+			continue
+		}
+		off := rowOff + px*4
+		if off+3 >= len(data) {
+			continue
+		}
+		data[off], data[off+1], data[off+2], data[off+3] = 255, 255, 255, 255
+	}
+}
+
+func (r *RegionSelector) drawVLine(data []byte, stride, bufW, bufH, x, y, length int, _ uint32) {
+	if x < 0 || x >= bufW {
+		return
+	}
+	for i := 0; i < length; i++ {
+		py := y + i
+		if py < 0 || py >= bufH {
+			continue
+		}
+		off := py*stride + x*4
+		if off+3 >= len(data) {
+			continue
+		}
+		data[off], data[off+1], data[off+2], data[off+3] = 255, 255, 255, 255
+	}
+}
+
+func (r *RegionSelector) drawDimensions(data []byte, stride, bufW, bufH, x, y, w, h int, format uint32) {
+	text := fmt.Sprintf("%dx%d", w, h)
+
+	const charW, charH = 8, 12
+	textW := len(text) * (charW + 1)
+	textH := charH
+
+	tx := x + (w-textW)/2
+	ty := y + h + 8
+
+	if ty+textH > bufH {
+		ty = y - textH - 8
+	}
+	tx = clamp(tx, 0, bufW-textW)
+
+	r.fillRect(data, stride, bufW, bufH, tx-4, ty-2, textW+8, textH+4, 0, 0, 0, 200, format)
+	r.drawText(data, stride, bufW, bufH, tx, ty, text, 255, 255, 255, format)
+}
+
+func (r *RegionSelector) fillRect(data []byte, stride, bufW, bufH, x, y, w, h int, cr, cg, cb, ca uint8, format uint32) {
+	alpha := float64(ca) / 255.0
+	invAlpha := 1.0 - alpha
+
+	c0, c2 := cb, cr
+	if format == uint32(FormatABGR8888) || format == uint32(FormatXBGR8888) {
+		c0, c2 = cr, cb
+	}
+
+	for py := y; py < y+h && py < bufH; py++ {
+		if py < 0 {
+			continue
+		}
+		for px := x; px < x+w && px < bufW; px++ {
+			if px < 0 {
+				continue
+			}
+			off := py*stride + px*4
+			if off+3 >= len(data) {
+				continue
+			}
+			data[off+0] = uint8(float64(data[off+0])*invAlpha + float64(c0)*alpha)
+			data[off+1] = uint8(float64(data[off+1])*invAlpha + float64(cg)*alpha)
+			data[off+2] = uint8(float64(data[off+2])*invAlpha + float64(c2)*alpha)
+			data[off+3] = 255
+		}
+	}
+}
+
+func (r *RegionSelector) drawText(data []byte, stride, bufW, bufH, x, y int, text string, cr, cg, cb uint8, format uint32) {
+	for i, ch := range text {
+		r.drawChar(data, stride, bufW, bufH, x+i*9, y, ch, cr, cg, cb, format)
+	}
+}
+
+func (r *RegionSelector) drawChar(data []byte, stride, bufW, bufH, x, y int, ch rune, cr, cg, cb uint8, format uint32) {
+	glyph, ok := fontGlyphs[ch]
+	if !ok {
+		return
+	}
+
+	c0, c2 := cb, cr
+	if format == uint32(FormatABGR8888) || format == uint32(FormatXBGR8888) {
+		c0, c2 = cr, cb
+	}
+
+	for row := 0; row < 12; row++ {
+		py := y + row
+		if py < 0 || py >= bufH {
+			continue
+		}
+		bits := glyph[row]
+		for col := 0; col < 8; col++ {
+			if (bits & (1 << (7 - col))) == 0 {
+				continue
+			}
+			px := x + col
+			if px < 0 || px >= bufW {
+				continue
+			}
+			off := py*stride + px*4
+			if off+3 >= len(data) {
+				continue
+			}
+			data[off], data[off+1], data[off+2], data[off+3] = c0, cg, c2, 255
+		}
+	}
+}
+
+func clamp(v, lo, hi int) int {
+	switch {
+	case v < lo:
+		return lo
+	case v > hi:
+		return hi
+	default:
+		return v
+	}
+}

core/internal/screenshot/shm.go

@@ -0,0 +1,35 @@
+package screenshot
+
+import "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/shm"
+
+type PixelFormat = shm.PixelFormat
+
+const (
+	FormatARGB8888 = shm.FormatARGB8888
+	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
+
+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/state.go

@@ -0,0 +1,65 @@
+package screenshot
+
+import (
+	"encoding/json"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+type PersistentState struct {
+	LastRegion Region `json:"last_region"`
+}
+
+func getStateFilePath() string {
+	cacheDir, err := os.UserCacheDir()
+	if err != nil {
+		cacheDir = path.Join(os.Getenv("HOME"), ".cache")
+	}
+	return filepath.Join(cacheDir, "dms", "screenshot-state.json")
+}
+
+func LoadState() (*PersistentState, error) {
+	path := getStateFilePath()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &PersistentState{}, nil
+		}
+		return nil, err
+	}
+
+	var state PersistentState
+	if err := json.Unmarshal(data, &state); err != nil {
+		return &PersistentState{}, nil
+	}
+	return &state, nil
+}
+
+func SaveState(state *PersistentState) error {
+	path := getStateFilePath()
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, data, 0644)
+}
+
+func GetLastRegion() Region {
+	state, err := LoadState()
+	if err != nil {
+		return Region{}
+	}
+	return state.LastRegion
+}
+
+func SaveLastRegion(r Region) error {
+	state, _ := LoadState()
+	state.LastRegion = r
+	return SaveState(state)
+}

core/internal/screenshot/theme.go

@@ -0,0 +1,121 @@
+package screenshot
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
+)
+
+type ThemeColors struct {
+	Background string `json:"surface"`
+	OnSurface  string `json:"on_surface"`
+	Primary    string `json:"primary"`
+}
+
+type ColorScheme struct {
+	Dark  ThemeColors `json:"dark"`
+	Light ThemeColors `json:"light"`
+}
+
+type ColorsFile struct {
+	Colors ColorScheme `json:"colors"`
+}
+
+var cachedStyle *OverlayStyle
+
+func LoadOverlayStyle() OverlayStyle {
+	if cachedStyle != nil {
+		return *cachedStyle
+	}
+
+	style := DefaultOverlayStyle
+	colors := loadColorsFile()
+	if colors == nil {
+		cachedStyle = &style
+		return style
+	}
+
+	theme := &colors.Dark
+	if isLightMode() {
+		theme = &colors.Light
+	}
+
+	if bg, ok := parseHexColor(theme.Background); ok {
+		style.BackgroundR, style.BackgroundG, style.BackgroundB = bg[0], bg[1], bg[2]
+	}
+	if text, ok := parseHexColor(theme.OnSurface); ok {
+		style.TextR, style.TextG, style.TextB = text[0], text[1], text[2]
+	}
+	if accent, ok := parseHexColor(theme.Primary); ok {
+		style.AccentR, style.AccentG, style.AccentB = accent[0], accent[1], accent[2]
+	}
+
+	cachedStyle = &style
+	return style
+}
+
+func loadColorsFile() *ColorScheme {
+	path := getColorsFilePath()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+
+	var file ColorsFile
+	if err := json.Unmarshal(data, &file); err != nil {
+		return nil
+	}
+
+	return &file.Colors
+}
+
+func getColorsFilePath() string {
+	return filepath.Join(utils.XDGCacheHome(), "DankMaterialShell", "dms-colors.json")
+}
+
+func isLightMode() bool {
+	out, err := exec.Command("gsettings", "get", "org.gnome.desktop.interface", "color-scheme").Output()
+	if err != nil {
+		return false
+	}
+
+	scheme := strings.TrimSpace(string(out))
+	switch scheme {
+	case "'prefer-light'", "'default'":
+		return true
+	}
+	return false
+}
+
+func parseHexColor(hex string) ([3]uint8, bool) {
+	hex = strings.TrimPrefix(hex, "#")
+	if len(hex) != 6 {
+		return [3]uint8{}, false
+	}
+
+	var r, g, b uint8
+	for i, ptr := range []*uint8{&r, &g, &b} {
+		val := 0
+		for j := 0; j < 2; j++ {
+			c := hex[i*2+j]
+			val *= 16
+			switch {
+			case c >= '0' && c <= '9':
+				val += int(c - '0')
+			case c >= 'a' && c <= 'f':
+				val += int(c - 'a' + 10)
+			case c >= 'A' && c <= 'F':
+				val += int(c - 'A' + 10)
+			default:
+				return [3]uint8{}, false
+			}
+		}
+		*ptr = uint8(val)
+	}
+
+	return [3]uint8{r, g, b}, true
+}

core/internal/screenshot/types.go

@@ -0,0 +1,70 @@
+package screenshot
+
+type Mode int
+
+const (
+	ModeRegion Mode = iota
+	ModeWindow
+	ModeFullScreen
+	ModeAllScreens
+	ModeOutput
+	ModeLastRegion
+)
+
+type Format int
+
+const (
+	FormatPNG Format = iota
+	FormatJPEG
+	FormatPPM
+)
+
+type Region struct {
+	X      int32  `json:"x"`
+	Y      int32  `json:"y"`
+	Width  int32  `json:"width"`
+	Height int32  `json:"height"`
+	Output string `json:"output,omitempty"`
+}
+
+func (r Region) IsEmpty() bool {
+	return r.Width <= 0 || r.Height <= 0
+}
+
+type Output struct {
+	Name            string
+	X, Y            int32
+	Width           int32
+	Height          int32
+	Scale           int32
+	FractionalScale float64
+	Transform       int32
+}
+
+type Config struct {
+	Mode          Mode
+	OutputName    string
+	IncludeCursor bool
+	Format        Format
+	Quality       int
+	OutputDir     string
+	Filename      string
+	Clipboard     bool
+	SaveFile      bool
+	Notify        bool
+	Stdout        bool
+}
+
+func DefaultConfig() Config {
+	return Config{
+		Mode:          ModeRegion,
+		IncludeCursor: false,
+		Format:        FormatPNG,
+		Quality:       90,
+		OutputDir:     "",
+		Filename:      "",
+		Clipboard:     true,
+		SaveFile:      true,
+		Notify:        true,
+	}
+}

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/ddc.go

@@ -40,6 +40,10 @@ func (b *DDCBackend) scanI2CDevices() error {
 	return b.scanI2CDevicesInternal(false)
 }
 
+func (b *DDCBackend) ForceRescan() error {
+	return b.scanI2CDevicesInternal(true)
+}
+
 func (b *DDCBackend) scanI2CDevicesInternal(force bool) error {
 	b.scanMutex.Lock()
 	defer b.scanMutex.Unlock()
@@ -64,10 +68,6 @@ func (b *DDCBackend) scanI2CDevicesInternal(force bool) error {
 		activeBuses[i] = true
 		id := fmt.Sprintf("ddc:i2c-%d", i)
 
-		if _, exists := b.devices.Load(id); exists {
-			continue
-		}
-
 		dev, err := b.probeDDCDevice(i)
 		if err != nil || dev == nil {
 			continue
@@ -261,8 +261,16 @@ func (b *DDCBackend) setBrightnessImmediateWithExponent(id string, value int) er
 
 	busPath := fmt.Sprintf("/dev/i2c-%d", dev.bus)
 
+	if _, err := os.Stat(busPath); os.IsNotExist(err) {
+		b.devices.Delete(id)
+		log.Debugf("removed stale DDC device %s (bus no longer exists)", id)
+		return fmt.Errorf("device disconnected: %s", id)
+	}
+
 	fd, err := syscall.Open(busPath, syscall.O_RDWR, 0)
 	if err != nil {
+		b.devices.Delete(id)
+		log.Debugf("removed DDC device %s (open failed: %v)", id, err)
 		return fmt.Errorf("open i2c device: %w", err)
 	}
 	defer syscall.Close(fd)

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/manager.go

@@ -89,6 +89,13 @@ func (m *Manager) initDDC() {
 
 func (m *Manager) Rescan() {
 	log.Debug("Rescanning brightness devices...")
+
+	if m.ddcReady && m.ddcBackend != nil {
+		if err := m.ddcBackend.ForceRescan(); err != nil {
+			log.Debugf("DDC force rescan failed: %v", err)
+		}
+	}
+
 	m.updateState()
 }
 

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/brightness/udev.go

@@ -5,13 +5,18 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/pilebones/go-udev/netlink"
 )
 
 type UdevMonitor struct {
-	stop chan struct{}
+	stop          chan struct{}
+	rescanMutex   sync.Mutex
+	rescanTimer   *time.Timer
+	rescanPending bool
 }
 
 func NewUdevMonitor(manager *Manager) *UdevMonitor {
@@ -34,10 +39,8 @@ func (m *UdevMonitor) run(manager *Manager) {
 	matcher := &netlink.RuleDefinitions{
 		Rules: []netlink.RuleDefinition{
 			{Env: map[string]string{"SUBSYSTEM": "backlight"}},
-			// ! TODO: most drivers dont emit this for leds?
-			// ! inotify brightness_hw_changed works, but thn some devices dont do that...
-			// ! So for now the GUI just shows OSDs for leds, without reflecting actual HW value
-			// {Env: map[string]string{"SUBSYSTEM": "leds"}},
+			{Env: map[string]string{"SUBSYSTEM": "drm"}},
+			{Env: map[string]string{"SUBSYSTEM": "i2c"}},
 		},
 	}
 	if err := matcher.Compile(); err != nil {
@@ -49,7 +52,7 @@ func (m *UdevMonitor) run(manager *Manager) {
 	errs := make(chan error)
 	conn.Monitor(events, errs, matcher)
 
-	log.Info("Udev monitor started for backlight/leds events")
+	log.Info("Udev monitor started for backlight/drm/i2c events")
 
 	for {
 		select {
@@ -75,11 +78,54 @@ func (m *UdevMonitor) handleEvent(manager *Manager, event netlink.UEvent) {
 	sysname := filepath.Base(devpath)
 	action := string(event.Action)
 
+	switch subsystem {
+	case "drm", "i2c":
+		m.handleDisplayEvent(manager, action, subsystem, sysname)
+	case "backlight":
+		m.handleBacklightEvent(manager, action, sysname)
+	}
+}
+
+func (m *UdevMonitor) handleDisplayEvent(manager *Manager, action, subsystem, sysname string) {
+	switch action {
+	case "add", "remove", "change":
+		log.Debugf("Udev %s event: %s:%s - queueing DDC rescan", action, subsystem, sysname)
+		m.debouncedRescan(manager)
+	}
+}
+
+func (m *UdevMonitor) debouncedRescan(manager *Manager) {
+	m.rescanMutex.Lock()
+	defer m.rescanMutex.Unlock()
+
+	m.rescanPending = true
+
+	if m.rescanTimer != nil {
+		m.rescanTimer.Reset(2 * time.Second)
+		return
+	}
+
+	m.rescanTimer = time.AfterFunc(2*time.Second, func() {
+		m.rescanMutex.Lock()
+		pending := m.rescanPending
+		m.rescanPending = false
+		m.rescanMutex.Unlock()
+
+		if !pending {
+			return
+		}
+
+		log.Debug("Executing debounced DDC rescan")
+		manager.Rescan()
+	})
+}
+
+func (m *UdevMonitor) handleBacklightEvent(manager *Manager, action, sysname string) {
 	switch action {
 	case "change":
-		m.handleChange(manager, subsystem, sysname)
+		m.handleChange(manager, "backlight", sysname)
 	case "add", "remove":
-		log.Debugf("Udev %s event: %s:%s - triggering rescan", action, subsystem, sysname)
+		log.Debugf("Udev %s event: backlight:%s - triggering rescan", action, sysname)
 		manager.Rescan()
 	}
 }

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)