fix gui

- Position, resolution, refresh, orientation, VRR
- niri, Hyprland, MangoWC
- Rely on wlr-output for reading data, compositors to write output
  configurations
- Re-organize display setting group

.editorconfig

@@ -0,0 +1,8 @@
+[*.sh]
+# like -i=4
+indent_style = space
+indent_size = 4
+[*.nix]
+# like -i=4
+indent_style = space
+indent_size = 4

.githooks/pre-commit

@@ -1,66 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-HOOK_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$HOOK_DIR/.." && pwd)"
-
-cd "$REPO_ROOT"
-
-# =============================================================================
-# Go CI checks (when core/ files are staged)
-# =============================================================================
-STAGED_CORE_FILES=$(git diff --cached --name-only --diff-filter=ACMR | grep '^core/' || true)
-
-if [[ -n "$STAGED_CORE_FILES" ]]; then
-    echo "Go files staged in core/, running CI checks..."
-    cd "$REPO_ROOT/core"
-
-    # Format check
-    echo "  Checking gofmt..."
-    UNFORMATTED=$(gofmt -s -l . 2>/dev/null || true)
-    if [[ -n "$UNFORMATTED" ]]; then
-        echo "The following files are not formatted:"
-        echo "$UNFORMATTED"
-        echo ""
-        echo "Run: cd core && gofmt -s -w ."
-        exit 1
-    fi
-
-    # golangci-lint
-    if command -v golangci-lint &>/dev/null; then
-        echo "  Running golangci-lint..."
-        golangci-lint run ./...
-    else
-        echo "  Warning: golangci-lint not installed, skipping lint"
-        echo "  Install: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"
-    fi
-
-    # Tests
-    echo "  Running tests..."
-    go test ./... > /dev/null
-
-    # Build checks
-    echo "  Building..."
-    mkdir -p bin
-    go build -buildvcs=false -o bin/dms ./cmd/dms
-    go build -buildvcs=false -o bin/dms-distro -tags distro_binary ./cmd/dms
-    go build -buildvcs=false -o bin/dankinstall ./cmd/dankinstall
-
-    echo "All Go CI checks passed!"
-    cd "$REPO_ROOT"
-fi
-
-# =============================================================================
-# i18n sync check (DISABLED for now)
-# =============================================================================
-# if [[ -n "${POEDITOR_API_TOKEN:-}" ]] && [[ -n "${POEDITOR_PROJECT_ID:-}" ]]; then
-#     if command -v python3 &>/dev/null; then
-#         if ! python3 scripts/i18nsync.py check &>/dev/null; then
-#             echo "Translations out of sync"
-#             echo "Run: python3 scripts/i18nsync.py sync"
-#             exit 1
-#         fi
-#     fi
-# fi
-
-exit 0

.github/workflows/backup/run-obs.yml.bak

@@ -0,0 +1,383 @@
+name: Update OBS Packages
+
+on:
+  workflow_dispatch:
+    inputs:
+      package:
+        description: "Package to update (dms, dms-git, or all)"
+        required: false
+        default: "all"
+      force_upload:
+        description: "Force upload without version check"
+        required: false
+        default: "false"
+        type: choice
+        options:
+          - "false"
+          - "true"
+      rebuild_release:
+        description: "Release number for rebuilds (e.g., 2, 3, 4 to increment spec Release)"
+        required: false
+        default: ""
+  push:
+    tags:
+      - "v*"
+  schedule:
+    - cron: "0 */3 * * *" # Every 3 hours for dms-git builds
+
+jobs:
+  check-updates:
+    name: Check for updates
+    runs-on: ubuntu-latest
+
+    outputs:
+      has_updates: ${{ steps.check.outputs.has_updates }}
+      packages: ${{ steps.check.outputs.packages }}
+      version: ${{ steps.check.outputs.version }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - 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: Check for updates
+        id: check
+        run: |
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            echo "packages=dms" >> $GITHUB_OUTPUT
+            VERSION="${GITHUB_REF#refs/tags/}"
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+            echo "Triggered by tag: $VERSION (always update)"
+          elif [[ "${{ github.event_name }}" == "schedule" ]]; then
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
+            echo "Checking if dms-git source has changed..."
+
+            # Get current commit hash (8 chars to match spec format)
+            CURRENT_COMMIT=$(git rev-parse --short=8 HEAD)
+
+            # Check OBS for last uploaded commit
+            OBS_BASE="$HOME/.cache/osc-checkouts"
+            mkdir -p "$OBS_BASE"
+            OBS_PROJECT="home:AvengeMedia:dms-git"
+
+            if [[ -d "$OBS_BASE/$OBS_PROJECT/dms-git" ]]; then
+              cd "$OBS_BASE/$OBS_PROJECT/dms-git"
+              osc up -q 2>/dev/null || true
+
+              # Extract commit hash from spec Version line & format like; 0.6.2+git2264.a679be68
+              if [[ -f "dms-git.spec" ]]; then
+                OBS_COMMIT=$(grep "^Version:" "dms-git.spec" | grep -oP '\.[a-f0-9]{8}' | tr -d '.' || echo "")
+
+                if [[ -n "$OBS_COMMIT" ]]; then
+                  if [[ "$CURRENT_COMMIT" == "$OBS_COMMIT" ]]; then
+                    echo "has_updates=false" >> $GITHUB_OUTPUT
+                    echo "📋 Commit $CURRENT_COMMIT already uploaded to OBS, skipping"
+                  else
+                    echo "has_updates=true" >> $GITHUB_OUTPUT
+                    echo "📋 New commit detected: $CURRENT_COMMIT (OBS has $OBS_COMMIT)"
+                  fi
+                else
+                  echo "has_updates=true" >> $GITHUB_OUTPUT
+                  echo "📋 Could not extract OBS commit, proceeding with update"
+                fi
+              else
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+                echo "📋 No spec file in OBS, proceeding with update"
+              fi
+
+              cd "${{ github.workspace }}"
+            else
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "📋 First upload to OBS, update needed"
+            fi
+          elif [[ "${{ github.event.inputs.force_upload }}" == "true" ]]; then
+            PKG="${{ github.event.inputs.package }}"
+            if [[ -z "$PKG" || "$PKG" == "all" ]]; then
+              echo "packages=all" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "🚀 Force upload: all packages"
+            else
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "🚀 Force upload: $PKG"
+            fi
+          elif [[ -n "${{ github.event.inputs.package }}" ]]; then
+            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+            echo "Manual trigger: ${{ github.event.inputs.package }}"
+          else
+            echo "packages=all" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+          fi
+
+  update-obs:
+    name: Upload to OBS
+    needs: check-updates
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    if: |
+      github.event.inputs.force_upload == 'true' ||
+      github.event_name == 'workflow_dispatch' ||
+      needs.check-updates.outputs.has_updates == 'true'
+
+    steps:
+      - name: Generate GitHub App Token
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ steps.generate_token.outputs.token }}
+
+      - name: Check if last commit was automated
+        id: check-loop
+        run: |
+          LAST_COMMIT_MSG=$(git log -1 --pretty=%B | head -1)
+          if [[ "$LAST_COMMIT_MSG" == "ci: Auto-update PPA packages"* ]] || [[ "$LAST_COMMIT_MSG" == "ci: Auto-update OBS packages"* ]]; then
+            echo "⏭️ Last commit was automated ($LAST_COMMIT_MSG), skipping to prevent infinite loop"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "✅ Last commit was not automated, proceeding"
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Determine packages to update
+        if: steps.check-loop.outputs.skip != 'true'
+        id: packages
+        run: |
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            echo "packages=dms" >> $GITHUB_OUTPUT
+            VERSION="${GITHUB_REF#refs/tags/}"
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+            echo "Triggered by tag: $VERSION"
+          elif [[ "${{ github.event_name }}" == "schedule" ]]; then
+            echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+            echo "Triggered by schedule: updating git package"
+          elif [[ -n "${{ github.event.inputs.package }}" ]]; then
+            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            echo "Manual trigger: ${{ github.event.inputs.package }}"
+          else
+            echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Update dms-git spec version
+        if: steps.check-loop.outputs.skip != 'true' && (contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all')
+        run: |
+          # Get commit info for dms-git versioning
+          COMMIT_HASH=$(git rev-parse --short=8 HEAD)
+          COMMIT_COUNT=$(git rev-list --count HEAD)
+          BASE_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1 || echo "0.6.2")
+
+          NEW_VERSION="${BASE_VERSION}+git${COMMIT_COUNT}.${COMMIT_HASH}"
+          echo "📦 Updating dms-git.spec to version: $NEW_VERSION"
+
+          # Update version in spec
+          sed -i "s/^Version:.*/Version:        $NEW_VERSION/" distro/opensuse/dms-git.spec
+
+          # Add changelog entry
+          DATE_STR=$(date "+%a %b %d %Y")
+          CHANGELOG_ENTRY="* $DATE_STR Avenge Media <AvengeMedia.US@gmail.com> - ${NEW_VERSION}-1\n- Git snapshot (commit $COMMIT_COUNT: $COMMIT_HASH)"
+          sed -i "/%changelog/a\\$CHANGELOG_ENTRY" distro/opensuse/dms-git.spec
+
+      - name: Update Debian dms-git changelog version
+        if: steps.check-loop.outputs.skip != 'true' && (contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all')
+        run: |
+          # Get commit info for dms-git versioning
+          COMMIT_HASH=$(git rev-parse --short=8 HEAD)
+          COMMIT_COUNT=$(git rev-list --count HEAD)
+          BASE_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1 || echo "0.6.2")
+
+          # Debian version format: 0.6.2+git2256.9162e314
+          NEW_VERSION="${BASE_VERSION}+git${COMMIT_COUNT}.${COMMIT_HASH}"
+          echo "📦 Updating Debian dms-git changelog to version: $NEW_VERSION"
+
+          CHANGELOG_DATE=$(date -R)
+
+          CHANGELOG_FILE="distro/debian/dms-git/debian/changelog"
+
+          # Get current version from changelog
+          CURRENT_VERSION=$(head -1 "$CHANGELOG_FILE" | sed 's/.*(\([^)]*\)).*/\1/')
+
+          echo "Current Debian version: $CURRENT_VERSION"
+          echo "New version: $NEW_VERSION"
+
+          # Only update if version changed
+          if [ "$CURRENT_VERSION" != "$NEW_VERSION" ]; then
+            # Create new changelog entry at top
+            TEMP_CHANGELOG=$(mktemp)
+
+            cat > "$TEMP_CHANGELOG" << EOF
+          dms-git ($NEW_VERSION) nightly; urgency=medium
+
+            * Git snapshot (commit $COMMIT_COUNT: $COMMIT_HASH)
+
+           -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE
+
+          EOF
+
+            # Prepend to existing changelog
+            cat "$CHANGELOG_FILE" >> "$TEMP_CHANGELOG"
+            mv "$TEMP_CHANGELOG" "$CHANGELOG_FILE"
+
+            echo "✓ Updated Debian changelog: $CURRENT_VERSION → $NEW_VERSION"
+          else
+            echo "✓ Debian changelog already at version $NEW_VERSION"
+          fi
+
+      - name: Update dms stable version
+        if: steps.check-loop.outputs.skip != 'true' && steps.packages.outputs.version != ''
+        run: |
+          VERSION="${{ steps.packages.outputs.version }}"
+          VERSION_NO_V="${VERSION#v}"
+          echo "Updating packaging to version $VERSION_NO_V"
+
+          # Update openSUSE dms spec (stable only)
+          sed -i "s/^Version:.*/Version:        $VERSION_NO_V/" distro/opensuse/dms.spec
+
+          # Update openSUSE spec changelog
+          DATE_STR=$(date "+%a %b %d %Y")
+          CHANGELOG_ENTRY="* $DATE_STR AvengeMedia <maintainer@avengemedia.com> - ${VERSION_NO_V}-1\\n- Update to stable $VERSION release\\n- Bug fixes and improvements"
+          sed -i "/%changelog/a\\$CHANGELOG_ENTRY\\n" distro/opensuse/dms.spec
+
+          # Update Debian _service files (both tar_scm and download_url formats)
+          for service in distro/debian/*/_service; do
+            if [[ -f "$service" ]]; then
+              # Update tar_scm revision parameter (for dms-git)
+              sed -i "s|<param name=\"revision\">v[0-9.]*</param>|<param name=\"revision\">$VERSION</param>|" "$service"
+
+              # Update download_url paths (for dms stable)
+              sed -i "s|/v[0-9.]\+/|/$VERSION/|g" "$service"
+              sed -i "s|/tags/v[0-9.]\+\.tar\.gz|/tags/$VERSION.tar.gz|g" "$service"
+            fi
+          done
+
+          # Update Debian changelog for dms stable
+          if [[ -f "distro/debian/dms/debian/changelog" ]]; then
+            CHANGELOG_DATE=$(date -R)
+            TEMP_CHANGELOG=$(mktemp)
+
+            cat > "$TEMP_CHANGELOG" << EOF
+          dms ($VERSION_NO_V) stable; urgency=medium
+
+            * Update to $VERSION stable release
+            * Bug fixes and improvements
+
+           -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE
+
+          EOF
+
+            cat "distro/debian/dms/debian/changelog" >> "$TEMP_CHANGELOG"
+            mv "$TEMP_CHANGELOG" "distro/debian/dms/debian/changelog"
+
+            echo "✓ Updated Debian changelog to $VERSION_NO_V"
+          fi
+
+      - name: Install Go
+        if: steps.check-loop.outputs.skip != 'true'
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+
+      - name: Install OSC
+        if: steps.check-loop.outputs.skip != 'true'
+        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: Upload to OBS
+        if: steps.check-loop.outputs.skip != 'true'
+        env:
+          FORCE_UPLOAD: ${{ github.event.inputs.force_upload }}
+          REBUILD_RELEASE: ${{ github.event.inputs.rebuild_release }}
+        run: |
+          PACKAGES="${{ steps.packages.outputs.packages }}"
+          MESSAGE="Automated update from GitHub Actions"
+
+          if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+            MESSAGE="Update to ${{ steps.packages.outputs.version }}"
+          fi
+
+          if [[ "$PACKAGES" == "all" ]]; then
+            bash distro/scripts/obs-upload.sh dms "$MESSAGE"
+            bash distro/scripts/obs-upload.sh dms-git "Automated git update"
+          else
+            bash distro/scripts/obs-upload.sh "$PACKAGES" "$MESSAGE"
+          fi
+
+      - name: Get changed packages
+        if: steps.check-loop.outputs.skip != 'true'
+        id: changed-packages
+        run: |
+          # Check if there are any changes to commit
+          if git diff --exit-code distro/debian/ distro/opensuse/ >/dev/null 2>&1; then
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+            echo "📋 No changelog or spec changes to commit"
+          else
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+            # Get list of changed packages for commit message
+            CHANGED_DEB=$(git diff --name-only distro/debian/ 2>/dev/null | grep 'debian/changelog' | xargs dirname 2>/dev/null | xargs dirname 2>/dev/null | xargs basename 2>/dev/null | tr '\n' ', ' | sed 's/, $//' || echo "")
+            CHANGED_SUSE=$(git diff --name-only distro/opensuse/ 2>/dev/null | grep '\.spec$' | sed 's|distro/opensuse/||' | sed 's/\.spec$//' | tr '\n' ', ' | sed 's/, $//' || echo "")
+
+            PKGS=$(echo "$CHANGED_DEB,$CHANGED_SUSE" | tr ',' '\n' | grep -v '^$' | sort -u | tr '\n' ',' | sed 's/,$//')
+            echo "packages=$PKGS" >> $GITHUB_OUTPUT
+            echo "📋 Changed packages: $PKGS"
+          fi
+
+      - name: Commit packaging changes
+        if: steps.check-loop.outputs.skip != 'true' && steps.changed-packages.outputs.has_changes == 'true'
+        run: |
+          git config user.name "dms-ci[bot]"
+          git config user.email "dms-ci[bot]@users.noreply.github.com"
+          git add distro/debian/*/debian/changelog distro/opensuse/*.spec
+          git commit -m "ci: Auto-update OBS packages [${{ steps.changed-packages.outputs.packages }}]" -m "🤖 Automated by GitHub Actions"
+          git pull --rebase origin master
+          git push
+
+      - name: Summary
+        run: |
+          echo "### OBS Package Update Complete" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- **Packages**: ${{ steps.packages.outputs.packages }}" >> $GITHUB_STEP_SUMMARY
+          if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+            echo "- **Version**: ${{ steps.packages.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          if [[ "${{ needs.check-updates.outputs.has_updates }}" == "false" ]]; then
+            echo "- **Status**: Skipped (no changes detected)" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo "- **Project**: https://build.opensuse.org/project/show/home:AvengeMedia" >> $GITHUB_STEP_SUMMARY

.github/workflows/backup/run-ppa.yml.bak

@@ -0,0 +1,298 @@
+name: Update PPA Packages
+
+on:
+  workflow_dispatch:
+    inputs:
+      package:
+        description: "Package to upload (dms, dms-git, dms-greeter, or all)"
+        required: false
+        default: "dms-git"
+      force_upload:
+        description: "Force upload without version check"
+        required: false
+        default: "false"
+        type: choice
+        options:
+          - "false"
+          - "true"
+      rebuild_release:
+        description: "Release number for rebuilds (e.g., 2, 3, 4 for ppa2, ppa3, ppa4)"
+        required: false
+        default: ""
+  schedule:
+    - cron: "0 */3 * * *" # Every 3 hours for dms-git builds
+
+jobs:
+  check-updates:
+    name: Check for updates
+    runs-on: ubuntu-latest
+
+    outputs:
+      has_updates: ${{ steps.check.outputs.has_updates }}
+      packages: ${{ steps.check.outputs.packages }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for updates
+        id: check
+        run: |
+          if [[ "${{ github.event_name }}" == "schedule" ]]; then
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
+            echo "Checking if dms-git source has changed..."
+
+            # Get current commit hash (8 chars to match changelog format)
+            CURRENT_COMMIT=$(git rev-parse --short=8 HEAD)
+
+            # Extract commit hash from changelog
+            # Format: dms-git (0.6.2+git2264.c5c5ce84) questing; urgency=medium
+            CHANGELOG_FILE="distro/ubuntu/dms-git/debian/changelog"
+
+            if [[ -f "$CHANGELOG_FILE" ]]; then
+              CHANGELOG_COMMIT=$(head -1 "$CHANGELOG_FILE" | grep -oP '\.[a-f0-9]{8}' | tr -d '.' || echo "")
+
+              if [[ -n "$CHANGELOG_COMMIT" ]]; then
+                if [[ "$CURRENT_COMMIT" == "$CHANGELOG_COMMIT" ]]; then
+                  echo "has_updates=false" >> $GITHUB_OUTPUT
+                  echo "📋 Commit $CURRENT_COMMIT already in changelog, skipping upload"
+                else
+                  echo "has_updates=true" >> $GITHUB_OUTPUT
+                  echo "📋 New commit detected: $CURRENT_COMMIT (changelog has $CHANGELOG_COMMIT)"
+                fi
+              else
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+                echo "📋 Could not extract commit from changelog, proceeding with upload"
+              fi
+            else
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "📋 No changelog file found, proceeding with upload"
+            fi
+          elif [[ -n "${{ github.event.inputs.package }}" ]]; then
+            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+            echo "Manual trigger: ${{ github.event.inputs.package }}"
+          else
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+          fi
+
+  upload-ppa:
+    name: Upload to PPA
+    needs: check-updates
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    if: |
+      github.event.inputs.force_upload == 'true' ||
+      github.event_name == 'workflow_dispatch' ||
+      needs.check-updates.outputs.has_updates == 'true'
+
+    steps:
+      - name: Generate GitHub App Token
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ steps.generate_token.outputs.token }}
+
+      - name: Check if last commit was automated
+        id: check-loop
+        run: |
+          LAST_COMMIT_MSG=$(git log -1 --pretty=%B | head -1)
+          if [[ "$LAST_COMMIT_MSG" == "ci: Auto-update PPA packages"* ]] || [[ "$LAST_COMMIT_MSG" == "ci: Auto-update OBS packages"* ]]; then
+            echo "⏭️ Last commit was automated ($LAST_COMMIT_MSG), skipping to prevent infinite loop"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "✅ Last commit was not automated, proceeding"
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Set up Go
+        if: steps.check-loop.outputs.skip != 'true'
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+          cache: false
+
+      - name: Install build dependencies
+        if: steps.check-loop.outputs.skip != 'true'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            debhelper \
+            devscripts \
+            dput \
+            lftp \
+            build-essential \
+            fakeroot \
+            dpkg-dev
+
+      - name: Configure GPG
+        if: steps.check-loop.outputs.skip != 'true'
+        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: Determine packages to upload
+        if: steps.check-loop.outputs.skip != 'true'
+        id: packages
+        run: |
+          if [[ "${{ github.event.inputs.force_upload }}" == "true" ]]; then
+            PKG="${{ github.event.inputs.package }}"
+            if [[ -z "$PKG" || "$PKG" == "all" ]]; then
+              echo "packages=all" >> $GITHUB_OUTPUT
+              echo "🚀 Force upload: all packages"
+            else
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "🚀 Force upload: $PKG"
+            fi
+          elif [[ "${{ github.event_name }}" == "schedule" ]]; then
+            echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+            echo "Triggered by schedule: uploading git package"
+          elif [[ -n "${{ github.event.inputs.package }}" ]]; then
+            # Manual package selection should respect change detection
+            SELECTED_PKG="${{ github.event.inputs.package }}"
+            UPDATED_PKG="${{ needs.check-updates.outputs.packages }}"
+
+            # Check if manually selected package is in the updated list
+            if [[ "$UPDATED_PKG" == *"$SELECTED_PKG"* ]] || [[ "$SELECTED_PKG" == "all" ]]; then
+              echo "packages=$SELECTED_PKG" >> $GITHUB_OUTPUT
+              echo "📦 Manual selection (has updates): $SELECTED_PKG"
+            else
+              echo "packages=" >> $GITHUB_OUTPUT
+              echo "⚠️ Manual selection '$SELECTED_PKG' has no updates - skipping (use force_upload to override)"
+            fi
+          else
+            echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Upload to PPA
+        if: steps.check-loop.outputs.skip != 'true'
+        run: |
+          PACKAGES="${{ steps.packages.outputs.packages }}"
+          REBUILD_RELEASE="${{ github.event.inputs.rebuild_release }}"
+
+          if [[ -z "$PACKAGES" ]]; then
+            echo "No packages selected for upload. Skipping."
+            exit 0
+          fi
+
+          # Build command arguments
+          BUILD_ARGS=()
+          if [[ -n "$REBUILD_RELEASE" ]]; then
+            BUILD_ARGS+=("$REBUILD_RELEASE")
+            echo "✓ Using rebuild release number: ppa$REBUILD_RELEASE"
+          fi
+
+          if [[ "$PACKAGES" == "all" ]]; then
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            echo "Uploading dms to PPA..."
+            if [ -n "$REBUILD_RELEASE" ]; then
+              echo "🔄 Using rebuild release number: ppa$REBUILD_RELEASE"
+            fi
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            bash distro/scripts/ppa-upload.sh dms dms questing "${BUILD_ARGS[@]}"
+
+            echo ""
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            echo "Uploading dms-git to PPA..."
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            bash distro/scripts/ppa-upload.sh dms-git dms-git questing "${BUILD_ARGS[@]}"
+
+            echo ""
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            echo "Uploading dms-greeter to PPA..."
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            bash distro/scripts/ppa-upload.sh dms-greeter danklinux questing "${BUILD_ARGS[@]}"
+          else
+            # Map package to PPA name
+            case "$PACKAGES" in
+              dms)
+                PPA_NAME="dms"
+                ;;
+              dms-git)
+                PPA_NAME="dms-git"
+                ;;
+              dms-greeter)
+                PPA_NAME="danklinux"
+                ;;
+              *)
+                PPA_NAME="$PACKAGES"
+                ;;
+            esac
+
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            echo "Uploading $PACKAGES to PPA..."
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+            bash distro/scripts/ppa-upload.sh "$PACKAGES" "$PPA_NAME" questing "${BUILD_ARGS[@]}"
+          fi
+
+      - name: Get changed packages
+        if: steps.check-loop.outputs.skip != 'true'
+        id: changed-packages
+        run: |
+          # Check if there are any changelog changes to commit
+          if git diff --exit-code distro/ubuntu/ >/dev/null 2>&1; then
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+            echo "📋 No changelog changes to commit"
+          else
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+            # Get list of changed packages for commit message (deduplicate)
+            CHANGED=$(git diff --name-only distro/ubuntu/ | grep 'debian/changelog' | sed 's|/debian/changelog||' | xargs -I{} basename {} | sort -u | tr '\n' ',' | sed 's/,$//')
+            echo "packages=$CHANGED" >> $GITHUB_OUTPUT
+            echo "📋 Changed packages: $CHANGED"
+            echo "📋 Debug - Changed files:"
+            git diff --name-only distro/ubuntu/ | grep 'debian/changelog' || echo "No changelog files found"
+          fi
+
+      - name: Commit changelog changes
+        if: steps.check-loop.outputs.skip != 'true' && steps.changed-packages.outputs.has_changes == 'true'
+        run: |
+          git config user.name "dms-ci[bot]"
+          git config user.email "dms-ci[bot]@users.noreply.github.com"
+          git add distro/ubuntu/*/debian/changelog
+          git commit -m "ci: Auto-update PPA packages [${{ steps.changed-packages.outputs.packages }}]" -m "🤖 Automated by GitHub Actions"
+          git pull --rebase origin master
+          git push
+
+      - name: Summary
+        run: |
+          echo "### PPA Package Upload Complete" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- **Packages**: ${{ steps.packages.outputs.packages }}" >> $GITHUB_STEP_SUMMARY
+
+          if [[ "${{ needs.check-updates.outputs.has_updates }}" == "false" ]]; then
+            echo "- **Status**: Skipped (no changes detected)" >> $GITHUB_STEP_SUMMARY
+          fi
+
+          PACKAGES="${{ steps.packages.outputs.packages }}"
+          if [[ "$PACKAGES" == "all" ]]; then
+            echo "- **PPA dms**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms/+packages" >> $GITHUB_STEP_SUMMARY
+            echo "- **PPA dms-git**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms-git/+packages" >> $GITHUB_STEP_SUMMARY
+            echo "- **PPA danklinux**: https://launchpad.net/~avengemedia/+archive/ubuntu/danklinux/+packages" >> $GITHUB_STEP_SUMMARY
+          elif [[ "$PACKAGES" == "dms" ]]; then
+            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms/+packages" >> $GITHUB_STEP_SUMMARY
+          elif [[ "$PACKAGES" == "dms-git" ]]; then
+            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms-git/+packages" >> $GITHUB_STEP_SUMMARY
+          elif [[ "$PACKAGES" == "dms-greeter" ]]; then
+            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/danklinux/+packages" >> $GITHUB_STEP_SUMMARY
+          fi
+
+          if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+            echo "- **Version**: ${{ steps.packages.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "Builds will appear once Launchpad processes the uploads." >> $GITHUB_STEP_SUMMARY

.github/workflows/go-ci.yml

@@ -33,20 +33,6 @@ jobs:
         with:
           go-version-file: ./core/go.mod
 
-      - name: Format check
-        run: |
-          if [ "$(gofmt -s -l . | wc -l)" -gt 0 ]; then
-            echo "The following files are not formatted:"
-            gofmt -s -l .
-            exit 1
-          fi
-
-      - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v9
-        with:
-          version: v2.6
-          working-directory: core
-
       - name: Test
         run: go test -v ./...
 

.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/prek.yml

@@ -0,0 +1,15 @@
+name: Pre-commit Checks
+
+on:
+  push:
+  pull_request:
+    branches: [master, main]
+jobs:
+  pre-commit-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: run pre-commit hooks
+        uses: j178/prek-action@v1

.github/workflows/release.yml

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

.github/workflows/run-obs.yml

@@ -4,18 +4,18 @@ on:
   workflow_dispatch:
     inputs:
       package:
-        description: 'Package to update (dms, dms-git, or all)'
+        description: "Package to update (dms, dms-git, or all)"
         required: false
-        default: 'all'
+        default: "all"
       rebuild_release:
-        description: 'Release number for rebuilds (e.g., 2, 3, 4 to increment spec Release)'
+        description: "Release number for rebuilds (e.g., 2, 3, 4 to increment spec Release)"
         required: false
-        default: ''
+        default: ""
   push:
     tags:
-      - 'v*'
+      - "v*"
   schedule:
-    - cron: '0 */3 * * *'  # Every 3 hours for dms-git builds
+    - cron: "0 */3 * * *" # Every 3 hours for dms-git builds
 
 jobs:
   check-updates:
@@ -33,90 +33,114 @@ jobs:
         with:
           fetch-depth: 0
 
-      - 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: Check for updates
         id: check
+        env:
+          OBS_USERNAME: ${{ secrets.OBS_USERNAME }}
+          OBS_PASSWORD: ${{ secrets.OBS_PASSWORD }}
         run: |
+          # Helper function to check dms-git commit
+          check_dms_git() {
+            local CURRENT_COMMIT=$(git rev-parse --short=8 HEAD)
+            local OBS_SPEC=$(curl -s -u "$OBS_USERNAME:$OBS_PASSWORD" "https://api.opensuse.org/source/home:AvengeMedia:dms-git/dms-git/dms-git.spec" 2>/dev/null || echo "")
+            local OBS_COMMIT=$(echo "$OBS_SPEC" | grep "^Version:" | grep -oP '\.[a-f0-9]{8}' | tr -d '.' || echo "")
+
+            if [[ -n "$OBS_COMMIT" && "$CURRENT_COMMIT" == "$OBS_COMMIT" ]]; then
+              echo "📋 dms-git: Commit $CURRENT_COMMIT already exists, skipping"
+              return 1  # No update needed
+            else
+              echo "📋 dms-git: New commit $CURRENT_COMMIT (OBS has ${OBS_COMMIT:-none})"
+              return 0  # Update needed
+            fi
+          }
+
+          # Helper function to check dms stable tag
+          check_dms_stable() {
+            local LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "v\?\([^"]*\)".*/\1/' || echo "")
+            local OBS_SPEC=$(curl -s -u "$OBS_USERNAME:$OBS_PASSWORD" "https://api.opensuse.org/source/home:AvengeMedia:dms/dms/dms.spec" 2>/dev/null || echo "")
+            local OBS_VERSION=$(echo "$OBS_SPEC" | grep "^Version:" | awk '{print $2}' | xargs || echo "")
+
+            if [[ -n "$LATEST_TAG" && "$LATEST_TAG" == "$OBS_VERSION" ]]; then
+              echo "📋 dms: Tag $LATEST_TAG already exists, skipping"
+              return 1  # No update needed
+            else
+              echo "📋 dms: New tag ${LATEST_TAG:-unknown} (OBS has ${OBS_VERSION:-none})"
+              return 0  # Update needed
+            fi
+          }
+
+          # Main logic
+          REBUILD="${{ github.event.inputs.rebuild_release }}"
+
           if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            # Tag push - always update stable package
             echo "packages=dms" >> $GITHUB_OUTPUT
             VERSION="${GITHUB_REF#refs/tags/}"
             echo "version=$VERSION" >> $GITHUB_OUTPUT
             echo "has_updates=true" >> $GITHUB_OUTPUT
             echo "Triggered by tag: $VERSION (always update)"
+
           elif [[ "${{ github.event_name }}" == "schedule" ]]; then
+            # Scheduled run - check dms-git only
             echo "packages=dms-git" >> $GITHUB_OUTPUT
-            echo "Checking if dms-git source has changed..."
+            if check_dms_git; then
-            
-            # Get latest commit hash from master branch
-            LATEST_COMMIT=$(git rev-parse origin/master 2>/dev/null || git rev-parse master 2>/dev/null || echo "")
-            
-            if [[ -z "$LATEST_COMMIT" ]]; then
               echo "has_updates=true" >> $GITHUB_OUTPUT
-              echo "Could not determine git commit, proceeding with update"
             else
-              # Check OBS for last uploaded commit
+              echo "has_updates=false" >> $GITHUB_OUTPUT
-              OBS_BASE="$HOME/.cache/osc-checkouts"
-              mkdir -p "$OBS_BASE"
-              OBS_PROJECT="home:AvengeMedia:dms-git"
-              
-              if [[ -d "$OBS_BASE/$OBS_PROJECT/dms-git" ]]; then
-                cd "$OBS_BASE/$OBS_PROJECT/dms-git"
-                osc up -q 2>/dev/null || true
-                
-                # Check tarball age - if older than 3 hours, update needed
-                if [[ -f "dms-git-source.tar.gz" ]]; then
-                  TARBALL_MTIME=$(stat -c%Y "dms-git-source.tar.gz" 2>/dev/null || echo "0")
-                  CURRENT_TIME=$(date +%s)
-                  AGE_SECONDS=$((CURRENT_TIME - TARBALL_MTIME))
-                  AGE_HOURS=$((AGE_SECONDS / 3600))
-                  
-                  # If tarball is older than 3 hours, check for new commits
-                  if [[ $AGE_HOURS -ge 3 ]]; then
-                    # Check if there are new commits in the last 3 hours
-                    cd "${{ github.workspace }}"
-                    NEW_COMMITS=$(git log --since="3 hours ago" --oneline origin/master 2>/dev/null | wc -l)
-                    
-                    if [[ $NEW_COMMITS -gt 0 ]]; then
-                      echo "has_updates=true" >> $GITHUB_OUTPUT
-                      echo "📋 New commits detected in last 3 hours, update needed"
-                    else
-                      echo "has_updates=false" >> $GITHUB_OUTPUT
-                      echo "📋 No new commits in last 3 hours, skipping update"
-                    fi
-                  else
-                    echo "has_updates=false" >> $GITHUB_OUTPUT
-                    echo "📋 Recent upload exists (< 3 hours), skipping update"
-                  fi
-                else
-                  echo "has_updates=true" >> $GITHUB_OUTPUT
-                  echo "📋 No existing tarball in OBS, update needed"
-                fi
-                cd "${{ github.workspace }}"
-              else
-                echo "has_updates=true" >> $GITHUB_OUTPUT
-                echo "📋 First upload to OBS, update needed"
-              fi
             fi
+
           elif [[ -n "${{ github.event.inputs.package }}" ]]; then
-            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            # Manual workflow trigger
-            echo "has_updates=true" >> $GITHUB_OUTPUT
+            PKG="${{ github.event.inputs.package }}"
-            echo "Manual trigger: ${{ github.event.inputs.package }}"
+
+            if [[ -n "$REBUILD" ]]; then
+              # Rebuild requested - always proceed
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "🔄 Manual rebuild requested: $PKG (ppa$REBUILD)"
+
+            elif [[ "$PKG" == "all" ]]; then
+              # Check each package and build list of those needing updates
+              PACKAGES_TO_UPDATE=()
+              check_dms_git && PACKAGES_TO_UPDATE+=("dms-git")
+              check_dms_stable && PACKAGES_TO_UPDATE+=("dms")
+
+              if [[ ${#PACKAGES_TO_UPDATE[@]} -gt 0 ]]; then
+                echo "packages=${PACKAGES_TO_UPDATE[*]}" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+                echo "✓ Packages to update: ${PACKAGES_TO_UPDATE[*]}"
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+                echo "✓ All packages up to date"
+              fi
+
+            elif [[ "$PKG" == "dms-git" ]]; then
+              if check_dms_git; then
+                echo "packages=$PKG" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+              fi
+
+            elif [[ "$PKG" == "dms" ]]; then
+              if check_dms_stable; then
+                echo "packages=$PKG" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+              fi
+
+            else
+              # Unknown package - proceed anyway
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "Manual trigger: $PKG"
+            fi
           else
+            # Fallback - proceed
             echo "packages=all" >> $GITHUB_OUTPUT
             echo "has_updates=true" >> $GITHUB_OUTPUT
           fi
@@ -125,9 +149,7 @@ jobs:
     name: Upload to OBS
     needs: check-updates
     runs-on: ubuntu-latest
-    if: |
+    if: needs.check-updates.outputs.has_updates == 'true'
-      github.event_name == 'workflow_dispatch' ||
-      needs.check-updates.outputs.has_updates == 'true'
 
     steps:
       - name: Checkout
@@ -147,8 +169,14 @@ jobs:
             echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
             echo "Triggered by schedule: updating git package"
           elif [[ -n "${{ github.event.inputs.package }}" ]]; then
-            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            # Use filtered packages from check-updates when package="all" and no rebuild requested
-            echo "Manual trigger: ${{ github.event.inputs.package }}"
+            if [[ "${{ github.event.inputs.package }}" == "all" ]] && [[ -z "${{ github.event.inputs.rebuild_release }}" ]]; then
+              echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+              echo "Manual trigger: all (filtered to: ${{ needs.check-updates.outputs.packages }})"
+            else
+              echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+              echo "Manual trigger: ${{ github.event.inputs.package }}"
+            fi
           else
             echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
           fi
@@ -156,21 +184,42 @@ jobs:
       - name: Update dms-git spec version
         if: contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all'
         run: |
-          # Get commit info for dms-git versioning
           COMMIT_HASH=$(git rev-parse --short=8 HEAD)
           COMMIT_COUNT=$(git rev-list --count HEAD)
           BASE_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1 || echo "0.6.2")
-          
           NEW_VERSION="${BASE_VERSION}+git${COMMIT_COUNT}.${COMMIT_HASH}"
           echo "📦 Updating dms-git.spec to version: $NEW_VERSION"
 
-          # Update version in spec
           sed -i "s/^Version:.*/Version:        $NEW_VERSION/" distro/opensuse/dms-git.spec
 
-          # Add changelog entry
+          # Single changelog entry (git snapshots don't need history)
           DATE_STR=$(date "+%a %b %d %Y")
-          CHANGELOG_ENTRY="* $DATE_STR Avenge Media <AvengeMedia.US@gmail.com> - ${NEW_VERSION}-1\n- Git snapshot (commit $COMMIT_COUNT: $COMMIT_HASH)"
+          LOCAL_SPEC_HEAD=$(sed -n '1,/%changelog/{ /%changelog/d; p }' distro/opensuse/dms-git.spec)
-          sed -i "/%changelog/a\\$CHANGELOG_ENTRY" distro/opensuse/dms-git.spec
+          {
+            echo "$LOCAL_SPEC_HEAD"
+            echo "%changelog"
+            echo "* $DATE_STR Avenge Media <AvengeMedia.US@gmail.com> - ${NEW_VERSION}-1"
+            echo "- Git snapshot (commit $COMMIT_COUNT: $COMMIT_HASH)"
+          } > distro/opensuse/dms-git.spec
+
+      - name: Update Debian dms-git changelog version
+        if: contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all'
+        run: |
+          COMMIT_HASH=$(git rev-parse --short=8 HEAD)
+          COMMIT_COUNT=$(git rev-list --count HEAD)
+          BASE_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1 || echo "0.6.2")
+          NEW_VERSION="${BASE_VERSION}+git${COMMIT_COUNT}.${COMMIT_HASH}"
+          echo "📦 Updating Debian dms-git changelog to version: $NEW_VERSION"
+
+          # Single changelog entry (git snapshots don't need history)
+          CHANGELOG_DATE=$(date -R)
+          {
+            echo "dms-git ($NEW_VERSION) nightly; urgency=medium"
+            echo ""
+            echo "  * Git snapshot (commit $COMMIT_COUNT: $COMMIT_HASH)"
+            echo ""
+            echo " -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE"
+          } > "distro/debian/dms-git/debian/changelog"
 
       - name: Update dms stable version
         if: steps.packages.outputs.version != ''
@@ -179,20 +228,47 @@ jobs:
           VERSION_NO_V="${VERSION#v}"
           echo "Updating packaging to version $VERSION_NO_V"
 
-          # Update openSUSE dms spec (stable only)
           sed -i "s/^Version:.*/Version:        $VERSION_NO_V/" distro/opensuse/dms.spec
 
-          # Update Debian _service files
+          # Single changelog entry (full history on OBS website)
+          DATE_STR=$(date "+%a %b %d %Y")
+          LOCAL_SPEC_HEAD=$(sed -n '1,/%changelog/{ /%changelog/d; p }' distro/opensuse/dms.spec)
+          {
+            echo "$LOCAL_SPEC_HEAD"
+            echo "%changelog"
+            echo "* $DATE_STR AvengeMedia <maintainer@avengemedia.com> - ${VERSION_NO_V}-1"
+            echo "- Update to stable $VERSION release"
+          } > distro/opensuse/dms.spec
+
+          # Update Debian _service files (both tar_scm and download_url formats)
           for service in distro/debian/*/_service; do
             if [[ -f "$service" ]]; then
+              # Update tar_scm revision parameter (for dms-git)
               sed -i "s|<param name=\"revision\">v[0-9.]*</param>|<param name=\"revision\">$VERSION</param>|" "$service"
+
+              # Update download_url paths (for dms stable)
+              sed -i "s|/v[0-9.]\+/|/$VERSION/|g" "$service"
+              sed -i "s|/tags/v[0-9.]\+\.tar\.gz|/tags/$VERSION.tar.gz|g" "$service"
             fi
           done
 
+          # Update Debian changelog for dms stable (single entry, history on OBS website)
+          if [[ -f "distro/debian/dms/debian/changelog" ]]; then
+            CHANGELOG_DATE=$(date -R)
+            {
+              echo "dms ($VERSION_NO_V) stable; urgency=medium"
+              echo ""
+              echo "  * Update to $VERSION stable release"
+              echo ""
+              echo " -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE"
+            } > "distro/debian/dms/debian/changelog"
+            echo "✓ Updated Debian changelog to $VERSION_NO_V"
+          fi
+
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: "1.24"
 
       - name: Install OSC
         run: |
@@ -212,32 +288,76 @@ jobs:
 
       - name: Upload to OBS
         env:
-          FORCE_REBUILD: ${{ github.event_name == 'workflow_dispatch' && 'true' || '' }}
           REBUILD_RELEASE: ${{ github.event.inputs.rebuild_release }}
         run: |
           PACKAGES="${{ steps.packages.outputs.packages }}"
-          MESSAGE="Automated update from GitHub Actions"
 
+          if [[ -z "$PACKAGES" ]]; then
+            echo "✓ No packages need uploading. All up to date!"
+            exit 0
+          fi
+
+          MESSAGE="Automated update from GitHub Actions"
           if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
             MESSAGE="Update to ${{ steps.packages.outputs.version }}"
           fi
 
-          if [[ "$PACKAGES" == "all" ]]; then
+          # PACKAGES can be space-separated list (e.g., "dms-git dms" from "all" check)
-            bash distro/scripts/obs-upload.sh dms "$MESSAGE"
+          # Loop through each package and upload
-            bash distro/scripts/obs-upload.sh dms-git "Automated git update"
+          for PKG in $PACKAGES; do
-          else
+            echo ""
-            bash distro/scripts/obs-upload.sh "$PACKAGES" "$MESSAGE"
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-          fi
+            echo "Uploading $PKG to OBS..."
+            if [[ -n "$REBUILD_RELEASE" ]]; then
+              echo "🔄 Using rebuild release number: ppa$REBUILD_RELEASE"
+            fi
+            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+            if [[ "$PKG" == "dms-git" ]]; then
+              bash distro/scripts/obs-upload.sh dms-git "Automated git update"
+            else
+              bash distro/scripts/obs-upload.sh "$PKG" "$MESSAGE"
+            fi
+          done
 
       - name: Summary
+        if: always()
         run: |
-          echo "### OBS Package Update Complete" >> $GITHUB_STEP_SUMMARY
+          echo "### OBS Package Upload Summary" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
-          echo "- **Packages**: ${{ steps.packages.outputs.packages }}" >> $GITHUB_STEP_SUMMARY
+
-          if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+          PACKAGES="${{ steps.packages.outputs.packages }}"
-            echo "- **Version**: ${{ steps.packages.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+
+          if [[ -z "$PACKAGES" ]]; then
+            echo "**Status:** ✅ All packages up to date (no uploads needed)" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo "All packages are current. Run completed successfully." >> $GITHUB_STEP_SUMMARY
+          else
+            echo "**Packages Uploaded:**" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+
+            for PKG in $PACKAGES; do
+              case "$PKG" in
+                dms)
+                  echo "- ✅ **dms** → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms/dms)" >> $GITHUB_STEP_SUMMARY
+                  ;;
+                dms-git)
+                  echo "- ✅ **dms-git** → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms-git/dms-git)" >> $GITHUB_STEP_SUMMARY
+                  ;;
+              esac
+            done
+
+            echo "" >> $GITHUB_STEP_SUMMARY
+
+            if [[ -n "${{ github.event.inputs.rebuild_release }}" ]]; then
+              echo "**Rebuild Number:** ppa${{ github.event.inputs.rebuild_release }}" >> $GITHUB_STEP_SUMMARY
+              echo "" >> $GITHUB_STEP_SUMMARY
+            fi
+
+            if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+              echo "**Version:** ${{ steps.packages.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+              echo "" >> $GITHUB_STEP_SUMMARY
+            fi
+
+            echo "Monitor build progress on [OBS project page](https://build.opensuse.org/project/show/home:AvengeMedia)." >> $GITHUB_STEP_SUMMARY
           fi
-          if [[ "${{ needs.check-updates.outputs.has_updates }}" == "false" ]]; then
-            echo "- **Status**: Skipped (no changes detected)" >> $GITHUB_STEP_SUMMARY
-          fi
-          echo "- **Project**: https://build.opensuse.org/project/show/home:AvengeMedia" >> $GITHUB_STEP_SUMMARY

.github/workflows/run-ppa.yml

@@ -4,20 +4,150 @@ on:
   workflow_dispatch:
     inputs:
       package:
-        description: 'Package to upload (dms, dms-git, dms-greeter, or all)'
+        description: "Package to upload (dms, dms-git, dms-greeter, or all)"
         required: false
-        default: 'dms-git'
+        default: "dms-git"
       rebuild_release:
-        description: 'Release number for rebuilds (e.g., 2, 3, 4 for ppa2, ppa3, ppa4)'
+        description: "Release number for rebuilds (e.g., 2, 3, 4 for ppa2, ppa3, ppa4)"
         required: false
-        default: ''
+        default: ""
   schedule:
-    - cron: '0 */3 * * *'  # Every 3 hours for dms-git builds
+    - cron: "0 */3 * * *" # Every 3 hours for dms-git builds
 
 jobs:
-  upload-ppa:
+  check-updates:
+    name: Check for updates
     runs-on: ubuntu-latest
 
+    outputs:
+      has_updates: ${{ steps.check.outputs.has_updates }}
+      packages: ${{ steps.check.outputs.packages }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for updates
+        id: check
+        run: |
+          # Helper function to check dms-git commit
+          check_dms_git() {
+            local CURRENT_COMMIT=$(git rev-parse --short=8 HEAD)
+            local PPA_VERSION=$(curl -s "https://api.launchpad.net/1.0/~avengemedia/+archive/ubuntu/dms-git?ws.op=getPublishedSources&source_name=dms-git&status=Published" | grep -oP '"source_package_version":\s*"\K[^"]+' | head -1 || echo "")
+            local PPA_COMMIT=$(echo "$PPA_VERSION" | grep -oP '\.[a-f0-9]{8}' | tr -d '.' || echo "")
+
+            if [[ -n "$PPA_COMMIT" && "$CURRENT_COMMIT" == "$PPA_COMMIT" ]]; then
+              echo "📋 dms-git: Commit $CURRENT_COMMIT already exists, skipping"
+              return 1  # No update needed
+            else
+              echo "📋 dms-git: New commit $CURRENT_COMMIT (PPA has ${PPA_COMMIT:-none})"
+              return 0  # Update needed
+            fi
+          }
+
+          # Helper function to check stable package tag
+          check_stable_package() {
+            local PKG="$1"
+            local PPA_NAME="$2"
+            local LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "v\?\([^"]*\)".*/\1/' || echo "")
+            local PPA_VERSION=$(curl -s "https://api.launchpad.net/1.0/~avengemedia/+archive/ubuntu/$PPA_NAME?ws.op=getPublishedSources&source_name=$PKG&status=Published" | grep -oP '"source_package_version":\s*"\K[^"]+' | head -1 || echo "")
+            local PPA_BASE_VERSION=$(echo "$PPA_VERSION" | sed 's/ppa[0-9]*$//')
+
+            if [[ -n "$LATEST_TAG" && "$LATEST_TAG" == "$PPA_BASE_VERSION" ]]; then
+              echo "📋 $PKG: Tag $LATEST_TAG already exists, skipping"
+              return 1  # No update needed
+            else
+              echo "📋 $PKG: New tag ${LATEST_TAG:-unknown} (PPA has ${PPA_BASE_VERSION:-none})"
+              return 0  # Update needed
+            fi
+          }
+
+          # Main logic
+          REBUILD="${{ github.event.inputs.rebuild_release }}"
+
+          if [[ "${{ github.event_name }}" == "schedule" ]]; then
+            # Scheduled run - check dms-git only
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
+            if check_dms_git; then
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+            else
+              echo "has_updates=false" >> $GITHUB_OUTPUT
+            fi
+
+          elif [[ -n "${{ github.event.inputs.package }}" ]]; then
+            # Manual workflow trigger
+            PKG="${{ github.event.inputs.package }}"
+
+            if [[ -n "$REBUILD" ]]; then
+              # Rebuild requested - always proceed
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "🔄 Manual rebuild requested: $PKG (ppa$REBUILD)"
+
+            elif [[ "$PKG" == "all" ]]; then
+              # Check each package and build list of those needing updates
+              PACKAGES_TO_UPDATE=()
+              check_dms_git && PACKAGES_TO_UPDATE+=("dms-git")
+              check_stable_package "dms" "dms" && PACKAGES_TO_UPDATE+=("dms")
+              check_stable_package "dms-greeter" "danklinux" && PACKAGES_TO_UPDATE+=("dms-greeter")
+
+              if [[ ${#PACKAGES_TO_UPDATE[@]} -gt 0 ]]; then
+                echo "packages=${PACKAGES_TO_UPDATE[*]}" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+                echo "✓ Packages to update: ${PACKAGES_TO_UPDATE[*]}"
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+                echo "✓ All packages up to date"
+              fi
+
+            elif [[ "$PKG" == "dms-git" ]]; then
+              if check_dms_git; then
+                echo "packages=$PKG" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+              fi
+
+            elif [[ "$PKG" == "dms" ]]; then
+              if check_stable_package "dms" "dms"; then
+                echo "packages=$PKG" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+              fi
+
+            elif [[ "$PKG" == "dms-greeter" ]]; then
+              if check_stable_package "dms-greeter" "danklinux"; then
+                echo "packages=$PKG" >> $GITHUB_OUTPUT
+                echo "has_updates=true" >> $GITHUB_OUTPUT
+              else
+                echo "packages=" >> $GITHUB_OUTPUT
+                echo "has_updates=false" >> $GITHUB_OUTPUT
+              fi
+
+            else
+              # Unknown package - proceed anyway
+              echo "packages=$PKG" >> $GITHUB_OUTPUT
+              echo "has_updates=true" >> $GITHUB_OUTPUT
+              echo "Manual trigger: $PKG"
+            fi
+          else
+            # Fallback
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
+            echo "has_updates=true" >> $GITHUB_OUTPUT
+          fi
+
+  upload-ppa:
+    name: Upload to PPA
+    needs: check-updates
+    runs-on: ubuntu-latest
+    if: needs.check-updates.outputs.has_updates == 'true'
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -27,7 +157,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: "1.24"
           cache: false
 
       - name: Install build dependencies
@@ -53,71 +183,97 @@ jobs:
       - name: Determine packages to upload
         id: packages
         run: |
+          # Use packages determined by check-updates job
+          echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
+
           if [[ "${{ github.event_name }}" == "schedule" ]]; then
-            echo "packages=dms-git" >> $GITHUB_OUTPUT
             echo "Triggered by schedule: uploading git package"
           elif [[ -n "${{ github.event.inputs.package }}" ]]; then
-            echo "packages=${{ github.event.inputs.package }}" >> $GITHUB_OUTPUT
+            echo "Manual trigger: ${{ needs.check-updates.outputs.packages }}"
-            echo "Manual trigger: ${{ github.event.inputs.package }}"
-          else
-            echo "packages=dms-git" >> $GITHUB_OUTPUT
           fi
 
       - name: Upload to PPA
-        env:
-          REBUILD_RELEASE: ${{ github.event.inputs.rebuild_release }}
         run: |
           PACKAGES="${{ steps.packages.outputs.packages }}"
+          REBUILD_RELEASE="${{ github.event.inputs.rebuild_release }}"
 
-          if [[ "$PACKAGES" == "all" ]]; then
+          if [[ -z "$PACKAGES" ]]; then
+            echo "✓ No packages need uploading. All up to date!"
+            exit 0
+          fi
+
+          # Export REBUILD_RELEASE so ppa-build.sh can use it
+          if [[ -n "$REBUILD_RELEASE" ]]; then
+            export REBUILD_RELEASE
+            echo "✓ Using rebuild release number: ppa$REBUILD_RELEASE"
+          fi
+
+          # PACKAGES can be space-separated list (e.g., "dms-git dms" from "all" check)
+          # Loop through each package and upload
+          for PKG in $PACKAGES; do
+            # Map package to PPA name
+            case "$PKG" in
+              dms)
+                PPA_NAME="dms"
+                ;;
+              dms-git)
+                PPA_NAME="dms-git"
+                ;;
+              dms-greeter)
+                PPA_NAME="danklinux"
+                ;;
+              *)
+                echo "⚠️ Unknown package: $PKG, skipping"
+                continue
+                ;;
+            esac
+
+            echo ""
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "Uploading dms to PPA..."
+            echo "Uploading $PKG to PPA $PPA_NAME..."
-            if [ -n "$REBUILD_RELEASE" ]; then
+            if [[ -n "$REBUILD_RELEASE" ]]; then
               echo "🔄 Using rebuild release number: ppa$REBUILD_RELEASE"
             fi
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            bash distro/scripts/ppa-upload.sh "distro/ubuntu/dms" dms questing
+            bash distro/scripts/ppa-upload.sh "$PKG" "$PPA_NAME" questing ${REBUILD_RELEASE:+"$REBUILD_RELEASE"}
-            
+          done
-            echo ""
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "Uploading dms-git to PPA..."
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            bash distro/scripts/ppa-upload.sh "distro/ubuntu/dms-git" dms-git questing
-            
-            echo ""
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "Uploading dms-greeter to PPA..."
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            bash distro/scripts/ppa-upload.sh "distro/ubuntu/dms-greeter" danklinux questing
-          else
-            PPA_NAME="$PACKAGES"
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            echo "Uploading $PACKAGES to PPA..."
-            echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            bash distro/scripts/ppa-upload.sh "distro/ubuntu/$PACKAGES" "$PPA_NAME" questing
-          fi
 
       - name: Summary
+        if: always()
         run: |
-          echo "### PPA Package Upload Complete" >> $GITHUB_STEP_SUMMARY
+          echo "### PPA Package Upload Summary" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
-          echo "- **Packages**: ${{ steps.packages.outputs.packages }}" >> $GITHUB_STEP_SUMMARY
 
           PACKAGES="${{ steps.packages.outputs.packages }}"
-          if [[ "$PACKAGES" == "all" ]]; then
-            echo "- **PPA dms**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms/+packages" >> $GITHUB_STEP_SUMMARY
-            echo "- **PPA dms-git**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms-git/+packages" >> $GITHUB_STEP_SUMMARY
-            echo "- **PPA danklinux**: https://launchpad.net/~avengemedia/+archive/ubuntu/danklinux/+packages" >> $GITHUB_STEP_SUMMARY
-          elif [[ "$PACKAGES" == "dms" ]]; then
-            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms/+packages" >> $GITHUB_STEP_SUMMARY
-          elif [[ "$PACKAGES" == "dms-git" ]]; then
-            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/dms-git/+packages" >> $GITHUB_STEP_SUMMARY
-          elif [[ "$PACKAGES" == "dms-greeter" ]]; then
-            echo "- **PPA**: https://launchpad.net/~avengemedia/+archive/ubuntu/danklinux/+packages" >> $GITHUB_STEP_SUMMARY
-          fi
 
-          if [[ -n "${{ steps.packages.outputs.version }}" ]]; then
+          if [[ -z "$PACKAGES" ]]; then
-            echo "- **Version**: ${{ steps.packages.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+            echo "**Status:** ✅ All packages up to date (no uploads needed)" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo "All packages are current. Run will complete successfully." >> $GITHUB_STEP_SUMMARY
+          else
+            echo "**Packages Uploaded:**" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+
+            for PKG in $PACKAGES; do
+              case "$PKG" in
+                dms)
+                  echo "- ✅ **dms** → [View builds](https://launchpad.net/~avengemedia/+archive/ubuntu/dms/+packages)" >> $GITHUB_STEP_SUMMARY
+                  ;;
+                dms-git)
+                  echo "- ✅ **dms-git** → [View builds](https://launchpad.net/~avengemedia/+archive/ubuntu/dms-git/+packages)" >> $GITHUB_STEP_SUMMARY
+                  ;;
+                dms-greeter)
+                  echo "- ✅ **dms-greeter** → [View builds](https://launchpad.net/~avengemedia/+archive/ubuntu/danklinux/+packages)" >> $GITHUB_STEP_SUMMARY
+                  ;;
+              esac
+            done
+
+            echo "" >> $GITHUB_STEP_SUMMARY
+
+            if [[ -n "${{ github.event.inputs.rebuild_release }}" ]]; then
+              echo "**Rebuild Number:** ppa${{ github.event.inputs.rebuild_release }}" >> $GITHUB_STEP_SUMMARY
+              echo "" >> $GITHUB_STEP_SUMMARY
+            fi
+
+            echo "Builds will appear once Launchpad processes the uploads." >> $GITHUB_STEP_SUMMARY
           fi
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "Builds will appear once Launchpad processes the uploads." >> $GITHUB_STEP_SUMMARY

.github/workflows/stable.yml

@@ -0,0 +1,19 @@
+name: Update stable branch
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  update-stable:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Push to stable branch
+        run: git push origin HEAD:refs/heads/stable --force

.github/workflows/update-vendor-hash.yml

@@ -36,7 +36,7 @@ jobs:
         run: |
           set -euo pipefail
           echo "Attempting nix build to get new vendorHash..."
-          if output=$(nix build .#dmsCli 2>&1); then
+          if output=$(nix build .#dms-shell 2>&1); then
             echo "Build succeeded, no hash update needed"
             exit 0
           fi
@@ -46,7 +46,7 @@ jobs:
           [ "$current_hash" = "$new_hash" ] && { echo "vendorHash already up to date"; exit 0; }
           sed -i "s|vendorHash = \"$current_hash\"|vendorHash = \"$new_hash\"|" flake.nix
           echo "Verifying build with new vendorHash..."
-          nix build .#dmsCli
+          nix build .#dms-shell
           echo "vendorHash updated successfully!"
 
       - name: Commit and push vendorHash update

.gitignore

@@ -102,43 +102,8 @@ 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  
+# direnv
-distro/ubuntu/*/dms-git-repo/
+.envrc
-distro/ubuntu/*/DankMaterialShell-*/
+.direnv/
-distro/ubuntu/danklinux/*/dsearch-*/
-distro/ubuntu/danklinux/*/dgop-*/

.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: end-of-file-fixer
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.10.0.1
+    hooks:
+      - id: shellcheck
+        args: [-e, SC2164, -e, SC2001, -e, SC2012, -e, SC2317]

CHANGELOG.MD

@@ -0,0 +1,6 @@
+# 1.2.0
+
+- Added clipboard and clipboard history integration
+- Added swipe to dismiss notification popups and from center
+- Added paste from clipboard history view - requires wtype
+- Optimize surface damage of OSD & Toast

CONTRIBUTING.md

@@ -6,12 +6,28 @@ To contribute fork this repository, make your changes, and open a pull request.
 
 ## Setup
 
-Enable pre-commit hooks to catch CI failures before pushing:
+Install [prek](https://prek.j178.dev/) then activate pre-commit hooks:
 
 ```bash
-git config core.hooksPath .githooks
+prek install
 ```
 
+### 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.
@@ -39,6 +55,20 @@ touch .qmlls.ini
 
 5. Make your changes, test, and open a pull request.
 
+### I18n/Localization
+
+When adding user-facing strings, ensure they are wrapped in `I18n.tr()` with context, for example.
+
+```qml
+import qs.Common
+
+Text {
+  text: I18n.tr("Hello World", "<This is context for the translators, example> Hello world greeting that appears on the lock screen")
+}
+```
+
+Preferably, try to keep new terms to a minimum and re-use existing terms where possible. See `quickshell/translations/en.json` for the list of existing terms. (This isn't always possible obviously, but instead of using `Auto-connect` you would use `Autoconnect` since it's already translated)
+
 ### GO (`core` directory)
 
 1. Install the [Go Extension](https://code.visualstudio.com/docs/languages/go)

Makefile

@@ -43,6 +43,7 @@ install-shell:
 	@mkdir -p $(SHELL_INSTALL_DIR)
 	@cp -r $(SHELL_DIR)/* $(SHELL_INSTALL_DIR)/
 	@rm -rf $(SHELL_INSTALL_DIR)/.git* $(SHELL_INSTALL_DIR)/.github
+	@$(MAKE) --no-print-directory -C $(CORE_DIR) print-version > $(SHELL_INSTALL_DIR)/VERSION
 	@echo "Shell files installed"
 
 install-completions:
@@ -80,8 +81,7 @@ install: build install-bin install-shell install-completions install-systemd ins
 	@echo ""
 	@echo "Installation complete!"
 	@echo ""
-	@echo "To enable and start DMS:"
+	@echo "=== Cheers, the DMS Team! ==="
-	@echo "  systemctl --user enable --now dms"
 
 # Uninstallation targets
 uninstall-bin:

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;

assets/systemd/dms.service

@@ -5,7 +5,8 @@ After=graphical-session.target
 Requisite=graphical-session.target
 
 [Service]
-Type=simple
+Type=dbus
+BusName=org.freedesktop.Notifications
 ExecStart=/usr/bin/dms run --session
 ExecReload=/usr/bin/pkill -USR1 -x dms
 Restart=always

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
@@ -99,7 +102,11 @@ linters:
       - linters:
           - ineffassign
         path: internal/proto/
-      # binary.Write to bytes.Buffer can't fail
+      # binary.Write/Read to bytes.Buffer can't fail
       - linters:
           - errcheck
-        text: "Error return value of `binary\\.Write` is not checked"
+        text: "Error return value of `binary\\.(Write|Read)` is not checked"
+      # bytes.Reader.Read can't fail (reads from memory)
+      - linters:
+          - errcheck
+        text: "Error return value of `buf\\.Read` is not checked"

core/.mockery.yml

@@ -56,3 +56,15 @@ packages:
       outpkg: mocks_version
     interfaces:
       VersionFetcher:
+  github.com/AvengeMedia/DankMaterialShell/core/internal/server/wlcontext:
+    config:
+      dir: "internal/mocks/wlcontext"
+      outpkg: mocks_wlcontext
+    interfaces:
+      WaylandContext:
+  github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client:
+    config:
+      dir: "internal/mocks/wlclient"
+      outpkg: mocks_wlclient
+    interfaces:
+      WaylandDisplay:

core/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/golangci/golangci-lint
+    rev: v2.6.2
+    hooks:
+      - id: golangci-lint-fmt
+        require_serial: true
+      - id: golangci-lint-full
+      - id: golangci-lint-config-verify
+  - repo: local
+    hooks:
+      - id: go-test
+        name: go test
+        entry: go test ./...
+        language: system
+        pass_filenames: false
+        types: [go]

core/Makefile

@@ -10,16 +10,19 @@ GO=go
 GOFLAGS=-ldflags="-s -w"
 
 # Version and build info
-VERSION=$(shell git describe --tags --always 2>/dev/null || echo "dev")
+BASE_VERSION=$(shell git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//' || echo "0.0.0")
-BUILD_TIME=$(shell date -u '+%Y-%m-%d_%H:%M:%S')
+COMMIT_COUNT=$(shell git rev-list --count HEAD 2>/dev/null || echo "0")
-COMMIT=$(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+COMMIT_HASH=$(shell git rev-parse --short=8 HEAD 2>/dev/null || echo "unknown")
+VERSION?=$(BASE_VERSION)+git$(COMMIT_COUNT).$(COMMIT_HASH)
+BUILD_TIME?=$(shell date -u '+%Y-%m-%d_%H:%M:%S')
+COMMIT?=$(COMMIT_HASH)
 
 BUILD_LDFLAGS=-ldflags='-s -w -X main.Version=$(VERSION) -X main.buildTime=$(BUILD_TIME) -X main.commit=$(COMMIT)'
 
 # Architecture to build for dist target (amd64, arm64, or all)
 ARCH ?= all
 
-.PHONY: all build dankinstall dist clean install install-all install-dankinstall uninstall uninstall-all uninstall-dankinstall install-config uninstall-config test fmt vet deps help
+.PHONY: all build dankinstall dist clean install install-all install-dankinstall uninstall uninstall-all uninstall-dankinstall install-config uninstall-config test fmt vet deps print-version help
 
 # Default target
 all: build
@@ -132,6 +135,9 @@ version: check-go
 	@echo "Build Time: $(BUILD_TIME)"
 	@echo "Commit: $(COMMIT)"
 
+print-version:
+	@echo "$(VERSION)"
+
 help:
 	@echo "Available targets:"
 	@echo "  all                 - Build the main binary (dms) (default)"

core/README.md

@@ -16,6 +16,9 @@ Distribution-aware installer with TUI for deploying DMS and compositor configura
 
 **Wayland Protocols**
 - `wlr-gamma-control-unstable-v1` - Night mode and gamma control
+- `wlr-screencopy-unstable-v1` - Screen capture for color picker
+- `wlr-layer-shell-unstable-v1` - Overlay surfaces for color picker
+- `wp-viewporter` - Fractional scaling support
 - `dwl-ipc-unstable-v2` - dwl/MangoWC workspace integration
 - `ext-workspace-v1` - Workspace protocol support
 - `wlr-output-management-unstable-v1` - Display configuration
@@ -44,9 +47,24 @@ Distribution-aware installer with TUI for deploying DMS and compositor configura
 - `dms ipc <command>` - Send IPC commands (toggle launcher, notifications, etc.)
 - `dms plugins [install|browse|search]` - Plugin management
 - `dms brightness [list|set]` - Control display/monitor brightness
+- `dms color pick` - Native color picker (see below)
 - `dms update` - Update DMS and dependencies (disabled in distro packages)
 - `dms greeter install` - Install greetd greeter (disabled in distro packages)
 
+### Color Picker
+
+Native Wayland color picker with magnifier, no external dependencies. Supports HiDPI and fractional scaling.
+
+```bash
+dms color pick              # Pick color, output hex
+dms color pick --rgb        # Output as RGB (255 128 64)
+dms color pick --hsv        # Output as HSV (24 75% 100%)
+dms color pick --json       # Output all formats as JSON
+dms color pick -a           # Auto-copy to clipboard
+```
+
+The on-screen preview displays the selected format. JSON output includes hex, RGB, HSL, HSV, and CMYK values.
+
 ## Building
 
 Requires Go 1.24+

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

@@ -28,7 +28,14 @@ var brightnessSetCmd = &cobra.Command{
 	Short: "Set brightness for a device",
 	Long:  "Set brightness percentage (0-100) for a specific device",
 	Args:  cobra.ExactArgs(2),
-	Run:   runBrightnessSet,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		includeDDC, _ := cmd.Flags().GetBool("ddc")
+		return getBrightnessDevices(includeDDC), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: runBrightnessSet,
 }
 
 var brightnessGetCmd = &cobra.Command{
@@ -36,7 +43,14 @@ var brightnessGetCmd = &cobra.Command{
 	Short: "Get brightness for a device",
 	Long:  "Get current brightness percentage for a specific device",
 	Args:  cobra.ExactArgs(1),
-	Run:   runBrightnessGet,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		includeDDC, _ := cmd.Flags().GetBool("ddc")
+		return getBrightnessDevices(includeDDC), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: runBrightnessGet,
 }
 
 func init() {
@@ -105,9 +119,7 @@ Global Flags:
 	brightnessCmd.AddCommand(brightnessListCmd, brightnessSetCmd, brightnessGetCmd)
 }
 
-func runBrightnessList(cmd *cobra.Command, args []string) {
+func getAllBrightnessDevices(includeDDC bool) []brightness.Device {
-	includeDDC, _ := cmd.Flags().GetBool("ddc")
-
 	allDevices := []brightness.Device{}
 
 	sysfs, err := brightness.NewSysfsBackend()
@@ -138,6 +150,13 @@ func runBrightnessList(cmd *cobra.Command, args []string) {
 		}
 	}
 
+	return allDevices
+}
+
+func runBrightnessList(cmd *cobra.Command, args []string) {
+	includeDDC, _ := cmd.Flags().GetBool("ddc")
+	allDevices := getAllBrightnessDevices(includeDDC)
+
 	if len(allDevices) == 0 {
 		fmt.Println("No brightness devices found")
 		return
@@ -192,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]
+		if ok := tryLogindBrightness(parts[0], parts[1], deviceID, percent, exponential, exponent); ok {
-		name := parts[1]
+			return
-
-		// 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)
-				}
-			}
 		}
 	}
 
-	// Fallback to direct sysfs (requires write permissions)
 	sysfs, err := brightness.NewSysfsBackend()
 	if err == nil {
 		if err := sysfs.SetBrightnessWithExponent(deviceID, percent, exponential, exponent); err == nil {
@@ -261,31 +248,51 @@ 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)
+
+	var deviceIDs []string
+	for _, device := range allDevices {
+		deviceIDs = append(deviceIDs, device.ID)
+	}
+	return deviceIDs
+}
+
 func runBrightnessGet(cmd *cobra.Command, args []string) {
 	deviceID := args[0]
 	includeDDC, _ := cmd.Flags().GetBool("ddc")
-
+	allDevices := getAllBrightnessDevices(includeDDC)
-	allDevices := []brightness.Device{}
-
-	sysfs, err := brightness.NewSysfsBackend()
-	if err == nil {
-		devices, err := sysfs.GetDevices()
-		if err == nil {
-			allDevices = append(allDevices, devices...)
-		}
-	}
-
-	if includeDDC {
-		ddc, err := brightness.NewDDCBackend()
-		if err == nil {
-			defer ddc.Close()
-			time.Sleep(100 * time.Millisecond)
-			devices, err := ddc.GetDevices()
-			if err == nil {
-				allDevices = append(allDevices, devices...)
-			}
-		}
-	}
 
 	for _, device := range allDevices {
 		if device.ID == deviceID {

core/cmd/dms/commands_clipboard.go

@@ -0,0 +1,628 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/spf13/cobra"
+)
+
+var clipboardCmd = &cobra.Command{
+	Use:     "clipboard",
+	Aliases: []string{"cl"},
+	Short:   "Manage clipboard",
+	Long:    "Interact with the clipboard manager",
+}
+
+var clipCopyCmd = &cobra.Command{
+	Use:   "copy [text]",
+	Short: "Copy text to clipboard",
+	Long:  "Copy text to clipboard. If no text provided, reads from stdin. Works without server.",
+	Run:   runClipCopy,
+}
+
+var (
+	clipCopyForeground bool
+	clipCopyPasteOnce  bool
+	clipCopyType       string
+	clipJSONOutput     bool
+)
+
+var clipPasteCmd = &cobra.Command{
+	Use:   "paste",
+	Short: "Paste text from clipboard",
+	Long:  "Paste text from clipboard to stdout. Works without server.",
+	Run:   runClipPaste,
+}
+
+var clipWatchCmd = &cobra.Command{
+	Use:   "watch [command]",
+	Short: "Watch clipboard for changes",
+	Long: `Watch clipboard for changes and optionally execute a command.
+Works like wl-paste --watch. Does not require server.
+
+If a command is provided, it will be executed each time the clipboard changes,
+with the clipboard content piped to its stdin.
+
+Examples:
+  dms cl watch              # Print clipboard changes to stdout
+  dms cl watch cat          # Same as above
+  dms cl watch notify-send  # Send notification on clipboard change`,
+	Run: runClipWatch,
+}
+
+var clipHistoryCmd = &cobra.Command{
+	Use:   "history",
+	Short: "Show clipboard history",
+	Long:  "Show clipboard history with previews (requires server)",
+	Run:   runClipHistory,
+}
+
+var clipGetCmd = &cobra.Command{
+	Use:   "get <id>",
+	Short: "Get clipboard entry by ID",
+	Long:  "Get full clipboard entry data by ID (requires server). Use --copy to copy it to clipboard.",
+	Args:  cobra.ExactArgs(1),
+	Run:   runClipGet,
+}
+
+var clipGetCopy bool
+
+var clipDeleteCmd = &cobra.Command{
+	Use:   "delete <id>",
+	Short: "Delete clipboard entry",
+	Long:  "Delete a clipboard history entry by ID (requires server)",
+	Args:  cobra.ExactArgs(1),
+	Run:   runClipDelete,
+}
+
+var clipClearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Clear clipboard history",
+	Long:  "Clear all clipboard history (requires server)",
+	Run:   runClipClear,
+}
+
+var clipWatchStore bool
+
+var clipSearchCmd = &cobra.Command{
+	Use:   "search [query]",
+	Short: "Search clipboard history",
+	Long:  "Search clipboard history with filters (requires server)",
+	Run:   runClipSearch,
+}
+
+var (
+	clipSearchLimit    int
+	clipSearchOffset   int
+	clipSearchMimeType string
+	clipSearchImages   bool
+	clipSearchText     bool
+)
+
+var clipConfigCmd = &cobra.Command{
+	Use:   "config",
+	Short: "Manage clipboard config",
+	Long:  "Get or set clipboard configuration (requires server)",
+}
+
+var clipConfigGetCmd = &cobra.Command{
+	Use:   "get",
+	Short: "Get clipboard config",
+	Run:   runClipConfigGet,
+}
+
+var clipConfigSetCmd = &cobra.Command{
+	Use:   "set",
+	Short: "Set clipboard config",
+	Long: `Set clipboard configuration options.
+
+Examples:
+  dms cl config set --max-history 200
+  dms cl config set --auto-clear-days 7
+  dms cl config set --clear-at-startup`,
+	Run: runClipConfigSet,
+}
+
+var (
+	clipConfigMaxHistory     int
+	clipConfigAutoClearDays  int
+	clipConfigClearAtStartup bool
+	clipConfigNoClearStartup bool
+	clipConfigDisabled       bool
+	clipConfigEnabled        bool
+	clipConfigDisableHistory bool
+	clipConfigEnableHistory  bool
+	clipConfigDisablePersist bool
+	clipConfigEnablePersist  bool
+)
+
+func init() {
+	clipCopyCmd.Flags().BoolVarP(&clipCopyForeground, "foreground", "f", false, "Stay in foreground instead of forking")
+	clipCopyCmd.Flags().BoolVarP(&clipCopyPasteOnce, "paste-once", "o", false, "Exit after first paste")
+	clipCopyCmd.Flags().StringVarP(&clipCopyType, "type", "t", "text/plain;charset=utf-8", "MIME type")
+
+	clipWatchCmd.Flags().BoolVar(&clipJSONOutput, "json", false, "Output as JSON")
+	clipHistoryCmd.Flags().BoolVar(&clipJSONOutput, "json", false, "Output as JSON")
+	clipGetCmd.Flags().BoolVar(&clipJSONOutput, "json", false, "Output as JSON")
+	clipGetCmd.Flags().BoolVarP(&clipGetCopy, "copy", "c", false, "Copy entry to clipboard")
+
+	clipSearchCmd.Flags().IntVarP(&clipSearchLimit, "limit", "l", 50, "Max results")
+	clipSearchCmd.Flags().IntVarP(&clipSearchOffset, "offset", "o", 0, "Result offset")
+	clipSearchCmd.Flags().StringVarP(&clipSearchMimeType, "mime", "m", "", "Filter by MIME type")
+	clipSearchCmd.Flags().BoolVar(&clipSearchImages, "images", false, "Only images")
+	clipSearchCmd.Flags().BoolVar(&clipSearchText, "text", false, "Only text")
+	clipSearchCmd.Flags().BoolVar(&clipJSONOutput, "json", false, "Output as JSON")
+
+	clipConfigSetCmd.Flags().IntVar(&clipConfigMaxHistory, "max-history", 0, "Max history entries")
+	clipConfigSetCmd.Flags().IntVar(&clipConfigAutoClearDays, "auto-clear-days", -1, "Auto-clear entries older than N days (0 to disable)")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigClearAtStartup, "clear-at-startup", false, "Clear history on startup")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigNoClearStartup, "no-clear-at-startup", false, "Don't clear history on startup")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisabled, "disable", false, "Disable clipboard manager entirely")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnabled, "enable", false, "Enable clipboard manager")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisableHistory, "disable-history", false, "Disable clipboard history persistence")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnableHistory, "enable-history", false, "Enable clipboard history persistence")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigDisablePersist, "disable-persist", false, "Disable clipboard ownership persistence")
+	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnablePersist, "enable-persist", false, "Enable clipboard ownership persistence")
+
+	clipWatchCmd.Flags().BoolVarP(&clipWatchStore, "store", "s", false, "Store clipboard changes to history (no server required)")
+
+	clipConfigCmd.AddCommand(clipConfigGetCmd, clipConfigSetCmd)
+	clipboardCmd.AddCommand(clipCopyCmd, clipPasteCmd, clipWatchCmd, clipHistoryCmd, clipGetCmd, clipDeleteCmd, clipClearCmd, clipSearchCmd, clipConfigCmd)
+}
+
+func runClipCopy(cmd *cobra.Command, args []string) {
+	var data []byte
+
+	if len(args) > 0 {
+		data = []byte(args[0])
+	} else {
+		var err error
+		data, err = io.ReadAll(os.Stdin)
+		if err != nil {
+			log.Fatalf("read stdin: %v", err)
+		}
+	}
+
+	if err := clipboard.CopyOpts(data, clipCopyType, clipCopyForeground, clipCopyPasteOnce); err != nil {
+		log.Fatalf("copy: %v", err)
+	}
+}
+
+func runClipPaste(cmd *cobra.Command, args []string) {
+	data, _, err := clipboard.Paste()
+	if err != nil {
+		log.Fatalf("paste: %v", err)
+	}
+	os.Stdout.Write(data)
+}
+
+func runClipWatch(cmd *cobra.Command, args []string) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigCh
+		cancel()
+	}()
+
+	switch {
+	case len(args) > 0:
+		if err := clipboard.Watch(ctx, func(data []byte, mimeType string) {
+			runCommand(args, data)
+		}); err != nil && err != context.Canceled {
+			log.Fatalf("Watch error: %v", err)
+		}
+	case clipWatchStore:
+		if err := clipboard.Watch(ctx, func(data []byte, mimeType string) {
+			if err := clipboard.Store(data, mimeType); err != nil {
+				log.Errorf("store: %v", err)
+			}
+		}); err != nil && err != context.Canceled {
+			log.Fatalf("Watch error: %v", err)
+		}
+	case clipJSONOutput:
+		if err := clipboard.Watch(ctx, func(data []byte, mimeType string) {
+			out := map[string]any{
+				"data":      string(data),
+				"mimeType":  mimeType,
+				"timestamp": time.Now().Format(time.RFC3339),
+				"size":      len(data),
+			}
+			j, _ := json.Marshal(out)
+			fmt.Println(string(j))
+		}); err != nil && err != context.Canceled {
+			log.Fatalf("Watch error: %v", err)
+		}
+	default:
+		if err := clipboard.Watch(ctx, func(data []byte, mimeType string) {
+			os.Stdout.Write(data)
+			os.Stdout.WriteString("\n")
+		}); err != nil && err != context.Canceled {
+			log.Fatalf("Watch error: %v", err)
+		}
+	}
+}
+
+func runCommand(args []string, stdin []byte) {
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if len(stdin) == 0 {
+		cmd.Run()
+		return
+	}
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		cmd.Run()
+		return
+	}
+
+	cmd.Stdin = r
+	go func() {
+		w.Write(stdin)
+		w.Close()
+	}()
+	cmd.Run()
+}
+
+func runClipHistory(cmd *cobra.Command, args []string) {
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.getHistory",
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to get clipboard history: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	if resp.Result == nil {
+		if clipJSONOutput {
+			fmt.Println("[]")
+		} else {
+			fmt.Println("No clipboard history")
+		}
+		return
+	}
+
+	historyList, ok := (*resp.Result).([]any)
+	if !ok {
+		log.Fatal("Invalid response format")
+	}
+
+	if clipJSONOutput {
+		out, _ := json.MarshalIndent(historyList, "", "  ")
+		fmt.Println(string(out))
+		return
+	}
+
+	if len(historyList) == 0 {
+		fmt.Println("No clipboard history")
+		return
+	}
+
+	fmt.Println("Clipboard History:")
+	fmt.Println()
+
+	for _, item := range historyList {
+		entry, ok := item.(map[string]any)
+		if !ok {
+			continue
+		}
+
+		id := uint64(entry["id"].(float64))
+		preview := entry["preview"].(string)
+		timestamp := entry["timestamp"].(string)
+		isImage := entry["isImage"].(bool)
+
+		typeStr := "text"
+		if isImage {
+			typeStr = "image"
+		}
+
+		fmt.Printf("ID: %d | %s | %s\n", id, typeStr, timestamp)
+		fmt.Printf("  %s\n", preview)
+		fmt.Println()
+	}
+}
+
+func runClipGet(cmd *cobra.Command, args []string) {
+	id, err := strconv.ParseUint(args[0], 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid ID: %v", err)
+	}
+
+	if clipGetCopy {
+		req := models.Request{
+			ID:     1,
+			Method: "clipboard.copyEntry",
+			Params: map[string]any{
+				"id": id,
+			},
+		}
+
+		resp, err := sendServerRequest(req)
+		if err != nil {
+			log.Fatalf("Failed to copy clipboard entry: %v", err)
+		}
+
+		if resp.Error != "" {
+			log.Fatalf("Error: %s", resp.Error)
+		}
+
+		fmt.Printf("Copied entry %d to clipboard\n", id)
+		return
+	}
+
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.getEntry",
+		Params: map[string]any{
+			"id": id,
+		},
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to get clipboard entry: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	if resp.Result == nil {
+		log.Fatal("Entry not found")
+	}
+
+	entry, ok := (*resp.Result).(map[string]any)
+	if !ok {
+		log.Fatal("Invalid response format")
+	}
+
+	switch {
+	case clipJSONOutput:
+		output, _ := json.MarshalIndent(entry, "", "  ")
+		fmt.Println(string(output))
+	default:
+		if data, ok := entry["data"].(string); ok {
+			fmt.Print(data)
+		} else {
+			output, _ := json.MarshalIndent(entry, "", "  ")
+			fmt.Println(string(output))
+		}
+	}
+}
+
+func runClipDelete(cmd *cobra.Command, args []string) {
+	id, err := strconv.ParseUint(args[0], 10, 64)
+	if err != nil {
+		log.Fatalf("Invalid ID: %v", err)
+	}
+
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.deleteEntry",
+		Params: map[string]any{
+			"id": id,
+		},
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to delete clipboard entry: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	fmt.Printf("Deleted entry %d\n", id)
+}
+
+func runClipClear(cmd *cobra.Command, args []string) {
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.clearHistory",
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to clear clipboard history: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	fmt.Println("Clipboard history cleared")
+}
+
+func runClipSearch(cmd *cobra.Command, args []string) {
+	params := map[string]any{
+		"limit":  clipSearchLimit,
+		"offset": clipSearchOffset,
+	}
+
+	if len(args) > 0 {
+		params["query"] = args[0]
+	}
+	if clipSearchMimeType != "" {
+		params["mimeType"] = clipSearchMimeType
+	}
+	if clipSearchImages {
+		params["isImage"] = true
+	} else if clipSearchText {
+		params["isImage"] = false
+	}
+
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.search",
+		Params: params,
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to search clipboard: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	if resp.Result == nil {
+		log.Fatal("No results")
+	}
+
+	result, ok := (*resp.Result).(map[string]any)
+	if !ok {
+		log.Fatal("Invalid response format")
+	}
+
+	if clipJSONOutput {
+		out, _ := json.MarshalIndent(result, "", "  ")
+		fmt.Println(string(out))
+		return
+	}
+
+	entries, _ := result["entries"].([]any)
+	total := int(result["total"].(float64))
+	hasMore := result["hasMore"].(bool)
+
+	if len(entries) == 0 {
+		fmt.Println("No results found")
+		return
+	}
+
+	fmt.Printf("Results: %d of %d\n\n", len(entries), total)
+
+	for _, item := range entries {
+		entry, ok := item.(map[string]any)
+		if !ok {
+			continue
+		}
+
+		id := uint64(entry["id"].(float64))
+		preview := entry["preview"].(string)
+		timestamp := entry["timestamp"].(string)
+		isImage := entry["isImage"].(bool)
+
+		typeStr := "text"
+		if isImage {
+			typeStr = "image"
+		}
+
+		fmt.Printf("ID: %d | %s | %s\n", id, typeStr, timestamp)
+		fmt.Printf("  %s\n\n", preview)
+	}
+
+	if hasMore {
+		fmt.Printf("Use --offset %d to see more results\n", clipSearchOffset+clipSearchLimit)
+	}
+}
+
+func runClipConfigGet(cmd *cobra.Command, args []string) {
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.getConfig",
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to get config: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	if resp.Result == nil {
+		log.Fatal("No config returned")
+	}
+
+	cfg, ok := (*resp.Result).(map[string]any)
+	if !ok {
+		log.Fatal("Invalid response format")
+	}
+
+	output, _ := json.MarshalIndent(cfg, "", "  ")
+	fmt.Println(string(output))
+}
+
+func runClipConfigSet(cmd *cobra.Command, args []string) {
+	params := map[string]any{}
+
+	if cmd.Flags().Changed("max-history") {
+		params["maxHistory"] = clipConfigMaxHistory
+	}
+	if cmd.Flags().Changed("auto-clear-days") {
+		params["autoClearDays"] = clipConfigAutoClearDays
+	}
+	if clipConfigClearAtStartup {
+		params["clearAtStartup"] = true
+	}
+	if clipConfigNoClearStartup {
+		params["clearAtStartup"] = false
+	}
+	if clipConfigDisabled {
+		params["disabled"] = true
+	}
+	if clipConfigEnabled {
+		params["disabled"] = false
+	}
+	if clipConfigDisableHistory {
+		params["disableHistory"] = true
+	}
+	if clipConfigEnableHistory {
+		params["disableHistory"] = false
+	}
+	if clipConfigDisablePersist {
+		params["disablePersist"] = true
+	}
+	if clipConfigEnablePersist {
+		params["disablePersist"] = false
+	}
+
+	if len(params) == 0 {
+		fmt.Println("No config options specified")
+		return
+	}
+
+	req := models.Request{
+		ID:     1,
+		Method: "clipboard.setConfig",
+		Params: params,
+	}
+
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		log.Fatalf("Failed to set config: %v", err)
+	}
+
+	if resp.Error != "" {
+		log.Fatalf("Error: %s", resp.Error)
+	}
+
+	fmt.Println("Config updated")
+}

core/cmd/dms/commands_colorpicker.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/colorpicker"
+	"github.com/spf13/cobra"
+)
+
+var (
+	colorOutputFmt string
+	colorAutocopy  bool
+	colorNotify    bool
+	colorLowercase bool
+)
+
+var colorCmd = &cobra.Command{
+	Use:   "color",
+	Short: "Color utilities",
+	Long:  "Color utilities including picking colors from the screen",
+}
+
+var colorPickCmd = &cobra.Command{
+	Use:   "pick",
+	Short: "Pick a color from the screen",
+	Long: `Pick a color from anywhere on your screen using an interactive color picker.
+
+Click on any pixel to capture its color, or press Escape to cancel.
+
+Output format flags (mutually exclusive, default: --hex):
+  --hex  - Hexadecimal (#RRGGBB)
+  --rgb  - RGB values (R G B)
+  --hsl  - HSL values (H S% L%)
+  --hsv  - HSV values (H S% V%)
+  --cmyk - CMYK values (C% M% Y% K%)
+  --json - JSON with all formats
+
+Examples:
+  dms color pick                # Pick color, output as hex
+  dms color pick --rgb          # Output as RGB
+  dms color pick --json         # Output all formats as JSON
+  dms color pick --hex -l       # Output hex in lowercase
+  dms color pick -a             # Auto-copy result to clipboard`,
+	Run: runColorPick,
+}
+
+func init() {
+	colorPickCmd.Flags().Bool("hex", false, "Output as hexadecimal (#RRGGBB)")
+	colorPickCmd.Flags().Bool("rgb", false, "Output as RGB (R G B)")
+	colorPickCmd.Flags().Bool("hsl", false, "Output as HSL (H S% L%)")
+	colorPickCmd.Flags().Bool("hsv", false, "Output as HSV (H S% V%)")
+	colorPickCmd.Flags().Bool("cmyk", false, "Output as CMYK (C% M% Y% K%)")
+	colorPickCmd.Flags().Bool("json", false, "Output all formats as JSON")
+	colorPickCmd.Flags().StringVarP(&colorOutputFmt, "output-format", "o", "", "Custom output format template")
+	colorPickCmd.Flags().BoolVarP(&colorAutocopy, "autocopy", "a", false, "Copy result to clipboard")
+	colorPickCmd.Flags().BoolVarP(&colorLowercase, "lowercase", "l", false, "Output hex in lowercase")
+
+	colorPickCmd.MarkFlagsMutuallyExclusive("hex", "rgb", "hsl", "hsv", "cmyk", "json")
+
+	colorCmd.AddCommand(colorPickCmd)
+}
+
+func runColorPick(cmd *cobra.Command, args []string) {
+	format := colorpicker.FormatHex // default
+	jsonOutput, _ := cmd.Flags().GetBool("json")
+
+	if rgb, _ := cmd.Flags().GetBool("rgb"); rgb {
+		format = colorpicker.FormatRGB
+	} else if hsl, _ := cmd.Flags().GetBool("hsl"); hsl {
+		format = colorpicker.FormatHSL
+	} else if hsv, _ := cmd.Flags().GetBool("hsv"); hsv {
+		format = colorpicker.FormatHSV
+	} else if cmyk, _ := cmd.Flags().GetBool("cmyk"); cmyk {
+		format = colorpicker.FormatCMYK
+	}
+
+	config := colorpicker.Config{
+		Format:       format,
+		CustomFormat: colorOutputFmt,
+		Lowercase:    colorLowercase,
+		Autocopy:     colorAutocopy,
+		Notify:       colorNotify,
+	}
+
+	picker := colorpicker.New(config)
+	color, err := picker.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	if color == nil {
+		os.Exit(0)
+	}
+
+	var output string
+	if jsonOutput {
+		jsonStr, err := color.ToJSON()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+		output = jsonStr
+	} else {
+		output = color.Format(config.Format, config.Lowercase, config.CustomFormat)
+	}
+
+	if colorAutocopy {
+		copyToClipboard(output)
+	}
+
+	if jsonOutput {
+		fmt.Println(output)
+	} else if color.IsDark() {
+		fmt.Printf("\033[48;2;%d;%d;%dm\033[97m %s \033[0m\n", color.R, color.G, color.B, output)
+	} else {
+		fmt.Printf("\033[48;2;%d;%d;%dm\033[30m %s \033[0m\n", color.R, color.G, color.B, output)
+	}
+}
+
+func copyToClipboard(text string) {
+	if err := clipboard.CopyText(text); err != nil {
+		fmt.Fprintln(os.Stderr, "clipboard copy failed:", err)
+	}
+}

core/cmd/dms/commands_common.go

@@ -2,6 +2,8 @@ package main
 
 import (
 	"fmt"
+	"os"
+	"regexp"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
@@ -66,6 +68,10 @@ var ipcCmd = &cobra.Command{
 	Short:   "Send IPC commands to running DMS shell",
 	Long:    "Send IPC commands to running DMS shell (qs -c dms ipc <args>)",
 	PreRunE: findConfig,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		_ = findConfig(cmd, args)
+		return getShellIPCCompletions(args, toComplete), cobra.ShellCompDirectiveNoFileComp
+	},
 	Run: func(cmd *cobra.Command, args []string) {
 		runShellIPCCommand(args)
 	},
@@ -115,6 +121,12 @@ var pluginsInstallCmd = &cobra.Command{
 	Short: "Install a plugin by ID",
 	Long:  "Install a DMS plugin from the registry using its ID (e.g., 'myPlugin'). Plugin names with spaces are also supported for backward compatibility.",
 	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 getAvailablePluginIDs(), cobra.ShellCompDirectiveNoFileComp
+	},
 	Run: func(cmd *cobra.Command, args []string) {
 		if err := installPluginCLI(args[0]); err != nil {
 			log.Fatalf("Error installing plugin: %v", err)
@@ -127,6 +139,12 @@ var pluginsUninstallCmd = &cobra.Command{
 	Short: "Uninstall a plugin by ID",
 	Long:  "Uninstall a DMS plugin using its ID (e.g., 'myPlugin'). Plugin names with spaces are also supported for backward compatibility.",
 	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 := uninstallPluginCLI(args[0]); err != nil {
 			log.Fatalf("Error uninstalling plugin: %v", err)
@@ -134,9 +152,75 @@ 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", Version)
+	fmt.Printf("%s\n", formatVersion(Version))
+}
+
+// Git builds: dms (git) v0.6.2-XXXX
+// Stable releases: dms v0.6.2
+func formatVersion(version string) string {
+	// Arch/Debian/Ubuntu/OpenSUSE git format: 0.6.2+git2264.c5c5ce84
+	re := regexp.MustCompile(`^([\d.]+)\+git(\d+)\.`)
+	if matches := re.FindStringSubmatch(version); matches != nil {
+		return fmt.Sprintf("dms (git) v%s-%s", matches[1], matches[2])
+	}
+
+	// Fedora COPR git format: 0.0.git.2267.d430cae9
+	re = regexp.MustCompile(`^[\d.]+\.git\.(\d+)\.`)
+	if matches := re.FindStringSubmatch(version); matches != nil {
+		baseVersion := getBaseVersion()
+		return fmt.Sprintf("dms (git) v%s-%s", baseVersion, matches[1])
+	}
+
+	// Stable release format: 0.6.2
+	re = regexp.MustCompile(`^([\d.]+)$`)
+	if matches := re.FindStringSubmatch(version); matches != nil {
+		return fmt.Sprintf("dms v%s", matches[1])
+	}
+
+	return fmt.Sprintf("dms %s", version)
+}
+
+func getBaseVersion() string {
+	paths := []string{
+		"/usr/share/quickshell/dms/VERSION",
+		"/usr/local/share/quickshell/dms/VERSION",
+		"/etc/xdg/quickshell/dms/VERSION",
+	}
+
+	for _, path := range paths {
+		if content, err := os.ReadFile(path); err == nil {
+			ver := strings.TrimSpace(string(content))
+			ver = strings.TrimPrefix(ver, "v")
+			if re := regexp.MustCompile(`^([\d.]+)`); re.MatchString(ver) {
+				if matches := re.FindStringSubmatch(ver); matches != nil {
+					return matches[1]
+				}
+			}
+		}
+	}
+
+	// Fallback
+	return "0.6.2"
 }
 
 func startDebugServer() error {
@@ -299,6 +383,38 @@ func installPluginCLI(idOrName string) error {
 	return nil
 }
 
+func getAvailablePluginIDs() []string {
+	registry, err := plugins.NewRegistry()
+	if err != nil {
+		return nil
+	}
+
+	pluginList, err := registry.List()
+	if err != nil {
+		return nil
+	}
+
+	var ids []string
+	for _, p := range pluginList {
+		ids = append(ids, p.ID)
+	}
+	return ids
+}
+
+func getInstalledPluginIDs() []string {
+	manager, err := plugins.NewManager()
+	if err != nil {
+		return nil
+	}
+
+	installed, err := manager.ListInstalled()
+	if err != nil {
+		return nil
+	}
+
+	return installed
+}
+
 func uninstallPluginCLI(idOrName string) error {
 	manager, err := plugins.NewManager()
 	if err != nil {
@@ -310,53 +426,73 @@ func uninstallPluginCLI(idOrName string) error {
 		return fmt.Errorf("failed to create registry: %w", err)
 	}
 
-	pluginList, err := registry.List()
+	pluginList, _ := registry.List()
-	if err != nil {
+	plugin := plugins.FindByIDOrName(idOrName, pluginList)
-		return fmt.Errorf("failed to list plugins: %w", err)
-	}
 
-	// First, try to find by ID (preferred method)
+	if plugin != nil {
-	var plugin *plugins.Plugin
+		installed, err := manager.IsInstalled(*plugin)
-	for _, p := range pluginList {
+		if err != nil {
-		if p.ID == idOrName {
+			return fmt.Errorf("failed to check install status: %w", err)
-			plugin = &p
-			break
 		}
-	}
+		if !installed {
-
+			return fmt.Errorf("plugin not installed: %s", plugin.Name)
-	// Fallback to name for backward compatibility
-	if plugin == nil {
-		for _, p := range pluginList {
-			if p.Name == idOrName {
-				plugin = &p
-				break
-			}
 		}
+
+		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 {
+	fmt.Printf("Uninstalling plugin: %s\n", idOrName)
-		return fmt.Errorf("plugin not found: %s", idOrName)
+	if err := manager.UninstallByIDOrName(idOrName); err != nil {
+		return err
 	}
-
+	fmt.Printf("Plugin uninstalled successfully: %s\n", idOrName)
-	installed, err := manager.IsInstalled(*plugin)
+	return nil
-	if err != nil {
+}
-		return fmt.Errorf("failed to check install status: %w", err)
+
-	}
+func updatePluginCLI(idOrName string) error {
-
+	manager, err := plugins.NewManager()
-	if !installed {
+	if err != nil {
-		return fmt.Errorf("plugin not installed: %s", plugin.Name)
+		return fmt.Errorf("failed to create manager: %w", err)
-	}
+	}
-
+
-	fmt.Printf("Uninstalling plugin: %s (ID: %s)\n", plugin.Name, plugin.ID)
+	registry, err := plugins.NewRegistry()
-	if err := manager.Uninstall(*plugin); err != nil {
+	if err != nil {
-		return fmt.Errorf("failed to uninstall plugin: %w", err)
+		return fmt.Errorf("failed to create registry: %w", err)
-	}
+	}
-
+
-	fmt.Printf("Plugin uninstalled successfully: %s\n", plugin.Name)
+	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,
@@ -373,5 +509,10 @@ func getCommonCommands() []*cobra.Command {
 		keybindsCmd,
 		greeterCmd,
 		setupCmd,
+		colorCmd,
+		screenshotCmd,
+		notifyActionCmd,
+		matugenCmd,
+		clipboardCmd,
 	}
 }

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,14 +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")
@@ -44,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_dpms.go

@@ -16,14 +16,26 @@ var dpmsOnCmd = &cobra.Command{
 	Use:   "on [output]",
 	Short: "Turn display(s) on",
 	Args:  cobra.MaximumNArgs(1),
-	Run:   runDPMSOn,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		return getDPMSOutputs(), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: runDPMSOn,
 }
 
 var dpmsOffCmd = &cobra.Command{
 	Use:   "off [output]",
 	Short: "Turn display(s) off",
 	Args:  cobra.MaximumNArgs(1),
-	Run:   runDPMSOff,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		return getDPMSOutputs(), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: runDPMSOff,
 }
 
 var dpmsListCmd = &cobra.Command{
@@ -71,6 +83,15 @@ func runDPMSOff(cmd *cobra.Command, args []string) {
 	}
 }
 
+func getDPMSOutputs() []string {
+	client, err := newDPMSClient()
+	if err != nil {
+		return nil
+	}
+	defer client.Close()
+	return client.ListOutputs()
+}
+
 func runDPMSList(cmd *cobra.Command, args []string) {
 	client, err := newDPMSClient()
 	if err != nil {

core/cmd/dms/commands_features.go

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

core/cmd/dms/commands_greeter.go

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

core/cmd/dms/commands_keybinds.go

@@ -30,14 +30,44 @@ var keybindsShowCmd = &cobra.Command{
 	Short: "Show keybinds for a provider",
 	Long:  "Display keybinds/cheatsheet for the specified provider",
 	Args:  cobra.ExactArgs(1),
-	Run:   runKeybindsShow,
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		registry := keybinds.GetDefaultRegistry()
+		return registry.List(), cobra.ShellCompDirectiveNoFileComp
+	},
+	Run: runKeybindsShow,
+}
+
+var keybindsSetCmd = &cobra.Command{
+	Use:   "set <provider> <key> <action>",
+	Short: "Set a keybind override",
+	Long:  "Create or update a keybind override for the specified provider",
+	Args:  cobra.ExactArgs(3),
+	Run:   runKeybindsSet,
+}
+
+var keybindsRemoveCmd = &cobra.Command{
+	Use:   "remove <provider> <key>",
+	Short: "Remove a keybind override",
+	Long:  "Remove a keybind override from the specified provider",
+	Args:  cobra.ExactArgs(2),
+	Run:   runKeybindsRemove,
 }
 
 func init() {
 	keybindsShowCmd.Flags().String("path", "", "Override config path for the provider")
+	keybindsSetCmd.Flags().String("desc", "", "Description for hotkey overlay")
+	keybindsSetCmd.Flags().Bool("allow-when-locked", false, "Allow when screen is locked")
+	keybindsSetCmd.Flags().Int("cooldown-ms", 0, "Cooldown in milliseconds")
+	keybindsSetCmd.Flags().Bool("no-repeat", false, "Disable key repeat")
+	keybindsSetCmd.Flags().String("replace-key", "", "Original key to replace (removes old key)")
 
 	keybindsCmd.AddCommand(keybindsListCmd)
 	keybindsCmd.AddCommand(keybindsShowCmd)
+	keybindsCmd.AddCommand(keybindsSetCmd)
+	keybindsCmd.AddCommand(keybindsRemoveCmd)
 
 	keybinds.SetJSONProviderFactory(func(filePath string) (keybinds.Provider, error) {
 		return providers.NewJSONFileProvider(filePath)
@@ -59,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)
@@ -75,69 +110,124 @@ func initializeProviders() {
 	}
 }
 
-func runKeybindsList(cmd *cobra.Command, args []string) {
+func runKeybindsList(_ *cobra.Command, _ []string) {
-	registry := keybinds.GetDefaultRegistry()
+	providerList := keybinds.GetDefaultRegistry().List()
-	providers := registry.List()
+	if len(providerList) == 0 {
-
-	if len(providers) == 0 {
 		fmt.Fprintln(os.Stdout, "No providers available")
 		return
 	}
-
 	fmt.Fprintln(os.Stdout, "Available providers:")
-	for _, name := range providers {
+	for _, name := range providerList {
 		fmt.Fprintf(os.Stdout, "  - %s\n", name)
 	}
 }
 
-func runKeybindsShow(cmd *cobra.Command, args []string) {
+func makeProviderWithPath(name, path string) keybinds.Provider {
-	providerName := args[0]
+	switch name {
-	registry := keybinds.GetDefaultRegistry()
+	case "hyprland":
-
+		return providers.NewHyprlandProvider(path)
-	customPath, _ := cmd.Flags().GetString("path")
+	case "mangowc":
-	if customPath != "" {
+		return providers.NewMangoWCProvider(path)
-		var provider keybinds.Provider
+	case "sway":
-		switch providerName {
+		return providers.NewSwayProvider(path)
-		case "hyprland":
+	case "scroll":
-			provider = providers.NewHyprlandProvider(customPath)
+		return providers.NewSwayProvider(path)
-		case "mangowc":
+	case "niri":
-			provider = providers.NewMangoWCProvider(customPath)
+		return providers.NewNiriProvider(path)
-		case "sway":
+	default:
-			provider = providers.NewSwayProvider(customPath)
+		return nil
-		case "niri":
-			provider = providers.NewNiriProvider(customPath)
-		default:
-			log.Fatalf("Provider %s does not support custom path", providerName)
-		}
-
-		sheet, err := provider.GetCheatSheet()
-		if err != nil {
-			log.Fatalf("Error getting cheatsheet: %v", err)
-		}
-
-		output, err := json.MarshalIndent(sheet, "", "  ")
-		if err != nil {
-			log.Fatalf("Error generating JSON: %v", err)
-		}
-
-		fmt.Fprintln(os.Stdout, string(output))
-		return
-	}
-
-	provider, err := registry.Get(providerName)
-	if err != nil {
-		log.Fatalf("Error: %v", err)
 	}
+}
 
+func printCheatSheet(provider keybinds.Provider) {
 	sheet, err := provider.GetCheatSheet()
 	if err != nil {
 		log.Fatalf("Error getting cheatsheet: %v", err)
 	}
-
 	output, err := json.MarshalIndent(sheet, "", "  ")
 	if err != nil {
 		log.Fatalf("Error generating JSON: %v", err)
 	}
-
+	fmt.Fprintln(os.Stdout, string(output))
+}
+
+func runKeybindsShow(cmd *cobra.Command, args []string) {
+	providerName := args[0]
+	customPath, _ := cmd.Flags().GetString("path")
+
+	if customPath != "" {
+		provider := makeProviderWithPath(providerName, customPath)
+		if provider == nil {
+			log.Fatalf("Provider %s does not support custom path", providerName)
+		}
+		printCheatSheet(provider)
+		return
+	}
+
+	provider, err := keybinds.GetDefaultRegistry().Get(providerName)
+	if err != nil {
+		log.Fatalf("Error: %v", err)
+	}
+	printCheatSheet(provider)
+}
+
+func getWritableProvider(name string) keybinds.WritableProvider {
+	provider, err := keybinds.GetDefaultRegistry().Get(name)
+	if err != nil {
+		log.Fatalf("Error: %v", err)
+	}
+	writable, ok := provider.(keybinds.WritableProvider)
+	if !ok {
+		log.Fatalf("Provider %s does not support writing keybinds", name)
+	}
+	return writable
+}
+
+func runKeybindsSet(cmd *cobra.Command, args []string) {
+	providerName, key, action := args[0], args[1], args[2]
+	writable := getWritableProvider(providerName)
+
+	if replaceKey, _ := cmd.Flags().GetString("replace-key"); replaceKey != "" && replaceKey != key {
+		_ = writable.RemoveBind(replaceKey)
+	}
+
+	options := make(map[string]any)
+	if v, _ := cmd.Flags().GetBool("allow-when-locked"); v {
+		options["allow-when-locked"] = true
+	}
+	if v, _ := cmd.Flags().GetInt("cooldown-ms"); v > 0 {
+		options["cooldown-ms"] = v
+	}
+	if v, _ := cmd.Flags().GetBool("no-repeat"); v {
+		options["repeat"] = false
+	}
+
+	desc, _ := cmd.Flags().GetString("desc")
+	if err := writable.SetBind(key, action, desc, options); err != nil {
+		log.Fatalf("Error setting keybind: %v", err)
+	}
+
+	output, _ := json.MarshalIndent(map[string]any{
+		"success": true,
+		"key":     key,
+		"action":  action,
+		"path":    writable.GetOverridePath(),
+	}, "", "  ")
+	fmt.Fprintln(os.Stdout, string(output))
+}
+
+func runKeybindsRemove(_ *cobra.Command, args []string) {
+	providerName, key := args[0], args[1]
+	writable := getWritableProvider(providerName)
+
+	if err := writable.RemoveBind(key); err != nil {
+		log.Fatalf("Error removing keybind: %v", err)
+	}
+
+	output, _ := json.MarshalIndent(map[string]any{
+		"success": true,
+		"key":     key,
+		"removed": true,
+	}, "", "  ")
 	fmt.Fprintln(os.Stdout, string(output))
 }

core/cmd/dms/commands_matugen.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/matugen"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"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")
+		cmd.Flags().String("skip-templates", "", "Comma-separated list of templates to skip")
+	}
+
+	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")
+	skipTemplates, _ := cmd.Flags().GetString("skip-templates")
+
+	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,
+		SkipTemplates:       skipTemplates,
+	}
+}
+
+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")
+
+	request := models.Request{
+		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,
+			"skipTemplates":       opts.SkipTemplates,
+			"wait":                wait,
+		},
+	}
+
+	if !wait {
+		if err := sendServerRequestFireAndForget(request); err != nil {
+			log.Info("Server unavailable, running synchronously")
+			if err := matugen.Run(opts); err != nil {
+				log.Fatalf("Theme generation failed: %v", err)
+			}
+			return
+		}
+		fmt.Println("Theme generation queued")
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	resultCh := make(chan error, 1)
+	go func() {
+		resp, ok := tryServerRequest(request)
+		if !ok {
+			log.Info("Server unavailable, running synchronously")
+			if err := matugen.Run(opts); err != nil {
+				resultCh <- err
+				return
+			}
+			resultCh <- nil
+			return
+		}
+		if resp.Error != "" {
+			resultCh <- fmt.Errorf("server error: %s", resp.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_open.go

@@ -1,17 +1,14 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"mime"
-	"net"
 	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 	"github.com/spf13/cobra"
 )
@@ -45,6 +42,9 @@ func init() {
 	openCmd.Flags().StringVar(&openMimeType, "mime", "", "MIME type for filtering applications")
 	openCmd.Flags().StringSliceVar(&openCategories, "category", []string{}, "Application categories to filter (e.g., WebBrowser, Office, Graphics)")
 	openCmd.Flags().StringVar(&openRequestType, "type", "url", "Request type (url, file, or custom)")
+	_ = openCmd.RegisterFlagCompletionFunc("type", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return []string{"url", "file", "custom"}, cobra.ShellCompDirectiveNoFileComp
+	})
 }
 
 // mimeTypeToCategories maps MIME types to desktop file categories
@@ -90,32 +90,6 @@ func mimeTypeToCategories(mimeType string) []string {
 }
 
 func runOpen(target string) {
-	socketPath, err := server.FindSocket()
-	if err != nil {
-		log.Warnf("DMS socket not found: %v", err)
-		fmt.Println("DMS is not running. Please start DMS first.")
-		os.Exit(1)
-	}
-
-	conn, err := net.Dial("unix", socketPath)
-	if err != nil {
-		log.Warnf("DMS socket connection failed: %v", err)
-		fmt.Println("DMS is not running. Please start DMS first.")
-		os.Exit(1)
-	}
-	defer conn.Close()
-
-	buf := make([]byte, 1)
-	for {
-		_, err := conn.Read(buf)
-		if err != nil {
-			return
-		}
-		if buf[0] == '\n' {
-			break
-		}
-	}
-
 	// Parse file:// URIs to extract the actual file path
 	actualTarget := target
 	detectedMimeType := openMimeType
@@ -216,8 +190,9 @@ func runOpen(target string) {
 
 	log.Infof("Sending request - Method: %s, Params: %+v", method, params)
 
-	if err := json.NewEncoder(conn).Encode(req); err != nil {
+	if err := sendServerRequestFireAndForget(req); err != nil {
-		log.Fatalf("Failed to send request: %v", err)
+		fmt.Println("DMS is not running. Please start DMS first.")
+		os.Exit(1)
 	}
 
 	log.Infof("Request sent successfully")

core/cmd/dms/commands_screenshot.go

@@ -0,0 +1,412 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
+	"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
+		}
+	}
+
+	return clipboard.Copy(data.Bytes(), mimeType)
+}
+
+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/server_client.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+)
+
+func sendServerRequest(req models.Request) (*models.Response[any], error) {
+	socketPath := getServerSocketPath()
+
+	conn, err := net.Dial("unix", socketPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to server (is it running?): %w", err)
+	}
+	defer conn.Close()
+
+	scanner := bufio.NewScanner(conn)
+	scanner.Scan() // discard initial capabilities message
+
+	reqData, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	if _, err := conn.Write(reqData); err != nil {
+		return nil, fmt.Errorf("failed to write request: %w", err)
+	}
+
+	if _, err := conn.Write([]byte("\n")); err != nil {
+		return nil, fmt.Errorf("failed to write newline: %w", err)
+	}
+
+	if !scanner.Scan() {
+		return nil, fmt.Errorf("failed to read response")
+	}
+
+	var resp models.Response[any]
+	if err := json.Unmarshal(scanner.Bytes(), &resp); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	return &resp, nil
+}
+
+// sendServerRequestFireAndForget sends a request without waiting for a response.
+// Useful for commands that trigger UI or async operations.
+func sendServerRequestFireAndForget(req models.Request) error {
+	socketPath := getServerSocketPath()
+
+	conn, err := net.Dial("unix", socketPath)
+	if err != nil {
+		return fmt.Errorf("failed to connect to server (is it running?): %w", err)
+	}
+	defer conn.Close()
+
+	scanner := bufio.NewScanner(conn)
+	scanner.Scan() // discard initial capabilities message
+
+	reqData, err := json.Marshal(req)
+	if err != nil {
+		return fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	if _, err := conn.Write(reqData); err != nil {
+		return fmt.Errorf("failed to write request: %w", err)
+	}
+
+	if _, err := conn.Write([]byte("\n")); err != nil {
+		return fmt.Errorf("failed to write newline: %w", err)
+	}
+
+	return nil
+}
+
+// tryServerRequest attempts to send a request but returns false if server unavailable.
+// Does not log errors - caller can decide what to do on failure.
+func tryServerRequest(req models.Request) (*models.Response[any], bool) {
+	resp, err := sendServerRequest(req)
+	if err != nil {
+		return nil, false
+	}
+	return resp, true
+}
+
+func getServerSocketPath() string {
+	runtimeDir := os.Getenv("XDG_RUNTIME_DIR")
+	if runtimeDir == "" {
+		runtimeDir = os.TempDir()
+	}
+
+	entries, err := os.ReadDir(runtimeDir)
+	if err != nil {
+		return filepath.Join(runtimeDir, "danklinux.sock")
+	}
+
+	for _, entry := range entries {
+		name := entry.Name()
+		if name == "danklinux.sock" {
+			return filepath.Join(runtimeDir, name)
+		}
+		if len(name) > 10 && name[:10] == "danklinux-" && filepath.Ext(name) == ".sock" {
+			return filepath.Join(runtimeDir, name)
+		}
+	}
+
+	return server.GetSocketPath()
+}

core/cmd/dms/shell.go

@@ -16,6 +16,8 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
 )
 
+type ipcTargets map[string]map[string][]string
+
 var isSessionManaged bool
 
 func execDetachedRestart(targetPID int) {
@@ -68,7 +70,7 @@ func getPIDFilePath() string {
 
 func writePIDFile(childPID int) error {
 	pidFile := getPIDFilePath()
-	return os.WriteFile(pidFile, []byte(strconv.Itoa(childPID)), 0644)
+	return os.WriteFile(pidFile, []byte(strconv.Itoa(childPID)), 0o644)
 }
 
 func removePIDFile() {
@@ -102,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)
@@ -110,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)
@@ -144,7 +142,7 @@ func runShellInteractive(session bool) {
 	socketPath := server.GetSocketPath()
 
 	configStateFile := filepath.Join(getRuntimeDir(), "danklinux.path")
-	if err := os.WriteFile(configStateFile, []byte(configPath), 0644); err != nil {
+	if err := os.WriteFile(configStateFile, []byte(configPath), 0o644); err != nil {
 		log.Warnf("Failed to write config state file: %v", err)
 	}
 	defer os.Remove(configStateFile)
@@ -157,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)
 		}
@@ -223,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)
@@ -280,7 +278,6 @@ func restartShell() {
 }
 
 func killShell() {
-	// Get all tracked DMS PIDs from PID files
 	pids := getAllDMSPIDs()
 
 	if len(pids) == 0 {
@@ -291,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 {
@@ -306,7 +301,6 @@ func killShell() {
 			continue
 		}
 
-		// Check if process is still alive before killing
 		if err := proc.Signal(syscall.Signal(0)); err != nil {
 			continue
 		}
@@ -318,7 +312,6 @@ func killShell() {
 		}
 	}
 
-	// Clean up any remaining PID files
 	dir := getRuntimeDir()
 	entries, err := os.ReadDir(dir)
 	if err != nil {
@@ -335,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" {
@@ -370,7 +362,7 @@ func runShellDaemon(session bool) {
 	socketPath := server.GetSocketPath()
 
 	configStateFile := filepath.Join(getRuntimeDir(), "danklinux.path")
-	if err := os.WriteFile(configStateFile, []byte(configPath), 0644); err != nil {
+	if err := os.WriteFile(configStateFile, []byte(configPath), 0o644); err != nil {
 		log.Warnf("Failed to write config state file: %v", err)
 	}
 	defer os.Remove(configStateFile)
@@ -473,6 +465,79 @@ func runShellDaemon(session bool) {
 	}
 }
 
+func parseTargetsFromIPCShowOutput(output string) ipcTargets {
+	targets := make(ipcTargets)
+	var currentTarget string
+	for _, line := range strings.Split(output, "\n") {
+		if strings.HasPrefix(line, "target ") {
+			currentTarget = strings.TrimSpace(strings.TrimPrefix(line, "target "))
+			targets[currentTarget] = make(map[string][]string)
+		}
+		if strings.HasPrefix(line, "  function") && currentTarget != "" {
+			argsList := []string{}
+			currentFunc := strings.TrimPrefix(line, "  function ")
+			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, _ string) []string {
+	cmdArgs := []string{"-p", configPath, "ipc", "show"}
+	cmd := exec.Command("qs", cmdArgs...)
+	var targets ipcTargets
+
+	if output, err := cmd.Output(); err == nil {
+		targets = parseTargetsFromIPCShowOutput(string(output))
+	} else {
+		log.Debugf("Error getting IPC show output for completions: %v", err)
+		return nil
+	}
+
+	if len(args) > 0 && args[0] == "call" {
+		args = args[1:]
+	}
+
+	if len(args) == 0 {
+		targetNames := make([]string, 0)
+		targetNames = append(targetNames, "call")
+		for k := range targets {
+			targetNames = append(targetNames, k)
+		}
+		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 nil
+}
+
 func runShellIPCCommand(args []string) {
 	if len(args) == 0 {
 		log.Error("IPC command requires arguments")

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

@@ -15,7 +15,9 @@ require (
 	github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a
 	github.com/spf13/cobra v1.10.1
 	github.com/stretchr/testify v1.11.1
+	go.etcd.io/bbolt v1.4.3
 	golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39
+	golang.org/x/image v0.34.0
 )
 
 require (
@@ -65,6 +67,6 @@ require (
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/sys v0.38.0
-	golang.org/x/text v0.31.0
+	golang.org/x/text v0.32.0
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

core/go.sum

@@ -131,20 +131,26 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
+go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
 golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
 golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
 golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 h1:DHNhtq3sNNzrvduZZIiFyXWOL9IWaDPHqTnLJp+rCBY=
 golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
+golang.org/x/image v0.34.0 h1:33gCkyw9hmwbZJeZkct8XyR11yH889EQt/QH4VmXMn8=
+golang.org/x/image v0.34.0/go.mod h1:2RNFBZRB+vnwwFil8GkMdRvrJOFd1AzdZI6vOY+eJVU=
 golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
 golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
 golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
 golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
-golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
-golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

core/install.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
 set -e
 
@@ -9,8 +9,8 @@ NC='\033[0m' # No Color
 
 # Check for root privileges
 if [ "$(id -u)" == "0" ]; then
-   printf "%bError: This script must not be run as root%b\n" "$RED" "$NC"
+    printf "%bError: This script must not be run as root%b\n" "$RED" "$NC"
-   exit 1
+    exit 1
 fi
 
 # Check if running on Linux
@@ -22,17 +22,17 @@ fi
 # Detect architecture
 ARCH=$(uname -m)
 case "$ARCH" in
-    x86_64)
+x86_64)
-        ARCH="amd64"
+    ARCH="amd64"
-        ;;
+    ;;
-    aarch64)
+aarch64)
-        ARCH="arm64"
+    ARCH="arm64"
-        ;;
+    ;;
-    *)
+*)
-        printf "%bError: Unsupported architecture: %s%b\n" "$RED" "$ARCH" "$NC"
+    printf "%bError: Unsupported architecture: %s%b\n" "$RED" "$ARCH" "$NC"
-        printf "This installer only supports x86_64 (amd64) and aarch64 (arm64) architectures\n"
+    printf "This installer only supports x86_64 (amd64) and aarch64 (arm64) architectures\n"
-        exit 1
+    exit 1
-        ;;
+    ;;
 esac
 
 # Get the latest release version
@@ -55,7 +55,7 @@ curl -L "https://github.com/AvengeMedia/DankMaterialShell/releases/download/$LAT
 curl -L "https://github.com/AvengeMedia/DankMaterialShell/releases/download/$LATEST_VERSION/dankinstall-$ARCH.gz.sha256" -o "expected.sha256"
 
 # Get the expected checksum
-EXPECTED_CHECKSUM=$(cat expected.sha256 | awk '{print $1}')
+EXPECTED_CHECKSUM=$(awk '{print $1}' expected.sha256)
 
 # Calculate actual checksum
 printf "%bVerifying checksum...%b\n" "$GREEN" "$NC"
@@ -67,7 +67,7 @@ if [ "$EXPECTED_CHECKSUM" != "$ACTUAL_CHECKSUM" ]; then
     printf "Expected: %s\n" "$EXPECTED_CHECKSUM"
     printf "Got:      %s\n" "$ACTUAL_CHECKSUM"
     printf "The downloaded file may be corrupted or tampered with\n"
-    cd - > /dev/null
+    cd - >/dev/null
     rm -rf "$TEMP_DIR"
     exit 1
 fi
@@ -82,5 +82,5 @@ printf "%bRunning installer...%b\n" "$GREEN" "$NC"
 ./installer
 
 # Cleanup
-cd - > /dev/null
+cd - >/dev/null
 rm -rf "$TEMP_DIR"

core/internal/clipboard/clipboard.go

@@ -0,0 +1,332 @@
+package clipboard
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"syscall"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/ext_data_control"
+	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+)
+
+func Copy(data []byte, mimeType string) error {
+	return CopyOpts(data, mimeType, false, false)
+}
+
+func CopyOpts(data []byte, mimeType string, foreground, pasteOnce bool) error {
+	if !foreground {
+		return copyFork(data, mimeType, pasteOnce)
+	}
+	return copyServe(data, mimeType, pasteOnce)
+}
+
+func copyFork(data []byte, mimeType string, pasteOnce bool) error {
+	args := []string{os.Args[0], "cl", "copy", "--foreground"}
+	if pasteOnce {
+		args = append(args, "--paste-once")
+	}
+	args = append(args, "--type", mimeType)
+
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = nil
+	cmd.Stdout = nil
+	cmd.Stderr = nil
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return fmt.Errorf("stdin pipe: %w", err)
+	}
+
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("start: %w", err)
+	}
+
+	if _, err := stdin.Write(data); err != nil {
+		stdin.Close()
+		return fmt.Errorf("write stdin: %w", err)
+	}
+	stdin.Close()
+
+	return nil
+}
+
+func copyServe(data []byte, mimeType string, pasteOnce bool) error {
+	display, err := wlclient.Connect("")
+	if err != nil {
+		return fmt.Errorf("wayland connect: %w", err)
+	}
+	defer display.Destroy()
+
+	ctx := display.Context()
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return fmt.Errorf("get registry: %w", err)
+	}
+	defer registry.Destroy()
+
+	var dataControlMgr *ext_data_control.ExtDataControlManagerV1
+	var seat *wlclient.Seat
+	var bindErr error
+
+	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
+		switch e.Interface {
+		case "ext_data_control_manager_v1":
+			dataControlMgr = ext_data_control.NewExtDataControlManagerV1(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, dataControlMgr); err != nil {
+				bindErr = err
+			}
+		case "wl_seat":
+			if seat != nil {
+				return
+			}
+			seat = wlclient.NewSeat(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, seat); err != nil {
+				bindErr = err
+			}
+		}
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	if bindErr != nil {
+		return fmt.Errorf("registry bind: %w", bindErr)
+	}
+
+	if dataControlMgr == nil {
+		return fmt.Errorf("compositor does not support ext_data_control_manager_v1")
+	}
+	defer dataControlMgr.Destroy()
+
+	if seat == nil {
+		return fmt.Errorf("no seat available")
+	}
+
+	device, err := dataControlMgr.GetDataDevice(seat)
+	if err != nil {
+		return fmt.Errorf("get data device: %w", err)
+	}
+	defer device.Destroy()
+
+	source, err := dataControlMgr.CreateDataSource()
+	if err != nil {
+		return fmt.Errorf("create data source: %w", err)
+	}
+
+	if err := source.Offer(mimeType); err != nil {
+		return fmt.Errorf("offer mime type: %w", err)
+	}
+	if mimeType == "text/plain;charset=utf-8" || mimeType == "text/plain" {
+		if err := source.Offer("text/plain"); err != nil {
+			return fmt.Errorf("offer text/plain: %w", err)
+		}
+		if err := source.Offer("text/plain;charset=utf-8"); err != nil {
+			return fmt.Errorf("offer text/plain;charset=utf-8: %w", err)
+		}
+		if err := source.Offer("UTF8_STRING"); err != nil {
+			return fmt.Errorf("offer UTF8_STRING: %w", err)
+		}
+		if err := source.Offer("STRING"); err != nil {
+			return fmt.Errorf("offer STRING: %w", err)
+		}
+		if err := source.Offer("TEXT"); err != nil {
+			return fmt.Errorf("offer TEXT: %w", err)
+		}
+	}
+
+	cancelled := make(chan struct{})
+	pasted := make(chan struct{}, 1)
+
+	source.SetSendHandler(func(e ext_data_control.ExtDataControlSourceV1SendEvent) {
+		defer syscall.Close(e.Fd)
+		file := os.NewFile(uintptr(e.Fd), "pipe")
+		defer file.Close()
+		file.Write(data)
+		select {
+		case pasted <- struct{}{}:
+		default:
+		}
+	})
+
+	source.SetCancelledHandler(func(e ext_data_control.ExtDataControlSourceV1CancelledEvent) {
+		close(cancelled)
+	})
+
+	if err := device.SetSelection(source); err != nil {
+		return fmt.Errorf("set selection: %w", err)
+	}
+
+	display.Roundtrip()
+
+	for {
+		select {
+		case <-cancelled:
+			return nil
+		case <-pasted:
+			if pasteOnce {
+				return nil
+			}
+		default:
+			if err := ctx.Dispatch(); err != nil {
+				return nil
+			}
+		}
+	}
+}
+
+func CopyText(text string) error {
+	return Copy([]byte(text), "text/plain;charset=utf-8")
+}
+
+func Paste() ([]byte, string, error) {
+	display, err := wlclient.Connect("")
+	if err != nil {
+		return nil, "", fmt.Errorf("wayland connect: %w", err)
+	}
+	defer display.Destroy()
+
+	ctx := display.Context()
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return nil, "", fmt.Errorf("get registry: %w", err)
+	}
+	defer registry.Destroy()
+
+	var dataControlMgr *ext_data_control.ExtDataControlManagerV1
+	var seat *wlclient.Seat
+	var bindErr error
+
+	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
+		switch e.Interface {
+		case "ext_data_control_manager_v1":
+			dataControlMgr = ext_data_control.NewExtDataControlManagerV1(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, dataControlMgr); err != nil {
+				bindErr = err
+			}
+		case "wl_seat":
+			if seat != nil {
+				return
+			}
+			seat = wlclient.NewSeat(ctx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, seat); err != nil {
+				bindErr = err
+			}
+		}
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	if bindErr != nil {
+		return nil, "", fmt.Errorf("registry bind: %w", bindErr)
+	}
+
+	if dataControlMgr == nil {
+		return nil, "", fmt.Errorf("compositor does not support ext_data_control_manager_v1")
+	}
+	defer dataControlMgr.Destroy()
+
+	if seat == nil {
+		return nil, "", fmt.Errorf("no seat available")
+	}
+
+	device, err := dataControlMgr.GetDataDevice(seat)
+	if err != nil {
+		return nil, "", fmt.Errorf("get data device: %w", err)
+	}
+	defer device.Destroy()
+
+	offerMimeTypes := make(map[*ext_data_control.ExtDataControlOfferV1][]string)
+
+	device.SetDataOfferHandler(func(e ext_data_control.ExtDataControlDeviceV1DataOfferEvent) {
+		if e.Id == nil {
+			return
+		}
+		offerMimeTypes[e.Id] = nil
+		e.Id.SetOfferHandler(func(me ext_data_control.ExtDataControlOfferV1OfferEvent) {
+			offerMimeTypes[e.Id] = append(offerMimeTypes[e.Id], me.MimeType)
+		})
+	})
+
+	var selectionOffer *ext_data_control.ExtDataControlOfferV1
+	gotSelection := false
+
+	device.SetSelectionHandler(func(e ext_data_control.ExtDataControlDeviceV1SelectionEvent) {
+		selectionOffer = e.Id
+		gotSelection = true
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	if !gotSelection || selectionOffer == nil {
+		return nil, "", fmt.Errorf("no clipboard data")
+	}
+
+	mimeTypes := offerMimeTypes[selectionOffer]
+	selectedMime := selectPreferredMimeType(mimeTypes)
+	if selectedMime == "" {
+		return nil, "", fmt.Errorf("no supported mime type")
+	}
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		return nil, "", fmt.Errorf("create pipe: %w", err)
+	}
+	defer r.Close()
+
+	if err := selectionOffer.Receive(selectedMime, int(w.Fd())); err != nil {
+		w.Close()
+		return nil, "", fmt.Errorf("receive: %w", err)
+	}
+	w.Close()
+
+	display.Roundtrip()
+
+	data, err := io.ReadAll(r)
+	if err != nil {
+		return nil, "", fmt.Errorf("read: %w", err)
+	}
+
+	return data, selectedMime, nil
+}
+
+func PasteText() (string, error) {
+	data, _, err := Paste()
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func selectPreferredMimeType(mimes []string) string {
+	preferred := []string{
+		"text/plain;charset=utf-8",
+		"text/plain",
+		"UTF8_STRING",
+		"STRING",
+		"TEXT",
+		"image/png",
+		"image/jpeg",
+	}
+
+	for _, pref := range preferred {
+		for _, mime := range mimes {
+			if mime == pref {
+				return mime
+			}
+		}
+	}
+
+	if len(mimes) > 0 {
+		return mimes[0]
+	}
+	return ""
+}
+
+func IsImageMimeType(mime string) bool {
+	return len(mime) > 6 && mime[:6] == "image/"
+}

core/internal/clipboard/store.go

@@ -0,0 +1,229 @@
+package clipboard
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"image"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	_ "golang.org/x/image/bmp"
+	_ "golang.org/x/image/tiff"
+	"hash/fnv"
+
+	bolt "go.etcd.io/bbolt"
+)
+
+type StoreConfig struct {
+	MaxHistory   int
+	MaxEntrySize int64
+}
+
+func DefaultStoreConfig() StoreConfig {
+	return StoreConfig{
+		MaxHistory:   100,
+		MaxEntrySize: 5 * 1024 * 1024,
+	}
+}
+
+type Entry struct {
+	ID        uint64
+	Data      []byte
+	MimeType  string
+	Preview   string
+	Size      int
+	Timestamp time.Time
+	IsImage   bool
+	Hash      uint64
+}
+
+func Store(data []byte, mimeType string) error {
+	return StoreWithConfig(data, mimeType, DefaultStoreConfig())
+}
+
+func StoreWithConfig(data []byte, mimeType string, cfg StoreConfig) error {
+	if len(data) == 0 {
+		return nil
+	}
+	if int64(len(data)) > cfg.MaxEntrySize {
+		return fmt.Errorf("data too large: %d > %d", len(data), cfg.MaxEntrySize)
+	}
+
+	dbPath, err := getDBPath()
+	if err != nil {
+		return fmt.Errorf("get db path: %w", err)
+	}
+
+	db, err := bolt.Open(dbPath, 0644, &bolt.Options{Timeout: 1 * time.Second})
+	if err != nil {
+		return fmt.Errorf("open db: %w", err)
+	}
+	defer db.Close()
+
+	entry := Entry{
+		Data:      data,
+		MimeType:  mimeType,
+		Size:      len(data),
+		Timestamp: time.Now(),
+		IsImage:   IsImageMimeType(mimeType),
+		Hash:      computeHash(data),
+	}
+
+	switch {
+	case entry.IsImage:
+		entry.Preview = imagePreview(data, mimeType)
+	default:
+		entry.Preview = textPreview(data)
+	}
+
+	return db.Update(func(tx *bolt.Tx) error {
+		b, err := tx.CreateBucketIfNotExists([]byte("clipboard"))
+		if err != nil {
+			return err
+		}
+
+		if err := deduplicateInTx(b, entry.Hash); err != nil {
+			return err
+		}
+
+		id, err := b.NextSequence()
+		if err != nil {
+			return err
+		}
+		entry.ID = id
+
+		encoded, err := encodeEntry(entry)
+		if err != nil {
+			return err
+		}
+
+		if err := b.Put(itob(id), encoded); err != nil {
+			return err
+		}
+
+		return trimLengthInTx(b, cfg.MaxHistory)
+	})
+}
+
+func getDBPath() (string, error) {
+	cacheDir, err := os.UserCacheDir()
+	if err != nil {
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		cacheDir = filepath.Join(homeDir, ".cache")
+	}
+
+	dbDir := filepath.Join(cacheDir, "dms-clipboard")
+	if err := os.MkdirAll(dbDir, 0700); err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dbDir, "db"), nil
+}
+
+func deduplicateInTx(b *bolt.Bucket, hash uint64) error {
+	c := b.Cursor()
+	for k, v := c.Last(); k != nil; k, v = c.Prev() {
+		if extractHash(v) != hash {
+			continue
+		}
+		if err := b.Delete(k); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func trimLengthInTx(b *bolt.Bucket, maxHistory int) error {
+	c := b.Cursor()
+	var count int
+	for k, _ := c.Last(); k != nil; k, _ = c.Prev() {
+		if count < maxHistory {
+			count++
+			continue
+		}
+		if err := b.Delete(k); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func encodeEntry(e Entry) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	binary.Write(buf, binary.BigEndian, e.ID)
+	binary.Write(buf, binary.BigEndian, uint32(len(e.Data)))
+	buf.Write(e.Data)
+	binary.Write(buf, binary.BigEndian, uint32(len(e.MimeType)))
+	buf.WriteString(e.MimeType)
+	binary.Write(buf, binary.BigEndian, uint32(len(e.Preview)))
+	buf.WriteString(e.Preview)
+	binary.Write(buf, binary.BigEndian, int32(e.Size))
+	binary.Write(buf, binary.BigEndian, e.Timestamp.Unix())
+	if e.IsImage {
+		buf.WriteByte(1)
+	} else {
+		buf.WriteByte(0)
+	}
+	binary.Write(buf, binary.BigEndian, e.Hash)
+
+	return buf.Bytes(), nil
+}
+
+func itob(v uint64) []byte {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, v)
+	return b
+}
+
+func computeHash(data []byte) uint64 {
+	h := fnv.New64a()
+	h.Write(data)
+	return h.Sum64()
+}
+
+func extractHash(data []byte) uint64 {
+	if len(data) < 8 {
+		return 0
+	}
+	return binary.BigEndian.Uint64(data[len(data)-8:])
+}
+
+func textPreview(data []byte) string {
+	text := string(data)
+	text = strings.TrimSpace(text)
+	text = strings.Join(strings.Fields(text), " ")
+
+	if len(text) > 100 {
+		return text[:100] + "…"
+	}
+	return text
+}
+
+func imagePreview(data []byte, format string) string {
+	config, imgFmt, err := image.DecodeConfig(bytes.NewReader(data))
+	if err != nil {
+		return fmt.Sprintf("[[ image %s %s ]]", sizeStr(len(data)), format)
+	}
+	return fmt.Sprintf("[[ image %s %s %dx%d ]]", sizeStr(len(data)), imgFmt, config.Width, config.Height)
+}
+
+func sizeStr(size int) string {
+	units := []string{"B", "KiB", "MiB"}
+	var i int
+	fsize := float64(size)
+	for fsize >= 1024 && i < len(units)-1 {
+		fsize /= 1024
+		i++
+	}
+	return fmt.Sprintf("%.0f %s", fsize, units[i])
+}

core/internal/clipboard/watch.go

@@ -0,0 +1,160 @@
+package clipboard
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/ext_data_control"
+	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+)
+
+type ClipboardChange struct {
+	Data     []byte
+	MimeType string
+}
+
+func Watch(ctx context.Context, callback func(data []byte, mimeType string)) error {
+	display, err := wlclient.Connect("")
+	if err != nil {
+		return fmt.Errorf("wayland connect: %w", err)
+	}
+	defer display.Destroy()
+
+	wlCtx := display.Context()
+	registry, err := display.GetRegistry()
+	if err != nil {
+		return fmt.Errorf("get registry: %w", err)
+	}
+	defer registry.Destroy()
+
+	var dataControlMgr *ext_data_control.ExtDataControlManagerV1
+	var seat *wlclient.Seat
+	var bindErr error
+
+	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
+		switch e.Interface {
+		case "ext_data_control_manager_v1":
+			dataControlMgr = ext_data_control.NewExtDataControlManagerV1(wlCtx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, dataControlMgr); err != nil {
+				bindErr = err
+			}
+		case "wl_seat":
+			if seat != nil {
+				return
+			}
+			seat = wlclient.NewSeat(wlCtx)
+			if err := registry.Bind(e.Name, e.Interface, e.Version, seat); err != nil {
+				bindErr = err
+			}
+		}
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	if bindErr != nil {
+		return fmt.Errorf("registry bind: %w", bindErr)
+	}
+
+	if dataControlMgr == nil {
+		return fmt.Errorf("compositor does not support ext_data_control_manager_v1")
+	}
+	defer dataControlMgr.Destroy()
+
+	if seat == nil {
+		return fmt.Errorf("no seat available")
+	}
+
+	device, err := dataControlMgr.GetDataDevice(seat)
+	if err != nil {
+		return fmt.Errorf("get data device: %w", err)
+	}
+	defer device.Destroy()
+
+	offerMimeTypes := make(map[*ext_data_control.ExtDataControlOfferV1][]string)
+
+	device.SetDataOfferHandler(func(e ext_data_control.ExtDataControlDeviceV1DataOfferEvent) {
+		if e.Id == nil {
+			return
+		}
+		offerMimeTypes[e.Id] = nil
+		e.Id.SetOfferHandler(func(me ext_data_control.ExtDataControlOfferV1OfferEvent) {
+			offerMimeTypes[e.Id] = append(offerMimeTypes[e.Id], me.MimeType)
+		})
+	})
+
+	device.SetSelectionHandler(func(e ext_data_control.ExtDataControlDeviceV1SelectionEvent) {
+		if e.Id == nil {
+			return
+		}
+
+		mimes := offerMimeTypes[e.Id]
+		selectedMime := selectPreferredMimeType(mimes)
+		if selectedMime == "" {
+			return
+		}
+
+		r, w, err := os.Pipe()
+		if err != nil {
+			return
+		}
+
+		if err := e.Id.Receive(selectedMime, int(w.Fd())); err != nil {
+			w.Close()
+			r.Close()
+			return
+		}
+		w.Close()
+
+		go func() {
+			defer r.Close()
+			data, err := io.ReadAll(r)
+			if err != nil || len(data) == 0 {
+				return
+			}
+			callback(data, selectedMime)
+		}()
+	})
+
+	display.Roundtrip()
+	display.Roundtrip()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			if err := wlCtx.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
+				return fmt.Errorf("set read deadline: %w", err)
+			}
+			if err := wlCtx.Dispatch(); err != nil && err != os.ErrDeadlineExceeded {
+				return fmt.Errorf("dispatch: %w", err)
+			}
+		}
+	}
+}
+
+func WatchChan(ctx context.Context) (<-chan ClipboardChange, <-chan error) {
+	ch := make(chan ClipboardChange, 16)
+	errCh := make(chan error, 1)
+
+	go func() {
+		defer close(ch)
+		err := Watch(ctx, func(data []byte, mimeType string) {
+			select {
+			case ch <- ClipboardChange{Data: data, MimeType: mimeType}:
+			default:
+			}
+		})
+		if err != nil && err != context.Canceled {
+			errCh <- err
+		}
+		close(errCh)
+	}()
+
+	time.Sleep(50 * time.Millisecond)
+	return ch, errCh
+}

core/internal/colorpicker/color.go

@@ -0,0 +1,306 @@
+package colorpicker
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"strings"
+)
+
+type Color struct {
+	R, G, B, A uint8
+}
+
+type OutputFormat int
+
+const (
+	FormatHex OutputFormat = iota
+	FormatRGB
+	FormatHSL
+	FormatHSV
+	FormatCMYK
+)
+
+func ParseFormat(s string) OutputFormat {
+	switch strings.ToLower(s) {
+	case "rgb":
+		return FormatRGB
+	case "hsl":
+		return FormatHSL
+	case "hsv":
+		return FormatHSV
+	case "cmyk":
+		return FormatCMYK
+	default:
+		return FormatHex
+	}
+}
+
+func (c Color) ToHex(lowercase bool) string {
+	if lowercase {
+		return fmt.Sprintf("#%02x%02x%02x", c.R, c.G, c.B)
+	}
+	return fmt.Sprintf("#%02X%02X%02X", c.R, c.G, c.B)
+}
+
+func (c Color) ToRGB() string {
+	return fmt.Sprintf("%d %d %d", c.R, c.G, c.B)
+}
+
+func (c Color) ToHSL() string {
+	h, s, l := rgbToHSL(c.R, c.G, c.B)
+	return fmt.Sprintf("%d %d%% %d%%", h, s, l)
+}
+
+func (c Color) ToHSV() string {
+	h, s, v := rgbToHSV(c.R, c.G, c.B)
+	return fmt.Sprintf("%d %d%% %d%%", h, s, v)
+}
+
+func (c Color) ToCMYK() string {
+	cy, m, y, k := rgbToCMYK(c.R, c.G, c.B)
+	return fmt.Sprintf("%d%% %d%% %d%% %d%%", cy, m, y, k)
+}
+
+func (c Color) Format(format OutputFormat, lowercase bool, customFmt string) string {
+	if customFmt != "" {
+		return c.formatCustom(format, customFmt)
+	}
+
+	switch format {
+	case FormatRGB:
+		return c.ToRGB()
+	case FormatHSL:
+		return c.ToHSL()
+	case FormatHSV:
+		return c.ToHSV()
+	case FormatCMYK:
+		return c.ToCMYK()
+	default:
+		return c.ToHex(lowercase)
+	}
+}
+
+func (c Color) formatCustom(format OutputFormat, customFmt string) string {
+	switch format {
+	case FormatRGB:
+		return replaceArgs(customFmt, c.R, c.G, c.B)
+	case FormatHSL:
+		h, s, l := rgbToHSL(c.R, c.G, c.B)
+		return replaceArgs(customFmt, h, s, l)
+	case FormatHSV:
+		h, s, v := rgbToHSV(c.R, c.G, c.B)
+		return replaceArgs(customFmt, h, s, v)
+	case FormatCMYK:
+		cy, m, y, k := rgbToCMYK(c.R, c.G, c.B)
+		return replaceArgs4(customFmt, cy, m, y, k)
+	default:
+		if strings.Contains(customFmt, "{0}") {
+			r := fmt.Sprintf("%02X", c.R)
+			g := fmt.Sprintf("%02X", c.G)
+			b := fmt.Sprintf("%02X", c.B)
+			return replaceArgsStr(customFmt, r, g, b)
+		}
+		return c.ToHex(false)
+	}
+}
+
+func replaceArgs[T any](format string, a, b, c T) string {
+	result := format
+	result = strings.ReplaceAll(result, "{0}", fmt.Sprintf("%v", a))
+	result = strings.ReplaceAll(result, "{1}", fmt.Sprintf("%v", b))
+	result = strings.ReplaceAll(result, "{2}", fmt.Sprintf("%v", c))
+	return result
+}
+
+func replaceArgs4[T any](format string, a, b, c, d T) string {
+	result := format
+	result = strings.ReplaceAll(result, "{0}", fmt.Sprintf("%v", a))
+	result = strings.ReplaceAll(result, "{1}", fmt.Sprintf("%v", b))
+	result = strings.ReplaceAll(result, "{2}", fmt.Sprintf("%v", c))
+	result = strings.ReplaceAll(result, "{3}", fmt.Sprintf("%v", d))
+	return result
+}
+
+func replaceArgsStr(format, a, b, c string) string {
+	result := format
+	result = strings.ReplaceAll(result, "{0}", a)
+	result = strings.ReplaceAll(result, "{1}", b)
+	result = strings.ReplaceAll(result, "{2}", c)
+	return result
+}
+
+func rgbToHSL(r, g, b uint8) (int, int, int) {
+	rf := float64(r) / 255.0
+	gf := float64(g) / 255.0
+	bf := float64(b) / 255.0
+
+	maxVal := math.Max(rf, math.Max(gf, bf))
+	minVal := math.Min(rf, math.Min(gf, bf))
+	l := (maxVal + minVal) / 2
+
+	if maxVal == minVal {
+		return 0, 0, int(math.Round(l * 100))
+	}
+
+	d := maxVal - minVal
+	var s float64
+	if l > 0.5 {
+		s = d / (2 - maxVal - minVal)
+	} else {
+		s = d / (maxVal + minVal)
+	}
+
+	var h float64
+	switch maxVal {
+	case rf:
+		h = (gf - bf) / d
+		if gf < bf {
+			h += 6
+		}
+	case gf:
+		h = (bf-rf)/d + 2
+	case bf:
+		h = (rf-gf)/d + 4
+	}
+	h /= 6
+
+	return int(math.Round(h * 360)), int(math.Round(s * 100)), int(math.Round(l * 100))
+}
+
+func rgbToHSV(r, g, b uint8) (int, int, int) {
+	rf := float64(r) / 255.0
+	gf := float64(g) / 255.0
+	bf := float64(b) / 255.0
+
+	maxVal := math.Max(rf, math.Max(gf, bf))
+	minVal := math.Min(rf, math.Min(gf, bf))
+	v := maxVal
+	d := maxVal - minVal
+
+	var s float64
+	if maxVal != 0 {
+		s = d / maxVal
+	}
+
+	if maxVal == minVal {
+		return 0, int(math.Round(s * 100)), int(math.Round(v * 100))
+	}
+
+	var h float64
+	switch maxVal {
+	case rf:
+		h = (gf - bf) / d
+		if gf < bf {
+			h += 6
+		}
+	case gf:
+		h = (bf-rf)/d + 2
+	case bf:
+		h = (rf-gf)/d + 4
+	}
+	h /= 6
+
+	return int(math.Round(h * 360)), int(math.Round(s * 100)), int(math.Round(v * 100))
+}
+
+func rgbToCMYK(r, g, b uint8) (int, int, int, int) {
+	if r == 0 && g == 0 && b == 0 {
+		return 0, 0, 0, 100
+	}
+
+	rf := float64(r) / 255.0
+	gf := float64(g) / 255.0
+	bf := float64(b) / 255.0
+
+	k := 1 - math.Max(rf, math.Max(gf, bf))
+	c := (1 - rf - k) / (1 - k)
+	m := (1 - gf - k) / (1 - k)
+	y := (1 - bf - k) / (1 - k)
+
+	return int(math.Round(c * 100)), int(math.Round(m * 100)), int(math.Round(y * 100)), int(math.Round(k * 100))
+}
+
+func (c Color) Luminance() float64 {
+	r := float64(c.R) / 255.0
+	g := float64(c.G) / 255.0
+	b := float64(c.B) / 255.0
+
+	if r <= 0.03928 {
+		r = r / 12.92
+	} else {
+		r = math.Pow((r+0.055)/1.055, 2.4)
+	}
+
+	if g <= 0.03928 {
+		g = g / 12.92
+	} else {
+		g = math.Pow((g+0.055)/1.055, 2.4)
+	}
+
+	if b <= 0.03928 {
+		b = b / 12.92
+	} else {
+		b = math.Pow((b+0.055)/1.055, 2.4)
+	}
+
+	return 0.2126*r + 0.7152*g + 0.0722*b
+}
+
+func (c Color) IsDark() bool {
+	return c.Luminance() < 0.179
+}
+
+type ColorJSON struct {
+	Hex string `json:"hex"`
+	RGB struct {
+		R int `json:"r"`
+		G int `json:"g"`
+		B int `json:"b"`
+	} `json:"rgb"`
+	HSL struct {
+		H int `json:"h"`
+		S int `json:"s"`
+		L int `json:"l"`
+	} `json:"hsl"`
+	HSV struct {
+		H int `json:"h"`
+		S int `json:"s"`
+		V int `json:"v"`
+	} `json:"hsv"`
+	CMYK struct {
+		C int `json:"c"`
+		M int `json:"m"`
+		Y int `json:"y"`
+		K int `json:"k"`
+	} `json:"cmyk"`
+}
+
+func (c Color) ToJSON() (string, error) {
+	h, s, l := rgbToHSL(c.R, c.G, c.B)
+	hv, sv, v := rgbToHSV(c.R, c.G, c.B)
+	cy, m, y, k := rgbToCMYK(c.R, c.G, c.B)
+
+	data := ColorJSON{
+		Hex: c.ToHex(false),
+	}
+	data.RGB.R = int(c.R)
+	data.RGB.G = int(c.G)
+	data.RGB.B = int(c.B)
+	data.HSL.H = h
+	data.HSL.S = s
+	data.HSL.L = l
+	data.HSV.H = hv
+	data.HSV.S = sv
+	data.HSV.V = v
+	data.CMYK.C = cy
+	data.CMYK.M = m
+	data.CMYK.Y = y
+	data.CMYK.K = k
+
+	bytes, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}

core/internal/colorpicker/picker.go

@@ -0,0 +1,750 @@
+package colorpicker
+
+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 Config struct {
+	Format       OutputFormat
+	CustomFormat string
+	Lowercase    bool
+	Autocopy     bool
+	Notify       bool
+}
+
+type Output struct {
+	wlOutput        *client.Output
+	name            string
+	globalName      uint32
+	x, y            int32
+	width           int32
+	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
+	bufferBusy  bool
+	oldPool     *client.ShmPool
+	oldBuffer   *client.Buffer
+	scopyBuffer *client.Buffer
+	configured  bool
+	hidden      bool
+}
+
+type Picker struct {
+	config Config
+
+	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]*Output
+	outputsMu sync.Mutex
+
+	surfaces      []*LayerSurface
+	activeSurface *LayerSurface
+
+	running     bool
+	pickedColor *Color
+	err         error
+}
+
+func New(config Config) *Picker {
+	return &Picker{
+		config:  config,
+		outputs: make(map[uint32]*Output),
+	}
+}
+
+func (p *Picker) Run() (*Color, error) {
+	if err := p.connect(); err != nil {
+		return nil, fmt.Errorf("wayland connect: %w", err)
+	}
+	defer p.cleanup()
+
+	if err := p.setupRegistry(); err != nil {
+		return nil, fmt.Errorf("registry setup: %w", err)
+	}
+
+	if err := p.roundtrip(); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	if p.screencopy == nil {
+		return nil, fmt.Errorf("compositor does not support wlr-screencopy-unstable-v1")
+	}
+
+	if p.layerShell == nil {
+		return nil, fmt.Errorf("compositor does not support wlr-layer-shell-unstable-v1")
+	}
+
+	if p.seat == nil {
+		return nil, fmt.Errorf("no seat available")
+	}
+
+	if err := p.roundtrip(); err != nil {
+		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)
+	}
+
+	if err := p.roundtrip(); err != nil {
+		return nil, fmt.Errorf("roundtrip: %w", err)
+	}
+
+	p.running = true
+	for p.running {
+		if err := p.ctx.Dispatch(); err != nil {
+			p.err = err
+			break
+		}
+
+		p.checkDone()
+	}
+
+	if p.err != nil {
+		return nil, p.err
+	}
+
+	return p.pickedColor, nil
+}
+
+func (p *Picker) checkDone() {
+	for _, ls := range p.surfaces {
+		picked, cancelled := ls.state.IsDone()
+		switch {
+		case cancelled:
+			p.running = false
+			return
+		case picked:
+			color, ok := ls.state.PickColor()
+			if ok {
+				p.pickedColor = &color
+			}
+			p.running = false
+			return
+		}
+	}
+}
+
+func (p *Picker) connect() error {
+	display, err := client.Connect("")
+	if err != nil {
+		return err
+	}
+	p.display = display
+	p.ctx = display.Context()
+	return nil
+}
+
+func (p *Picker) roundtrip() error {
+	return wlhelpers.Roundtrip(p.display, p.ctx)
+}
+
+func (p *Picker) setupRegistry() error {
+	registry, err := p.display.GetRegistry()
+	if err != nil {
+		return err
+	}
+	p.registry = registry
+
+	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
+		p.handleGlobal(e)
+	})
+
+	registry.SetGlobalRemoveHandler(func(e client.RegistryGlobalRemoveEvent) {
+		p.outputsMu.Lock()
+		delete(p.outputs, e.Name)
+		p.outputsMu.Unlock()
+	})
+
+	return nil
+}
+
+func (p *Picker) handleGlobal(e client.RegistryGlobalEvent) {
+	switch e.Interface {
+	case client.CompositorInterfaceName:
+		compositor := client.NewCompositor(p.ctx)
+		if err := p.registry.Bind(e.Name, e.Interface, e.Version, compositor); err == nil {
+			p.compositor = compositor
+		}
+
+	case client.ShmInterfaceName:
+		shm := client.NewShm(p.ctx)
+		if err := p.registry.Bind(e.Name, e.Interface, e.Version, shm); err == nil {
+			p.shm = shm
+		}
+
+	case client.SeatInterfaceName:
+		seat := client.NewSeat(p.ctx)
+		if err := p.registry.Bind(e.Name, e.Interface, e.Version, seat); err == nil {
+			p.seat = seat
+			p.setupInput()
+		}
+
+	case client.OutputInterfaceName:
+		output := client.NewOutput(p.ctx)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
+		if err := p.registry.Bind(e.Name, e.Interface, version, output); err == nil {
+			p.outputsMu.Lock()
+			p.outputs[e.Name] = &Output{
+				wlOutput:        output,
+				globalName:      e.Name,
+				scale:           1,
+				fractionalScale: 1.0,
+			}
+			p.outputsMu.Unlock()
+			p.setupOutputHandlers(e.Name, output)
+		}
+
+	case wlr_layer_shell.ZwlrLayerShellV1InterfaceName:
+		layerShell := wlr_layer_shell.NewZwlrLayerShellV1(p.ctx)
+		version := e.Version
+		if version > 4 {
+			version = 4
+		}
+		if err := p.registry.Bind(e.Name, e.Interface, version, layerShell); err == nil {
+			p.layerShell = layerShell
+		}
+
+	case wlr_screencopy.ZwlrScreencopyManagerV1InterfaceName:
+		screencopy := wlr_screencopy.NewZwlrScreencopyManagerV1(p.ctx)
+		version := e.Version
+		if version > 3 {
+			version = 3
+		}
+		if err := p.registry.Bind(e.Name, e.Interface, version, screencopy); err == nil {
+			p.screencopy = screencopy
+		}
+
+	case wp_viewporter.WpViewporterInterfaceName:
+		viewporter := wp_viewporter.NewWpViewporter(p.ctx)
+		if err := p.registry.Bind(e.Name, e.Interface, e.Version, viewporter); err == nil {
+			p.viewporter = viewporter
+		}
+
+	case keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitManagerV1InterfaceName:
+		mgr := keyboard_shortcuts_inhibit.NewZwpKeyboardShortcutsInhibitManagerV1(p.ctx)
+		if err := p.registry.Bind(e.Name, e.Interface, e.Version, mgr); err == nil {
+			p.shortcutsInhibitMgr = mgr
+		}
+	}
+}
+
+func (p *Picker) setupOutputHandlers(name uint32, output *client.Output) {
+	output.SetGeometryHandler(func(e client.OutputGeometryEvent) {
+		p.outputsMu.Lock()
+		if o, ok := p.outputs[name]; ok {
+			o.x = e.X
+			o.y = e.Y
+			o.transform = int32(e.Transform)
+		}
+		p.outputsMu.Unlock()
+	})
+
+	output.SetModeHandler(func(e client.OutputModeEvent) {
+		if e.Flags&uint32(client.OutputModeCurrent) == 0 {
+			return
+		}
+		p.outputsMu.Lock()
+		if o, ok := p.outputs[name]; ok {
+			o.width = e.Width
+			o.height = e.Height
+		}
+		p.outputsMu.Unlock()
+	})
+
+	output.SetScaleHandler(func(e client.OutputScaleEvent) {
+		p.outputsMu.Lock()
+		if o, ok := p.outputs[name]; ok {
+			o.scale = e.Factor
+			o.fractionalScale = float64(e.Factor)
+		}
+		p.outputsMu.Unlock()
+	})
+
+	output.SetNameHandler(func(e client.OutputNameEvent) {
+		p.outputsMu.Lock()
+		if o, ok := p.outputs[name]; ok {
+			o.name = e.Name
+		}
+		p.outputsMu.Unlock()
+	})
+}
+
+func (p *Picker) createSurfaces() error {
+	p.outputsMu.Lock()
+	outputs := make([]*Output, 0, len(p.outputs))
+	for _, o := range p.outputs {
+		outputs = append(outputs, o)
+	}
+	p.outputsMu.Unlock()
+
+	for _, output := range outputs {
+		ls, err := p.createLayerSurface(output)
+		if err != nil {
+			return fmt.Errorf("output %s: %w", output.name, err)
+		}
+		p.surfaces = append(p.surfaces, ls)
+	}
+
+	return nil
+}
+
+func (p *Picker) createLayerSurface(output *Output) (*LayerSurface, error) {
+	surface, err := p.compositor.CreateSurface()
+	if err != nil {
+		return nil, fmt.Errorf("create surface: %w", err)
+	}
+
+	layerSurf, err := p.layerShell.GetLayerSurface(
+		surface,
+		output.wlOutput,
+		uint32(wlr_layer_shell.ZwlrLayerShellV1LayerOverlay),
+		"dms-colorpicker",
+	)
+	if err != nil {
+		return nil, fmt.Errorf("get layer surface: %w", err)
+	}
+
+	ls := &LayerSurface{
+		output:    output,
+		state:     NewSurfaceState(p.config.Format, p.config.Lowercase),
+		wlSurface: surface,
+		layerSurf: layerSurf,
+		hidden:    true, // Start hidden, will show overlay when pointer enters
+	}
+
+	if p.viewporter != nil {
+		vp, err := p.viewporter.GetViewport(surface)
+		if err == nil {
+			ls.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 {
+		log.Warn("failed to set layer anchor", "err", err)
+	}
+	if err := layerSurf.SetExclusiveZone(-1); err != nil {
+		log.Warn("failed to set exclusive zone", "err", err)
+	}
+	if err := layerSurf.SetKeyboardInteractivity(uint32(wlr_layer_shell.ZwlrLayerSurfaceV1KeyboardInteractivityExclusive)); err != nil {
+		log.Warn("failed to set keyboard interactivity", "err", err)
+	}
+
+	layerSurf.SetConfigureHandler(func(e wlr_layer_shell.ZwlrLayerSurfaceV1ConfigureEvent) {
+		if err := layerSurf.AckConfigure(e.Serial); err != nil {
+			log.Warn("failed to ack configure", "err", err)
+		}
+		if err := ls.state.OnLayerConfigure(int(e.Width), int(e.Height)); err != nil {
+			log.Warn("failed to handle layer configure", "err", err)
+		}
+		ls.configured = true
+
+		scale := p.computeSurfaceScale(ls)
+		ls.state.SetScale(scale)
+
+		if !ls.state.IsReady() {
+			p.captureForSurface(ls)
+		} else {
+			p.redrawSurface(ls)
+		}
+
+		// Request shortcut inhibition once surface is configured
+		p.ensureShortcutsInhibitor(ls)
+	})
+
+	layerSurf.SetClosedHandler(func(e wlr_layer_shell.ZwlrLayerSurfaceV1ClosedEvent) {
+		p.running = false
+	})
+
+	if err := surface.Commit(); err != nil {
+		log.Warn("failed to commit surface", "err", err)
+	}
+	return ls, nil
+}
+
+func (p *Picker) computeSurfaceScale(ls *LayerSurface) int32 {
+	out := ls.output
+	if out == nil || out.scale <= 0 {
+		return 1
+	}
+	return out.scale
+}
+
+func (p *Picker) ensureShortcutsInhibitor(ls *LayerSurface) {
+	if p.shortcutsInhibitMgr == nil || p.seat == nil || p.shortcutsInhibitor != nil {
+		return
+	}
+
+	inhibitor, err := p.shortcutsInhibitMgr.InhibitShortcuts(ls.wlSurface, p.seat)
+	if err != nil {
+		log.Debug("failed to create shortcuts inhibitor", "err", err)
+		return
+	}
+
+	p.shortcutsInhibitor = inhibitor
+
+	inhibitor.SetActiveHandler(func(e keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitorV1ActiveEvent) {
+		log.Debug("shortcuts inhibitor active")
+	})
+
+	inhibitor.SetInactiveHandler(func(e keyboard_shortcuts_inhibit.ZwpKeyboardShortcutsInhibitorV1InactiveEvent) {
+		log.Debug("shortcuts inhibitor deactivated by compositor")
+	})
+}
+
+func (p *Picker) captureForSurface(ls *LayerSurface) {
+	frame, err := p.screencopy.CaptureOutput(0, ls.output.wlOutput)
+	if err != nil {
+		return
+	}
+
+	frame.SetBufferHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1BufferEvent) {
+		if err := ls.state.OnScreencopyBuffer(PixelFormat(e.Format), int(e.Width), int(e.Height), int(e.Stride)); err != nil {
+			log.Error("failed to create screencopy buffer", "err", err)
+		}
+	})
+
+	frame.SetBufferDoneHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1BufferDoneEvent) {
+		screenBuf := ls.state.ScreenBuffer()
+		if screenBuf == nil {
+			return
+		}
+
+		pool, err := p.shm.CreatePool(screenBuf.Fd(), int32(screenBuf.Size()))
+		if err != nil {
+			return
+		}
+
+		wlBuffer, err := pool.CreateBuffer(0, int32(screenBuf.Width), int32(screenBuf.Height), int32(screenBuf.Stride), uint32(ls.state.screenFormat))
+		if err != nil {
+			pool.Destroy()
+			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)
+		}
+		pool.Destroy()
+	})
+
+	frame.SetFlagsHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1FlagsEvent) {
+		ls.state.OnScreencopyFlags(e.Flags)
+	})
+
+	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()
+		p.redrawSurface(ls)
+	})
+
+	frame.SetFailedHandler(func(e wlr_screencopy.ZwlrScreencopyFrameV1FailedEvent) {
+		frame.Destroy()
+	})
+}
+
+func (p *Picker) redrawSurface(ls *LayerSurface) {
+	var renderBuf *ShmBuffer
+	if ls.hidden {
+		renderBuf = ls.state.RedrawScreenOnly()
+	} else {
+		renderBuf = ls.state.Redraw()
+	}
+	if renderBuf == nil {
+		return
+	}
+
+	if ls.oldBuffer != nil {
+		ls.oldBuffer.Destroy()
+		ls.oldBuffer = 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(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)
+	}
+
+	if ls.viewport != nil {
+		_ = ls.wlSurface.SetBufferScale(1)
+		_ = ls.viewport.SetSource(0, 0, float64(renderBuf.Width), float64(renderBuf.Height))
+		_ = ls.viewport.SetDestination(int32(logicalW), int32(logicalH))
+	} else {
+		bufferScale := ls.output.scale
+		if bufferScale <= 0 {
+			bufferScale = 1
+		}
+		_ = ls.wlSurface.SetBufferScale(bufferScale)
+	}
+	_ = ls.wlSurface.Attach(wlBuffer, 0, 0)
+	_ = ls.wlSurface.Damage(0, 0, int32(logicalW), int32(logicalH))
+	_ = ls.wlSurface.Commit()
+
+	ls.state.SwapBuffers()
+}
+
+func (p *Picker) hideSurface(ls *LayerSurface) {
+	if ls == nil || ls.wlSurface == nil || ls.hidden {
+		return
+	}
+	ls.hidden = true
+	// Redraw without the crosshair overlay
+	p.redrawSurface(ls)
+}
+
+func (p *Picker) setupInput() {
+	if p.seat == nil {
+		return
+	}
+
+	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 {
+				return
+			}
+			p.pointer = pointer
+			p.setupPointerHandlers()
+		}
+		if e.Capabilities&uint32(client.SeatCapabilityKeyboard) != 0 && p.keyboard == nil {
+			keyboard, err := p.seat.GetKeyboard()
+			if err != nil {
+				return
+			}
+			p.keyboard = keyboard
+			p.setupKeyboardHandlers()
+		}
+	})
+}
+
+func (p *Picker) setupPointerHandlers() {
+	p.pointer.SetEnterHandler(func(e client.PointerEnterEvent) {
+		if err := p.pointer.SetCursor(e.Serial, nil, 0, 0); err != nil {
+			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() == surfaceID {
+				p.activeSurface = ls
+				break
+			}
+		}
+		if p.activeSurface == nil {
+			return
+		}
+
+		if p.activeSurface.hidden {
+			p.activeSurface.hidden = false
+		}
+
+		p.activeSurface.state.OnPointerMotion(e.SurfaceX, e.SurfaceY)
+		p.redrawSurface(p.activeSurface)
+	})
+
+	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() == surfaceID {
+				p.hideSurface(ls)
+				break
+			}
+		}
+	})
+
+	p.pointer.SetMotionHandler(func(e client.PointerMotionEvent) {
+		if p.activeSurface == nil {
+			return
+		}
+		p.activeSurface.state.OnPointerMotion(e.SurfaceX, e.SurfaceY)
+		p.redrawSurface(p.activeSurface)
+	})
+
+	p.pointer.SetButtonHandler(func(e client.PointerButtonEvent) {
+		if p.activeSurface == nil {
+			return
+		}
+		p.activeSurface.state.OnPointerButton(e.Button, e.State)
+	})
+}
+
+func (p *Picker) setupKeyboardHandlers() {
+	p.keyboard.SetKeyHandler(func(e client.KeyboardKeyEvent) {
+		for _, ls := range p.surfaces {
+			ls.state.OnKey(e.Key, e.State)
+		}
+	})
+}
+
+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()
+		}
+		if ls.wlPool != nil {
+			ls.wlPool.Destroy()
+		}
+		if ls.viewport != nil {
+			ls.viewport.Destroy()
+		}
+		if ls.layerSurf != nil {
+			ls.layerSurf.Destroy()
+		}
+		if ls.wlSurface != nil {
+			ls.wlSurface.Destroy()
+		}
+		if ls.state != nil {
+			ls.state.Destroy()
+		}
+	}
+
+	if p.shortcutsInhibitor != nil {
+		if err := p.shortcutsInhibitor.Destroy(); err != nil {
+			log.Debug("failed to destroy shortcuts inhibitor", "err", err)
+		}
+		p.shortcutsInhibitor = nil
+	}
+
+	if p.shortcutsInhibitMgr != nil {
+		if err := p.shortcutsInhibitMgr.Destroy(); err != nil {
+			log.Debug("failed to destroy shortcuts inhibit manager", "err", err)
+		}
+		p.shortcutsInhibitMgr = nil
+	}
+
+	if p.viewporter != nil {
+		p.viewporter.Destroy()
+	}
+
+	if p.screencopy != nil {
+		p.screencopy.Destroy()
+	}
+
+	if p.pointer != nil {
+		p.pointer.Release()
+	}
+
+	if p.keyboard != nil {
+		p.keyboard.Release()
+	}
+
+	if p.display != nil {
+		p.ctx.Close()
+	}
+}

core/internal/colorpicker/shm.go

@@ -0,0 +1,55 @@
+package colorpicker
+
+import "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/shm"
+
+type ShmBuffer = shm.Buffer
+
+const (
+	TransformNormal     = shm.TransformNormal
+	Transform90         = shm.Transform90
+	Transform180        = shm.Transform180
+	Transform270        = shm.Transform270
+	TransformFlipped    = shm.TransformFlipped
+	TransformFlipped90  = shm.TransformFlipped90
+	TransformFlipped180 = shm.TransformFlipped180
+	TransformFlipped270 = shm.TransformFlipped270
+)
+
+func CreateShmBuffer(width, height, stride int) (*ShmBuffer, error) {
+	return shm.CreateBuffer(width, height, stride)
+}
+
+func InverseTransform(transform int32) int32 {
+	return shm.InverseTransform(transform)
+}
+
+func GetPixelColor(buf *ShmBuffer, x, y int) Color {
+	return GetPixelColorWithFormat(buf, x, y, FormatARGB8888)
+}
+
+func GetPixelColorWithFormat(buf *ShmBuffer, x, y int, format PixelFormat) Color {
+	if x < 0 || x >= buf.Width || y < 0 || y >= buf.Height {
+		return Color{}
+	}
+
+	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: data[offset],
+		G: data[offset+1],
+		R: data[offset+2],
+		A: data[offset+3],
+	}
+}

core/internal/colorpicker/state_test.go

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

core/internal/config/deployer.go

@@ -46,11 +46,20 @@ func (cd *ConfigDeployer) DeployConfigurationsWithTerminal(ctx context.Context,
 	return cd.DeployConfigurationsSelective(ctx, wm, terminal, nil, nil)
 }
 
+// DeployConfigurationsWithSystemd deploys configurations with systemd option
+func (cd *ConfigDeployer) DeployConfigurationsWithSystemd(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, useSystemd bool) ([]DeploymentResult, error) {
+	return cd.deployConfigurationsInternal(ctx, wm, terminal, nil, nil, nil, useSystemd)
+}
+
 func (cd *ConfigDeployer) DeployConfigurationsSelective(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool) ([]DeploymentResult, error) {
 	return cd.DeployConfigurationsSelectiveWithReinstalls(ctx, wm, terminal, installedDeps, replaceConfigs, nil)
 }
 
 func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool, reinstallItems map[string]bool) ([]DeploymentResult, error) {
+	return cd.deployConfigurationsInternal(ctx, wm, terminal, installedDeps, replaceConfigs, reinstallItems, true)
+}
+
+func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool, reinstallItems map[string]bool, useSystemd bool) ([]DeploymentResult, error) {
 	var results []DeploymentResult
 
 	shouldReplaceConfig := func(configType string) bool {
@@ -64,7 +73,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 	switch wm {
 	case deps.WindowManagerNiri:
 		if shouldReplaceConfig("Niri") {
-			result, err := cd.deployNiriConfig(terminal)
+			result, err := cd.deployNiriConfig(terminal, useSystemd)
 			results = append(results, result)
 			if err != nil {
 				return results, fmt.Errorf("failed to deploy Niri config: %w", err)
@@ -72,7 +81,7 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 		}
 	case deps.WindowManagerHyprland:
 		if shouldReplaceConfig("Hyprland") {
-			result, err := cd.deployHyprlandConfig(terminal)
+			result, err := cd.deployHyprlandConfig(terminal, useSystemd)
 			results = append(results, result)
 			if err != nil {
 				return results, fmt.Errorf("failed to deploy Hyprland config: %w", err)
@@ -110,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, useSystemd bool) (DeploymentResult, error) {
-func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal) (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(NiriConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
-	newConfig = strings.ReplaceAll(newConfig, "{{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(HyprlandConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
-	newConfig = strings.ReplaceAll(newConfig, "{{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
-	insertPos := headerMatch[1] + 1 // +1 for the newline
 
 	var builder strings.Builder
 	builder.WriteString(mergedConfig[:insertPos])
@@ -572,3 +557,70 @@ 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) {
+		// Insert spawn-at-startup for dms after the environment block
+		envBlockEnd := regexp.MustCompile(`environment \{[^}]*\}`)
+		if loc := envBlockEnd.FindStringIndex(config); loc != nil {
+			config = config[:loc[1]] + "\n" + spawnDms + config[loc[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, NiriBindsConfig, "binds {")
-	assert.Contains(t, NiriConfig, `spawn "{{TERMINAL_COMMAND}}"`)
+	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, "bind = $mod, T, exec, {{TERMINAL_COMMAND}}")
-	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, space, exec, dms ipc call spotlight toggle")
 	assert.Contains(t, HyprlandConfig, "windowrulev2 = noborder, class:^(com\\.mitchellh\\.ghostty)$")
 }

core/internal/config/dms.go

@@ -7,18 +7,11 @@ import (
 	"strings"
 )
 
-// LocateDMSConfig searches for DMS installation following XDG Base Directory specification
 func LocateDMSConfig() (string, error) {
 	var primaryPaths []string
 
-	configHome := os.Getenv("XDG_CONFIG_HOME")
+	configHome, err := os.UserConfigDir()
-	if configHome == "" {
+	if err == nil && configHome != "" {
-		if homeDir, err := os.UserHomeDir(); err == nil {
-			configHome = filepath.Join(homeDir, ".config")
-		}
-	}
-
-	if configHome != "" {
 		primaryPaths = append(primaryPaths, filepath.Join(configHome, "quickshell", "dms"))
 	}
 

core/internal/config/embedded/hyprland.conf

@@ -7,21 +7,11 @@
 # 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 = bash -c "wl-paste --watch cliphist store &"
+exec-once = dbus-update-activation-environment --systemd --all
-exec-once = dms run
+exec-once = systemctl --user start hyprland-session.target
-exec-once = {{POLKIT_AGENT_PATH}}
 
 # ==================
 # INPUT CONFIG
@@ -140,8 +130,8 @@ $mod = SUPER
 bind = $mod, T, exec, {{TERMINAL_COMMAND}}
 bind = $mod, space, exec, dms ipc call spotlight toggle
 bind = $mod, V, exec, dms ipc call clipboard toggle
-bind = $mod, M, exec, dms ipc call processlist toggle
+bind = $mod, M, exec, dms ipc call processlist focusOrToggle
-bind = $mod, comma, exec, dms ipc call settings toggle
+bind = $mod, comma, exec, dms ipc call settings focusOrToggle
 bind = $mod, N, exec, dms ipc call notifications toggle
 bind = $mod SHIFT, N, exec, dms ipc call notepad toggle
 bind = $mod, Y, exec, dms ipc call dankdash wallpaper
@@ -153,7 +143,7 @@ bind = $mod SHIFT, Slash, exec, dms ipc call keybinds toggle hyprland
 # === Security ===
 bind = $mod ALT, L, exec, dms ipc call lock lock
 bind = $mod SHIFT, E, exit
-bind = CTRL ALT, Delete, exec, dms ipc call processlist toggle
+bind = CTRL ALT, Delete, exec, dms ipc call processlist focusOrToggle
 
 # === Audio Controls ===
 bindel = , XF86AudioRaiseVolume, exec, dms ipc call audio increment 3
@@ -281,12 +271,9 @@ binde = $mod SHIFT, minus, resizeactive, 0 -10%
 binde = $mod SHIFT, equal, resizeactive, 0 10%
 
 # === Screenshots ===
-bind = , XF86Launch1, exec, grimblast copy area
+bind = , Print, exec, dms screenshot
-bind = CTRL, XF86Launch1, exec, grimblast copy screen
+bind = CTRL, Print, exec, dms screenshot full
-bind = ALT, XF86Launch1, exec, grimblast copy active
+bind = ALT, Print, exec, dms screenshot window
-bind = , Print, exec, grimblast copy area
-bind = CTRL, Print, exec, grimblast copy screen
-bind = ALT, Print, exec, grimblast copy active
 
 # === System Controls ===
-bind = $mod SHIFT, P, dpms, off
+bind = $mod SHIFT, P, dpms, toggle

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

@@ -0,0 +1,10 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+recent-windows {
+    highlight {
+        corner-radius 12
+    }
+}

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

@@ -0,0 +1,200 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+binds {
+    // === System & Overview ===
+    Mod+D repeat=false { toggle-overview; }
+    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,41 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+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,22 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+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

@@ -18,15 +18,64 @@ gestures {
 input {
     keyboard {
         xkb {
+            // You can set rules, model, layout, variant and options.
+            // For more information, see xkeyboard-config(7).
+
+            // For example:
+            // layout "us,ru"
+            // options "grp:win_space_toggle,compose:ralt,ctrl:nocaps"
+
+            // If this section is empty, niri will fetch xkb settings
+            // from org.freedesktop.locale1. You can control these using
+            // localectl set-x11-keymap.
         }
+
+        // Enable numlock on startup, omitting this setting disables it.
         numlock
     }
+
+    // Next sections include libinput settings.
+    // Omitting settings disables them, or leaves them at their default values.
+    // All commented-out settings here are examples, not defaults.
     touchpad {
+        // off
+        tap
+        // dwt
+        // dwtp
+        // drag false
+        // drag-lock
+        natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "two-finger"
+        // disabled-on-external-mouse
     }
+
     mouse {
+        // off
+        // natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "no-scroll"
     }
+
     trackpoint {
+        // off
+        // natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "on-button-down"
+        // scroll-button 273
+        // scroll-button-lock
+        // middle-emulation
     }
+
+    // Uncomment this to make the mouse warp to the center of newly focused windows.
+    // warp-mouse-to-focus
+
+    // Focus windows and outputs automatically when moving the mouse into them.
+    // Setting max-scroll-amount="0%" makes it work only on windows already fully on screen.
+    // focus-follows-mouse max-scroll-amount="0%"
 }
 // You can configure outputs by their name, which you can find
 // by running `niri msg outputs` while inside a niri instance.
@@ -44,7 +93,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 +135,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
@@ -115,16 +158,8 @@ overview {
 // which may be more convenient to use.
 // 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 +249,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" "toggle";
-    }
-    Mod+Comma hotkey-overlay-title="Settings" {
-        spawn "dms" "ipc" "call" "settings" "toggle";
-    }
-    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" "toggle";
-    }
-
-    // === 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
@@ -104,55 +103,18 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 		dependencies = append(dependencies, a.detectXwaylandSatellite())
 	}
 
-	// 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
+	return a.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", a.packageInstalled("xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (a *ArchDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
+	return a.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", a.packageInstalled("accountsservice"))
-	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,
-	}
 }
 
 func (a *ArchDistribution) packageInstalled(pkg string) bool {
@@ -175,21 +137,14 @@ func (a *ArchDistribution) GetPackageMappingWithVariants(wm deps.WindowManager,
 		"ghostty":                 {Name: "ghostty", Repository: RepoTypeSystem},
 		"kitty":                   {Name: "kitty", Repository: RepoTypeSystem},
 		"alacritty":               {Name: "alacritty", Repository: RepoTypeSystem},
-		"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 +158,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 {
+func (a *ArchDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "hyprland-git", Repository: RepoTypeAUR}
-	}
 	return PackageMapping{Name: "hyprland", Repository: RepoTypeSystem}
 }
 
@@ -378,6 +331,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 (
-const forceDMSGit = false
+	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) detectCommand(name, description string) deps.Dependency {
-func (b *BaseDistribution) detectGit() 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
+	return b.detectCommand("matugen", "Material Design color generation tool")
-	if b.commandExists("matugen") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "matugen",
-		Status:      status,
-		Description: "Material Design color generation tool",
-		Required:    true,
-	}
 }
 
 func (b *BaseDistribution) detectDgop() deps.Dependency {
-	status := deps.StatusMissing
+	return b.detectCommand("dgop", "Desktop portal management tool")
-	if b.commandExists("dgop") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "dgop",
-		Status:      status,
-		Description: "Desktop portal management tool",
-		Required:    true,
-	}
 }
 
 func (b *BaseDistribution) detectDMS() deps.Dependency {
@@ -188,51 +185,6 @@ func (b *BaseDistribution) detectSpecificTerminal(terminal deps.Terminal) deps.D
 	}
 }
 
-func (b *BaseDistribution) detectClipboardTools() []deps.Dependency {
-	var dependencies []deps.Dependency
-
-	cliphist := deps.StatusMissing
-	if b.commandExists("cliphist") {
-		cliphist = deps.StatusInstalled
-	}
-
-	wlClipboard := deps.StatusMissing
-	if b.commandExists("wl-copy") && b.commandExists("wl-paste") {
-		wlClipboard = deps.StatusInstalled
-	}
-
-	dependencies = append(dependencies,
-		deps.Dependency{
-			Name:        "cliphist",
-			Status:      cliphist,
-			Description: "Wayland clipboard manager",
-			Required:    true,
-		},
-		deps.Dependency{
-			Name:        "wl-clipboard",
-			Status:      wlClipboard,
-			Description: "Wayland clipboard utilities",
-			Required:    true,
-		},
-	)
-
-	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 +192,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 +513,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 +660,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 {
@@ -70,66 +69,20 @@ func (d *DebianDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 
 	dependencies = append(dependencies, d.detectMatugen())
 	dependencies = append(dependencies, d.detectDgop())
-	dependencies = append(dependencies, d.detectHyprpicker())
-	dependencies = append(dependencies, d.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 func (d *DebianDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
+	return d.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", d.packageInstalled("xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (d *DebianDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
+	return d.detectCommand("xwayland-satellite", "Xwayland support")
-	if d.commandExists("xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
 }
 
 func (d *DebianDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
+	return d.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", d.packageInstalled("accountsservice"))
-	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,
-	}
 }
 
 func (d *DebianDistribution) packageInstalled(pkg string) bool {
@@ -139,33 +92,63 @@ func (d *DebianDistribution) packageInstalled(pkg string) bool {
 }
 
 func (d *DebianDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
+	return d.GetPackageMappingWithVariants(wm, make(map[string]deps.PackageVariant))
+}
+
+func (d *DebianDistribution) GetPackageMappingWithVariants(wm deps.WindowManager, variants map[string]deps.PackageVariant) map[string]PackageMapping {
 	packages := map[string]PackageMapping{
+		// Standard APT packages
 		"git":                    {Name: "git", Repository: RepoTypeSystem},
 		"kitty":                  {Name: "kitty", Repository: RepoTypeSystem},
 		"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 (DankMaterialShell)": {Name: "dms", Repository: RepoTypeManual, BuildFunc: "installDankMaterialShell"},
+		// DMS packages from OBS with variant support
-		"niri":                    {Name: "niri", Repository: RepoTypeManual, BuildFunc: "installNiri"},
+		"dms (DankMaterialShell)": d.getDmsMapping(variants["dms (DankMaterialShell)"]),
-		"quickshell":              {Name: "quickshell", Repository: RepoTypeManual, BuildFunc: "installQuickshell"},
+		"quickshell":              d.getQuickshellMapping(variants["quickshell"]),
-		"ghostty":                 {Name: "ghostty", Repository: RepoTypeManual, BuildFunc: "installGhostty"},
+		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
-		"matugen":                 {Name: "matugen", Repository: RepoTypeManual, BuildFunc: "installMatugen"},
+		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
-		"dgop":                    {Name: "dgop", Repository: RepoTypeManual, BuildFunc: "installDgop"},
+		"ghostty":                 {Name: "ghostty", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
-		"cliphist":                {Name: "cliphist", Repository: RepoTypeManual, BuildFunc: "installCliphist"},
-		"hyprpicker":              {Name: "hyprpicker", Repository: RepoTypeManual, BuildFunc: "installHyprpicker"},
 	}
 
 	if wm == deps.WindowManagerNiri {
-		packages["niri"] = PackageMapping{Name: "niri", Repository: RepoTypeManual, BuildFunc: "installNiri"}
+		niriVariant := variants["niri"]
-		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeManual, BuildFunc: "installXwaylandSatellite"}
+		packages["niri"] = d.getNiriMapping(niriVariant)
+		packages["xwayland-satellite"] = d.getXwaylandSatelliteMapping(niriVariant)
 	}
 
 	return packages
 }
 
+func (d *DebianDistribution) getDmsMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "dms-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:dms-git"}
+	}
+	return PackageMapping{Name: "dms", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:dms"}
+}
+
+func (d *DebianDistribution) getQuickshellMapping(variant deps.PackageVariant) PackageMapping {
+	if forceQuickshellGit || variant == deps.VariantGit {
+		return PackageMapping{Name: "quickshell-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "quickshell", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+}
+
+func (d *DebianDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "niri-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "niri", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+}
+
+func (d *DebianDistribution) getXwaylandSatelliteMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "xwayland-satellite-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+}
+
 func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	progressChan <- InstallProgressMsg{
 		Phase:      PhasePrerequisites,
@@ -192,7 +175,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)
 		}
@@ -209,7 +192,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)
 	}
@@ -238,8 +221,23 @@ func (d *DebianDistribution) InstallPackages(ctx context.Context, dependencies [
 		return fmt.Errorf("failed to install prerequisites: %w", err)
 	}
 
-	systemPkgs, manualPkgs, variantMap := d.categorizePackages(dependencies, wm, reinstallFlags, disabledFlags)
+	systemPkgs, obsPkgs, manualPkgs, variantMap := d.categorizePackages(dependencies, wm, reinstallFlags, disabledFlags)
 
+	// Enable OBS repositories
+	if len(obsPkgs) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:      PhaseSystemPackages,
+			Progress:   0.15,
+			Step:       "Enabling OBS repositories...",
+			IsComplete: false,
+			LogOutput:  "Setting up OBS repositories for additional packages",
+		}
+		if err := d.enableOBSRepos(ctx, obsPkgs, sudoPassword, progressChan); err != nil {
+			return fmt.Errorf("failed to enable OBS repositories: %w", err)
+		}
+	}
+
+	// System Packages
 	if len(systemPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
 			Phase:      PhaseSystemPackages,
@@ -254,6 +252,22 @@ func (d *DebianDistribution) InstallPackages(ctx context.Context, dependencies [
 		}
 	}
 
+	// OBS Packages
+	obsPkgNames := d.extractPackageNames(obsPkgs)
+	if len(obsPkgNames) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:      PhaseAURPackages,
+			Progress:   0.65,
+			Step:       fmt.Sprintf("Installing %d OBS packages...", len(obsPkgNames)),
+			IsComplete: false,
+			LogOutput:  fmt.Sprintf("Installing OBS packages: %s", strings.Join(obsPkgNames, ", ")),
+		}
+		if err := d.installAPTPackages(ctx, obsPkgNames, sudoPassword, progressChan); err != nil {
+			return fmt.Errorf("failed to install OBS packages: %w", err)
+		}
+	}
+
+	// Manual Builds
 	if len(manualPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
 			Phase:      PhaseSystemPackages,
@@ -286,6 +300,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,
@@ -297,8 +324,9 @@ func (d *DebianDistribution) InstallPackages(ctx context.Context, dependencies [
 	return nil
 }
 
-func (d *DebianDistribution) categorizePackages(dependencies []deps.Dependency, wm deps.WindowManager, reinstallFlags map[string]bool, disabledFlags map[string]bool) ([]string, []string, map[string]deps.PackageVariant) {
+func (d *DebianDistribution) categorizePackages(dependencies []deps.Dependency, wm deps.WindowManager, reinstallFlags map[string]bool, disabledFlags map[string]bool) ([]string, []PackageMapping, []string, map[string]deps.PackageVariant) {
 	systemPkgs := []string{}
+	obsPkgs := []PackageMapping{}
 	manualPkgs := []string{}
 
 	variantMap := make(map[string]deps.PackageVariant)
@@ -306,7 +334,7 @@ func (d *DebianDistribution) categorizePackages(dependencies []deps.Dependency,
 		variantMap[dep.Name] = dep.Variant
 	}
 
-	packageMap := d.GetPackageMapping(wm)
+	packageMap := d.GetPackageMappingWithVariants(wm, variantMap)
 
 	for _, dep := range dependencies {
 		if disabledFlags[dep.Name] {
@@ -326,12 +354,116 @@ func (d *DebianDistribution) categorizePackages(dependencies []deps.Dependency,
 		switch pkgInfo.Repository {
 		case RepoTypeSystem:
 			systemPkgs = append(systemPkgs, pkgInfo.Name)
+		case RepoTypeOBS:
+			obsPkgs = append(obsPkgs, pkgInfo)
 		case RepoTypeManual:
 			manualPkgs = append(manualPkgs, dep.Name)
 		}
 	}
 
-	return systemPkgs, manualPkgs, variantMap
+	return systemPkgs, obsPkgs, manualPkgs, variantMap
+}
+
+func (d *DebianDistribution) extractPackageNames(packages []PackageMapping) []string {
+	names := make([]string, len(packages))
+	for i, pkg := range packages {
+		names[i] = pkg.Name
+	}
+	return names
+}
+
+func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []PackageMapping, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
+	enabledRepos := make(map[string]bool)
+
+	osInfo, err := GetOSInfo()
+	if err != nil {
+		return fmt.Errorf("failed to get OS info: %w", err)
+	}
+
+	// Determine Debian version for OBS repository URL
+	debianVersion := "Debian_13"
+	if osInfo.VersionID == "testing" {
+		debianVersion = "Debian_Testing"
+	}
+
+	for _, pkg := range obsPkgs {
+		if pkg.RepoURL != "" && !enabledRepos[pkg.RepoURL] {
+			d.log(fmt.Sprintf("Enabling OBS repository: %s", pkg.RepoURL))
+
+			// RepoURL format: "home:AvengeMedia:danklinux"
+			repoPath := strings.ReplaceAll(pkg.RepoURL, ":", ":/")
+			repoName := strings.ReplaceAll(pkg.RepoURL, ":", "-")
+			baseURL := fmt.Sprintf("https://download.opensuse.org/repositories/%s/%s", repoPath, debianVersion)
+
+			// Check if repository already exists
+			listFile := fmt.Sprintf("/etc/apt/sources.list.d/%s.list", repoName)
+			checkCmd := exec.CommandContext(ctx, "test", "-f", listFile)
+			if checkCmd.Run() == nil {
+				d.log(fmt.Sprintf("OBS repo %s already exists, skipping", pkg.RepoURL))
+				enabledRepos[pkg.RepoURL] = true
+				continue
+			}
+
+			keyringPath := fmt.Sprintf("/etc/apt/keyrings/%s.gpg", repoName)
+
+			// Create keyrings directory if it doesn't exist
+			mkdirCmd := ExecSudoCommand(ctx, sudoPassword, "mkdir -p /etc/apt/keyrings")
+			if err := mkdirCmd.Run(); err != nil {
+				d.log(fmt.Sprintf("Warning: failed to create keyrings directory: %v", err))
+			}
+
+			progressChan <- InstallProgressMsg{
+				Phase:       PhaseSystemPackages,
+				Progress:    0.18,
+				Step:        fmt.Sprintf("Adding OBS GPG key for %s...", pkg.RepoURL),
+				NeedsSudo:   true,
+				CommandInfo: fmt.Sprintf("curl & gpg to add key for %s", pkg.RepoURL),
+			}
+
+			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)
+			}
+
+			// Add repository
+			repoLine := fmt.Sprintf("deb [signed-by=%s] %s/ /", keyringPath, baseURL)
+
+			progressChan <- InstallProgressMsg{
+				Phase:       PhaseSystemPackages,
+				Progress:    0.20,
+				Step:        fmt.Sprintf("Adding OBS repository %s...", pkg.RepoURL),
+				NeedsSudo:   true,
+				CommandInfo: fmt.Sprintf("echo '%s' | sudo tee %s", repoLine, listFile),
+			}
+
+			addRepoCmd := ExecSudoCommand(ctx, sudoPassword,
+				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)
+			}
+
+			enabledRepos[pkg.RepoURL] = true
+			d.log(fmt.Sprintf("OBS repo %s enabled successfully", pkg.RepoURL))
+		}
+	}
+
+	if len(enabledRepos) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:       PhaseSystemPackages,
+			Progress:    0.25,
+			Step:        "Updating package lists...",
+			NeedsSudo:   true,
+			CommandInfo: "sudo apt-get update",
+		}
+
+		updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
+		if err := d.runWithProgress(updateCmd, progressChan, PhaseSystemPackages, 0.25, 0.27); err != nil {
+			return fmt.Errorf("failed to update package lists after adding OBS repos: %w", err)
+		}
+	}
+
+	return nil
 }
 
 func (d *DebianDistribution) installAPTPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -341,7 +473,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{
@@ -414,7 +546,7 @@ func (d *DebianDistribution) installBuildDependencies(ctx context.Context, manua
 			if err := d.installRust(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install Rust: %w", err)
 			}
-		case "cliphist", "dgop":
+		case "dgop":
 			if err := d.installGo(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install Go: %w", err)
 			}
@@ -451,7 +583,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)
 	}
@@ -490,34 +622,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
@@ -527,10 +635,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
@@ -89,41 +88,14 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 		dependencies = append(dependencies, f.detectXwaylandSatellite())
 	}
 
-	// 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
+	return f.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", f.packageInstalled("xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (f *FedoraDistribution) packageInstalled(pkg string) bool {
@@ -143,16 +115,12 @@ func (f *FedoraDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"ghostty":                {Name: "ghostty", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
 		"kitty":                  {Name: "kitty", Repository: RepoTypeSystem},
 		"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"]),
 		"matugen":                 {Name: "matugen", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
-		"cliphist":                {Name: "cliphist", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
 		"dms (DankMaterialShell)": f.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"dgop":                    {Name: "dgop", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
 	}
@@ -160,10 +128,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 +152,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 {
+func (f *FedoraDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
-	if variant == deps.VariantGit {
-		return PackageMapping{Name: "hyprland-git", Repository: RepoTypeCOPR, RepoURL: "solopasha/hyprland"}
-	}
 	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 +340,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,20 @@ 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
+	return g.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", g.packageInstalled("sys-apps/xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (g *GentooDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
+	return g.detectPackage("xwayland-satellite", "Xwayland support", g.packageInstalled("gui-apps/xwayland-satellite"))
-	if g.packageInstalled("gui-apps/xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
 }
 
 func (g *GentooDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
+	return g.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", g.packageInstalled("sys-apps/accountsservice"))
-	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,
-	}
 }
 
 func (g *GentooDistribution) packageInstalled(pkg string) bool {
@@ -186,11 +139,8 @@ func (g *GentooDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		"git":                    {Name: "dev-vcs/git", Repository: RepoTypeSystem},
 		"kitty":                  {Name: "x11-terms/kitty", Repository: RepoTypeSystem, UseFlags: "X wayland"},
 		"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"},
@@ -199,7 +149,6 @@ func (g *GentooDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 
 		"quickshell":              g.getQuickshellMapping(variants["quickshell"]),
 		"matugen":                 {Name: "x11-misc/matugen", Repository: RepoTypeGURU, AcceptKeywords: archKeyword},
-		"cliphist":                {Name: "app-misc/cliphist", Repository: RepoTypeGURU, AcceptKeywords: archKeyword},
 		"dms (DankMaterialShell)": g.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"dgop":                    {Name: "dgop", Repository: RepoTypeManual, BuildFunc: "installDgop"},
 	}
@@ -207,10 +156,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 +174,8 @@ func (g *GentooDistribution) getDmsMapping(_ deps.PackageVariant) PackageMapping
 	return PackageMapping{Name: "dms", Repository: RepoTypeManual, BuildFunc: "installDankMaterialShell"}
 }
 
-func (g *GentooDistribution) getHyprlandMapping(variant deps.PackageVariant) PackageMapping {
+func (g *GentooDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
-	archKeyword := g.getArchKeyword()
+	return PackageMapping{Name: "gui-wm/hyprland", Repository: RepoTypeSystem, UseFlags: "X", AcceptKeywords: 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) getNiriMapping(_ deps.PackageVariant) PackageMapping {
@@ -460,6 +398,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/interface.go

@@ -39,6 +39,7 @@ const (
 	RepoTypeAUR    RepositoryType = "aur"    // Arch User Repository
 	RepoTypeCOPR   RepositoryType = "copr"   // Fedora COPR
 	RepoTypePPA    RepositoryType = "ppa"    // Ubuntu PPA
+	RepoTypeOBS    RepositoryType = "obs"    // OpenBuild Service (Debian/OpenSUSE)
 	RepoTypeFlake  RepositoryType = "flake"  // Nix flake
 	RepoTypeGURU   RepositoryType = "guru"   // Gentoo GURU
 	RepoTypeManual RepositoryType = "manual" // Manual build from source

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)
@@ -78,10 +74,6 @@ func (m *ManualPackageInstaller) InstallManualPackages(ctx context.Context, pack
 			if err := m.installHyprland(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install hyprland: %w", err)
 			}
-		case "hyprpicker":
-			if err := m.installHyprpicker(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install hyprpicker: %w", err)
-			}
 		case "ghostty":
 			if err := m.installGhostty(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install ghostty: %w", err)
@@ -90,10 +82,6 @@ func (m *ManualPackageInstaller) InstallManualPackages(ctx context.Context, pack
 			if err := m.installMatugen(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install matugen: %w", err)
 			}
-		case "cliphist":
-			if err := m.installCliphist(ctx, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install cliphist: %w", err)
-			}
 		case "xwayland-satellite":
 			if err := m.installXwaylandSatellite(ctx, sudoPassword, progressChan); err != nil {
 				return fmt.Errorf("failed to install xwayland-satellite: %w", err)
@@ -166,62 +154,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...")
 
@@ -465,184 +397,6 @@ func (m *ManualPackageInstaller) installHyprland(ctx context.Context, sudoPasswo
 	return nil
 }
 
-func (m *ManualPackageInstaller) installHyprpicker(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	m.log("Installing hyprpicker from source...")
-
-	homeDir := os.Getenv("HOME")
-	if homeDir == "" {
-		return fmt.Errorf("HOME environment variable not set")
-	}
-
-	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0755); err != nil {
-		return fmt.Errorf("failed to create cache directory: %w", err)
-	}
-
-	// Install hyprutils first
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.05,
-		Step:        "Building hyprutils dependency...",
-		IsComplete:  false,
-		CommandInfo: "git clone https://github.com/hyprwm/hyprutils.git",
-	}
-
-	hyprutilsDir := filepath.Join(cacheDir, "hyprutils-build")
-	if err := os.MkdirAll(hyprutilsDir, 0755); err != nil {
-		return fmt.Errorf("failed to create hyprutils directory: %w", err)
-	}
-	defer os.RemoveAll(hyprutilsDir)
-
-	cloneUtilsCmd := exec.CommandContext(ctx, "git", "clone", "https://github.com/hyprwm/hyprutils.git", hyprutilsDir)
-	if err := cloneUtilsCmd.Run(); err != nil {
-		return fmt.Errorf("failed to clone hyprutils: %w", err)
-	}
-
-	configureUtilsCmd := exec.CommandContext(ctx, "cmake",
-		"--no-warn-unused-cli",
-		"-DCMAKE_BUILD_TYPE:STRING=Release",
-		"-DCMAKE_INSTALL_PREFIX:PATH=/usr",
-		"-DBUILD_TESTING=off",
-		"-S", ".",
-		"-B", "./build")
-	configureUtilsCmd.Dir = hyprutilsDir
-	configureUtilsCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-	if err := m.runWithProgressStep(configureUtilsCmd, progressChan, PhaseSystemPackages, 0.05, 0.1, "Configuring hyprutils..."); err != nil {
-		return fmt.Errorf("failed to configure hyprutils: %w", err)
-	}
-
-	buildUtilsCmd := exec.CommandContext(ctx, "cmake", "--build", "./build", "--config", "Release", "--target", "all")
-	buildUtilsCmd.Dir = hyprutilsDir
-	buildUtilsCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-	if err := m.runWithProgressStep(buildUtilsCmd, progressChan, PhaseSystemPackages, 0.1, 0.2, "Building hyprutils..."); err != nil {
-		return fmt.Errorf("failed to build hyprutils: %w", err)
-	}
-
-	installUtilsCmd := ExecSudoCommand(ctx, sudoPassword, "cmake --install ./build")
-	installUtilsCmd.Dir = hyprutilsDir
-	if err := installUtilsCmd.Run(); err != nil {
-		return fmt.Errorf("failed to install hyprutils: %w", err)
-	}
-
-	// Install hyprwayland-scanner
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.2,
-		Step:        "Building hyprwayland-scanner dependency...",
-		IsComplete:  false,
-		CommandInfo: "git clone https://github.com/hyprwm/hyprwayland-scanner.git",
-	}
-
-	scannerDir := filepath.Join(cacheDir, "hyprwayland-scanner-build")
-	if err := os.MkdirAll(scannerDir, 0755); err != nil {
-		return fmt.Errorf("failed to create scanner directory: %w", err)
-	}
-	defer os.RemoveAll(scannerDir)
-
-	cloneScannerCmd := exec.CommandContext(ctx, "git", "clone", "https://github.com/hyprwm/hyprwayland-scanner.git", scannerDir)
-	if err := cloneScannerCmd.Run(); err != nil {
-		return fmt.Errorf("failed to clone hyprwayland-scanner: %w", err)
-	}
-
-	configureScannerCmd := exec.CommandContext(ctx, "cmake",
-		"-DCMAKE_INSTALL_PREFIX=/usr",
-		"-B", "build")
-	configureScannerCmd.Dir = scannerDir
-	configureScannerCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-	if err := m.runWithProgressStep(configureScannerCmd, progressChan, PhaseSystemPackages, 0.2, 0.25, "Configuring hyprwayland-scanner..."); err != nil {
-		return fmt.Errorf("failed to configure hyprwayland-scanner: %w", err)
-	}
-
-	buildScannerCmd := exec.CommandContext(ctx, "cmake", "--build", "build", "-j")
-	buildScannerCmd.Dir = scannerDir
-	buildScannerCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-	if err := m.runWithProgressStep(buildScannerCmd, progressChan, PhaseSystemPackages, 0.25, 0.35, "Building hyprwayland-scanner..."); err != nil {
-		return fmt.Errorf("failed to build hyprwayland-scanner: %w", err)
-	}
-
-	installScannerCmd := ExecSudoCommand(ctx, sudoPassword, "cmake --install build")
-	installScannerCmd.Dir = scannerDir
-	if err := installScannerCmd.Run(); err != nil {
-		return fmt.Errorf("failed to install hyprwayland-scanner: %w", err)
-	}
-
-	// Now build hyprpicker
-	tmpDir := filepath.Join(cacheDir, "hyprpicker-build")
-	if err := os.MkdirAll(tmpDir, 0755); err != nil {
-		return fmt.Errorf("failed to create temp directory: %w", err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.35,
-		Step:        "Cloning hyprpicker repository...",
-		IsComplete:  false,
-		CommandInfo: "git clone https://github.com/hyprwm/hyprpicker.git",
-	}
-
-	cloneCmd := exec.CommandContext(ctx, "git", "clone", "https://github.com/hyprwm/hyprpicker.git", tmpDir)
-	if err := cloneCmd.Run(); err != nil {
-		return fmt.Errorf("failed to clone hyprpicker: %w", err)
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.45,
-		Step:        "Configuring hyprpicker build...",
-		IsComplete:  false,
-		CommandInfo: "cmake -B build -S . -DCMAKE_BUILD_TYPE=Release",
-	}
-
-	configureCmd := exec.CommandContext(ctx, "cmake",
-		"--no-warn-unused-cli",
-		"-DCMAKE_BUILD_TYPE:STRING=Release",
-		"-DCMAKE_INSTALL_PREFIX:PATH=/usr",
-		"-S", ".",
-		"-B", "./build")
-	configureCmd.Dir = tmpDir
-	configureCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-
-	output, err := configureCmd.CombinedOutput()
-	if err != nil {
-		m.log(fmt.Sprintf("cmake configure failed. Output:\n%s", string(output)))
-		return fmt.Errorf("failed to configure hyprpicker: %w\nCMake output:\n%s", err, string(output))
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.55,
-		Step:        "Building hyprpicker...",
-		IsComplete:  false,
-		CommandInfo: "cmake --build build --target hyprpicker",
-	}
-
-	buildCmd := exec.CommandContext(ctx, "cmake", "--build", "./build", "--config", "Release", "--target", "hyprpicker")
-	buildCmd.Dir = tmpDir
-	buildCmd.Env = append(os.Environ(), "TMPDIR="+cacheDir)
-	if err := m.runWithProgressStep(buildCmd, progressChan, PhaseSystemPackages, 0.55, 0.8, "Building hyprpicker..."); err != nil {
-		return fmt.Errorf("failed to build hyprpicker: %w", err)
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.8,
-		Step:        "Installing hyprpicker...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: "sudo cmake --install build",
-	}
-
-	installCmd := ExecSudoCommand(ctx, sudoPassword, "cmake --install ./build")
-	installCmd.Dir = tmpDir
-	if err := installCmd.Run(); err != nil {
-		return fmt.Errorf("failed to install hyprpicker: %w", err)
-	}
-
-	m.log("hyprpicker installed successfully from source")
-	return nil
-}
-
 func (m *ManualPackageInstaller) installGhostty(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	m.log("Installing Ghostty from source...")
 
@@ -863,52 +617,6 @@ func (m *ManualPackageInstaller) installDankMaterialShell(ctx context.Context, v
 	return nil
 }
 
-func (m *ManualPackageInstaller) installCliphist(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	m.log("Installing cliphist from source...")
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.1,
-		Step:        "Installing cliphist via go install...",
-		IsComplete:  false,
-		CommandInfo: "go install go.senan.xyz/cliphist@latest",
-	}
-
-	installCmd := exec.CommandContext(ctx, "go", "install", "go.senan.xyz/cliphist@latest")
-	if err := m.runWithProgressStep(installCmd, progressChan, PhaseSystemPackages, 0.1, 0.7, "Building cliphist..."); err != nil {
-		return fmt.Errorf("failed to install cliphist: %w", err)
-	}
-
-	homeDir := os.Getenv("HOME")
-	sourcePath := filepath.Join(homeDir, "go", "bin", "cliphist")
-	targetPath := "/usr/local/bin/cliphist"
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseSystemPackages,
-		Progress:    0.7,
-		Step:        "Installing cliphist binary to system...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: fmt.Sprintf("sudo cp %s %s", sourcePath, targetPath),
-	}
-
-	copyCmd := exec.CommandContext(ctx, "sudo", "-S", "cp", sourcePath, targetPath)
-	copyCmd.Stdin = strings.NewReader(sudoPassword + "\n")
-	if err := copyCmd.Run(); err != nil {
-		return fmt.Errorf("failed to copy cliphist to /usr/local/bin: %w", err)
-	}
-
-	// Make it executable
-	chmodCmd := exec.CommandContext(ctx, "sudo", "-S", "chmod", "+x", targetPath)
-	chmodCmd.Stdin = strings.NewReader(sudoPassword + "\n")
-	if err := chmodCmd.Run(); err != nil {
-		return fmt.Errorf("failed to make cliphist executable: %w", err)
-	}
-
-	m.log("cliphist installed successfully from source")
-	return nil
-}
-
 func (m *ManualPackageInstaller) installXwaylandSatellite(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	m.log("Installing xwayland-satellite 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
@@ -79,41 +78,14 @@ func (o *OpenSUSEDistribution) DetectDependenciesWithTerminal(ctx context.Contex
 		dependencies = append(dependencies, o.detectXwaylandSatellite())
 	}
 
-	// Base detections (common across distros)
 	dependencies = append(dependencies, o.detectMatugen())
 	dependencies = append(dependencies, o.detectDgop())
-	dependencies = append(dependencies, o.detectHyprpicker())
-	dependencies = append(dependencies, o.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 func (o *OpenSUSEDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
+	return o.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", o.packageInstalled("xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (o *OpenSUSEDistribution) packageInstalled(pkg string) bool {
@@ -133,36 +105,59 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 		"ghostty":                {Name: "ghostty", Repository: RepoTypeSystem},
 		"kitty":                  {Name: "kitty", Repository: RepoTypeSystem},
 		"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},
-		"hyprpicker":             {Name: "hyprpicker", Repository: RepoTypeSystem},
 
-		// Manual builds
+		// DMS packages from OBS
-		"dms (DankMaterialShell)": {Name: "dms", Repository: RepoTypeManual, BuildFunc: "installDankMaterialShell"},
+		"dms (DankMaterialShell)": o.getDmsMapping(variants["dms (DankMaterialShell)"]),
-		"dgop":                    {Name: "dgop", Repository: RepoTypeManual, BuildFunc: "installDgop"},
+		"quickshell":              o.getQuickshellMapping(variants["quickshell"]),
-		"quickshell":              {Name: "quickshell", Repository: RepoTypeManual, BuildFunc: "installQuickshell"},
+		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
-		"matugen":                 {Name: "matugen", Repository: RepoTypeManual, BuildFunc: "installMatugen"},
+		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 	}
 
 	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:
-		packages["niri"] = PackageMapping{Name: "niri", Repository: RepoTypeSystem}
+		// Niri stable has native package support on openSUSE
-		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
+		niriVariant := variants["niri"]
+		packages["niri"] = o.getNiriMapping(niriVariant)
+		packages["xwayland-satellite"] = o.getXwaylandSatelliteMapping(niriVariant)
 	}
 
 	return packages
 }
 
+func (o *OpenSUSEDistribution) getDmsMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "dms-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:dms-git"}
+	}
+	return PackageMapping{Name: "dms", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:dms"}
+}
+
+func (o *OpenSUSEDistribution) getQuickshellMapping(variant deps.PackageVariant) PackageMapping {
+	if forceQuickshellGit || variant == deps.VariantGit {
+		return PackageMapping{Name: "quickshell-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "quickshell", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+}
+
+func (o *OpenSUSEDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "niri-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "niri", Repository: RepoTypeSystem}
+}
+
+func (o *OpenSUSEDistribution) getXwaylandSatelliteMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "xwayland-satellite-git", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"}
+	}
+	return PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
+}
+
 func (o *OpenSUSEDistribution) detectXwaylandSatellite() deps.Dependency {
 	status := deps.StatusMissing
 	if o.commandExists("xwayland-satellite") {
@@ -294,9 +289,23 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		return fmt.Errorf("failed to install prerequisites: %w", err)
 	}
 
-	systemPkgs, manualPkgs, variantMap := o.categorizePackages(dependencies, wm, reinstallFlags, disabledFlags)
+	systemPkgs, obsPkgs, manualPkgs, variantMap := o.categorizePackages(dependencies, wm, reinstallFlags, disabledFlags)
 
-	// Phase 2: System Packages (Zypper)
+	// Enable OBS repositories
+	if len(obsPkgs) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:      PhaseSystemPackages,
+			Progress:   0.15,
+			Step:       "Enabling OBS repositories...",
+			IsComplete: false,
+			LogOutput:  "Setting up OBS repositories for additional packages",
+		}
+		if err := o.enableOBSRepos(ctx, obsPkgs, sudoPassword, progressChan); err != nil {
+			return fmt.Errorf("failed to enable OBS repositories: %w", err)
+		}
+	}
+
+	// Phase 3: System Packages (Zypper)
 	if len(systemPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
 			Phase:      PhaseSystemPackages,
@@ -311,7 +320,22 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		}
 	}
 
-	// Phase 3: Manual Builds
+	// OBS Packages
+	obsPkgNames := o.extractPackageNames(obsPkgs)
+	if len(obsPkgNames) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:      PhaseAURPackages,
+			Progress:   0.65,
+			Step:       fmt.Sprintf("Installing %d OBS packages...", len(obsPkgNames)),
+			IsComplete: false,
+			LogOutput:  fmt.Sprintf("Installing OBS packages: %s", strings.Join(obsPkgNames, ", ")),
+		}
+		if err := o.installZypperPackages(ctx, obsPkgNames, sudoPassword, progressChan); err != nil {
+			return fmt.Errorf("failed to install OBS packages: %w", err)
+		}
+	}
+
+	// Manual Builds
 	if len(manualPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
 			Phase:      PhaseSystemPackages,
@@ -325,7 +349,7 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		}
 	}
 
-	// Phase 4: Configuration
+	// Configuration
 	progressChan <- InstallProgressMsg{
 		Phase:      PhaseConfiguration,
 		Progress:   0.90,
@@ -334,7 +358,20 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		LogOutput:  "Starting post-installation configuration...",
 	}
 
-	// Phase 5: Complete
+	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,
 		Progress:   1.0,
@@ -346,8 +383,9 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 	return nil
 }
 
-func (o *OpenSUSEDistribution) categorizePackages(dependencies []deps.Dependency, wm deps.WindowManager, reinstallFlags map[string]bool, disabledFlags map[string]bool) ([]string, []string, map[string]deps.PackageVariant) {
+func (o *OpenSUSEDistribution) categorizePackages(dependencies []deps.Dependency, wm deps.WindowManager, reinstallFlags map[string]bool, disabledFlags map[string]bool) ([]string, []PackageMapping, []string, map[string]deps.PackageVariant) {
 	systemPkgs := []string{}
+	obsPkgs := []PackageMapping{}
 	manualPkgs := []string{}
 
 	variantMap := make(map[string]deps.PackageVariant)
@@ -375,12 +413,80 @@ func (o *OpenSUSEDistribution) categorizePackages(dependencies []deps.Dependency
 		switch pkgInfo.Repository {
 		case RepoTypeSystem:
 			systemPkgs = append(systemPkgs, pkgInfo.Name)
+		case RepoTypeOBS:
+			obsPkgs = append(obsPkgs, pkgInfo)
 		case RepoTypeManual:
 			manualPkgs = append(manualPkgs, dep.Name)
 		}
 	}
 
-	return systemPkgs, manualPkgs, variantMap
+	return systemPkgs, obsPkgs, manualPkgs, variantMap
+}
+
+func (o *OpenSUSEDistribution) extractPackageNames(packages []PackageMapping) []string {
+	names := make([]string, len(packages))
+	for i, pkg := range packages {
+		names[i] = pkg.Name
+	}
+	return names
+}
+
+func (o *OpenSUSEDistribution) enableOBSRepos(ctx context.Context, obsPkgs []PackageMapping, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
+	enabledRepos := make(map[string]bool)
+
+	for _, pkg := range obsPkgs {
+		if pkg.RepoURL != "" && !enabledRepos[pkg.RepoURL] {
+			o.log(fmt.Sprintf("Enabling OBS repository: %s", pkg.RepoURL))
+
+			// RepoURL format: "home:AvengeMedia:danklinux"
+			repoPath := strings.ReplaceAll(pkg.RepoURL, ":", ":/")
+			repoName := strings.ReplaceAll(pkg.RepoURL, ":", "-")
+			repoURL := fmt.Sprintf("https://download.opensuse.org/repositories/%s/openSUSE_Tumbleweed/%s.repo",
+				repoPath, pkg.RepoURL)
+
+			checkCmd := exec.CommandContext(ctx, "zypper", "repos", repoName)
+			if checkCmd.Run() == nil {
+				o.log(fmt.Sprintf("OBS repo %s already exists, skipping", pkg.RepoURL))
+				enabledRepos[pkg.RepoURL] = true
+				continue
+			}
+
+			progressChan <- InstallProgressMsg{
+				Phase:       PhaseSystemPackages,
+				Progress:    0.20,
+				Step:        fmt.Sprintf("Enabling OBS repo %s...", pkg.RepoURL),
+				NeedsSudo:   true,
+				CommandInfo: fmt.Sprintf("sudo zypper addrepo %s", repoURL),
+			}
+
+			cmd := ExecSudoCommand(ctx, sudoPassword,
+				fmt.Sprintf("zypper addrepo -f %s", repoURL))
+			if err := o.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
+				o.log(fmt.Sprintf("OBS repo %s add failed (may already exist): %v", pkg.RepoURL, err))
+			}
+
+			enabledRepos[pkg.RepoURL] = true
+			o.log(fmt.Sprintf("OBS repo %s enabled successfully", pkg.RepoURL))
+		}
+	}
+
+	// Refresh repositories with GPG auto-import
+	if len(enabledRepos) > 0 {
+		progressChan <- InstallProgressMsg{
+			Phase:       PhaseSystemPackages,
+			Progress:    0.25,
+			Step:        "Refreshing repositories...",
+			NeedsSudo:   true,
+			CommandInfo: "sudo zypper --gpg-auto-import-keys refresh",
+		}
+
+		refreshCmd := ExecSudoCommand(ctx, sudoPassword, "zypper --gpg-auto-import-keys refresh")
+		if err := o.runWithProgress(refreshCmd, progressChan, PhaseSystemPackages, 0.25, 0.27); err != nil {
+			return fmt.Errorf("failed to refresh repositories: %w", err)
+		}
+	}
+
+	return nil
 }
 
 func (o *OpenSUSEDistribution) installZypperPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {

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
@@ -79,69 +76,22 @@ func (u *UbuntuDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 		dependencies = append(dependencies, u.detectXwaylandSatellite())
 	}
 
-	// Base detections (common across distros)
 	dependencies = append(dependencies, u.detectMatugen())
 	dependencies = append(dependencies, u.detectDgop())
-	dependencies = append(dependencies, u.detectHyprpicker())
-	dependencies = append(dependencies, u.detectClipboardTools()...)
 
 	return dependencies, nil
 }
 
 func (u *UbuntuDistribution) detectXDGPortal() deps.Dependency {
-	status := deps.StatusMissing
+	return u.detectPackage("xdg-desktop-portal-gtk", "Desktop integration portal for GTK", u.packageInstalled("xdg-desktop-portal-gtk"))
-	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,
-	}
 }
 
 func (u *UbuntuDistribution) detectXwaylandSatellite() deps.Dependency {
-	status := deps.StatusMissing
+	return u.detectCommand("xwayland-satellite", "Xwayland support")
-	if u.commandExists("xwayland-satellite") {
-		status = deps.StatusInstalled
-	}
-
-	return deps.Dependency{
-		Name:        "xwayland-satellite",
-		Status:      status,
-		Description: "Xwayland support",
-		Required:    true,
-	}
 }
 
 func (u *UbuntuDistribution) detectAccountsService() deps.Dependency {
-	status := deps.StatusMissing
+	return u.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", u.packageInstalled("accountsservice"))
-	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,
-	}
 }
 
 func (u *UbuntuDistribution) packageInstalled(pkg string) bool {
@@ -151,44 +101,69 @@ func (u *UbuntuDistribution) packageInstalled(pkg string) bool {
 }
 
 func (u *UbuntuDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
+	return u.GetPackageMappingWithVariants(wm, make(map[string]deps.PackageVariant))
+}
+
+func (u *UbuntuDistribution) GetPackageMappingWithVariants(wm deps.WindowManager, variants map[string]deps.PackageVariant) map[string]PackageMapping {
 	packages := map[string]PackageMapping{
 		// Standard APT packages
 		"git":                    {Name: "git", Repository: RepoTypeSystem},
 		"kitty":                  {Name: "kitty", Repository: RepoTypeSystem},
 		"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":             {Name: "hyprpicker", Repository: RepoTypePPA, RepoURL: "ppa:cppiber/hyprland"},
 
-		// Manual builds (niri and quickshell likely not available in Ubuntu repos or PPAs)
+		// DMS packages from PPAs
-		"dms (DankMaterialShell)": {Name: "dms", Repository: RepoTypeManual, BuildFunc: "installDankMaterialShell"},
+		"dms (DankMaterialShell)": u.getDmsMapping(variants["dms (DankMaterialShell)"]),
-		"niri":                    {Name: "niri", Repository: RepoTypeManual, BuildFunc: "installNiri"},
+		"quickshell":              u.getQuickshellMapping(variants["quickshell"]),
-		"quickshell":              {Name: "quickshell", Repository: RepoTypeManual, BuildFunc: "installQuickshell"},
+		"matugen":                 {Name: "matugen", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
-		"ghostty":                 {Name: "ghostty", Repository: RepoTypeManual, BuildFunc: "installGhostty"},
+		"dgop":                    {Name: "dgop", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
-		"matugen":                 {Name: "matugen", Repository: RepoTypeManual, BuildFunc: "installMatugen"},
+		"ghostty":                 {Name: "ghostty", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
-		"dgop":                    {Name: "dgop", Repository: RepoTypeManual, BuildFunc: "installDgop"},
-		"cliphist":                {Name: "cliphist", Repository: RepoTypeManual, BuildFunc: "installCliphist"},
 	}
 
 	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:
-		packages["niri"] = PackageMapping{Name: "niri", Repository: RepoTypeManual, BuildFunc: "installNiri"}
+		niriVariant := variants["niri"]
-		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeManual, BuildFunc: "installXwaylandSatellite"}
+		packages["niri"] = u.getNiriMapping(niriVariant)
+		packages["xwayland-satellite"] = u.getXwaylandSatelliteMapping(niriVariant)
 	}
 
 	return packages
 }
 
+func (u *UbuntuDistribution) getDmsMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "dms-git", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/dms-git"}
+	}
+	return PackageMapping{Name: "dms", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/dms"}
+}
+
+func (u *UbuntuDistribution) getQuickshellMapping(variant deps.PackageVariant) PackageMapping {
+	if forceQuickshellGit || variant == deps.VariantGit {
+		return PackageMapping{Name: "quickshell-git", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+	}
+	return PackageMapping{Name: "quickshell", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+}
+
+func (u *UbuntuDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "niri-git", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+	}
+	return PackageMapping{Name: "niri", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+}
+
+func (u *UbuntuDistribution) getXwaylandSatelliteMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "xwayland-satellite-git", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+	}
+	return PackageMapping{Name: "xwayland-satellite", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"}
+}
+
 func (u *UbuntuDistribution) InstallPrerequisites(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	progressChan <- InstallProgressMsg{
 		Phase:      PhasePrerequisites,
@@ -343,6 +318,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,
@@ -365,7 +353,7 @@ func (u *UbuntuDistribution) categorizePackages(dependencies []deps.Dependency,
 		variantMap[dep.Name] = dep.Variant
 	}
 
-	packageMap := u.GetPackageMapping(wm)
+	packageMap := u.GetPackageMappingWithVariants(wm, variantMap)
 
 	for _, dep := range dependencies {
 		if disabledFlags[dep.Name] {
@@ -545,14 +533,8 @@ 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":
-			// Go will be installed separately with PPA
 		}
 	}
 
@@ -562,11 +544,7 @@ 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":
+		case "dgop":
-			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)
 			}
@@ -629,40 +607,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
@@ -710,30 +654,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
@@ -743,10 +663,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

@@ -105,14 +105,19 @@ type MenuItem struct {
 
 func NewModel(version string) Model {
 	detector, _ := NewDetector()
-	dependencies := detector.GetInstalledComponents()
+	var dependencies []DependencyInfo
+	var hyprlandInstalled, niriInstalled bool
+	var err error
+	if detector != nil {
+		dependencies = detector.GetInstalledComponents()
 
-	// Use the proper detection method for both window managers
+		// Use the proper detection method for both window managers
-	hyprlandInstalled, niriInstalled, err := detector.GetWindowManagerStatus()
+		hyprlandInstalled, niriInstalled, err = detector.GetWindowManagerStatus()
-	if err != nil {
+		if err != nil {
-		// Fallback to false if detection fails
+			// Fallback to false if detection fails
-		hyprlandInstalled = false
+			hyprlandInstalled = false
-		niriInstalled = false
+			niriInstalled = false
+		}
 	}
 
 	updateToggles := make(map[string]bool)
@@ -281,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
+	var dependencies []DependencyInfo
-	hyprlandInstalled, niriInstalled, err := detector.GetWindowManagerStatus()
+	var hyprlandInstalled, niriInstalled bool
-	if err != nil {
+
-		// Fallback to false if detection fails
+	if detector != nil {
-		hyprlandInstalled = false
+		dependencies = detector.GetInstalledComponents()
-		niriInstalled = false
+		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_common.go

@@ -109,6 +109,9 @@ func (m Model) renderAboutView() string {
 
 	b.WriteString(normalStyle.Render("Components:"))
 	b.WriteString("\n")
+	if len(m.dependencies) == 0 {
+		b.WriteString(normalStyle.Render("\n  Component detection not supported on this platform."))
+	}
 	for _, dep := range m.dependencies {
 		status := "✗"
 		if dep.Status == 1 {

core/internal/dms/views_features.go

@@ -514,11 +514,11 @@ 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)
-		case "kitty", "alacritty", "ghostty", "hyprpicker":
+		case "kitty", "alacritty", "ghostty":
 			categories["Shared Components"] = append(categories["Shared Components"], dep)
 		default:
 			categories["Shared Components"] = append(categories["Shared 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,15 +16,9 @@ type DiscoveryConfig struct {
 func DefaultDiscoveryConfig() *DiscoveryConfig {
 	var searchPaths []string
 
-	configHome := os.Getenv("XDG_CONFIG_HOME")
+	configDir, err := os.UserConfigDir()
-	if configHome == "" {
+	if err == nil && configDir != "" {
-		if homeDir, err := os.UserHomeDir(); err == nil {
+		searchPaths = append(searchPaths, filepath.Join(configDir, "DankMaterialShell", "cheatsheets"))
-			configHome = filepath.Join(homeDir, ".config")
-		}
-	}
-
-	if configHome != "" {
-		searchPaths = append(searchPaths, filepath.Join(configHome, "DankMaterialShell", "cheatsheets"))
 	}
 
 	configDirs := os.Getenv("XDG_CONFIG_DIRS")
@@ -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, err := utils.ExpandPath(directory)
-	expandedDir = filepath.Clean(expandedDir)
+	if err != nil {
-	if strings.HasPrefix(expandedDir, "~") {
+		return err
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedDir = filepath.Join(home, expandedDir[1:])
 	}
 
 	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, err := utils.ExpandPath(path)
-	expandedPath = filepath.Clean(expandedPath)
+	if err != nil {
-	if strings.HasPrefix(expandedPath, "~") {
+		return err
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
 	}
 
 	info, err := os.Stat(expandedPath)

core/internal/keybinds/providers/niri.go

@@ -3,14 +3,21 @@ package providers
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
+	"github.com/sblinch/kdl-go"
+	"github.com/sblinch/kdl-go/document"
 )
 
 type NiriProvider struct {
-	configDir string
+	configDir        string
+	dmsBindsIncluded bool
+	parsed           bool
 }
 
 func NewNiriProvider(configDir string) *NiriProvider {
@@ -23,16 +30,11 @@ func NewNiriProvider(configDir string) *NiriProvider {
 }
 
 func defaultNiriConfigDir() string {
-	configHome := os.Getenv("XDG_CONFIG_HOME")
+	configDir, err := os.UserConfigDir()
-	if configHome != "" {
-		return filepath.Join(configHome, "niri")
-	}
-
-	home, err := os.UserHomeDir()
 	if err != nil {
 		return ""
 	}
-	return filepath.Join(home, ".config", "niri")
+	return filepath.Join(configDir, "niri")
 }
 
 func (n *NiriProvider) Name() string {
@@ -40,22 +42,56 @@ func (n *NiriProvider) Name() string {
 }
 
 func (n *NiriProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
-	section, err := ParseNiriKeys(n.configDir)
+	result, err := ParseNiriKeys(n.configDir)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse niri config: %w", err)
 	}
 
-	categorizedBinds := make(map[string][]keybinds.Keybind)
+	n.dmsBindsIncluded = result.DMSBindsIncluded
-	n.convertSection(section, "", categorizedBinds)
+	n.parsed = true
 
-	return &keybinds.CheatSheet{
+	categorizedBinds := make(map[string][]keybinds.Keybind)
-		Title:    "Niri Keybinds",
+	n.convertSection(result.Section, "", categorizedBinds, result.ConflictingConfigs)
-		Provider: n.Name(),
+
-		Binds:    categorizedBinds,
+	sheet := &keybinds.CheatSheet{
-	}, nil
+		Title:            "Niri Keybinds",
+		Provider:         n.Name(),
+		Binds:            categorizedBinds,
+		DMSBindsIncluded: result.DMSBindsIncluded,
+	}
+
+	if result.DMSStatus != nil {
+		sheet.DMSStatus = &keybinds.DMSBindsStatus{
+			Exists:          result.DMSStatus.Exists,
+			Included:        result.DMSStatus.Included,
+			IncludePosition: result.DMSStatus.IncludePosition,
+			TotalIncludes:   result.DMSStatus.TotalIncludes,
+			BindsAfterDMS:   result.DMSStatus.BindsAfterDMS,
+			Effective:       result.DMSStatus.Effective,
+			OverriddenBy:    result.DMSStatus.OverriddenBy,
+			StatusMessage:   result.DMSStatus.StatusMessage,
+		}
+	}
+
+	return sheet, nil
 }
 
-func (n *NiriProvider) convertSection(section *NiriSection, subcategory string, categorizedBinds map[string][]keybinds.Keybind) {
+func (n *NiriProvider) HasDMSBindsIncluded() bool {
+	if n.parsed {
+		return n.dmsBindsIncluded
+	}
+
+	result, err := ParseNiriKeys(n.configDir)
+	if err != nil {
+		return false
+	}
+
+	n.dmsBindsIncluded = result.DMSBindsIncluded
+	n.parsed = true
+	return n.dmsBindsIncluded
+}
+
+func (n *NiriProvider) convertSection(section *NiriSection, subcategory string, categorizedBinds map[string][]keybinds.Keybind, conflicts map[string]*NiriKeyBinding) {
 	currentSubcat := subcategory
 	if section.Name != "" {
 		currentSubcat = section.Name
@@ -63,12 +99,12 @@ func (n *NiriProvider) convertSection(section *NiriSection, subcategory string,
 
 	for _, kb := range section.Keybinds {
 		category := n.categorizeByAction(kb.Action)
-		bind := n.convertKeybind(&kb, currentSubcat)
+		bind := n.convertKeybind(&kb, currentSubcat, conflicts)
 		categorizedBinds[category] = append(categorizedBinds[category], bind)
 	}
 
 	for _, child := range section.Children {
-		n.convertSection(&child, currentSubcat, categorizedBinds)
+		n.convertSection(&child, currentSubcat, categorizedBinds, conflicts)
 	}
 }
 
@@ -105,27 +141,52 @@ func (n *NiriProvider) categorizeByAction(action string) string {
 	}
 }
 
-func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string) keybinds.Keybind {
+func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string, conflicts map[string]*NiriKeyBinding) keybinds.Keybind {
-	key := n.formatKey(kb)
-	desc := kb.Description
 	rawAction := n.formatRawAction(kb.Action, kb.Args)
+	keyStr := n.formatKey(kb)
 
-	if desc == "" {
+	source := "config"
-		desc = rawAction
+	if strings.Contains(kb.Source, "dms/binds.kdl") {
+		source = "dms"
 	}
 
-	return keybinds.Keybind{
+	bind := keybinds.Keybind{
-		Key:         key,
+		Key:           keyStr,
-		Description: desc,
+		Description:   kb.Description,
-		Action:      rawAction,
+		Action:        rawAction,
-		Subcategory: subcategory,
+		Subcategory:   subcategory,
+		Source:        source,
+		HideOnOverlay: kb.HideOnOverlay,
+		CooldownMs:    kb.CooldownMs,
 	}
+
+	if source == "dms" && conflicts != nil {
+		if conflictKb, ok := conflicts[keyStr]; ok {
+			bind.Conflict = &keybinds.Keybind{
+				Key:         keyStr,
+				Description: conflictKb.Description,
+				Action:      n.formatRawAction(conflictKb.Action, conflictKb.Args),
+				Source:      "config",
+			}
+		}
+	}
+
+	return bind
 }
 
 func (n *NiriProvider) formatRawAction(action string, args []string) string {
 	if len(args) == 0 {
 		return action
 	}
+
+	if action == "spawn" && len(args) >= 3 && args[1] == "-c" {
+		switch args[0] {
+		case "sh", "bash":
+			cmd := strings.Join(args[2:], " ")
+			return fmt.Sprintf("spawn %s -c \"%s\"", args[0], strings.ReplaceAll(cmd, "\"", "\\\""))
+		}
+	}
+
 	return action + " " + strings.Join(args, " ")
 }
 
@@ -135,3 +196,403 @@ func (n *NiriProvider) formatKey(kb *NiriKeyBinding) string {
 	parts = append(parts, kb.Key)
 	return strings.Join(parts, "+")
 }
+
+func (n *NiriProvider) GetOverridePath() string {
+	return filepath.Join(n.configDir, "dms", "binds.kdl")
+}
+
+func (n *NiriProvider) validateAction(action string) error {
+	action = strings.TrimSpace(action)
+	switch {
+	case action == "":
+		return fmt.Errorf("action cannot be empty")
+	case action == "spawn" || action == "spawn ":
+		return fmt.Errorf("spawn command requires arguments")
+	case strings.HasPrefix(action, "spawn "):
+		rest := strings.TrimSpace(strings.TrimPrefix(action, "spawn "))
+		switch rest {
+		case "":
+			return fmt.Errorf("spawn command requires arguments")
+		case "sh -c \"\"", "sh -c ''", "bash -c \"\"", "bash -c ''":
+			return fmt.Errorf("shell command cannot be empty")
+		}
+	}
+	return nil
+}
+
+func (n *NiriProvider) SetBind(key, action, description string, options map[string]any) error {
+	if err := n.validateAction(action); err != nil {
+		return err
+	}
+
+	overridePath := n.GetOverridePath()
+
+	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
+		return fmt.Errorf("failed to create dms directory: %w", err)
+	}
+
+	existingBinds, err := n.loadOverrideBinds()
+	if err != nil {
+		existingBinds = make(map[string]*overrideBind)
+	}
+
+	existingBinds[key] = &overrideBind{
+		Key:         key,
+		Action:      action,
+		Description: description,
+		Options:     options,
+	}
+
+	return n.writeOverrideBinds(existingBinds)
+}
+
+func (n *NiriProvider) RemoveBind(key string) error {
+	existingBinds, err := n.loadOverrideBinds()
+	if err != nil {
+		return nil
+	}
+
+	delete(existingBinds, key)
+	return n.writeOverrideBinds(existingBinds)
+}
+
+type overrideBind struct {
+	Key         string
+	Action      string
+	Description string
+	Options     map[string]any
+}
+
+func (n *NiriProvider) loadOverrideBinds() (map[string]*overrideBind, error) {
+	overridePath := n.GetOverridePath()
+	binds := make(map[string]*overrideBind)
+
+	data, err := os.ReadFile(overridePath)
+	if os.IsNotExist(err) {
+		return binds, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	parser := NewNiriParser(filepath.Dir(overridePath))
+	parser.currentSource = overridePath
+
+	doc, err := kdl.Parse(strings.NewReader(string(data)))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, node := range doc.Nodes {
+		if node.Name.String() != "binds" || node.Children == nil {
+			continue
+		}
+		for _, child := range node.Children {
+			kb := parser.parseKeybindNode(child, "")
+			if kb == nil {
+				continue
+			}
+			keyStr := parser.formatBindKey(kb)
+			binds[keyStr] = &overrideBind{
+				Key:         keyStr,
+				Action:      n.formatRawAction(kb.Action, kb.Args),
+				Description: kb.Description,
+				Options:     n.extractOptions(child),
+			}
+		}
+	}
+
+	return binds, nil
+}
+
+func (n *NiriProvider) extractOptions(node *document.Node) map[string]any {
+	if node.Properties == nil {
+		return make(map[string]any)
+	}
+
+	opts := make(map[string]any)
+	if val, ok := node.Properties.Get("repeat"); ok {
+		opts["repeat"] = val.String() == "true"
+	}
+	if val, ok := node.Properties.Get("cooldown-ms"); ok {
+		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"
+	}
+	return opts
+}
+
+func (n *NiriProvider) isRecentWindowsAction(action string) bool {
+	switch action {
+	case "next-window", "previous-window":
+		return true
+	default:
+		return false
+	}
+}
+
+func (n *NiriProvider) buildBindNode(bind *overrideBind) *document.Node {
+	node := document.NewNode()
+	node.SetName(bind.Key)
+
+	if bind.Options != nil {
+		if v, ok := bind.Options["repeat"]; ok && v == false {
+			node.AddProperty("repeat", false, "")
+		}
+		if v, ok := bind.Options["cooldown-ms"]; ok {
+			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, "")
+		}
+	}
+
+	if bind.Description != "" {
+		node.AddProperty("hotkey-overlay-title", bind.Description, "")
+	}
+
+	actionNode := n.buildActionNode(bind.Action)
+	node.AddNode(actionNode)
+
+	return node
+}
+
+func (n *NiriProvider) buildActionNode(action string) *document.Node {
+	action = strings.TrimSpace(action)
+	node := document.NewNode()
+
+	parts := n.parseActionParts(action)
+	if len(parts) == 0 {
+		node.SetName(action)
+		return node
+	}
+
+	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)
+
+	if err := n.validateBindsContent(content); err != nil {
+		return err
+	}
+
+	return os.WriteFile(overridePath, []byte(content), 0644)
+}
+
+func (n *NiriProvider) getBindSortPriority(action string) int {
+	switch {
+	case strings.HasPrefix(action, "spawn") && strings.Contains(action, "dms"):
+		return 0
+	case strings.Contains(action, "workspace"):
+		return 1
+	case strings.Contains(action, "window") || strings.Contains(action, "column") ||
+		strings.Contains(action, "focus") || strings.Contains(action, "move") ||
+		strings.Contains(action, "swap") || strings.Contains(action, "resize"):
+		return 2
+	case strings.HasPrefix(action, "focus-monitor") || strings.Contains(action, "monitor"):
+		return 3
+	case strings.Contains(action, "screenshot"):
+		return 4
+	case action == "quit" || action == "power-off-monitors" || strings.Contains(action, "dpms"):
+		return 5
+	case strings.HasPrefix(action, "spawn"):
+		return 6
+	default:
+		return 7
+	}
+}
+
+const dmsWarningHeader = `// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+`
+
+func (n *NiriProvider) generateBindsContent(binds map[string]*overrideBind) string {
+	if len(binds) == 0 {
+		return dmsWarningHeader + "binds {}\n"
+	}
+
+	var regularBinds, recentWindowsBinds []*overrideBind
+	for _, bind := range binds {
+		switch {
+		case n.isRecentWindowsAction(bind.Action):
+			recentWindowsBinds = append(recentWindowsBinds, bind)
+		default:
+			regularBinds = append(regularBinds, bind)
+		}
+	}
+
+	sort.Slice(regularBinds, func(i, j int) bool {
+		pi, pj := n.getBindSortPriority(regularBinds[i].Action), n.getBindSortPriority(regularBinds[j].Action)
+		if pi != pj {
+			return pi < pj
+		}
+		return regularBinds[i].Key < regularBinds[j].Key
+	})
+
+	sort.Slice(recentWindowsBinds, func(i, j int) bool {
+		return recentWindowsBinds[i].Key < recentWindowsBinds[j].Key
+	})
+
+	var sb strings.Builder
+
+	sb.WriteString(dmsWarningHeader)
+	sb.WriteString("binds {\n")
+	for _, bind := range regularBinds {
+		n.writeBindNode(&sb, bind, "    ")
+	}
+	sb.WriteString("}\n")
+
+	if len(recentWindowsBinds) > 0 {
+		sb.WriteString("\nrecent-windows {\n")
+		sb.WriteString("    binds {\n")
+		for _, bind := range recentWindowsBinds {
+			n.writeBindNode(&sb, bind, "        ")
+		}
+		sb.WriteString("    }\n")
+		sb.WriteString("}\n")
+	}
+
+	return sb.String()
+}
+
+func (n *NiriProvider) writeBindNode(sb *strings.Builder, bind *overrideBind, indent string) {
+	node := n.buildBindNode(bind)
+
+	sb.WriteString(indent)
+	sb.WriteString(node.Name.String())
+
+	if node.Properties.Exist() {
+		sb.WriteString(" ")
+		sb.WriteString(strings.TrimLeft(node.Properties.String(), " "))
+	}
+
+	sb.WriteString(" { ")
+	if len(node.Children) > 0 {
+		child := node.Children[0]
+		actionName := child.Name.String()
+		sb.WriteString(actionName)
+		forceQuote := actionName == "spawn"
+		for _, arg := range child.Arguments {
+			sb.WriteString(" ")
+			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) 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 {
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.WriteString(content); err != nil {
+		tmpFile.Close()
+		return fmt.Errorf("failed to write temp file: %w", err)
+	}
+	tmpFile.Close()
+
+	cmd := exec.Command("niri", "validate", "-c", tmpFile.Name())
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("invalid config: %s", strings.TrimSpace(string(output)))
+	}
+
+	return 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,11 +12,14 @@ import (
 )
 
 type NiriKeyBinding struct {
-	Mods        []string
+	Mods          []string
-	Key         string
+	Key           string
-	Action      string
+	Action        string
-	Args        []string
+	Args          []string
-	Description string
+	Description   string
+	HideOnOverlay bool
+	CooldownMs    int
+	Source        string
 }
 
 type NiriSection struct {
@@ -25,32 +29,78 @@ type NiriSection struct {
 }
 
 type NiriParser struct {
-	configDir      string
+	configDir          string
-	processedFiles map[string]bool
+	processedFiles     map[string]bool
-	bindMap        map[string]*NiriKeyBinding
+	bindMap            map[string]*NiriKeyBinding
-	bindOrder      []string
+	bindOrder          []string
+	currentSource      string
+	dmsBindsIncluded   bool
+	dmsBindsExists     bool
+	includeCount       int
+	dmsIncludePos      int
+	bindsBeforeDMS     int
+	bindsAfterDMS      int
+	dmsBindKeys        map[string]bool
+	configBindKeys     map[string]bool
+	dmsProcessed       bool
+	dmsBindMap         map[string]*NiriKeyBinding
+	conflictingConfigs map[string]*NiriKeyBinding
 }
 
 func NewNiriParser(configDir string) *NiriParser {
 	return &NiriParser{
-		configDir:      configDir,
+		configDir:          configDir,
-		processedFiles: make(map[string]bool),
+		processedFiles:     make(map[string]bool),
-		bindMap:        make(map[string]*NiriKeyBinding),
+		bindMap:            make(map[string]*NiriKeyBinding),
-		bindOrder:      []string{},
+		bindOrder:          []string{},
+		currentSource:      "",
+		dmsIncludePos:      -1,
+		dmsBindKeys:        make(map[string]bool),
+		configBindKeys:     make(map[string]bool),
+		dmsBindMap:         make(map[string]*NiriKeyBinding),
+		conflictingConfigs: make(map[string]*NiriKeyBinding),
 	}
 }
 
 func (p *NiriParser) Parse() (*NiriSection, error) {
+	dmsBindsPath := filepath.Join(p.configDir, "dms", "binds.kdl")
+	if _, err := os.Stat(dmsBindsPath); err == nil {
+		p.dmsBindsExists = true
+	}
+
 	configPath := filepath.Join(p.configDir, "config.kdl")
 	section, err := p.parseFile(configPath, "")
 	if err != nil {
 		return nil, err
 	}
 
+	if p.dmsBindsExists && !p.dmsProcessed {
+		p.parseDMSBindsDirectly(dmsBindsPath, section)
+	}
+
 	section.Keybinds = p.finalizeBinds()
 	return section, nil
 }
 
+func (p *NiriParser) parseDMSBindsDirectly(dmsBindsPath string, section *NiriSection) {
+	data, err := os.ReadFile(dmsBindsPath)
+	if err != nil {
+		return
+	}
+
+	doc, err := kdl.Parse(strings.NewReader(string(data)))
+	if err != nil {
+		return
+	}
+
+	prevSource := p.currentSource
+	p.currentSource = dmsBindsPath
+	baseDir := filepath.Dir(dmsBindsPath)
+	p.processNodes(doc.Nodes, section, baseDir)
+	p.currentSource = prevSource
+	p.dmsProcessed = true
+}
+
 func (p *NiriParser) finalizeBinds() []NiriKeyBinding {
 	binds := make([]NiriKeyBinding, 0, len(p.bindOrder))
 	for _, key := range p.bindOrder {
@@ -63,6 +113,20 @@ func (p *NiriParser) finalizeBinds() []NiriKeyBinding {
 
 func (p *NiriParser) addBind(kb *NiriKeyBinding) {
 	key := p.formatBindKey(kb)
+	isDMSBind := strings.Contains(kb.Source, "dms/binds.kdl")
+
+	if isDMSBind {
+		p.dmsBindKeys[key] = true
+		p.dmsBindMap[key] = kb
+	} else if p.dmsBindKeys[key] {
+		p.bindsAfterDMS++
+		p.conflictingConfigs[key] = kb
+		p.configBindKeys[key] = true
+		return
+	} else {
+		p.configBindKeys[key] = true
+	}
+
 	if _, exists := p.bindMap[key]; !exists {
 		p.bindOrder = append(p.bindOrder, key)
 	}
@@ -101,8 +165,11 @@ func (p *NiriParser) parseFile(filePath, sectionName string) (*NiriSection, erro
 		Name: sectionName,
 	}
 
+	prevSource := p.currentSource
+	p.currentSource = absPath
 	baseDir := filepath.Dir(absPath)
 	p.processNodes(doc.Nodes, section, baseDir)
+	p.currentSource = prevSource
 
 	return section, nil
 }
@@ -127,14 +194,23 @@ func (p *NiriParser) handleInclude(node *document.Node, section *NiriSection, ba
 		return
 	}
 
-	includePath := node.Arguments[0].String()
+	includePath := strings.Trim(node.Arguments[0].String(), "\"")
-	includePath = strings.Trim(includePath, "\"")
+	isDMSInclude := includePath == "dms/binds.kdl" || strings.HasSuffix(includePath, "/dms/binds.kdl")
 
-	var fullPath string
+	p.includeCount++
+	if isDMSInclude {
+		p.dmsBindsIncluded = true
+		p.dmsIncludePos = p.includeCount
+		p.bindsBeforeDMS = len(p.bindMap)
+	}
+
+	fullPath := filepath.Join(baseDir, includePath)
 	if filepath.IsAbs(includePath) {
 		fullPath = includePath
-	} else {
+	}
-		fullPath = filepath.Join(baseDir, includePath)
+
+	if isDMSInclude {
+		p.dmsProcessed = true
 	}
 
 	includedSection, err := p.parseFile(fullPath, "")
@@ -145,6 +221,10 @@ func (p *NiriParser) handleInclude(node *document.Node, section *NiriSection, ba
 	section.Children = append(section.Children, includedSection.Children...)
 }
 
+func (p *NiriParser) HasDMSBindsIncluded() bool {
+	return p.dmsBindsIncluded
+}
+
 func (p *NiriParser) handleRecentWindows(node *document.Node, section *NiriSection) {
 	if node.Children == nil {
 		return
@@ -172,7 +252,7 @@ func (p *NiriParser) extractBinds(node *document.Node, section *NiriSection, sub
 	}
 }
 
-func (p *NiriParser) parseKeybindNode(node *document.Node, subcategory string) *NiriKeyBinding {
+func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBinding {
 	keyCombo := node.Name.String()
 	if keyCombo == "" {
 		return nil
@@ -182,48 +262,117 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, subcategory string) *
 
 	var action string
 	var args []string
-
 	if len(node.Children) > 0 {
 		actionNode := node.Children[0]
 		action = actionNode.Name.String()
 		for _, arg := range actionNode.Arguments {
-			args = append(args, strings.Trim(arg.String(), "\""))
+			args = append(args, arg.ValueString())
+		}
+		if actionNode.Properties != nil {
+			if val, ok := actionNode.Properties.Get("focus"); ok {
+				args = append(args, "focus="+val.String())
+			}
 		}
 	}
 
-	description := ""
+	var description string
+	var hideOnOverlay bool
+	var cooldownMs int
 	if node.Properties != nil {
 		if val, ok := node.Properties.Get("hotkey-overlay-title"); ok {
-			description = strings.Trim(val.String(), "\"")
+			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,
+		Mods:          mods,
-		Key:         key,
+		Key:           key,
-		Action:      action,
+		Action:        action,
-		Args:        args,
+		Args:          args,
-		Description: description,
+		Description:   description,
+		HideOnOverlay: hideOnOverlay,
+		CooldownMs:    cooldownMs,
+		Source:        p.currentSource,
 	}
 }
 
 func (p *NiriParser) parseKeyCombo(combo string) ([]string, string) {
 	parts := strings.Split(combo, "+")
-	if len(parts) == 0 {
+
+	switch len(parts) {
+	case 0:
 		return nil, combo
-	}
+	case 1:
-
-	if len(parts) == 1 {
 		return nil, parts[0]
+	default:
+		return parts[:len(parts)-1], parts[len(parts)-1]
+	}
+}
+
+type NiriParseResult struct {
+	Section            *NiriSection
+	DMSBindsIncluded   bool
+	DMSStatus          *DMSBindsStatusInfo
+	ConflictingConfigs map[string]*NiriKeyBinding
+}
+
+type DMSBindsStatusInfo struct {
+	Exists          bool
+	Included        bool
+	IncludePosition int
+	TotalIncludes   int
+	BindsAfterDMS   int
+	Effective       bool
+	OverriddenBy    int
+	StatusMessage   string
+}
+
+func (p *NiriParser) buildDMSStatus() *DMSBindsStatusInfo {
+	status := &DMSBindsStatusInfo{
+		Exists:          p.dmsBindsExists,
+		Included:        p.dmsBindsIncluded,
+		IncludePosition: p.dmsIncludePos,
+		TotalIncludes:   p.includeCount,
+		BindsAfterDMS:   p.bindsAfterDMS,
 	}
 
-	mods := parts[:len(parts)-1]
+	switch {
-	key := parts[len(parts)-1]
+	case !p.dmsBindsExists:
+		status.Effective = false
+		status.StatusMessage = "dms/binds.kdl does not exist"
+	case !p.dmsBindsIncluded:
+		status.Effective = false
+		status.StatusMessage = "dms/binds.kdl is not included in config.kdl"
+	case p.bindsAfterDMS > 0:
+		status.Effective = true
+		status.OverriddenBy = p.bindsAfterDMS
+		status.StatusMessage = "Some DMS binds may be overridden by config binds"
+	default:
+		status.Effective = true
+		status.StatusMessage = "DMS binds are active"
+	}
 
-	return mods, key
+	return status
 }
 
-func ParseNiriKeys(configDir string) (*NiriSection, error) {
+func ParseNiriKeys(configDir string) (*NiriParseResult, error) {
 	parser := NewNiriParser(configDir)
-	return parser.Parse()
+	section, err := parser.Parse()
+	if err != nil {
+		return nil, err
+	}
+	return &NiriParseResult{
+		Section:            section,
+		DMSBindsIncluded:   parser.HasDMSBindsIncluded(),
+		DMSStatus:          parser.buildDMSStatus(),
+		ConflictingConfigs: parser.conflictingConfigs,
+	}, nil
 }

core/internal/keybinds/providers/niri_parser_test.go

@@ -57,20 +57,20 @@ func TestNiriParseBasicBinds(t *testing.T) {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 3 {
+	if len(result.Section.Keybinds) != 3 {
-		t.Errorf("Expected 3 keybinds, got %d", len(section.Keybinds))
+		t.Errorf("Expected 3 keybinds, got %d", len(result.Section.Keybinds))
 	}
 
 	foundClose := false
 	foundFullscreen := false
 	foundTerminal := false
 
-	for _, kb := range section.Keybinds {
+	for _, kb := range result.Section.Keybinds {
 		switch kb.Action {
 		case "close-window":
 			foundClose = true
@@ -116,19 +116,19 @@ func TestNiriParseRecentWindows(t *testing.T) {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 2 {
+	if len(result.Section.Keybinds) != 2 {
-		t.Errorf("Expected 2 keybinds from recent-windows, got %d", len(section.Keybinds))
+		t.Errorf("Expected 2 keybinds from recent-windows, got %d", len(result.Section.Keybinds))
 	}
 
 	foundNext := false
 	foundPrev := false
 
-	for _, kb := range section.Keybinds {
+	for _, kb := range result.Section.Keybinds {
 		switch kb.Action {
 		case "next-window":
 			foundNext = true
@@ -172,13 +172,13 @@ include "dms/binds.kdl"
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 2 {
+	if len(result.Section.Keybinds) != 2 {
-		t.Errorf("Expected 2 keybinds (1 main + 1 include), got %d", len(section.Keybinds))
+		t.Errorf("Expected 2 keybinds (1 main + 1 include), got %d", len(result.Section.Keybinds))
 	}
 }
 
@@ -209,17 +209,17 @@ include "dms/binds.kdl"
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 1 {
+	if len(result.Section.Keybinds) != 1 {
-		t.Errorf("Expected 1 keybind (later overrides earlier), got %d", len(section.Keybinds))
+		t.Errorf("Expected 1 keybind (later overrides earlier), got %d", len(result.Section.Keybinds))
 	}
 
-	if len(section.Keybinds) > 0 {
+	if len(result.Section.Keybinds) > 0 {
-		kb := section.Keybinds[0]
+		kb := result.Section.Keybinds[0]
 		if kb.Description != "Override Terminal" {
 			t.Errorf("Expected description 'Override Terminal' (from include), got %q", kb.Description)
 		}
@@ -253,13 +253,13 @@ include "config.kdl"
 		t.Fatalf("Failed to write other config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed (should handle circular includes): %v", err)
 	}
 
-	if len(section.Keybinds) != 2 {
+	if len(result.Section.Keybinds) != 2 {
-		t.Errorf("Expected 2 keybinds (circular include handled), got %d", len(section.Keybinds))
+		t.Errorf("Expected 2 keybinds (circular include handled), got %d", len(result.Section.Keybinds))
 	}
 }
 
@@ -276,13 +276,13 @@ include "nonexistent/file.kdl"
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed (should skip missing include): %v", err)
 	}
 
-	if len(section.Keybinds) != 1 {
+	if len(result.Section.Keybinds) != 1 {
-		t.Errorf("Expected 1 keybind (missing include skipped), got %d", len(section.Keybinds))
+		t.Errorf("Expected 1 keybind (missing include skipped), got %d", len(result.Section.Keybinds))
 	}
 }
 
@@ -305,13 +305,13 @@ input {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 0 {
+	if len(result.Section.Keybinds) != 0 {
-		t.Errorf("Expected 0 keybinds, got %d", len(section.Keybinds))
+		t.Errorf("Expected 0 keybinds, got %d", len(result.Section.Keybinds))
 	}
 }
 
@@ -352,18 +352,18 @@ func TestNiriBindOverrideBehavior(t *testing.T) {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 3 {
+	if len(result.Section.Keybinds) != 3 {
-		t.Fatalf("Expected 3 unique keybinds, got %d", len(section.Keybinds))
+		t.Fatalf("Expected 3 unique keybinds, got %d", len(result.Section.Keybinds))
 	}
 
 	var modT *NiriKeyBinding
-	for i := range section.Keybinds {
+	for i := range result.Section.Keybinds {
-		kb := &section.Keybinds[i]
+		kb := &result.Section.Keybinds[i]
 		if len(kb.Mods) == 1 && kb.Mods[0] == "Mod" && kb.Key == "T" {
 			modT = kb
 			break
@@ -416,18 +416,18 @@ binds {
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 4 {
+	if len(result.Section.Keybinds) != 4 {
-		t.Errorf("Expected 4 unique keybinds, got %d", len(section.Keybinds))
+		t.Errorf("Expected 4 unique keybinds, got %d", len(result.Section.Keybinds))
 	}
 
 	bindMap := make(map[string]*NiriKeyBinding)
-	for i := range section.Keybinds {
+	for i := range result.Section.Keybinds {
-		kb := &section.Keybinds[i]
+		kb := &result.Section.Keybinds[i]
 		key := ""
 		for _, m := range kb.Mods {
 			key += m + "+"
@@ -475,16 +475,16 @@ func TestNiriParseMultipleArgs(t *testing.T) {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
-	section, err := ParseNiriKeys(tmpDir)
+	result, err := ParseNiriKeys(tmpDir)
 	if err != nil {
 		t.Fatalf("ParseNiriKeys failed: %v", err)
 	}
 
-	if len(section.Keybinds) != 1 {
+	if len(result.Section.Keybinds) != 1 {
-		t.Fatalf("Expected 1 keybind, got %d", len(section.Keybinds))
+		t.Fatalf("Expected 1 keybind, got %d", len(result.Section.Keybinds))
 	}
 
-	kb := section.Keybinds[0]
+	kb := result.Section.Keybinds[0]
 	if len(kb.Args) != 5 {
 		t.Errorf("Expected 5 args, got %d: %v", len(kb.Args), kb.Args)
 	}
@@ -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

@@ -6,6 +6,13 @@ import (
 	"testing"
 )
 
+const testHeader = `// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+`
+
 func TestNiriProviderName(t *testing.T) {
 	provider := NewNiriProvider("")
 	if provider.Name() != "niri" {
@@ -186,6 +193,144 @@ func TestNiriDefaultConfigDir(t *testing.T) {
 	}
 }
 
+func TestNiriGenerateBindsContent(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	tests := []struct {
+		name     string
+		binds    map[string]*overrideBind
+		expected string
+	}{
+		{
+			name:     "empty binds",
+			binds:    map[string]*overrideBind{},
+			expected: testHeader + "binds {}\n",
+		},
+		{
+			name: "simple spawn bind",
+			binds: map[string]*overrideBind{
+				"Mod+T": {
+					Key:         "Mod+T",
+					Action:      "spawn kitty",
+					Description: "Open Terminal",
+				},
+			},
+			expected: testHeader + `binds {
+    Mod+T hotkey-overlay-title="Open Terminal" { spawn "kitty"; }
+}
+`,
+		},
+		{
+			name: "spawn with multiple args",
+			binds: map[string]*overrideBind{
+				"Mod+Space": {
+					Key:         "Mod+Space",
+					Action:      `spawn "dms" "ipc" "call" "spotlight" "toggle"`,
+					Description: "Application Launcher",
+				},
+			},
+			expected: testHeader + `binds {
+    Mod+Space hotkey-overlay-title="Application Launcher" { spawn "dms" "ipc" "call" "spotlight" "toggle"; }
+}
+`,
+		},
+		{
+			name: "bind with allow-when-locked",
+			binds: map[string]*overrideBind{
+				"XF86AudioMute": {
+					Key:     "XF86AudioMute",
+					Action:  `spawn "dms" "ipc" "call" "audio" "mute"`,
+					Options: map[string]any{"allow-when-locked": true},
+				},
+			},
+			expected: testHeader + `binds {
+    XF86AudioMute allow-when-locked=true { spawn "dms" "ipc" "call" "audio" "mute"; }
+}
+`,
+		},
+		{
+			name: "simple action without args",
+			binds: map[string]*overrideBind{
+				"Mod+Q": {
+					Key:         "Mod+Q",
+					Action:      "close-window",
+					Description: "Close Window",
+				},
+			},
+			expected: testHeader + `binds {
+    Mod+Q hotkey-overlay-title="Close Window" { close-window; }
+}
+`,
+		},
+		{
+			name: "recent-windows action",
+			binds: map[string]*overrideBind{
+				"Alt+Tab": {
+					Key:    "Alt+Tab",
+					Action: "next-window",
+				},
+			},
+			expected: testHeader + `binds {
+}
+
+recent-windows {
+    binds {
+        Alt+Tab { next-window; }
+    }
+}
+`,
+		},
+	}
+
+	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 TestNiriGenerateBindsContentRoundTrip(t *testing.T) {
+	provider := NewNiriProvider("")
+
+	binds := map[string]*overrideBind{
+		"Mod+Space": {
+			Key:         "Mod+Space",
+			Action:      `spawn "dms" "ipc" "call" "spotlight" "toggle"`,
+			Description: "Application Launcher",
+		},
+		"XF86AudioMute": {
+			Key:     "XF86AudioMute",
+			Action:  `spawn "dms" "ipc" "call" "audio" "mute"`,
+			Options: map[string]any{"allow-when-locked": true},
+		},
+		"Mod+Q": {
+			Key:         "Mod+Q",
+			Action:      "close-window",
+			Description: "Close Window",
+		},
+	}
+
+	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) != 3 {
+		t.Errorf("Expected 3 keybinds after round-trip, got %d", len(result.Section.Keybinds))
+	}
+}
+
 func TestNiriProviderWithRealWorldConfig(t *testing.T) {
 	tmpDir := t.TempDir()
 	configFile := filepath.Join(tmpDir, "config.kdl")
@@ -259,3 +404,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: testHeader + `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: testHeader + `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: testHeader + `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: testHeader + `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 := testHeader + `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 := testHeader + `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 := testHeader + `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, err := utils.ExpandPath(path)
-	expandedPath = filepath.Clean(expandedPath)
+	if err != nil {
-	if strings.HasPrefix(expandedPath, "~") {
+		return err
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return err
-		}
-		expandedPath = filepath.Join(home, expandedPath[1:])
 	}
 
 	info, err := os.Stat(expandedPath)

core/internal/keybinds/types.go

@@ -1,19 +1,43 @@
 package keybinds
 
 type Keybind struct {
-	Key         string `json:"key"`
+	Key           string   `json:"key"`
-	Description string `json:"desc"`
+	Description   string   `json:"desc"`
-	Action      string `json:"action,omitempty"`
+	Action        string   `json:"action,omitempty"`
-	Subcategory string `json:"subcat,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 {
+	Exists          bool   `json:"exists"`
+	Included        bool   `json:"included"`
+	IncludePosition int    `json:"includePosition"`
+	TotalIncludes   int    `json:"totalIncludes"`
+	BindsAfterDMS   int    `json:"bindsAfterDms"`
+	Effective       bool   `json:"effective"`
+	OverriddenBy    int    `json:"overriddenBy"`
+	StatusMessage   string `json:"statusMessage"`
 }
 
 type CheatSheet struct {
-	Title    string               `json:"title"`
+	Title            string               `json:"title"`
-	Provider string               `json:"provider"`
+	Provider         string               `json:"provider"`
-	Binds    map[string][]Keybind `json:"binds"`
+	Binds            map[string][]Keybind `json:"binds"`
+	DMSBindsIncluded bool                 `json:"dmsBindsIncluded"`
+	DMSStatus        *DMSBindsStatus      `json:"dmsStatus,omitempty"`
 }
 
 type Provider interface {
 	Name() string
 	GetCheatSheet() (*CheatSheet, error)
 }
+
+type WritableProvider interface {
+	Provider
+	SetBind(key, action, description string, options map[string]any) error
+	RemoveBind(key string) error
+	GetOverridePath() string
+}

core/internal/matugen/matugen.go

@@ -0,0 +1,628 @@
+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
+	SkipTemplates       string
+}
+
+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 (o *Options) ShouldSkipTemplate(name string) bool {
+	if o.SkipTemplates == "" {
+		return false
+	}
+	for _, skip := range strings.Split(o.SkipTemplates, ",") {
+		if strings.TrimSpace(skip) == name {
+			return true
+		}
+	}
+	return false
+}
+
+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())
+
+	if !opts.ShouldSkipTemplate("gtk") {
+		switch opts.Mode {
+		case "light":
+			appendConfig(opts, cfgFile, "skip", "gtk3-light.toml")
+		default:
+			appendConfig(opts, cfgFile, "skip", "gtk3-dark.toml")
+		}
+	}
+
+	if !opts.ShouldSkipTemplate("niri") {
+		appendConfig(opts, cfgFile, "niri", "niri.toml")
+	}
+	if !opts.ShouldSkipTemplate("qt5ct") {
+		appendConfig(opts, cfgFile, "qt5ct", "qt5ct.toml")
+	}
+	if !opts.ShouldSkipTemplate("qt6ct") {
+		appendConfig(opts, cfgFile, "qt6ct", "qt6ct.toml")
+	}
+	if !opts.ShouldSkipTemplate("firefox") {
+		appendConfig(opts, cfgFile, "firefox", "firefox.toml")
+	}
+	if !opts.ShouldSkipTemplate("pywalfox") {
+		appendConfig(opts, cfgFile, "pywalfox", "pywalfox.toml")
+	}
+	if !opts.ShouldSkipTemplate("vesktop") {
+		appendConfig(opts, cfgFile, "vesktop", "vesktop.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("ghostty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "ghostty", "ghostty.toml")
+	}
+	if !opts.ShouldSkipTemplate("kitty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "kitty", "kitty.toml")
+	}
+	if !opts.ShouldSkipTemplate("foot") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "foot", "foot.toml")
+	}
+	if !opts.ShouldSkipTemplate("alacritty") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "alacritty", "alacritty.toml")
+	}
+	if !opts.ShouldSkipTemplate("wezterm") {
+		appendTerminalConfig(opts, cfgFile, tmpDir, "wezterm", "wezterm.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("dgop") {
+		appendConfig(opts, cfgFile, "dgop", "dgop.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("kcolorscheme") {
+		appendConfig(opts, cfgFile, "skip", "kcolorscheme.toml")
+	}
+
+	if !opts.ShouldSkipTemplate("vscode") {
+		homeDir, _ := os.UserHomeDir()
+		appendVSCodeConfig(cfgFile, "vscode", filepath.Join(homeDir, ".vscode/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "codium", filepath.Join(homeDir, ".vscode-oss/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "codeoss", filepath.Join(homeDir, ".config/Code - OSS/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "cursor", filepath.Join(homeDir, ".cursor/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+		appendVSCodeConfig(cfgFile, "windsurf", filepath.Join(homeDir, ".windsurf/extensions/local.dynamic-base16-dankshell-0.0.1"), opts.ShellDir)
+	}
+
+	if opts.RunUserTemplates {
+		if data, err := os.ReadFile(userConfigPath); err == nil {
+			templatesSection := extractTOMLSection(string(data), "[templates]", "")
+			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
+}