labwc patch (#1391)

* niri: Handle new Cast events

* bar: Add screen sharing indicator

Configurable like other icons; on by default.

* lockscreen: Add screen sharing indicator

.agents/settings.local.json

@@ -1,57 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(cat:*)",
-      "Bash(git -C /home/purian23/dms diff --stat .github/workflows/)",
-      "Bash(git -C /home/purian23/projects/danklinux diff --stat .github/workflows/)",
-      "Bash(git -C /home/purian23/dms diff .github/workflows/)",
-      "Bash(git -C /home/purian23/dms diff .github/workflows/run-ppa.yml)",
-      "Bash(osc cat:*)",
-      "Bash(ls:*)",
-      "Bash(find:*)",
-      "Bash(git show-ref:*)",
-      "Bash(git tag:*)",
-      "Bash(bash -c 'ALL_PATHS=$(grep -A 5 \"\"<service name=\\\"\"download_url\\\"\">\"\" distro/debian/dms/_service | grep \"\"<param name=\\\"\"path\\\"\">\"\" | sed \"\"s/.*<param name=\\\"\"path\\\"\">\\(.*\\)<\\/param>.*/\\1/\"\"); SOURCE_PATH=\"\"\"\"; for path in $ALL_PATHS; do if echo \"\"$path\"\" | grep -qE \"\"(source|archive|\\.tar\\.(gz|xz|bz2))\"\" && ! echo \"\"$path\"\" | grep -qE \"\"(distropkg|binary)\"\"; then SOURCE_PATH=\"\"$path\"\"; break; fi; done; echo \"\"Selected path: $SOURCE_PATH\"\"')",
-      "Bash(curl:*)",
-      "Bash(tar:*)",
-      "Bash(git -C /home/purian23/dms log:*)",
-      "Bash(osc status:*)",
-      "Bash(osc commit:*)",
-      "Bash(osc up:*)",
-      "Bash(osc results:*)",
-      "Bash(osc api:*)",
-      "Bash(systemctl:*)",
-      "Bash(dms version:*)",
-      "Bash(git describe:*)",
-      "Bash(qmlsc:*)",
-      "Bash(qmllint-qt6:*)",
-      "Bash(make fmt:*)",
-      "Bash(make test:*)",
-      "Bash(dms chroma list-styles:*)",
-      "Bash(python3:*)",
-      "Bash(time dms chroma:*)",
-      "Bash(dms chroma:*)",
-      "Bash(make build:*)",
-      "Bash(pgrep:*)",
-      "Bash(go build:*)",
-      "Bash(/tmp/dms-test chroma:*)",
-      "Bash(1)",
-      "Bash(go install:*)",
-      "Bash(grep:*)",
-      "Bash(journalctl:*)",
-      "Bash(qdbus:*)",
-      "Bash(TZ='Asia/Tokyo' date:*)",
-      "Bash(dms --help:*)",
-      "Bash(dms run:*)",
-      "Bash(dms status:*)",
-      "Bash(dms kill:*)",
-      "Bash(tee:*)",
-      "Bash(qmlscene:*)",
-      "Bash(quickshell --version:*)",
-      "WebFetch(domain:forum.qt.io)",
-      "Bash(gh api:*)",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:raw.githubusercontent.com)"
-    ]
-  }
-}

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -8,31 +8,31 @@ body:
       value: |
         ## DankMaterialShell Bug Report
         Limit your report to one issue per submission unless closely related
-  - type: dropdown
+  - type: checkboxes
     id: compositor
     attributes:
       label: Compositor
       options:
-        - Niri
-        - Hyprland
-        - MangoWC (dwl)
-        - Sway
+        - label: Niri
+        - label: Hyprland
+        - label: MangoWC (dwl)
+        - label: Sway
     validations:
       required: true
-  - type: dropdown
+  - type: checkboxes
     id: distribution
     attributes:
       label: Distribution
       options:
-        - Arch Linux
-        - CachyOS
-        - Fedora
-        - NixOS
-        - Debian
-        - Ubuntu
-        - Gentoo
-        - OpenSUSE
-        - Other (specify below)
+        - label: Arch Linux
+        - label: CachyOS
+        - label: Fedora
+        - label: NixOS
+        - label: Debian
+        - label: Ubuntu
+        - label: Gentoo
+        - label: OpenSUSE
+        - label: Other (specify below)
     validations:
       required: true
   - type: input
@@ -42,45 +42,12 @@ body:
       placeholder: e.g., PikaOS, Void Linux, etc.
     validations:
       required: false
-  - type: dropdown
-    id: installation_method
-    attributes:
-      label: Select your Installation Method
-      options:
-        - DankInstaller
-        - Distro Packaging
-        - Source
-    validations:
-      required: true
-  - type: dropdown
-    id: original_installation_method_different
-    attributes:
-      label: Was your original Installation method different?
-      options:
-        - "Yes"
-        - No (specify below)
-      default: 0
-    validations:
-      required: false
   - type: input
-    id: original_installation_method_specify
+    id: dms_version
     attributes:
-      label: If no, specify
-      placeholder: e.g., Distro Packaging, then Source
-    validations:
-      required: false
-  - type: textarea
-    id: dms_doctor
-    attributes:
-      label: dms doctor -vC
-      description: Output of `dms doctor -vC` command — paste between the lines below to keep it collapsed in the issue
-      placeholder: Paste the output of `dms doctor -vC` here
-      value: |
-        <details>
-        <summary>Click to expand</summary>
-
-
-        </details>
+      label: dms version
+      description: Output of dms version command
+      placeholder: e.g., 1.2.3
     validations:
       required: true
   - type: textarea
@@ -102,7 +69,7 @@ body:
   - type: textarea
     id: steps_to_reproduce
     attributes:
-      label: Steps to Reproduce
+      label: Steps to Reproduce & Installation Method
       description: Please provide detailed steps to reproduce the issue
       placeholder: |
         1. ...

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,5 +1,5 @@
 name: Feature Request
-description: Suggest a new feature or improvement for DMS. Keep features focused on a single topic with clear benefits, examples, etc. Avoid vague or broad requests, they will be closed.
+description: Suggest a new feature or improvement for DMS
 labels:
   - enhancement
 body:
@@ -23,25 +23,18 @@ body:
       placeholder: Why is this feature important?
     validations:
       required: false
-  - type: dropdown
+  - type: checkboxes
     id: compositor
     attributes:
       label: Compositor(s)
       description: Is this feature specific to one or more compositors?
       options:
-        - All compositors
-        - Niri
-        - Hyprland
-        - MangoWC (dwl)
-        - Sway
-        - Other (specify below)
-    validations:
-      required: true
-  - type: input
-    id: compositor_other
-    attributes:
-      label: If Other, please specify
-      placeholder: e.g., Wayfire, Mutter, etc.
+        - label: All compositors
+        - label: Niri
+        - label: Hyprland
+        - label: MangoWC (dwl)
+        - label: Sway
+        - label: Other (specify below)
     validations:
       required: false
   - type: textarea

.github/ISSUE_TEMPLATE/support_request.yml

@@ -7,87 +7,32 @@ body:
     attributes:
       value: |
         ## DankMaterialShell Support Request
-  - type: dropdown
+  - type: checkboxes
     id: compositor
     attributes:
       label: Compositor
       options:
-        - Niri
-        - Hyprland
-        - MangoWC (dwl)
-        - Sway
-        - Other (specify below)
-    validations:
-      required: true
-  - type: input
-    id: compositor_other
-    attributes:
-      label: If Other, please specify
-      placeholder: e.g., Wayfire, Mutter, etc.
+        - label: Niri
+        - label: Hyprland
+        - label: MangoWC (dwl)
+        - label: Sway
+        - label: Other (specify below)
     validations:
       required: false
-  - type: dropdown
+  - type: input
     id: distribution
     attributes:
       label: Distribution
-      options:
-        - Arch Linux
-        - CachyOS
-        - Fedora
-        - NixOS
-        - Debian
-        - Ubuntu
-        - Gentoo
-        - OpenSUSE
-        - Other (specify below)
-    validations:
-      required: true
-  - type: input
-    id: distribution_other
-    attributes:
-      label: If Other, please specify
-      placeholder: e.g., PikaOS, Void Linux, etc.
-    validations:
-      required: false
-  - type: dropdown
-    id: installation_method
-    attributes:
-      label: Select your Installation Method
-      options:
-        - DankInstaller
-        - Distro Packaging
-        - Source
-    validations:
-      required: true
-  - type: dropdown
-    id: original_installation_method_different
-    attributes:
-      label: Was your original Installation method different?
-      options:
-        - "Yes"
-        - No (specify below)
-      default: 0
+      description: Which Linux distribution are you using? (e.g., Arch, Fedora, Debian, etc.)
+      placeholder: Your Linux distribution
     validations:
       required: false
   - type: input
-    id: original_installation_method_specify
+    id: dms_version
     attributes:
-      label: If no, specify
-      placeholder: e.g., Distro Packaging, then Source
-    validations:
-      required: false
-  - type: textarea
-    id: dms_doctor
-    attributes:
-      label: dms doctor -vC
-      description: Output of `dms doctor -vC` command — paste between the lines below to keep it collapsed in the issue
-      placeholder: Paste the output of `dms doctor -vC` here
-      value: |
-        <details>
-        <summary>Click to expand</summary>
-
-
-        </details>
+      label: dms version
+      description: Output of dms version command
+      placeholder: e.g., 1.2.3
     validations:
       required: false
   - type: textarea

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

@@ -20,10 +20,5 @@ jobs:
       - name: Add a flatpak that mutagen could support
         run: sudo flatpak install -y org.freedesktop.Platform/x86_64/24.08 app.zen_browser.zen
 
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: core/go.mod
-
       - name: run pre-commit hooks
         uses: j178/prek-action@v1

.github/workflows/release.yml

@@ -191,11 +191,6 @@ jobs:
           git fetch origin --force tag ${TAG}
           git checkout ${TAG}
 
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: ./core/go.mod
-
       - name: Download core artifacts
         uses: actions/download-artifact@v4
         with:
@@ -234,7 +229,6 @@ jobs:
           - **`dms-distropkg-arm64.gz`** - DMS CLI binary built with distro_package tag for ARM64 systems
           - **`dankinstall-amd64.gz`** - Installer binary for x86_64 systems
           - **`dankinstall-arm64.gz`** - Installer binary for ARM64 systems
-          - **`dms-cli-<version>.tar.gz`** - Go source code with vendored modules (for distro packaging)
           - **`dms-qml.tar.gz`** - QML source code only
 
           ### Checksums
@@ -393,19 +387,6 @@ jobs:
             rm -rf _temp_full
           done
 
-      - name: Generate vendored source tarball
-        run: |
-          set -euxo pipefail
-          VERSION_NUM=${TAG#v}
-          cd core
-          go mod vendor
-          cd ..
-          tar czf "_release_assets/dms-cli-${VERSION_NUM}.tar.gz" \
-            --transform "s,^core/,dms-cli-${VERSION_NUM}/," \
-            --exclude='core/.git' \
-            core/
-          (cd _release_assets && sha256sum "dms-cli-${VERSION_NUM}.tar.gz" > "dms-cli-${VERSION_NUM}.tar.gz.sha256")
-
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:

.github/workflows/run-obs.yml

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

.github/workflows/run-ppa.yml

@@ -12,7 +12,7 @@ on:
         required: false
         default: ""
   schedule:
-    - cron: "0 2,5,14,17,20,23 * * *" # 9am, 12pm, 3pm, 6pm, 9pm, 12am EST (UTC times shown)
+    - cron: "0 */3 * * *" # Every 3 hours for dms-git builds
 
 jobs:
   check-updates:
@@ -158,7 +158,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version-file: ./core/go.mod
+          go-version: "1.24"
           cache: false
 
       - name: Install build dependencies

.gitignore

@@ -56,8 +56,6 @@ UNUSED
 
 CLAUDE-activeContext.md
 CLAUDE-temp.md
-AGENTS-activeContext.md
-AGENTS-temp.md
 
 # Auto-generated theme files
 *.generated.*

.pre-commit-config.yaml

@@ -5,18 +5,8 @@ repos:
       - id: trailing-whitespace
       - id: check-yaml
       - id: end-of-file-fixer
-  - repo: local
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.10.0.1
     hooks:
       - id: shellcheck
-        name: shellcheck
-        entry: shellcheck -e SC2164 -e SC2001 -e SC2012 -e SC2317
-        language: system
-        types: [shell]
-  - repo: local
-    hooks:
-      - id: go-mod-tidy
-        name: go mod tidy
-        entry: bash -c 'cd core && go mod tidy'
-        language: system
-        files: ^core/.*\.(go|mod|sum)$
-        pass_filenames: false
+        args: [-e, SC2164, -e, SC2001, -e, SC2012, -e, SC2317]

CHANGELOG.MD

@@ -1,15 +1,5 @@
 This file is more of a quick reference so I know what to account for before next releases.
 
-# 1.4.0
-
-- Overhauled system monitor, graphs, styling
-- dbus API for plugins, KDEConnect
-- new dank16 algorithm
-- launcher actions, customize env, args, name, icon
-- launcher v2 - omega stuff, GIF search, supa powerful
-- dock on bar
-- window rule manager, with IPC - #TODO verify RTL layout (niri only)
-
 # 1.2.0
 
 - Added clipboard and clipboard history integration

CONTRIBUTING.md

@@ -22,7 +22,7 @@ nix develop
 
 This will provide:
 
-- Go 1.25+ toolchain (go, gopls, delve, go-tools) and GNU Make
+- Go 1.24 toolchain (go, gopls, delve, go-tools) and GNU Make
 - Quickshell and required QML packages
 - Properly configured QML2_IMPORT_PATH
 
@@ -37,43 +37,10 @@ This is a monorepo, the easiest thing to do is to open an editor in either `quic
 1. Install the [QML Extension](https://doc.qt.io/vscodeext/)
 2. Configure `ctrl+shift+p` -> user preferences (json) with qmlls path
 
-**Note:** Paths may vary by distribution. Below are examples for Arch Linux and Fedora.
-
-**Arch Linux:**
-
 ```json
 {
-  "[qml]": {
-    "editor.defaultFormatter": "qt-project.qmlls",
-    "editor.formatOnSave": true
-  },
   "qt-qml.doNotAskForQmllsDownload": true,
-  "qt-qml.qmlls.customExePath": "/usr/lib/qt6/bin/qmlls",
-  "qt-core.additionalQtPaths": [
-    {
-      "name": "Qt-6.x-linux-g++",
-      "path": "/usr/bin/qmake"
-    }
-  ]
-}
-```
-
-**Fedora:**
-
-```json
-{
-  "[qml]": {
-    "editor.defaultFormatter": "qt-project.qmlls",
-    "editor.formatOnSave": true
-  },
-  "qt-qml.doNotAskForQmllsDownload": true,
-  "qt-qml.qmlls.customExePath": "/usr/bin/qmlls",
-  "qt-core.additionalQtPaths": [
-    {
-      "name": "Qt-6.x-Fedora-linux-g++",
-      "path": "/usr/bin/qmake6"
-    }
-  ]
+  "qt-qml.qmlls.customExePath": "/usr/lib/qt6/bin/qmlls"
 }
 ```
 

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:
@@ -58,10 +59,10 @@ install-completions:
 install-systemd:
 	@echo "Installing systemd user service..."
 	@mkdir -p $(SYSTEMD_USER_DIR)
-	@if [ -n "$(SUDO_USER)" ]; then chown -R $(SUDO_USER):"$(id -gn $SUDO_USER)" $(SYSTEMD_USER_DIR); fi
+	@if [ -n "$(SUDO_USER)" ]; then chown -R $(SUDO_USER):$(SUDO_USER) $(SYSTEMD_USER_DIR); fi
 	@sed 's|/usr/bin/dms|$(INSTALL_DIR)/dms|g' $(ASSETS_DIR)/systemd/dms.service > $(SYSTEMD_USER_DIR)/dms.service
 	@chmod 644 $(SYSTEMD_USER_DIR)/dms.service
-	@if [ -n "$(SUDO_USER)" ]; then chown $(SUDO_USER):"$(id -gn $SUDO_USER)" $(SYSTEMD_USER_DIR)/dms.service; fi
+	@if [ -n "$(SUDO_USER)" ]; then chown $(SUDO_USER):$(SUDO_USER) $(SYSTEMD_USER_DIR)/dms.service; fi
 	@echo "Systemd service installed to $(SYSTEMD_USER_DIR)/dms.service"
 
 install-icon:

README.md

@@ -19,7 +19,7 @@ Built with [Quickshell](https://quickshell.org/) and [Go](https://go.dev/)
 
 </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/), [Scroll](https://github.com/dawsers/scroll), [Miracle WM](https://github.com/miracle-wm-org/miracle-wm), 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), [labwc](https://labwc.github.io/), [Scroll](https://github.com/dawsers/scroll), and [Miracle WM](https://github.com/miracle-wm-org/miracle-wm) 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)
 

core/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/golangci/golangci-lint
-    rev: v2.9.0
+    rev: v2.6.2
     hooks:
       - id: golangci-lint-fmt
         require_serial: true

core/README.md

@@ -96,7 +96,7 @@ The on-screen preview displays the selected format. JSON output includes hex, RG
 
 ## Building
 
-Requires Go 1.25+
+Requires Go 1.24+
 
 **Development build:**
 

core/cmd/dms/commands_chroma.go

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

core/cmd/dms/commands_clipboard.go

@@ -12,21 +12,17 @@ import (
 	_ "image/jpeg"
 	_ "image/png"
 	"io"
-	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"os/signal"
 	"path/filepath"
 	"strconv"
-	"strings"
 	"syscall"
 	"time"
 
 	bolt "go.etcd.io/bbolt"
 	_ "golang.org/x/image/bmp"
 	_ "golang.org/x/image/tiff"
-	_ "golang.org/x/image/webp"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
@@ -52,7 +48,6 @@ var (
 	clipCopyForeground bool
 	clipCopyPasteOnce  bool
 	clipCopyType       string
-	clipCopyDownload   bool
 	clipJSONOutput     bool
 )
 
@@ -112,7 +107,6 @@ var clipClearCmd = &cobra.Command{
 }
 
 var clipWatchStore bool
-var clipWatchMimes bool
 
 var clipSearchCmd = &cobra.Command{
 	Use:   "search [query]",
@@ -190,12 +184,11 @@ 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")
-	clipCopyCmd.Flags().BoolVarP(&clipCopyDownload, "download", "d", false, "Download URL as image and copy as file")
 
 	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")
+	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")
@@ -212,7 +205,6 @@ func init() {
 	clipConfigSetCmd.Flags().BoolVar(&clipConfigEnabled, "enable", false, "Enable clipboard tracking")
 
 	clipWatchCmd.Flags().BoolVarP(&clipWatchStore, "store", "s", false, "Store clipboard changes to history (no server required)")
-	clipWatchCmd.Flags().BoolVarP(&clipWatchMimes, "mimes", "m", false, "Show all offered MIME types")
 
 	clipMigrateCmd.Flags().BoolVar(&clipMigrateDelete, "delete", false, "Delete cliphist db after successful migration")
 
@@ -223,10 +215,9 @@ func init() {
 func runClipCopy(cmd *cobra.Command, args []string) {
 	var data []byte
 
-	switch {
-	case len(args) > 0:
+	if len(args) > 0 {
 		data = []byte(args[0])
-	default:
+	} else {
 		var err error
 		data, err = io.ReadAll(os.Stdin)
 		if err != nil {
@@ -234,68 +225,11 @@ func runClipCopy(cmd *cobra.Command, args []string) {
 		}
 	}
 
-	if clipCopyDownload {
-		filePath, err := downloadToTempFile(strings.TrimSpace(string(data)))
-		if err != nil {
-			log.Fatalf("download: %v", err)
-		}
-		if err := copyFileToClipboard(filePath); err != nil {
-			log.Fatalf("copy file: %v", err)
-		}
-		fmt.Printf("Downloaded and copied: %s\n", filePath)
-		return
-	}
-
-	if clipCopyType == "__multi__" {
-		offers, err := parseMultiOffers(data)
-		if err != nil {
-			log.Fatalf("parse multi offers: %v", err)
-		}
-		if err := clipboard.CopyMulti(offers, true, clipCopyPasteOnce); err != nil {
-			log.Fatalf("copy multi: %v", err)
-		}
-		return
-	}
-
 	if err := clipboard.CopyOpts(data, clipCopyType, clipCopyForeground, clipCopyPasteOnce); err != nil {
 		log.Fatalf("copy: %v", err)
 	}
 }
 
-func parseMultiOffers(data []byte) ([]clipboard.Offer, error) {
-	var offers []clipboard.Offer
-	pos := 0
-
-	for pos < len(data) {
-		mimeEnd := bytes.IndexByte(data[pos:], 0)
-		if mimeEnd == -1 {
-			break
-		}
-		mimeType := string(data[pos : pos+mimeEnd])
-		pos += mimeEnd + 1
-
-		lenEnd := bytes.IndexByte(data[pos:], 0)
-		if lenEnd == -1 {
-			break
-		}
-		dataLen, err := strconv.Atoi(string(data[pos : pos+lenEnd]))
-		if err != nil {
-			return nil, fmt.Errorf("parse length: %w", err)
-		}
-		pos += lenEnd + 1
-
-		if pos+dataLen > len(data) {
-			return nil, fmt.Errorf("data truncated")
-		}
-		offerData := data[pos : pos+dataLen]
-		pos += dataLen
-
-		offers = append(offers, clipboard.Offer{MimeType: mimeType, Data: offerData})
-	}
-
-	return offers, nil
-}
-
 func runClipPaste(cmd *cobra.Command, args []string) {
 	data, _, err := clipboard.Paste()
 	if err != nil {
@@ -330,30 +264,6 @@ func runClipWatch(cmd *cobra.Command, args []string) {
 		}); err != nil && err != context.Canceled {
 			log.Fatalf("Watch error: %v", err)
 		}
-	case clipWatchMimes:
-		if err := clipboard.WatchAll(ctx, func(data []byte, mimeType string, allMimes []string) {
-			if clipJSONOutput {
-				out := map[string]any{
-					"data":      string(data),
-					"mimeType":  mimeType,
-					"mimeTypes": allMimes,
-					"timestamp": time.Now().Format(time.RFC3339),
-					"size":      len(data),
-				}
-				j, _ := json.Marshal(out)
-				fmt.Println(string(j))
-				return
-			}
-			fmt.Printf("=== Clipboard Change ===\n")
-			fmt.Printf("Selected: %s\n", mimeType)
-			fmt.Printf("All MIME types:\n")
-			for _, m := range allMimes {
-				fmt.Printf("  - %s\n", m)
-			}
-			fmt.Printf("Size: %d bytes\n\n", len(data))
-		}); 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{
@@ -476,13 +386,16 @@ func runClipGet(cmd *cobra.Command, args []string) {
 		req := models.Request{
 			ID:     1,
 			Method: "clipboard.copyEntry",
-			Params: map[string]any{"id": id},
+			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)
 		}
@@ -759,7 +672,7 @@ func runClipExport(cmd *cobra.Command, args []string) {
 		return
 	}
 
-	if err := os.WriteFile(args[0], out, 0o644); err != nil {
+	if err := os.WriteFile(args[0], out, 0644); err != nil {
 		log.Fatalf("Failed to write file: %v", err)
 	}
 	fmt.Printf("Exported to %s\n", args[0])
@@ -814,7 +727,7 @@ func runClipMigrate(cmd *cobra.Command, args []string) {
 		log.Fatalf("Cliphist db not found: %s", dbPath)
 	}
 
-	db, err := bolt.Open(dbPath, 0o644, &bolt.Options{
+	db, err := bolt.Open(dbPath, 0644, &bolt.Options{
 		ReadOnly: true,
 		Timeout:  1 * time.Second,
 	})
@@ -882,113 +795,3 @@ func detectMimeType(data []byte) string {
 func btoi(v []byte) uint64 {
 	return binary.BigEndian.Uint64(v)
 }
-
-func downloadToTempFile(rawURL string) (string, error) {
-	if !strings.HasPrefix(rawURL, "http://") && !strings.HasPrefix(rawURL, "https://") {
-		return "", fmt.Errorf("invalid URL: %s", rawURL)
-	}
-
-	parsedURL, err := url.Parse(rawURL)
-	if err != nil {
-		return "", fmt.Errorf("parse URL: %w", err)
-	}
-
-	ext := filepath.Ext(parsedURL.Path)
-	if ext == "" {
-		ext = ".png"
-	}
-
-	client := &http.Client{Timeout: 30 * time.Second}
-
-	var data []byte
-	var contentType string
-	var lastErr error
-
-	for attempt := 0; attempt < 3; attempt++ {
-		if attempt > 0 {
-			time.Sleep(time.Duration(attempt) * 500 * time.Millisecond)
-		}
-
-		req, err := http.NewRequest("GET", rawURL, nil)
-		if err != nil {
-			lastErr = fmt.Errorf("create request: %w", err)
-			continue
-		}
-		req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
-		req.Header.Set("Accept", "image/*,video/*,*/*")
-
-		resp, err := client.Do(req)
-		if err != nil {
-			lastErr = fmt.Errorf("download (attempt %d): %w", attempt+1, err)
-			continue
-		}
-
-		if resp.StatusCode != http.StatusOK {
-			resp.Body.Close()
-			lastErr = fmt.Errorf("download failed (attempt %d): status %d", attempt+1, resp.StatusCode)
-			continue
-		}
-
-		data, err = io.ReadAll(resp.Body)
-		resp.Body.Close()
-		if err != nil {
-			lastErr = fmt.Errorf("read response (attempt %d): %w", attempt+1, err)
-			continue
-		}
-
-		contentType = resp.Header.Get("Content-Type")
-		if idx := strings.Index(contentType, ";"); idx != -1 {
-			contentType = strings.TrimSpace(contentType[:idx])
-		}
-
-		lastErr = nil
-		break
-	}
-
-	if lastErr != nil {
-		return "", lastErr
-	}
-
-	if len(data) == 0 {
-		return "", fmt.Errorf("downloaded empty file")
-	}
-
-	if !strings.HasPrefix(contentType, "image/") && !strings.HasPrefix(contentType, "video/") {
-		if _, _, err := image.DecodeConfig(bytes.NewReader(data)); err != nil {
-			return "", fmt.Errorf("not a valid media file (content-type: %s)", contentType)
-		}
-	}
-
-	cacheDir, err := os.UserCacheDir()
-	if err != nil {
-		cacheDir = "/tmp"
-	}
-	clipDir := filepath.Join(cacheDir, "dms", "clipboard")
-	if err := os.MkdirAll(clipDir, 0o755); err != nil {
-		return "", fmt.Errorf("create cache dir: %w", err)
-	}
-
-	filePath := filepath.Join(clipDir, fmt.Sprintf("%d%s", time.Now().UnixNano(), ext))
-	if err := os.WriteFile(filePath, data, 0o644); err != nil {
-		return "", fmt.Errorf("write file: %w", err)
-	}
-
-	return filePath, nil
-}
-
-func copyFileToClipboard(filePath string) error {
-	req := models.Request{
-		ID:     1,
-		Method: "clipboard.copyFile",
-		Params: map[string]any{"filePath": filePath},
-	}
-
-	resp, err := sendServerRequest(req)
-	if err != nil {
-		return fmt.Errorf("server request: %w", err)
-	}
-	if resp.Error != "" {
-		return fmt.Errorf("server error: %s", resp.Error)
-	}
-	return nil
-}

core/cmd/dms/commands_common.go

@@ -64,8 +64,9 @@ var killCmd = &cobra.Command{
 }
 
 var ipcCmd = &cobra.Command{
-	Use:     "ipc [target] [function] [args...]",
+	Use:     "ipc",
 	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)
@@ -76,13 +77,6 @@ var ipcCmd = &cobra.Command{
 	},
 }
 
-func init() {
-	ipcCmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		_ = findConfig(cmd, args)
-		printIPCHelp()
-	})
-}
-
 var debugSrvCmd = &cobra.Command{
 	Use:   "debug-srv",
 	Short: "Start the debug server",
@@ -517,13 +511,9 @@ func getCommonCommands() []*cobra.Command {
 		colorCmd,
 		screenshotCmd,
 		notifyActionCmd,
-		notifyCmd,
-		genericNotifyActionCmd,
 		matugenCmd,
 		clipboardCmd,
-		chromaCmd,
 		doctorCmd,
 		configCmd,
-		dlCmd,
 	}
 }

core/cmd/dms/commands_doctor.go

@@ -11,7 +11,6 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/brightness"
@@ -102,13 +101,11 @@ var doctorCmd = &cobra.Command{
 var (
 	doctorVerbose bool
 	doctorJSON    bool
-	doctorCopy    bool
 )
 
 func init() {
 	doctorCmd.Flags().BoolVarP(&doctorVerbose, "verbose", "v", false, "Show detailed output including paths and versions")
 	doctorCmd.Flags().BoolVarP(&doctorJSON, "json", "j", false, "Output results in JSON format")
-	doctorCmd.Flags().BoolVarP(&doctorCopy, "copy", "C", false, "Copy results to clipboard in GitHub-friendly format")
 }
 
 type category int
@@ -195,7 +192,7 @@ func (r checkResult) toJSON() checkResultJSON {
 }
 
 func runDoctor(cmd *cobra.Command, args []string) {
-	if !doctorJSON && !doctorCopy {
+	if !doctorJSON {
 		printDoctorHeader()
 	}
 
@@ -213,17 +210,9 @@ func runDoctor(cmd *cobra.Command, args []string) {
 		checkEnvironmentVars(),
 	)
 
-	switch {
-	case doctorCopy:
-		text := formatResultsPlain(results)
-		if err := clipboard.CopyOpts([]byte(text), "text/plain;charset=utf-8", false, false); err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to copy to clipboard: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Println("Doctor report copied to clipboard")
-	case doctorJSON:
+	if doctorJSON {
 		printResultsJSON(results)
-	default:
+	} else {
 		printResults(results)
 		printSummary(results, qsMissingFeatures)
 	}
@@ -602,7 +591,7 @@ ShellRoot {
 }
 `
 
-	if err := os.WriteFile(testScript, []byte(qmlContent), 0o644); err != nil {
+	if err := os.WriteFile(testScript, []byte(qmlContent), 0644); err != nil {
 		return nil, false
 	}
 
@@ -649,109 +638,6 @@ func checkI2CAvailability() checkResult {
 	return checkResult{catOptionalFeatures, "I2C/DDC", statusOK, fmt.Sprintf("%d monitor(s) detected", len(devices)), "External monitor brightness control", doctorDocsURL + "#optional-features"}
 }
 
-func checkImageFormatPlugins() []checkResult {
-	url := doctorDocsURL + "#optional-features"
-
-	pluginDir := findQtPluginDir()
-	if pluginDir == "" {
-		return []checkResult{
-			{catOptionalFeatures, "qt6-imageformats", statusInfo, "Cannot detect (plugin dir not found)", "WebP, TIFF, JP2 support", url},
-			{catOptionalFeatures, "kimageformats", statusInfo, "Cannot detect (plugin dir not found)", "AVIF, HEIF, JXL support", url},
-		}
-	}
-
-	imageFormatsDir := filepath.Join(pluginDir, "imageformats")
-
-	type pluginCheck struct {
-		name    string
-		desc    string
-		plugins []struct{ file, format string }
-	}
-
-	checks := []pluginCheck{
-		{
-			name: "qt6-imageformats",
-			desc: "WebP, TIFF, GIF, JP2 support",
-			plugins: []struct{ file, format string }{
-				{"libqwebp.so", "WebP"},
-				{"libqtiff.so", "TIFF"},
-				{"libqgif.so", "GIF"},
-				{"libqjp2.so", "JP2"},
-				{"libqicns.so", "ICNS"},
-			},
-		},
-		{
-			name: "kimageformats",
-			desc: "AVIF, HEIF, JXL support",
-			plugins: []struct{ file, format string }{
-				{"kimg_avif.so", "AVIF"},
-				{"kimg_heif.so", "HEIF"},
-				{"kimg_jxl.so", "JXL"},
-				{"kimg_exr.so", "EXR"},
-			},
-		},
-	}
-
-	var results []checkResult
-	for _, c := range checks {
-		var found []string
-		for _, p := range c.plugins {
-			if _, err := os.Stat(filepath.Join(imageFormatsDir, p.file)); err == nil {
-				found = append(found, p.format)
-			}
-		}
-
-		var result checkResult
-		switch {
-		case len(found) == 0:
-			result = checkResult{catOptionalFeatures, c.name, statusWarn, "Not installed", c.desc, url}
-		default:
-			details := ""
-			if doctorVerbose {
-				details = fmt.Sprintf("Formats: %s (%s)", strings.Join(found, ", "), imageFormatsDir)
-			}
-			result = checkResult{catOptionalFeatures, c.name, statusOK, fmt.Sprintf("Installed (%d formats)", len(found)), details, url}
-		}
-		results = append(results, result)
-	}
-
-	return results
-}
-
-func findQtPluginDir() string {
-	// Check QT_PLUGIN_PATH env var first (used by NixOS and custom setups)
-	if envPath := os.Getenv("QT_PLUGIN_PATH"); envPath != "" {
-		for dir := range strings.SplitSeq(envPath, ":") {
-			if _, err := os.Stat(filepath.Join(dir, "imageformats")); err == nil {
-				return dir
-			}
-		}
-	}
-
-	// Try qtpaths
-	for _, cmd := range []string{"qtpaths6", "qtpaths"} {
-		if output, err := exec.Command(cmd, "-query", "QT_INSTALL_PLUGINS").Output(); err == nil {
-			if dir := strings.TrimSpace(string(output)); dir != "" {
-				return dir
-			}
-		}
-	}
-
-	// Fallback: common distro paths
-	for _, dir := range []string{
-		"/usr/lib/qt6/plugins",
-		"/usr/lib64/qt6/plugins",
-		"/usr/lib/x86_64-linux-gnu/qt6/plugins",
-		"/usr/lib/aarch64-linux-gnu/qt6/plugins",
-	} {
-		if _, err := os.Stat(filepath.Join(dir, "imageformats")); err == nil {
-			return dir
-		}
-	}
-
-	return ""
-}
-
 func detectNetworkBackend(stackResult *network.DetectResult) string {
 	switch stackResult.Backend {
 	case network.BackendNetworkManager:
@@ -792,21 +678,7 @@ func checkOptionalDependencies() []checkResult {
 	logindStatus, logindMsg := getOptionalDBusStatus("org.freedesktop.login1")
 	results = append(results, checkResult{catOptionalFeatures, "logind", logindStatus, logindMsg, "Session management", optionalFeaturesURL})
 
-	cupsPkHelperBus := "org.opensuse.CupsPkHelper.Mechanism"
-	var cupsPkStatus status
-	var cupsPkMsg string
-	switch {
-	case utils.IsDBusServiceAvailable(cupsPkHelperBus):
-		cupsPkStatus, cupsPkMsg = statusOK, "Running"
-	case utils.IsDBusServiceActivatable(cupsPkHelperBus):
-		cupsPkStatus, cupsPkMsg = statusOK, "Available"
-	default:
-		cupsPkStatus, cupsPkMsg = statusWarn, "Not available (install cups-pk-helper)"
-	}
-	results = append(results, checkResult{catOptionalFeatures, "cups-pk-helper", cupsPkStatus, cupsPkMsg, "Printer management", optionalFeaturesURL})
-
 	results = append(results, checkI2CAvailability())
-	results = append(results, checkImageFormatPlugins()...)
 
 	terminals := []string{"ghostty", "kitty", "alacritty", "foot", "wezterm"}
 	if idx := slices.IndexFunc(terminals, utils.CommandExists); idx >= 0 {
@@ -880,7 +752,7 @@ func checkConfigurationFiles() []checkResult {
 
 		status := statusOK
 		message := "Present"
-		if info.Mode().Perm()&0o200 == 0 {
+		if info.Mode().Perm()&0200 == 0 {
 			status = statusWarn
 			message += " (read-only)"
 		}
@@ -1057,36 +929,3 @@ func printSummary(results []checkResult, qsMissingFeatures bool) {
 	}
 	fmt.Println()
 }
-
-func formatResultsPlain(results []checkResult) string {
-	var sb strings.Builder
-	sb.WriteString("## DMS Doctor Report\n\n")
-
-	currentCategory := category(-1)
-	for _, r := range results {
-		if r.category != currentCategory {
-			if currentCategory != -1 {
-				sb.WriteString("\n")
-			}
-			sb.WriteString(fmt.Sprintf("**%s**\n", r.category.String()))
-			currentCategory = r.category
-		}
-
-		sb.WriteString(fmt.Sprintf("- [%s] %s: %s\n", r.status, r.name, r.message))
-
-		if doctorVerbose && r.details != "" {
-			sb.WriteString(fmt.Sprintf("  - %s\n", r.details))
-		}
-	}
-
-	var ds DoctorStatus
-	for _, r := range results {
-		ds.Add(r)
-	}
-
-	sb.WriteString("\n---\n")
-	sb.WriteString(fmt.Sprintf("**Summary:** %d error(s), %d warning(s), %d ok\n",
-		ds.ErrorCount(), ds.WarningCount(), ds.OKCount()))
-
-	return sb.String()
-}

core/cmd/dms/commands_download.go

@@ -1,99 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/spf13/cobra"
-)
-
-var dlOutput string
-var dlUserAgent string
-var dlTimeout int
-var dlIPv4Only bool
-
-var dlCmd = &cobra.Command{
-	Use:   "dl <url>",
-	Short: "Download a URL to stdout or file",
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runDownload(args[0]); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-	},
-}
-
-func init() {
-	dlCmd.Flags().StringVarP(&dlOutput, "output", "o", "", "Output file path (default: stdout)")
-	dlCmd.Flags().StringVar(&dlUserAgent, "user-agent", "", "Custom User-Agent header")
-	dlCmd.Flags().IntVar(&dlTimeout, "timeout", 10, "Request timeout in seconds")
-	dlCmd.Flags().BoolVarP(&dlIPv4Only, "ipv4", "4", false, "Force IPv4 only")
-}
-
-func runDownload(url string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(dlTimeout)*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return fmt.Errorf("invalid request: %w", err)
-	}
-
-	switch {
-	case dlUserAgent != "":
-		req.Header.Set("User-Agent", dlUserAgent)
-	default:
-		req.Header.Set("User-Agent", "DankMaterialShell/1.0 (Linux)")
-	}
-
-	dialer := &net.Dialer{Timeout: 5 * time.Second}
-	transport := &http.Transport{DialContext: dialer.DialContext}
-	if dlIPv4Only {
-		transport.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
-			return dialer.DialContext(ctx, "tcp4", addr)
-		}
-	}
-	client := &http.Client{Transport: transport}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("download failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("HTTP %d", resp.StatusCode)
-	}
-
-	if dlOutput == "" {
-		_, err = io.Copy(os.Stdout, resp.Body)
-		return err
-	}
-
-	if dir := filepath.Dir(dlOutput); dir != "." {
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			return fmt.Errorf("mkdir failed: %w", err)
-		}
-	}
-
-	f, err := os.Create(dlOutput)
-	if err != nil {
-		return fmt.Errorf("create failed: %w", err)
-	}
-	defer f.Close()
-
-	if _, err := io.Copy(f, resp.Body); err != nil {
-		os.Remove(dlOutput)
-		return fmt.Errorf("write failed: %w", err)
-	}
-
-	fmt.Println(dlOutput)
-	return nil
-}

core/cmd/dms/commands_greeter.go

@@ -119,7 +119,7 @@ func installGreeter() error {
 	}
 
 	fmt.Println("\nSynchronizing DMS configurations...")
-	if err := greeter.SyncDMSConfigs(dmsPath, selectedCompositor, logFunc, ""); err != nil {
+	if err := greeter.SyncDMSConfigs(dmsPath, logFunc, ""); err != nil {
 		return err
 	}
 
@@ -147,30 +147,12 @@ func syncGreeter() error {
 	}
 	fmt.Printf("✓ Found DMS at: %s\n", dmsPath)
 
-	if !isGreeterEnabled() {
-		fmt.Println("\n⚠ DMS greeter is not enabled in greetd config.")
-		fmt.Print("Would you like to enable it now? (Y/n): ")
-
-		var response string
-		fmt.Scanln(&response)
-		response = strings.ToLower(strings.TrimSpace(response))
-
-		if response != "n" && response != "no" {
-			if err := enableGreeter(); err != nil {
-				return err
-			}
-		} else {
-			return fmt.Errorf("greeter must be enabled before syncing")
-		}
-	}
-
 	cacheDir := "/var/cache/dms-greeter"
 	if _, err := os.Stat(cacheDir); os.IsNotExist(err) {
 		return fmt.Errorf("greeter cache directory not found at %s\nPlease install the greeter first", cacheDir)
 	}
 
-	greeterGroup := greeter.DetectGreeterGroup()
-	greeterGroupExists := utils.HasGroup(greeterGroup)
+	greeterGroupExists := checkGroupExists("greeter")
 	if greeterGroupExists {
 		currentUser, err := user.Current()
 		if err != nil {
@@ -183,59 +165,36 @@ func syncGreeter() error {
 			return fmt.Errorf("failed to check groups: %w", err)
 		}
 
-		inGreeterGroup := strings.Contains(string(groupsOutput), greeterGroup)
+		inGreeterGroup := strings.Contains(string(groupsOutput), "greeter")
 		if !inGreeterGroup {
-			fmt.Printf("\n⚠ Warning: You are not in the %s group.\n", greeterGroup)
-			fmt.Printf("Would you like to add your user to the %s group? (Y/n): ", greeterGroup)
+			fmt.Println("\n⚠ Warning: You are not in the greeter group.")
+			fmt.Print("Would you like to add your user to the greeter group? (y/N): ")
 
 			var response string
 			fmt.Scanln(&response)
 			response = strings.ToLower(strings.TrimSpace(response))
 
-			if response != "n" && response != "no" {
-				fmt.Printf("\nAdding user to %s group...\n", greeterGroup)
-				addUserCmd := exec.Command("sudo", "usermod", "-aG", greeterGroup, currentUser.Username)
+			if response == "y" || response == "yes" {
+				fmt.Println("\nAdding user to greeter group...")
+				addUserCmd := exec.Command("sudo", "usermod", "-aG", "greeter", currentUser.Username)
 				addUserCmd.Stdout = os.Stdout
 				addUserCmd.Stderr = os.Stderr
 				if err := addUserCmd.Run(); err != nil {
-					return fmt.Errorf("failed to add user to %s group: %w", greeterGroup, err)
+					return fmt.Errorf("failed to add user to greeter group: %w", err)
 				}
-				fmt.Printf("✓ User added to %s group\n", greeterGroup)
+				fmt.Println("✓ User added to greeter group")
 				fmt.Println("⚠ You will need to log out and back in for the group change to take effect")
-			} else {
-				return fmt.Errorf("aborted: user must be in the greeter group before syncing")
 			}
 		}
 	}
 
-	compositor := detectConfiguredCompositor()
-	if compositor == "" {
-		compositors := greeter.DetectCompositors()
-		switch len(compositors) {
-		case 0:
-			return fmt.Errorf("no supported compositors found")
-		case 1:
-			compositor = compositors[0]
-			fmt.Printf("✓ Using compositor: %s\n", compositor)
-		default:
-			var err error
-			compositor, err = promptCompositorChoice(compositors)
-			if err != nil {
-				return err
-			}
-			fmt.Printf("✓ Selected compositor: %s\n", compositor)
-		}
-	} else {
-		fmt.Printf("✓ Detected compositor from config: %s\n", compositor)
-	}
-
 	fmt.Println("\nSetting up permissions and ACLs...")
 	if err := greeter.SetupDMSGroup(logFunc, ""); err != nil {
 		return err
 	}
 
 	fmt.Println("\nSynchronizing DMS configurations...")
-	if err := greeter.SyncDMSConfigs(dmsPath, compositor, logFunc, ""); err != nil {
+	if err := greeter.SyncDMSConfigs(dmsPath, logFunc, ""); err != nil {
 		return err
 	}
 
@@ -246,6 +205,21 @@ func syncGreeter() error {
 	return nil
 }
 
+func checkGroupExists(groupName string) bool {
+	data, err := os.ReadFile("/etc/group")
+	if err != nil {
+		return false
+	}
+
+	lines := strings.SplitSeq(string(data), "\n")
+	for line := range lines {
+		if strings.HasPrefix(line, groupName+":") {
+			return true
+		}
+	}
+	return false
+}
+
 func disableDisplayManager(dmName string) (bool, error) {
 	state, err := getSystemdServiceState(dmName)
 	if err != nil {
@@ -377,7 +351,7 @@ func ensureGraphicalTarget() error {
 func handleConflictingDisplayManagers() error {
 	fmt.Println("\n=== Checking for Conflicting Display Managers ===")
 
-	conflictingDMs := []string{"gdm", "gdm3", "lightdm", "sddm", "lxdm", "xdm", "cosmic-greeter"}
+	conflictingDMs := []string{"gdm", "gdm3", "lightdm", "sddm", "lxdm", "xdm"}
 
 	disabledAny := false
 	var errors []string
@@ -578,39 +552,6 @@ func enableGreeter() error {
 	return nil
 }
 
-func isGreeterEnabled() bool {
-	data, err := os.ReadFile("/etc/greetd/config.toml")
-	if err != nil {
-		return false
-	}
-	return strings.Contains(string(data), "dms-greeter")
-}
-
-func detectConfiguredCompositor() string {
-	data, err := os.ReadFile("/etc/greetd/config.toml")
-	if err != nil {
-		return ""
-	}
-
-	for _, line := range strings.Split(string(data), "\n") {
-		trimmed := strings.TrimSpace(line)
-		if !strings.HasPrefix(trimmed, "command") || !strings.Contains(trimmed, "dms-greeter") {
-			continue
-		}
-
-		switch {
-		case strings.Contains(trimmed, "--command niri"):
-			return "niri"
-		case strings.Contains(trimmed, "--command hyprland"):
-			return "hyprland"
-		case strings.Contains(trimmed, "--command sway"):
-			return "sway"
-		}
-	}
-
-	return ""
-}
-
 func promptCompositorChoice(compositors []string) (string, error) {
 	fmt.Println("\nMultiple compositors detected:")
 	for i, comp := range compositors {

core/cmd/dms/commands_keybinds.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"path/filepath"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds/providers"
@@ -64,7 +63,6 @@ func init() {
 	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().Bool("no-inhibiting", false, "Keep bind active when shortcuts are inhibited (allow-inhibiting=false)")
 	keybindsSetCmd.Flags().String("replace-key", "", "Original key to replace (removes old key)")
 	keybindsSetCmd.Flags().String("flags", "", "Hyprland bind flags (e.g., 'e' for repeat, 'l' for locked, 'r' for release)")
 
@@ -83,35 +81,24 @@ func init() {
 func initializeProviders() {
 	registry := keybinds.GetDefaultRegistry()
 
-	hyprlandProvider := providers.NewHyprlandProvider("")
+	hyprlandProvider := providers.NewHyprlandProvider("$HOME/.config/hypr")
 	if err := registry.Register(hyprlandProvider); err != nil {
 		log.Warnf("Failed to register Hyprland provider: %v", err)
 	}
 
-	mangowcProvider := providers.NewMangoWCProvider("")
+	mangowcProvider := providers.NewMangoWCProvider("$HOME/.config/mango")
 	if err := registry.Register(mangowcProvider); err != nil {
 		log.Warnf("Failed to register MangoWC provider: %v", err)
 	}
 
-	configDir, _ := os.UserConfigDir()
-
-	if configDir != "" {
-		scrollProvider := providers.NewSwayProvider(filepath.Join(configDir, "scroll"))
-		if err := registry.Register(scrollProvider); err != nil {
-			log.Warnf("Failed to register Scroll 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)
 	}
 
-	miracleProvider := providers.NewMiracleProvider("")
-	if err := registry.Register(miracleProvider); err != nil {
-		log.Warnf("Failed to register Miracle WM provider: %v", err)
-	}
-
-	if configDir != "" {
-		swayProvider := providers.NewSwayProvider(filepath.Join(configDir, "sway"))
-		if err := registry.Register(swayProvider); err != nil {
-			log.Warnf("Failed to register Sway 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)
 	}
 
 	niriProvider := providers.NewNiriProvider("")
@@ -156,8 +143,6 @@ func makeProviderWithPath(name, path string) keybinds.Provider {
 		return providers.NewSwayProvider(path)
 	case "scroll":
 		return providers.NewSwayProvider(path)
-	case "miracle":
-		return providers.NewMiracleProvider(path)
 	case "niri":
 		return providers.NewNiriProvider(path)
 	default:
@@ -227,9 +212,6 @@ func runKeybindsSet(cmd *cobra.Command, args []string) {
 	if v, _ := cmd.Flags().GetBool("no-repeat"); v {
 		options["repeat"] = false
 	}
-	if v, _ := cmd.Flags().GetBool("no-inhibiting"); v {
-		options["allow-inhibiting"] = false
-	}
 	if v, _ := cmd.Flags().GetString("flags"); v != "" {
 		options["flags"] = v
 	}

core/cmd/dms/commands_notify.go

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

core/cmd/dms/commands_root.go

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

core/cmd/dms/commands_screenshot.go

@@ -13,16 +13,16 @@ import (
 )
 
 var (
-	ssOutputName  string
-	ssCursor      string
-	ssFormat      string
-	ssQuality     int
-	ssOutputDir   string
-	ssFilename    string
-	ssNoClipboard bool
-	ssNoFile      bool
-	ssNoNotify    bool
-	ssStdout      bool
+	ssOutputName    string
+	ssIncludeCursor bool
+	ssFormat        string
+	ssQuality       int
+	ssOutputDir     string
+	ssFilename      string
+	ssNoClipboard   bool
+	ssNoFile        bool
+	ssNoNotify      bool
+	ssStdout        bool
 )
 
 var screenshotCmd = &cobra.Command{
@@ -52,7 +52,7 @@ Examples:
   dms screenshot last                # Last region (pre-selected)
   dms screenshot --no-clipboard      # Save file only
   dms screenshot --no-file           # Clipboard only
-  dms screenshot --cursor=on         # Include cursor
+  dms screenshot --cursor            # Include cursor
   dms screenshot -f jpg -q 85        # JPEG with quality 85`,
 }
 
@@ -111,7 +111,7 @@ var notifyActionCmd = &cobra.Command{
 
 func init() {
 	screenshotCmd.PersistentFlags().StringVarP(&ssOutputName, "output", "o", "", "Output name for 'output' mode")
-	screenshotCmd.PersistentFlags().StringVar(&ssCursor, "cursor", "off", "Include cursor in screenshot (on/off)")
+	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")
@@ -136,9 +136,7 @@ func getScreenshotConfig(mode screenshot.Mode) screenshot.Config {
 	config := screenshot.DefaultConfig()
 	config.Mode = mode
 	config.OutputName = ssOutputName
-	if strings.EqualFold(ssCursor, "on") {
-		config.Cursor = screenshot.CursorOn
-	}
+	config.IncludeCursor = ssIncludeCursor
 	config.Clipboard = !ssNoClipboard
 	config.SaveFile = !ssNoFile
 	config.Notify = !ssNoNotify

core/cmd/dms/commands_setup.go

@@ -9,9 +9,7 @@ import (
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"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"
 )
 
@@ -26,243 +24,6 @@ var setupCmd = &cobra.Command{
 	},
 }
 
-var setupBindsCmd = &cobra.Command{
-	Use:   "binds",
-	Short: "Deploy default keybinds config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("binds"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupLayoutCmd = &cobra.Command{
-	Use:   "layout",
-	Short: "Deploy default layout config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("layout"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupColorsCmd = &cobra.Command{
-	Use:   "colors",
-	Short: "Deploy default colors config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("colors"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupAlttabCmd = &cobra.Command{
-	Use:   "alttab",
-	Short: "Deploy default alt-tab config (niri only)",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("alttab"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupOutputsCmd = &cobra.Command{
-	Use:   "outputs",
-	Short: "Deploy default outputs config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("outputs"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupCursorCmd = &cobra.Command{
-	Use:   "cursor",
-	Short: "Deploy default cursor config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("cursor"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-var setupWindowrulesCmd = &cobra.Command{
-	Use:   "windowrules",
-	Short: "Deploy default window rules config",
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runSetupDmsConfig("windowrules"); err != nil {
-			log.Fatalf("Error: %v", err)
-		}
-	},
-}
-
-type dmsConfigSpec struct {
-	niriFile    string
-	hyprFile    string
-	niriContent func(terminal string) string
-	hyprContent func(terminal string) string
-}
-
-var dmsConfigSpecs = map[string]dmsConfigSpec{
-	"binds": {
-		niriFile: "binds.kdl",
-		hyprFile: "binds.conf",
-		niriContent: func(t string) string {
-			return strings.ReplaceAll(config.NiriBindsConfig, "{{TERMINAL_COMMAND}}", t)
-		},
-		hyprContent: func(t string) string {
-			return strings.ReplaceAll(config.HyprBindsConfig, "{{TERMINAL_COMMAND}}", t)
-		},
-	},
-	"layout": {
-		niriFile:    "layout.kdl",
-		hyprFile:    "layout.conf",
-		niriContent: func(_ string) string { return config.NiriLayoutConfig },
-		hyprContent: func(_ string) string { return config.HyprLayoutConfig },
-	},
-	"colors": {
-		niriFile:    "colors.kdl",
-		hyprFile:    "colors.conf",
-		niriContent: func(_ string) string { return config.NiriColorsConfig },
-		hyprContent: func(_ string) string { return config.HyprColorsConfig },
-	},
-	"alttab": {
-		niriFile:    "alttab.kdl",
-		niriContent: func(_ string) string { return config.NiriAlttabConfig },
-	},
-	"outputs": {
-		niriFile:    "outputs.kdl",
-		hyprFile:    "outputs.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
-	},
-	"cursor": {
-		niriFile:    "cursor.kdl",
-		hyprFile:    "cursor.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
-	},
-	"windowrules": {
-		niriFile:    "windowrules.kdl",
-		hyprFile:    "windowrules.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
-	},
-}
-
-func detectTerminal() (string, error) {
-	terminals := []string{"ghostty", "foot", "kitty", "alacritty"}
-	var found []string
-	for _, t := range terminals {
-		if utils.CommandExists(t) {
-			found = append(found, t)
-		}
-	}
-
-	switch len(found) {
-	case 0:
-		return "ghostty", nil
-	case 1:
-		return found[0], nil
-	}
-
-	fmt.Println("Multiple terminals detected:")
-	for i, t := range found {
-		fmt.Printf("%d) %s\n", i+1, t)
-	}
-	fmt.Printf("\nChoice (1-%d): ", len(found))
-
-	var response string
-	fmt.Scanln(&response)
-	response = strings.TrimSpace(response)
-
-	choice := 0
-	fmt.Sscanf(response, "%d", &choice)
-	if choice < 1 || choice > len(found) {
-		return "", fmt.Errorf("invalid choice")
-	}
-	return found[choice-1], nil
-}
-
-func detectCompositorForSetup() (string, error) {
-	compositors := greeter.DetectCompositors()
-
-	switch len(compositors) {
-	case 0:
-		return "", fmt.Errorf("no supported compositors found (niri or Hyprland required)")
-	case 1:
-		return strings.ToLower(compositors[0]), nil
-	}
-
-	selected, err := greeter.PromptCompositorChoice(compositors)
-	if err != nil {
-		return "", err
-	}
-	return strings.ToLower(selected), nil
-}
-
-func runSetupDmsConfig(name string) error {
-	spec, ok := dmsConfigSpecs[name]
-	if !ok {
-		return fmt.Errorf("unknown config: %s", name)
-	}
-
-	compositor, err := detectCompositorForSetup()
-	if err != nil {
-		return err
-	}
-
-	var filename string
-	var contentFn func(string) string
-	switch compositor {
-	case "niri":
-		filename = spec.niriFile
-		contentFn = spec.niriContent
-	case "hyprland":
-		filename = spec.hyprFile
-		contentFn = spec.hyprContent
-	default:
-		return fmt.Errorf("unsupported compositor: %s", compositor)
-	}
-
-	if filename == "" {
-		return fmt.Errorf("%s is not supported for %s", name, compositor)
-	}
-
-	var dmsDir string
-	switch compositor {
-	case "niri":
-		dmsDir = filepath.Join(os.Getenv("HOME"), ".config", "niri", "dms")
-	case "hyprland":
-		dmsDir = filepath.Join(os.Getenv("HOME"), ".config", "hypr", "dms")
-	}
-
-	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
-		return fmt.Errorf("failed to create dms directory: %w", err)
-	}
-
-	path := filepath.Join(dmsDir, filename)
-	if info, err := os.Stat(path); err == nil && info.Size() > 0 {
-		return fmt.Errorf("%s already exists and is not empty: %s", name, path)
-	}
-
-	terminal := "ghostty"
-	if contentFn != nil && name == "binds" {
-		terminal, err = detectTerminal()
-		if err != nil {
-			return err
-		}
-	}
-
-	content := contentFn(terminal)
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		return fmt.Errorf("failed to write %s: %w", filename, err)
-	}
-
-	fmt.Printf("Deployed %s to %s\n", name, path)
-	return nil
-}
-
 func runSetup() error {
 	fmt.Println("=== DMS Configuration Setup ===")
 

core/cmd/dms/commands_windowrules.go

@@ -1,338 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/windowrules"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/windowrules/providers"
-	"github.com/spf13/cobra"
-)
-
-var windowrulesCmd = &cobra.Command{
-	Use:   "windowrules",
-	Short: "Manage window rules",
-}
-
-var windowrulesListCmd = &cobra.Command{
-	Use:   "list [compositor]",
-	Short: "List all window rules",
-	Long:  "List all window rules from compositor config file. Returns JSON with rules and DMS status.",
-	Args:  cobra.MaximumNArgs(1),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runWindowrulesList,
-}
-
-var windowrulesAddCmd = &cobra.Command{
-	Use:   "add <compositor> '<json>'",
-	Short: "Add a window rule to DMS file",
-	Long:  "Add a new window rule to the DMS-managed rules file.",
-	Args:  cobra.ExactArgs(2),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == 0 {
-			// ! disabled hyprland return []string{"hyprland", "niri"}, cobra.ShellCompDirectiveNoFileComp
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runWindowrulesAdd,
-}
-
-var windowrulesUpdateCmd = &cobra.Command{
-	Use:   "update <compositor> <id> '<json>'",
-	Short: "Update a window rule in DMS file",
-	Long:  "Update an existing window rule in the DMS-managed rules file.",
-	Args:  cobra.ExactArgs(3),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runWindowrulesUpdate,
-}
-
-var windowrulesRemoveCmd = &cobra.Command{
-	Use:   "remove <compositor> <id>",
-	Short: "Remove a window rule from DMS file",
-	Long:  "Remove a window rule from the DMS-managed rules file.",
-	Args:  cobra.ExactArgs(2),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runWindowrulesRemove,
-}
-
-var windowrulesReorderCmd = &cobra.Command{
-	Use:   "reorder <compositor> '<json-array-of-ids>'",
-	Short: "Reorder window rules in DMS file",
-	Long:  "Reorder window rules by providing a JSON array of rule IDs in the desired order.",
-	Args:  cobra.ExactArgs(2),
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	},
-	Run: runWindowrulesReorder,
-}
-
-func init() {
-	configCmd.AddCommand(windowrulesCmd)
-	windowrulesCmd.AddCommand(windowrulesListCmd)
-	windowrulesCmd.AddCommand(windowrulesAddCmd)
-	windowrulesCmd.AddCommand(windowrulesUpdateCmd)
-	windowrulesCmd.AddCommand(windowrulesRemoveCmd)
-	windowrulesCmd.AddCommand(windowrulesReorderCmd)
-}
-
-type WindowRulesListResult struct {
-	Rules     []windowrules.WindowRule    `json:"rules"`
-	DMSStatus *windowrules.DMSRulesStatus `json:"dmsStatus,omitempty"`
-}
-
-type WindowRuleWriteResult struct {
-	Success bool   `json:"success"`
-	ID      string `json:"id,omitempty"`
-	Path    string `json:"path,omitempty"`
-	Error   string `json:"error,omitempty"`
-}
-
-func getCompositor(args []string) string {
-	if len(args) > 0 {
-		return strings.ToLower(args[0])
-	}
-	if os.Getenv("NIRI_SOCKET") != "" {
-		return "niri"
-	}
-	// if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") != "" {
-	// 	return "hyprland"
-	// }
-	return ""
-}
-
-func writeRuleError(errMsg string) {
-	result := WindowRuleWriteResult{Success: false, Error: errMsg}
-	output, _ := json.Marshal(result)
-	fmt.Fprintln(os.Stdout, string(output))
-	os.Exit(1)
-}
-
-func writeRuleSuccess(id, path string) {
-	result := WindowRuleWriteResult{Success: true, ID: id, Path: path}
-	output, _ := json.Marshal(result)
-	fmt.Fprintln(os.Stdout, string(output))
-}
-
-func runWindowrulesList(cmd *cobra.Command, args []string) {
-	compositor := getCompositor(args)
-	if compositor == "" {
-		log.Fatalf("Could not detect compositor. Please specify: hyprland or niri")
-	}
-
-	var result WindowRulesListResult
-
-	switch compositor {
-	case "niri":
-		configDir, err := utils.ExpandPath("$HOME/.config/niri")
-		if err != nil {
-			log.Fatalf("Failed to expand niri config path: %v", err)
-		}
-
-		parseResult, err := providers.ParseNiriWindowRules(configDir)
-		if err != nil {
-			log.Fatalf("Failed to parse niri window rules: %v", err)
-		}
-
-		allRules := providers.ConvertNiriRulesToWindowRules(parseResult.Rules)
-
-		provider := providers.NewNiriWritableProvider(configDir)
-		dmsRulesPath := provider.GetOverridePath()
-		dmsRules, _ := provider.LoadDMSRules()
-
-		dmsRuleMap := make(map[int]windowrules.WindowRule)
-		for i, dr := range dmsRules {
-			dmsRuleMap[i] = dr
-		}
-
-		dmsIdx := 0
-		for i, r := range allRules {
-			if r.Source == dmsRulesPath {
-				if dmr, ok := dmsRuleMap[dmsIdx]; ok {
-					allRules[i].ID = dmr.ID
-					allRules[i].Name = dmr.Name
-				}
-				dmsIdx++
-			}
-		}
-
-		result.Rules = allRules
-		result.DMSStatus = parseResult.DMSStatus
-
-	case "hyprland":
-		log.Fatalf("Hyprland support is currently disabled.") // ! disabled hyprland
-		configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-		if err != nil {
-			log.Fatalf("Failed to expand hyprland config path: %v", err)
-		}
-
-		parseResult, err := providers.ParseHyprlandWindowRules(configDir)
-		if err != nil {
-			log.Fatalf("Failed to parse hyprland window rules: %v", err)
-		}
-
-		allRules := providers.ConvertHyprlandRulesToWindowRules(parseResult.Rules)
-
-		provider := providers.NewHyprlandWritableProvider(configDir)
-		dmsRulesPath := provider.GetOverridePath()
-		dmsRules, _ := provider.LoadDMSRules()
-
-		dmsRuleMap := make(map[int]windowrules.WindowRule)
-		for i, dr := range dmsRules {
-			dmsRuleMap[i] = dr
-		}
-
-		dmsIdx := 0
-		for i, r := range allRules {
-			if r.Source == dmsRulesPath {
-				if dmr, ok := dmsRuleMap[dmsIdx]; ok {
-					allRules[i].ID = dmr.ID
-					allRules[i].Name = dmr.Name
-				}
-				dmsIdx++
-			}
-		}
-
-		result.Rules = allRules
-		result.DMSStatus = parseResult.DMSStatus
-
-	default:
-		log.Fatalf("Unknown compositor: %s", compositor)
-	}
-
-	output, _ := json.Marshal(result)
-	fmt.Fprintln(os.Stdout, string(output))
-}
-
-func runWindowrulesAdd(cmd *cobra.Command, args []string) {
-	compositor := strings.ToLower(args[0])
-	ruleJSON := args[1]
-
-	var rule windowrules.WindowRule
-	if err := json.Unmarshal([]byte(ruleJSON), &rule); err != nil {
-		writeRuleError(fmt.Sprintf("Invalid JSON: %v", err))
-	}
-
-	if rule.ID == "" {
-		rule.ID = generateRuleID()
-	}
-	rule.Enabled = true
-
-	provider := getWindowRulesProvider(compositor)
-	if provider == nil {
-		writeRuleError(fmt.Sprintf("Unknown compositor: %s", compositor))
-	}
-
-	if err := provider.SetRule(rule); err != nil {
-		writeRuleError(err.Error())
-	}
-
-	writeRuleSuccess(rule.ID, provider.GetOverridePath())
-}
-
-func runWindowrulesUpdate(cmd *cobra.Command, args []string) {
-	compositor := strings.ToLower(args[0])
-	ruleID := args[1]
-	ruleJSON := args[2]
-
-	var rule windowrules.WindowRule
-	if err := json.Unmarshal([]byte(ruleJSON), &rule); err != nil {
-		writeRuleError(fmt.Sprintf("Invalid JSON: %v", err))
-	}
-
-	rule.ID = ruleID
-
-	provider := getWindowRulesProvider(compositor)
-	if provider == nil {
-		writeRuleError(fmt.Sprintf("Unknown compositor: %s", compositor))
-	}
-
-	if err := provider.SetRule(rule); err != nil {
-		writeRuleError(err.Error())
-	}
-
-	writeRuleSuccess(rule.ID, provider.GetOverridePath())
-}
-
-func runWindowrulesRemove(cmd *cobra.Command, args []string) {
-	compositor := strings.ToLower(args[0])
-	ruleID := args[1]
-
-	provider := getWindowRulesProvider(compositor)
-	if provider == nil {
-		writeRuleError(fmt.Sprintf("Unknown compositor: %s", compositor))
-	}
-
-	if err := provider.RemoveRule(ruleID); err != nil {
-		writeRuleError(err.Error())
-	}
-
-	writeRuleSuccess(ruleID, provider.GetOverridePath())
-}
-
-func runWindowrulesReorder(cmd *cobra.Command, args []string) {
-	compositor := strings.ToLower(args[0])
-	idsJSON := args[1]
-
-	var ids []string
-	if err := json.Unmarshal([]byte(idsJSON), &ids); err != nil {
-		writeRuleError(fmt.Sprintf("Invalid JSON array: %v", err))
-	}
-
-	provider := getWindowRulesProvider(compositor)
-	if provider == nil {
-		writeRuleError(fmt.Sprintf("Unknown compositor: %s", compositor))
-	}
-
-	if err := provider.ReorderRules(ids); err != nil {
-		writeRuleError(err.Error())
-	}
-
-	writeRuleSuccess("", provider.GetOverridePath())
-}
-
-func getWindowRulesProvider(compositor string) windowrules.WritableProvider {
-	switch compositor {
-	case "niri":
-		configDir, err := utils.ExpandPath("$HOME/.config/niri")
-		if err != nil {
-			return nil
-		}
-		return providers.NewNiriWritableProvider(configDir)
-	case "hyprland":
-		configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-		if err != nil {
-			return nil
-		}
-		return providers.NewHyprlandWritableProvider(configDir)
-	default:
-		return nil
-	}
-}
-
-func generateRuleID() string {
-	return fmt.Sprintf("wr_%d", time.Now().UnixNano())
-}

core/cmd/dms/main.go

@@ -19,9 +19,6 @@ func init() {
 	// Add subcommands to greeter
 	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd)
 
-	// Add subcommands to setup
-	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
-
 	// Add subcommands to update
 	updateCmd.AddCommand(updateCheckCmd)
 

core/cmd/dms/main_distro.go

@@ -20,9 +20,6 @@ func init() {
 	// Add subcommands to greeter
 	greeterCmd.AddCommand(greeterSyncCmd, greeterEnableCmd, greeterStatusCmd)
 
-	// Add subcommands to setup
-	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
-
 	// Add subcommands to plugins
 	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)
 

core/cmd/dms/shell.go

@@ -210,7 +210,7 @@ func runShellInteractive(session bool) {
 		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORMTHEME_QT6=gtk3")
 	}
 	if os.Getenv("QT_QPA_PLATFORM") == "" {
-		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland;xcb")
+		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland")
 	}
 
 	cmd.Stdin = os.Stdin
@@ -450,7 +450,7 @@ func runShellDaemon(session bool) {
 		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORMTHEME_QT6=gtk3")
 	}
 	if os.Getenv("QT_QPA_PLATFORM") == "" {
-		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland;xcb")
+		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland")
 	}
 
 	devNull, err := os.OpenFile("/dev/null", os.O_RDWR, 0)
@@ -618,8 +618,9 @@ func getShellIPCCompletions(args []string, _ string) []string {
 
 func runShellIPCCommand(args []string) {
 	if len(args) == 0 {
-		printIPCHelp()
-		return
+		log.Error("IPC command requires arguments")
+		log.Info("Usage: dms ipc <command> [args...]")
+		os.Exit(1)
 	}
 
 	if args[0] != "call" {
@@ -641,45 +642,3 @@ func runShellIPCCommand(args []string) {
 		log.Fatalf("Error running IPC command: %v", err)
 	}
 }
-
-func printIPCHelp() {
-	fmt.Println("Usage: dms ipc <target> <function> [args...]")
-	fmt.Println()
-
-	cmdArgs := []string{"ipc"}
-	if qsHasAnyDisplay() {
-		cmdArgs = append(cmdArgs, "--any-display")
-	}
-	cmdArgs = append(cmdArgs, "-p", configPath, "show")
-	cmd := exec.Command("qs", cmdArgs...)
-
-	output, err := cmd.Output()
-	if err != nil {
-		fmt.Println("Could not retrieve available IPC targets (is DMS running?)")
-		return
-	}
-
-	targets := parseTargetsFromIPCShowOutput(string(output))
-	if len(targets) == 0 {
-		fmt.Println("No IPC targets available")
-		return
-	}
-
-	fmt.Println("Targets:")
-
-	targetNames := make([]string, 0, len(targets))
-	for name := range targets {
-		targetNames = append(targetNames, name)
-	}
-	slices.Sort(targetNames)
-
-	for _, targetName := range targetNames {
-		funcs := targets[targetName]
-		funcNames := make([]string, 0, len(funcs))
-		for fn := range funcs {
-			funcNames = append(funcNames, fn)
-		}
-		slices.Sort(funcNames)
-		fmt.Printf("  %-16s %s\n", targetName, strings.Join(funcNames, ", "))
-	}
-}

core/go.mod

@@ -1,11 +1,10 @@
 module github.com/AvengeMedia/DankMaterialShell/core
 
-go 1.25.0
+go 1.24.6
 
 require (
 	github.com/Wifx/gonetworkmanager/v2 v2.2.0
-	github.com/alecthomas/chroma/v2 v2.23.1
-	github.com/charmbracelet/bubbles v1.0.0
+	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10
 	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/charmbracelet/log v0.4.2
@@ -13,49 +12,47 @@ require (
 	github.com/godbus/dbus/v5 v5.2.2
 	github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83
 	github.com/pilebones/go-udev v0.9.1
-	github.com/sblinch/kdl-go v0.0.0-20260121213736-8b7053306ca6
+	github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
-	github.com/yuin/goldmark v1.7.16
-	github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc
 	go.etcd.io/bbolt v1.4.3
-	golang.org/x/exp v0.0.0-20260212183809-81e46e3db34a
-	golang.org/x/image v0.36.0
+	golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93
+	golang.org/x/image v0.34.0
 )
 
 require (
 	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/clipperhouse/displaywidth v0.10.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
-	github.com/cloudflare/circl v1.6.3 // indirect
+	github.com/clipperhouse/displaywidth v0.6.2 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
+	github.com/cloudflare/circl v1.6.2 // indirect
 	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
-	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/go-git/gcfg/v2 v2.0.2 // indirect
-	github.com/go-git/go-billy/v6 v6.0.0-20260209124918-37866f83c2d3 // indirect
+	github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd // indirect
 	github.com/go-logfmt/logfmt v0.6.1 // indirect
 	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
-	github.com/kevinburke/ssh_config v1.6.0 // indirect
+	github.com/kevinburke/ssh_config v1.4.0 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/pjbgf/sha1cd v0.5.0 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/stretchr/objx v0.5.3 // indirect
-	golang.org/x/crypto v0.48.0 // indirect
-	golang.org/x/net v0.50.0 // indirect
+	golang.org/x/crypto v0.46.0 // indirect
+	golang.org/x/net v0.48.0 // indirect
 )
 
 require (
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.4.2 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.6 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
+	github.com/charmbracelet/x/ansi v0.11.3 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/go-git/go-git/v6 v6.0.0-20260216160506-e6a3f881772f
+	github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -69,11 +66,7 @@ require (
 	github.com/spf13/afero v1.15.0
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/sys v0.41.0
-	golang.org/x/text v0.34.0
-	gopkg.in/yaml.v3 v3.0.1
+	golang.org/x/sys v0.39.0
+	golang.org/x/text v0.32.0
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
-
-// v0.0.1 tag is missing a LICENSE file; master has it.
-// See: https://github.com/mattn/go-localereader/issues/2
-replace github.com/mattn/go-localereader v0.0.1 => github.com/mattn/go-localereader v0.0.2-0.20220822084749-2491eb6c1c75

core/go.sum

@@ -4,14 +4,6 @@ github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBi
 github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
 github.com/Wifx/gonetworkmanager/v2 v2.2.0 h1:kPstgsQtY8CmDOOFZd81ytM9Gi3f6ImzPCKF7nNhQ2U=
 github.com/Wifx/gonetworkmanager/v2 v2.2.0/go.mod h1:fMDb//SHsKWxyDUAwXvCqurV3npbIyyaQWenGpZ/uXg=
-github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
-github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.2.0/go.mod h1:vf4zrexSH54oEjJ7EdB65tGNHmH3pGZmVkgTP5RHvAs=
-github.com/alecthomas/chroma/v2 v2.23.1 h1:nv2AVZdTyClGbVQkIzlDm/rnhk1E9bU9nXwmZ/Vk/iY=
-github.com/alecthomas/chroma/v2 v2.23.1/go.mod h1:NqVhfBR0lte5Ouh3DcthuUCTUpDC9cxBOfyMbMQPs3o=
-github.com/alecthomas/repr v0.0.0-20220113201626-b1b626ac65ae/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
-github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
-github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
@@ -20,40 +12,48 @@ github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/charmbracelet/bubbles v1.0.0 h1:12J8/ak/uCZEMQ6KU7pcfwceyjLlWsDLAxB5fXonfvc=
-github.com/charmbracelet/bubbles v1.0.0/go.mod h1:9d/Zd5GdnauMI5ivUIVisuEm3ave1XwXtD1ckyV6r3E=
+github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
 github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
-github.com/charmbracelet/colorprofile v0.4.2 h1:BdSNuMjRbotnxHSfxy+PCSa4xAmz7szw70ktAtWRYrY=
-github.com/charmbracelet/colorprofile v0.4.2/go.mod h1:0rTi81QpwDElInthtrQ6Ni7cG0sDtwAd4C4le060fT8=
+github.com/charmbracelet/colorprofile v0.3.3 h1:DjJzJtLP6/NZ8p7Cgjno0CKGr7wwRJGxWUwh2IyhfAI=
+github.com/charmbracelet/colorprofile v0.3.3/go.mod h1:nB1FugsAbzq284eJcjfah2nhdSLppN2NqvfotkfRYP4=
+github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
+github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=
 github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
 github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
-github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
-github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
-github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
-github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
+github.com/charmbracelet/x/ansi v0.11.2 h1:XAG3FSjiVtFvgEgGrNBkCNNYrsucAt8c6bfxHyROLLs=
+github.com/charmbracelet/x/ansi v0.11.2/go.mod h1:9tY2bzX5SiJCU0iWyskjBeI2BRQfvPqI+J760Mjf+Rg=
+github.com/charmbracelet/x/ansi v0.11.3 h1:6DcVaqWI82BBVM/atTyq6yBoRLZFBsnoDoX9GCu2YOI=
+github.com/charmbracelet/x/ansi v0.11.3/go.mod h1:yI7Zslym9tCJcedxz5+WBq+eUGMJT0bM06Fqy1/Y4dI=
+github.com/charmbracelet/x/cellbuf v0.0.14 h1:iUEMryGyFTelKW3THW4+FfPgi4fkmKnnaLOXuc+/Kj4=
+github.com/charmbracelet/x/cellbuf v0.0.14/go.mod h1:P447lJl49ywBbil/KjCk2HexGh4tEY9LH0/1QrZZ9rA=
 github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
 github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
-github.com/clipperhouse/displaywidth v0.10.0 h1:GhBG8WuerxjFQQYeuZAeVTuyxuX+UraiZGD4HJQ3Y8g=
-github.com/clipperhouse/displaywidth v0.10.0/go.mod h1:XqJajYsaiEwkxOj4bowCTMcT1SgvHo9flfF3jQasdbs=
-github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
-github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
-github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8=
-github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
+github.com/clipperhouse/displaywidth v0.6.0 h1:k32vueaksef9WIKCNcoqRNyKbyvkvkysNYnAWz2fN4s=
+github.com/clipperhouse/displaywidth v0.6.0/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/displaywidth v0.6.2 h1:ZDpTkFfpHOKte4RG5O/BOyf3ysnvFswpyYrV7z2uAKo=
+github.com/clipperhouse/displaywidth v0.6.2/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
+github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
+github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
+github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/cloudflare/circl v1.6.2 h1:hL7VBpHHKzrV5WTfHCaBsgx/HGbBYlgrwvNXEVDYYsQ=
+github.com/cloudflare/circl v1.6.2/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/cyphar/filepath-securejoin v0.6.1 h1:5CeZ1jPXEiYt3+Z6zqprSAgSWiggmpVyciv8syjIpVE=
 github.com/cyphar/filepath-securejoin v0.6.1/go.mod h1:A8hd4EnAeyujCJRrICiOWqjS1AX0a9kM5XL+NwKoYSc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
-github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
-github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
+github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
@@ -64,15 +64,22 @@ github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
 github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 github.com/go-git/gcfg/v2 v2.0.2 h1:MY5SIIfTGGEMhdA7d7JePuVVxtKL7Hp+ApGDJAJ7dpo=
 github.com/go-git/gcfg/v2 v2.0.2/go.mod h1:/lv2NsxvhepuMrldsFilrgct6pxzpGdSRC13ydTLSLs=
-github.com/go-git/go-billy/v6 v6.0.0-20260209124918-37866f83c2d3 h1:UU7oARtwQ5g85aFiCSwIUA6PBmAshYj0sytl/5CCBgs=
-github.com/go-git/go-billy/v6 v6.0.0-20260209124918-37866f83c2d3/go.mod h1:ZW9JC5gionMP1kv5uiaOaV23q0FFmNrVOV8VW+y/acc=
-github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20260122163445-0622d7459a67 h1:3hutPZF+/FBjR/9MdsLJ7e1mlt9pwHgwxMW7CrbmWII=
-github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20260122163445-0622d7459a67/go.mod h1:xKt0pNHST9tYHvbiLxSY27CQWFwgIxBJuDrOE0JvbZw=
-github.com/go-git/go-git/v6 v6.0.0-20260216160506-e6a3f881772f h1:TBkCJv9YwPOuXq1OG0r01bcxRrvs15Hp/DtZuPt4H6s=
-github.com/go-git/go-git/v6 v6.0.0-20260216160506-e6a3f881772f/go.mod h1:B88nWzfnhTlIikoJ4d84Nc9noKS5mJoA7SgDdkt0aPU=
+github.com/go-git/go-billy/v6 v6.0.0-20251126203821-7f9c95185ee0 h1:eY5aB2GXiVdgTueBcqsBt53WuJTRZAuCdIS/86Pcq5c=
+github.com/go-git/go-billy/v6 v6.0.0-20251126203821-7f9c95185ee0/go.mod h1:0NjwVNrwtVFZBReAp5OoGklGJIgJFEbVyHneAr4lc8k=
+github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd h1:Gd/f9cGi/3h1JOPaa6er+CkKUGyGX2DBJdFbDKVO+R0=
+github.com/go-git/go-billy/v6 v6.0.0-20251217170237-e9738f50a3cd/go.mod h1:d3XQcsHu1idnquxt48kAv+h+1MUiYKLH/e7LAzjP+pI=
+github.com/go-git/go-git-fixtures/v5 v5.1.1 h1:OH8i1ojV9bWfr0ZfasfpgtUXQHQyVS8HXik/V1C099w=
+github.com/go-git/go-git-fixtures/v5 v5.1.1/go.mod h1:Altk43lx3b1ks+dVoAG2300o5WWUnktvfY3VI6bcaXU=
+github.com/go-git/go-git-fixtures/v5 v5.1.2-0.20251229094738-4b14af179146 h1:xYfxAopYyL44ot6dMBIb1Z1njFM0ZBQ99HdIB99KxLs=
+github.com/go-git/go-git/v6 v6.0.0-20251128074608-48f817f57805 h1:jxQ3BzYeErNRvlI/4+0mpwqMzvB4g97U+ksfgvrUEbY=
+github.com/go-git/go-git/v6 v6.0.0-20251128074608-48f817f57805/go.mod h1:dIwT3uWK1ooHInyVnK2JS5VfQ3peVGYaw2QPqX7uFvs=
+github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19 h1:0lz2eJScP8v5YZQsrEw+ggWC5jNySjg4bIZo5BIh6iI=
+github.com/go-git/go-git/v6 v6.0.0-20251231065035-29ae690a9f19/go.mod h1:L+Evfcs7EdTqxwv854354cb6+++7TFL3hJn3Wy4g+3w=
 github.com/go-logfmt/logfmt v0.6.1 h1:4hvbpePJKnIzH1B+8OR/JPbTx37NktoI9LE2QZBBkvE=
 github.com/go-logfmt/logfmt v0.6.1/go.mod h1:EV2pOAQoZaT1ZXZbqDl5hrymndi4SY9ED9/z6CO0XAk=
 github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/godbus/dbus/v5 v5.2.0 h1:3WexO+U+yg9T70v9FdHr9kCxYlazaAXUhx2VMkbfax8=
+github.com/godbus/dbus/v5 v5.2.0/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
 github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
@@ -80,14 +87,12 @@ github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUv
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83 h1:B+A58zGFuDrvEZpPN+yS6swJA0nzqgZvDzgl/OPyefU=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83/go.mod h1:iHAf8OIncO2gcQ8XOjS7CMJ2aPbX2Bs0wl5pZyanEqk=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/kevinburke/ssh_config v1.6.0 h1:J1FBfmuVosPHf5GRdltRLhPJtJpTlMdKTBjRgTaQBFY=
-github.com/kevinburke/ssh_config v1.6.0/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
+github.com/kevinburke/ssh_config v1.4.0 h1:6xxtP5bZ2E4NF5tuQulISpTO2z8XbtH8cg1PWkxoFkQ=
+github.com/kevinburke/ssh_config v1.4.0/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -101,8 +106,8 @@ github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQ
 github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.2-0.20220822084749-2491eb6c1c75 h1:P8UmIzZMYDR+NGImiFvErt6VWfIRPuGM+vyjiEdkmIw=
-github.com/mattn/go-localereader v0.0.2-0.20220822084749-2491eb6c1c75/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
 github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
 github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
@@ -122,12 +127,16 @@ github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUc
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sblinch/kdl-go v0.0.0-20260121213736-8b7053306ca6 h1:JsjzqC6ymELkN4XlTjZPSahSAem21GySugLbKz6uF5E=
-github.com/sblinch/kdl-go v0.0.0-20260121213736-8b7053306ca6/go.mod h1:b3oNGuAKOQzhsCKmuLc/urEOPzgHj6fB8vl8bwTBh28=
+github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a h1:8ZZwZWIQKC0YVMyaCkbrdeI8faTjD1QBrRAAWc1TjMI=
+github.com/sblinch/kdl-go v0.0.0-20250930225324-bf4099d4614a/go.mod h1:b3oNGuAKOQzhsCKmuLc/urEOPzgHj6fB8vl8bwTBh28=
+github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3 h1:msKaIZrrNpvofLPDzNBW3152PJBsnPZsoNNosOCS+C0=
+github.com/sblinch/kdl-go v0.0.0-20251203232544-981d4ecc17c3/go.mod h1:b3oNGuAKOQzhsCKmuLc/urEOPzgHj6fB8vl8bwTBh28=
 github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
 github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
+github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
+github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -137,43 +146,45 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
 github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-github.com/yuin/goldmark v1.4.15/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yuin/goldmark v1.7.16 h1:n+CJdUxaFMiDUNnWC3dMWCIQJSkxH4uz3ZwQBkAlVNE=
-github.com/yuin/goldmark v1.7.16/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
-github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc h1:+IAOyRda+RLrxa1WC7umKOZRsGq4QrFFMYApOeHzQwQ=
-github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc/go.mod h1:ovIvrum6DQJA4QsJSovrkC4saKHQVs7TvcaeO8AIl5I=
 go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
 go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
-golang.org/x/exp v0.0.0-20260212183809-81e46e3db34a h1:ovFr6Z0MNmU7nH8VaX5xqw+05ST2uO1exVfZPVqRC5o=
-golang.org/x/exp v0.0.0-20260212183809-81e46e3db34a/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
-golang.org/x/image v0.36.0 h1:Iknbfm1afbgtwPTmHnS2gTM/6PPZfH+z2EFuOkSbqwc=
-golang.org/x/image v0.36.0/go.mod h1:YsWD2TyyGKiIX1kZlu9QfKIsQ4nAAK9bdgdrIsE7xy4=
-golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
-golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
+golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
+golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 h1:DHNhtq3sNNzrvduZZIiFyXWOL9IWaDPHqTnLJp+rCBY=
+golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
+golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93 h1:fQsdNF2N+/YewlRZiricy4P1iimyPKZ/xwniHj8Q2a0=
+golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93/go.mod h1:EPRbTFwzwjXj9NpYyyrvenVh9Y+GFeEvMNh7Xuz7xgU=
+golang.org/x/image v0.34.0 h1:33gCkyw9hmwbZJeZkct8XyR11yH889EQt/QH4VmXMn8=
+golang.org/x/image v0.34.0/go.mod h1:2RNFBZRB+vnwwFil8GkMdRvrJOFd1AzdZI6vOY+eJVU=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
+golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
-golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
+golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
+golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

core/internal/clipboard/clipboard.go

@@ -330,163 +330,3 @@ func selectPreferredMimeType(mimes []string) string {
 func IsImageMimeType(mime string) bool {
 	return len(mime) > 6 && mime[:6] == "image/"
 }
-
-type Offer struct {
-	MimeType string
-	Data     []byte
-}
-
-func CopyMulti(offers []Offer, foreground, pasteOnce bool) error {
-	if !foreground {
-		return copyMultiFork(offers, pasteOnce)
-	}
-	return copyMultiServe(offers, pasteOnce)
-}
-
-func copyMultiFork(offers []Offer, pasteOnce bool) error {
-	args := []string{os.Args[0], "cl", "copy", "--foreground", "--type", "__multi__"}
-	if pasteOnce {
-		args = append(args, "--paste-once")
-	}
-
-	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)
-	}
-
-	for _, offer := range offers {
-		fmt.Fprintf(stdin, "%s\x00%d\x00", offer.MimeType, len(offer.Data))
-		if _, err := stdin.Write(offer.Data); err != nil {
-			stdin.Close()
-			return fmt.Errorf("write offer data: %w", err)
-		}
-	}
-	stdin.Close()
-
-	return nil
-}
-
-func copyMultiServe(offers []Offer, 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)
-	}
-
-	offerMap := make(map[string][]byte)
-	for _, offer := range offers {
-		if err := source.Offer(offer.MimeType); err != nil {
-			return fmt.Errorf("offer %s: %w", offer.MimeType, err)
-		}
-		offerMap[offer.MimeType] = offer.Data
-	}
-
-	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()
-
-		if data, ok := offerMap[e.MimeType]; ok {
-			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
-			}
-		}
-	}
-}

core/internal/clipboard/store.go

@@ -60,7 +60,7 @@ func StoreWithConfig(data []byte, mimeType string, cfg StoreConfig) error {
 		return fmt.Errorf("get db path: %w", err)
 	}
 
-	db, err := bolt.Open(dbPath, 0o644, &bolt.Options{Timeout: 1 * time.Second})
+	db, err := bolt.Open(dbPath, 0644, &bolt.Options{Timeout: 1 * time.Second})
 	if err != nil {
 		return fmt.Errorf("open db: %w", err)
 	}
@@ -132,7 +132,7 @@ func GetDBPath() (string, error) {
 	oldPath := filepath.Join(oldDir, "db")
 
 	if _, err := os.Stat(oldPath); err == nil {
-		if err := os.MkdirAll(newDir, 0o700); err != nil {
+		if err := os.MkdirAll(newDir, 0700); err != nil {
 			return "", err
 		}
 		if err := os.Rename(oldPath, newPath); err != nil {
@@ -142,7 +142,7 @@ func GetDBPath() (string, error) {
 		return newPath, nil
 	}
 
-	if err := os.MkdirAll(newDir, 0o700); err != nil {
+	if err := os.MkdirAll(newDir, 0700); err != nil {
 		return "", err
 	}
 	return newPath, nil

core/internal/clipboard/watch.go

@@ -2,7 +2,6 @@ package clipboard
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -13,9 +12,8 @@ import (
 )
 
 type ClipboardChange struct {
-	Data      []byte
-	MimeType  string
-	MimeTypes []string
+	Data     []byte
+	MimeType string
 }
 
 func Watch(ctx context.Context, callback func(data []byte, mimeType string)) error {
@@ -132,154 +130,13 @@ func Watch(ctx context.Context, callback func(data []byte, mimeType string)) err
 			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 {
-				if isTimeoutError(err) {
-					continue
-				}
+			if err := wlCtx.Dispatch(); err != nil && err != os.ErrDeadlineExceeded {
 				return fmt.Errorf("dispatch: %w", err)
 			}
 		}
 	}
 }
 
-func WatchAll(ctx context.Context, callback func(data []byte, mimeType string, allMimeTypes []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
-		}
-
-		mimesCopy := make([]string, len(mimes))
-		copy(mimesCopy, mimes)
-
-		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, mimesCopy)
-		}()
-	})
-
-	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 {
-				if isTimeoutError(err) {
-					continue
-				}
-				return fmt.Errorf("dispatch: %w", err)
-			}
-		}
-	}
-}
-
-func isTimeoutError(err error) bool {
-	if err == nil {
-		return false
-	}
-	if errors.Is(err, os.ErrDeadlineExceeded) {
-		return true
-	}
-	if netErr, ok := err.(interface{ Timeout() bool }); ok && netErr.Timeout() {
-		return true
-	}
-	return false
-}
-
 func WatchChan(ctx context.Context) (<-chan ClipboardChange, <-chan error) {
 	ch := make(chan ClipboardChange, 16)
 	errCh := make(chan error, 1)

core/internal/config/deployer.go

@@ -126,13 +126,13 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal, useSystemd bo
 	}
 
 	configDir := filepath.Dir(result.Path)
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
+	if err := os.MkdirAll(configDir, 0755); err != nil {
 		result.Error = fmt.Errorf("failed to create config directory: %w", err)
 		return result, result.Error
 	}
 
 	dmsDir := filepath.Join(configDir, "dms")
-	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+	if err := os.MkdirAll(dmsDir, 0755); err != nil {
 		result.Error = fmt.Errorf("failed to create dms directory: %w", err)
 		return result, result.Error
 	}
@@ -150,7 +150,7 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal, useSystemd bo
 
 		timestamp := time.Now().Format("2006-01-02_15-04-05")
 		result.BackupPath = result.Path + ".backup." + timestamp
-		if err := os.WriteFile(result.BackupPath, existingData, 0o644); err != nil {
+		if err := os.WriteFile(result.BackupPath, existingData, 0644); err != nil {
 			result.Error = fmt.Errorf("failed to create backup: %w", err)
 			return result, result.Error
 		}
@@ -185,7 +185,7 @@ func (cd *ConfigDeployer) deployNiriConfig(terminal deps.Terminal, useSystemd bo
 		}
 	}
 
-	if err := os.WriteFile(result.Path, []byte(newConfig), 0o644); err != nil {
+	if err := os.WriteFile(result.Path, []byte(newConfig), 0644); err != nil {
 		result.Error = fmt.Errorf("failed to write config: %w", err)
 		return result, result.Error
 	}
@@ -211,17 +211,16 @@ func (cd *ConfigDeployer) deployNiriDmsConfigs(dmsDir, terminalCommand string) e
 		{"binds.kdl", strings.ReplaceAll(NiriBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
 		{"outputs.kdl", ""},
 		{"cursor.kdl", ""},
-		{"windowrules.kdl", ""},
 	}
 
 	for _, cfg := range configs {
 		path := filepath.Join(dmsDir, cfg.name)
-		// Skip if file already exists and is not empty to preserve user modifications
-		if info, err := os.Stat(path); err == nil && info.Size() > 0 {
+		// Skip if file already exists to preserve user modifications
+		if _, err := os.Stat(path); err == nil {
 			cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
 			continue
 		}
-		if err := os.WriteFile(path, []byte(cfg.content), 0o644); err != nil {
+		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))
@@ -239,7 +238,7 @@ func (cd *ConfigDeployer) deployGhosttyConfig() ([]DeploymentResult, error) {
 	}
 
 	configDir := filepath.Dir(mainResult.Path)
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
+	if err := os.MkdirAll(configDir, 0755); err != nil {
 		mainResult.Error = fmt.Errorf("failed to create config directory: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -255,14 +254,14 @@ func (cd *ConfigDeployer) deployGhosttyConfig() ([]DeploymentResult, error) {
 
 		timestamp := time.Now().Format("2006-01-02_15-04-05")
 		mainResult.BackupPath = mainResult.Path + ".backup." + timestamp
-		if err := os.WriteFile(mainResult.BackupPath, existingData, 0o644); err != nil {
+		if err := os.WriteFile(mainResult.BackupPath, existingData, 0644); err != nil {
 			mainResult.Error = fmt.Errorf("failed to create backup: %w", err)
 			return []DeploymentResult{mainResult}, mainResult.Error
 		}
 		cd.log(fmt.Sprintf("Backed up existing config to %s", mainResult.BackupPath))
 	}
 
-	if err := os.WriteFile(mainResult.Path, []byte(GhosttyConfig), 0o644); err != nil {
+	if err := os.WriteFile(mainResult.Path, []byte(GhosttyConfig), 0644); err != nil {
 		mainResult.Error = fmt.Errorf("failed to write config: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -277,12 +276,12 @@ func (cd *ConfigDeployer) deployGhosttyConfig() ([]DeploymentResult, error) {
 	}
 
 	themesDir := filepath.Dir(colorResult.Path)
-	if err := os.MkdirAll(themesDir, 0o755); err != nil {
+	if err := os.MkdirAll(themesDir, 0755); err != nil {
 		mainResult.Error = fmt.Errorf("failed to create themes directory: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
 
-	if err := os.WriteFile(colorResult.Path, []byte(GhosttyColorConfig), 0o644); err != nil {
+	if err := os.WriteFile(colorResult.Path, []byte(GhosttyColorConfig), 0644); err != nil {
 		colorResult.Error = fmt.Errorf("failed to write color config: %w", err)
 		return results, colorResult.Error
 	}
@@ -303,7 +302,7 @@ func (cd *ConfigDeployer) deployKittyConfig() ([]DeploymentResult, error) {
 	}
 
 	configDir := filepath.Dir(mainResult.Path)
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
+	if err := os.MkdirAll(configDir, 0755); err != nil {
 		mainResult.Error = fmt.Errorf("failed to create config directory: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -319,14 +318,14 @@ func (cd *ConfigDeployer) deployKittyConfig() ([]DeploymentResult, error) {
 
 		timestamp := time.Now().Format("2006-01-02_15-04-05")
 		mainResult.BackupPath = mainResult.Path + ".backup." + timestamp
-		if err := os.WriteFile(mainResult.BackupPath, existingData, 0o644); err != nil {
+		if err := os.WriteFile(mainResult.BackupPath, existingData, 0644); err != nil {
 			mainResult.Error = fmt.Errorf("failed to create backup: %w", err)
 			return []DeploymentResult{mainResult}, mainResult.Error
 		}
 		cd.log(fmt.Sprintf("Backed up existing config to %s", mainResult.BackupPath))
 	}
 
-	if err := os.WriteFile(mainResult.Path, []byte(KittyConfig), 0o644); err != nil {
+	if err := os.WriteFile(mainResult.Path, []byte(KittyConfig), 0644); err != nil {
 		mainResult.Error = fmt.Errorf("failed to write config: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -340,7 +339,7 @@ func (cd *ConfigDeployer) deployKittyConfig() ([]DeploymentResult, error) {
 		Path:       filepath.Join(os.Getenv("HOME"), ".config", "kitty", "dank-theme.conf"),
 	}
 
-	if err := os.WriteFile(themeResult.Path, []byte(KittyThemeConfig), 0o644); err != nil {
+	if err := os.WriteFile(themeResult.Path, []byte(KittyThemeConfig), 0644); err != nil {
 		themeResult.Error = fmt.Errorf("failed to write theme config: %w", err)
 		return results, themeResult.Error
 	}
@@ -354,7 +353,7 @@ func (cd *ConfigDeployer) deployKittyConfig() ([]DeploymentResult, error) {
 		Path:       filepath.Join(os.Getenv("HOME"), ".config", "kitty", "dank-tabs.conf"),
 	}
 
-	if err := os.WriteFile(tabsResult.Path, []byte(KittyTabsConfig), 0o644); err != nil {
+	if err := os.WriteFile(tabsResult.Path, []byte(KittyTabsConfig), 0644); err != nil {
 		tabsResult.Error = fmt.Errorf("failed to write tabs config: %w", err)
 		return results, tabsResult.Error
 	}
@@ -375,7 +374,7 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 	}
 
 	configDir := filepath.Dir(mainResult.Path)
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
+	if err := os.MkdirAll(configDir, 0755); err != nil {
 		mainResult.Error = fmt.Errorf("failed to create config directory: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -391,14 +390,14 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 
 		timestamp := time.Now().Format("2006-01-02_15-04-05")
 		mainResult.BackupPath = mainResult.Path + ".backup." + timestamp
-		if err := os.WriteFile(mainResult.BackupPath, existingData, 0o644); err != nil {
+		if err := os.WriteFile(mainResult.BackupPath, existingData, 0644); err != nil {
 			mainResult.Error = fmt.Errorf("failed to create backup: %w", err)
 			return []DeploymentResult{mainResult}, mainResult.Error
 		}
 		cd.log(fmt.Sprintf("Backed up existing config to %s", mainResult.BackupPath))
 	}
 
-	if err := os.WriteFile(mainResult.Path, []byte(AlacrittyConfig), 0o644); err != nil {
+	if err := os.WriteFile(mainResult.Path, []byte(AlacrittyConfig), 0644); err != nil {
 		mainResult.Error = fmt.Errorf("failed to write config: %w", err)
 		return []DeploymentResult{mainResult}, mainResult.Error
 	}
@@ -412,7 +411,7 @@ func (cd *ConfigDeployer) deployAlacrittyConfig() ([]DeploymentResult, error) {
 		Path:       filepath.Join(os.Getenv("HOME"), ".config", "alacritty", "dank-theme.toml"),
 	}
 
-	if err := os.WriteFile(themeResult.Path, []byte(AlacrittyThemeConfig), 0o644); err != nil {
+	if err := os.WriteFile(themeResult.Path, []byte(AlacrittyThemeConfig), 0644); err != nil {
 		themeResult.Error = fmt.Errorf("failed to write theme config: %w", err)
 		return results, themeResult.Error
 	}
@@ -439,7 +438,7 @@ func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig, dms
 			outputsContent.WriteString(output)
 			outputsContent.WriteString("\n\n")
 		}
-		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0o644); err != nil {
+		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0644); err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to migrate outputs to %s: %v", outputsPath, err))
 		} else {
 			cd.log("Migrated output sections to dms/outputs.kdl")
@@ -480,13 +479,13 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 	}
 
 	configDir := filepath.Dir(result.Path)
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
+	if err := os.MkdirAll(configDir, 0755); err != nil {
 		result.Error = fmt.Errorf("failed to create config directory: %w", err)
 		return result, result.Error
 	}
 
 	dmsDir := filepath.Join(configDir, "dms")
-	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+	if err := os.MkdirAll(dmsDir, 0755); err != nil {
 		result.Error = fmt.Errorf("failed to create dms directory: %w", err)
 		return result, result.Error
 	}
@@ -504,7 +503,7 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 
 		timestamp := time.Now().Format("2006-01-02_15-04-05")
 		result.BackupPath = result.Path + ".backup." + timestamp
-		if err := os.WriteFile(result.BackupPath, existingData, 0o644); err != nil {
+		if err := os.WriteFile(result.BackupPath, existingData, 0644); err != nil {
 			result.Error = fmt.Errorf("failed to create backup: %w", err)
 			return result, result.Error
 		}
@@ -539,7 +538,7 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		}
 	}
 
-	if err := os.WriteFile(result.Path, []byte(newConfig), 0o644); err != nil {
+	if err := os.WriteFile(result.Path, []byte(newConfig), 0644); err != nil {
 		result.Error = fmt.Errorf("failed to write config: %w", err)
 		return result, result.Error
 	}
@@ -564,17 +563,15 @@ func (cd *ConfigDeployer) deployHyprlandDmsConfigs(dmsDir string, terminalComman
 		{"binds.conf", strings.ReplaceAll(HyprBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
 		{"outputs.conf", ""},
 		{"cursor.conf", ""},
-		{"windowrules.conf", ""},
 	}
 
 	for _, cfg := range configs {
 		path := filepath.Join(dmsDir, cfg.name)
-		// Skip if file already exists and is not empty to preserve user modifications
-		if info, err := os.Stat(path); err == nil && info.Size() > 0 {
+		if _, err := os.Stat(path); err == nil {
 			cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
 			continue
 		}
-		if err := os.WriteFile(path, []byte(cfg.content), 0o644); err != nil {
+		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))
@@ -598,7 +595,7 @@ func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig
 			outputsContent.WriteString(monitor)
 			outputsContent.WriteString("\n")
 		}
-		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0o644); err != nil {
+		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0644); err != nil {
 			cd.log(fmt.Sprintf("Warning: Failed to migrate monitors to %s: %v", outputsPath, err))
 		} else {
 			cd.log("Migrated monitor sections to dms/outputs.conf")
@@ -644,7 +641,7 @@ func (cd *ConfigDeployer) transformHyprlandConfigForNonSystemd(config, terminalC
 		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;xcb")
+			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")
@@ -659,7 +656,7 @@ func (cd *ConfigDeployer) transformHyprlandConfigForNonSystemd(config, terminalC
 			if strings.Contains(line, "STARTUP APPS") {
 				insertLines := []string{
 					"exec-once = dms run",
-					"env = QT_QPA_PLATFORM,wayland;xcb",
+					"env = QT_QPA_PLATFORM,wayland",
 					"env = ELECTRON_OZONE_PLATFORM_HINT,auto",
 					"env = QT_QPA_PLATFORMTHEME,gtk3",
 					"env = QT_QPA_PLATFORMTHEME_QT6,gtk3",
@@ -677,7 +674,7 @@ func (cd *ConfigDeployer) transformHyprlandConfigForNonSystemd(config, terminalC
 func (cd *ConfigDeployer) transformNiriConfigForNonSystemd(config, terminalCommand string) string {
 	envVars := fmt.Sprintf(`environment {
   XDG_CURRENT_DESKTOP "niri"
-  QT_QPA_PLATFORM "wayland;xcb"
+  QT_QPA_PLATFORM "wayland"
   ELECTRON_OZONE_PLATFORM_HINT "auto"
   QT_QPA_PLATFORMTHEME "gtk3"
   QT_QPA_PLATFORMTHEME_QT6 "gtk3"

core/internal/config/deployer_test.go

@@ -220,9 +220,9 @@ func TestConfigDeploymentFlow(t *testing.T) {
 	t.Run("deploy ghostty config with existing file", func(t *testing.T) {
 		existingContent := "# Old config\nfont-size = 14\n"
 		ghosttyPath := getGhosttyPath()
-		err := os.MkdirAll(filepath.Dir(ghosttyPath), 0o755)
+		err := os.MkdirAll(filepath.Dir(ghosttyPath), 0755)
 		require.NoError(t, err)
-		err = os.WriteFile(ghosttyPath, []byte(existingContent), 0o644)
+		err = os.WriteFile(ghosttyPath, []byte(existingContent), 0644)
 		require.NoError(t, err)
 
 		results, err := cd.deployGhosttyConfig()
@@ -422,9 +422,9 @@ general {
 }
 `
 		hyprPath := filepath.Join(tempDir, ".config", "hypr", "hyprland.conf")
-		err := os.MkdirAll(filepath.Dir(hyprPath), 0o755)
+		err := os.MkdirAll(filepath.Dir(hyprPath), 0755)
 		require.NoError(t, err)
-		err = os.WriteFile(hyprPath, []byte(existingContent), 0o644)
+		err = os.WriteFile(hyprPath, []byte(existingContent), 0644)
 		require.NoError(t, err)
 
 		result, err := cd.deployHyprlandConfig(deps.TerminalKitty, true)
@@ -600,9 +600,9 @@ func TestAlacrittyConfigDeployment(t *testing.T) {
 	t.Run("deploy alacritty config with existing file", func(t *testing.T) {
 		existingContent := "# Old alacritty config\n[window]\nopacity = 0.9\n"
 		alacrittyPath := filepath.Join(tempDir, ".config", "alacritty", "alacritty.toml")
-		err := os.MkdirAll(filepath.Dir(alacrittyPath), 0o755)
+		err := os.MkdirAll(filepath.Dir(alacrittyPath), 0755)
 		require.NoError(t, err)
-		err = os.WriteFile(alacrittyPath, []byte(existingContent), 0o644)
+		err = os.WriteFile(alacrittyPath, []byte(existingContent), 0644)
 		require.NoError(t, err)
 
 		results, err := cd.deployAlacrittyConfig()

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

@@ -27,8 +27,6 @@ bindl = , XF86AudioPause, exec, dms ipc call mpris playPause
 bindl = , XF86AudioPlay, exec, dms ipc call mpris playPause
 bindl = , XF86AudioPrev, exec, dms ipc call mpris previous
 bindl = , XF86AudioNext, exec, dms ipc call mpris next
-bindel = CTRL, XF86AudioRaiseVolume, exec, dms ipc call mpris increment 3
-bindel = CTRL, XF86AudioLowerVolume, exec, dms ipc call mpris decrement 3
 
 # === Brightness Controls ===
 bindel = , XF86MonBrightnessUp, exec, dms ipc call brightness increment 5 ""
@@ -40,7 +38,6 @@ bind = SUPER, F, fullscreen, 1
 bind = SUPER SHIFT, F, fullscreen, 0
 bind = SUPER SHIFT, T, togglefloating
 bind = SUPER, W, togglegroup
-bind = SUPER SHIFT, W, exec, dms ipc call window-rules toggle
 
 # === Focus Navigation ===
 bind = SUPER, left, movefocus, l
@@ -94,9 +91,6 @@ bind = SUPER CTRL, up, movetoworkspace, e-1
 bind = SUPER CTRL, U, movetoworkspace, e+1
 bind = SUPER CTRL, I, movetoworkspace, e-1
 
-# === Workspace Management ===
-bind = CTRL SHIFT, R, exec, dms ipc call workspace-rename open
-
 # === Move Workspaces ===
 bind = SUPER SHIFT, Page_Down, movetoworkspace, e+1
 bind = SUPER SHIFT, Page_Up, movetoworkspace, e-1

core/internal/config/embedded/hyprland.conf

@@ -81,6 +81,7 @@ master {
 misc {
     disable_hyprland_logo = true
     disable_splash_rendering = true
+    vrr = 1
 }
 
 # ==================
@@ -98,11 +99,9 @@ windowrule = float on, match:class ^(gnome-calculator)$
 windowrule = float on, match:class ^(galculator)$
 windowrule = float on, match:class ^(blueman-manager)$
 windowrule = float on, match:class ^(org\.gnome\.Nautilus)$
+windowrule = float on, match:class ^(steam)$
 windowrule = float on, match:class ^(xdg-desktop-portal)$
 
-windowrule = no_initial_focus on, match:class ^(steam)$, match:title ^(notificationtoasts)
-windowrule = pin on, match:class ^(steam)$, match:title ^(notificationtoasts)
-
 windowrule = float on, match:class ^(firefox)$, match:title ^(Picture-in-Picture)$
 windowrule = float on, match:class ^(zoom)$
 
@@ -111,7 +110,6 @@ windowrule = float on, match:class ^(zoom)$
 # windowrule = float on, match:class ^(org.quickshell)$
 
 layerrule = no_anim on, match:namespace ^(quickshell)$
-layerrule = no_anim on, match:namespace ^dms:.*
 
 source = ./dms/colors.conf
 source = ./dms/outputs.conf

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

@@ -60,12 +60,6 @@ binds {
 		XF86AudioNext allow-when-locked=true {
 		    spawn "dms" "ipc" "call" "mpris" "next";
 		}
-        Ctrl+XF86AudioRaiseVolume allow-when-locked=true {
-            spawn "dms" "ipc" "call" "mpris" "increment" "3";
-        }
-        Ctrl+XF86AudioLowerVolume allow-when-locked=true {
-            spawn "dms" "ipc" "call" "mpris" "decrement" "3";
-        }
 
     // === Brightness Controls ===
     XF86MonBrightnessUp allow-when-locked=true {
@@ -82,7 +76,6 @@ binds {
     Mod+Shift+T { toggle-window-floating; }
     Mod+Shift+V { switch-focus-between-floating-and-tiling; }
     Mod+W { toggle-column-tabbed-display; }
-    Mod+Shift+W hotkey-overlay-title="Create window rule" { spawn "dms" "ipc" "call" "window-rules" "toggle"; }
 
     // === Focus Navigation ===
     Mod+Left  { focus-column-left; }
@@ -140,11 +133,6 @@ binds {
     Mod+Ctrl+U         { move-column-to-workspace-down; }
     Mod+Ctrl+I         { move-column-to-workspace-up; }
 
-    // === Workspace Management ===
-    Ctrl+Shift+R hotkey-overlay-title="Rename Workspace" {
-        spawn "dms" "ipc" "call" "workspace-rename" "open";
-    }
-
     // === Move Workspaces ===
     Mod+Shift+Page_Down { move-workspace-down; }
     Mod+Shift+Page_Up   { move-workspace-up; }

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

@@ -1,17 +0,0 @@
-hotkey-overlay {
-    skip-at-startup
-}
-
-environment {
-    DMS_RUN_GREETER "1"
-}
-
-gestures {
-    hot-corners {
-        off
-    }
-}
-
-layout {
-    background-color "#000000"
-}

core/internal/config/embedded/niri.kdl

@@ -228,14 +228,10 @@ window-rule {
     match app-id=r#"^galculator$"#
     match app-id=r#"^blueman-manager$"#
     match app-id=r#"^org\.gnome\.Nautilus$"#
+    match app-id=r#"^steam$"#
     match app-id=r#"^xdg-desktop-portal$"#
     open-floating true
 }
-window-rule {
-    match app-id=r#"^steam$"# title=r#"^notificationtoasts_\d+_desktop$"#
-    default-floating-position x=10 y=10 relative-to="bottom-right"
-    open-focused false
-}
 window-rule {
     match app-id=r#"^org\.wezfurlong\.wezterm$"#
     match app-id="Alacritty"

core/internal/config/niri.go

@@ -16,6 +16,3 @@ var NiriAlttabConfig string
 
 //go:embed embedded/niri-binds.kdl
 var NiriBindsConfig string
-
-//go:embed embedded/niri-greeter.kdl
-var NiriGreeterConfig string

core/internal/dank16/dank16.go

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

core/internal/dank16/dank16_test.go

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

core/internal/distros/arch.go

@@ -26,9 +26,6 @@ func init() {
 	Register("cachyos", "#08A283", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewArchDistribution(config, logChan)
 	})
-	Register("catos", "#1793D1", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
-		return NewArchDistribution(config, logChan)
-	})
 	Register("endeavouros", "#7F3FBF", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewArchDistribution(config, logChan)
 	})
@@ -44,9 +41,6 @@ func init() {
 	Register("artix", "#1793D1", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewArchDistribution(config, logChan)
 	})
-	Register("XeroLinux", "#888fe2", FamilyArch, func(config DistroConfig, logChan chan<- string) Distribution {
-		return NewArchDistribution(config, logChan)
-	})
 }
 
 type ArchDistribution struct {

core/internal/distros/base.go

@@ -534,7 +534,7 @@ func (b *BaseDistribution) WriteEnvironmentConfig(terminal deps.Terminal) error
 	}
 
 	envDir := filepath.Join(homeDir, ".config", "environment.d")
-	if err := os.MkdirAll(envDir, 0o755); err != nil {
+	if err := os.MkdirAll(envDir, 0755); err != nil {
 		return fmt.Errorf("failed to create environment.d directory: %w", err)
 	}
 
@@ -555,7 +555,7 @@ TERMINAL=%s
 `, terminalCmd)
 
 	envFile := filepath.Join(envDir, "90-dms.conf")
-	if err := os.WriteFile(envFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(envFile, []byte(content), 0644); err != nil {
 		return fmt.Errorf("failed to write environment config: %w", err)
 	}
 
@@ -594,7 +594,7 @@ func (b *BaseDistribution) WriteHyprlandSessionTarget() error {
 	}
 
 	targetDir := filepath.Join(homeDir, ".config", "systemd", "user")
-	if err := os.MkdirAll(targetDir, 0o755); err != nil {
+	if err := os.MkdirAll(targetDir, 0755); err != nil {
 		return fmt.Errorf("failed to create systemd user directory: %w", err)
 	}
 
@@ -605,7 +605,7 @@ Requires=graphical-session.target
 After=graphical-session.target
 `
 
-	if err := os.WriteFile(targetPath, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(targetPath, []byte(content), 0644); err != nil {
 		return fmt.Errorf("failed to write hyprland-session.target: %w", err)
 	}
 

core/internal/distros/base_test.go

@@ -43,7 +43,7 @@ func TestBaseDistribution_detectDMS_Installed(t *testing.T) {
 
 	tempDir := t.TempDir()
 	dmsPath := filepath.Join(tempDir, ".config", "quickshell", "dms")
-	os.MkdirAll(dmsPath, 0o755)
+	os.MkdirAll(dmsPath, 0755)
 
 	originalHome := os.Getenv("HOME")
 	defer os.Setenv("HOME", originalHome)
@@ -55,7 +55,7 @@ func TestBaseDistribution_detectDMS_Installed(t *testing.T) {
 	exec.Command("git", "-C", dmsPath, "checkout", "-b", "master").Run()
 
 	testFile := filepath.Join(dmsPath, "test.txt")
-	os.WriteFile(testFile, []byte("test"), 0o644)
+	os.WriteFile(testFile, []byte("test"), 0644)
 	exec.Command("git", "-C", dmsPath, "add", ".").Run()
 	exec.Command("git", "-C", dmsPath, "commit", "-m", "initial").Run()
 
@@ -87,7 +87,7 @@ func TestBaseDistribution_detectDMS_NeedsUpdate(t *testing.T) {
 
 	tempDir := t.TempDir()
 	dmsPath := filepath.Join(tempDir, ".config", "quickshell", "dms")
-	os.MkdirAll(dmsPath, 0o755)
+	os.MkdirAll(dmsPath, 0755)
 
 	originalHome := os.Getenv("HOME")
 	defer os.Setenv("HOME", originalHome)
@@ -99,7 +99,7 @@ func TestBaseDistribution_detectDMS_NeedsUpdate(t *testing.T) {
 	exec.Command("git", "-C", dmsPath, "remote", "add", "origin", "https://github.com/AvengeMedia/DankMaterialShell.git").Run()
 
 	testFile := filepath.Join(dmsPath, "test.txt")
-	os.WriteFile(testFile, []byte("test"), 0o644)
+	os.WriteFile(testFile, []byte("test"), 0644)
 	exec.Command("git", "-C", dmsPath, "add", ".").Run()
 	exec.Command("git", "-C", dmsPath, "commit", "-m", "initial").Run()
 	exec.Command("git", "-C", dmsPath, "tag", "v0.0.1").Run()
@@ -125,7 +125,7 @@ func TestBaseDistribution_detectDMS_NeedsUpdate(t *testing.T) {
 func TestBaseDistribution_detectDMS_DirectoryWithoutGit(t *testing.T) {
 	tempDir := t.TempDir()
 	dmsPath := filepath.Join(tempDir, ".config", "quickshell", "dms")
-	os.MkdirAll(dmsPath, 0o755)
+	os.MkdirAll(dmsPath, 0755)
 
 	originalHome := os.Getenv("HOME")
 	defer os.Setenv("HOME", originalHome)

core/internal/distros/debian.go

@@ -430,7 +430,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 			}
 
 			// Add repository
-			repoLine := fmt.Sprintf("deb [signed-by=%s arch=%s] %s/ /", keyringPath, runtime.GOARCH, baseURL)
+			repoLine := fmt.Sprintf("deb [signed-by=%s, arch=%s] %s/ /", keyringPath, runtime.GOARCH, baseURL)
 
 			progressChan <- InstallProgressMsg{
 				Phase:       PhaseSystemPackages,

core/internal/distros/opensuse.go

@@ -540,12 +540,12 @@ func (o *OpenSUSEDistribution) installQuickshell(ctx context.Context, variant de
 	}
 
 	cacheDir := filepath.Join(homeDir, ".cache", "dankinstall")
-	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
 	tmpDir := filepath.Join(cacheDir, "quickshell-build")
-	if err := os.MkdirAll(tmpDir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return fmt.Errorf("failed to create temp directory: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -576,7 +576,7 @@ func (o *OpenSUSEDistribution) installQuickshell(ctx context.Context, variant de
 	}
 
 	buildDir := tmpDir + "/build"
-	if err := os.MkdirAll(buildDir, 0o755); err != nil {
+	if err := os.MkdirAll(buildDir, 0755); err != nil {
 		return fmt.Errorf("failed to create build directory: %w", err)
 	}
 

core/internal/dms/app.go

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

core/internal/dms/app_distro.go

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

core/internal/dms/detector.go

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

core/internal/dms/handlers_common.go

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

core/internal/dms/handlers_features.go

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

core/internal/dms/handlers_mainmenu.go

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

core/internal/dms/handlers_mainmenu_distro.go

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

core/internal/dms/plugins_handlers.go

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

core/internal/dms/plugins_views.go

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

core/internal/dms/views_common.go

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

core/internal/dms/views_features.go

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

core/internal/greeter/installer.go

@@ -8,13 +8,10 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"github.com/sblinch/kdl-go"
-	"github.com/sblinch/kdl-go/document"
 )
 
 // DetectDMSPath checks for DMS installation following XDG Base Directory specification
@@ -22,21 +19,6 @@ func DetectDMSPath() (string, error) {
 	return config.LocateDMSConfig()
 }
 
-func DetectGreeterGroup() string {
-	data, err := os.ReadFile("/etc/group")
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "⚠ Warning: could not read /etc/group, defaulting to greeter")
-		return "greeter"
-	}
-
-	if group, found := utils.FindGroupData(string(data), "greeter", "greetd", "_greeter"); found {
-		return group
-	}
-
-	fmt.Fprintln(os.Stderr, "⚠ Warning: no greeter group found in /etc/group, defaulting to greeter")
-	return "greeter"
-}
-
 // DetectCompositors checks which compositors are installed
 func DetectCompositors() []string {
 	var compositors []string
@@ -209,17 +191,14 @@ func CopyGreeterFiles(dmsPath, compositor string, logFunc func(string), sudoPass
 		return fmt.Errorf("failed to create cache directory: %w", err)
 	}
 
-	group := DetectGreeterGroup()
-	owner := fmt.Sprintf("%s:%s", group, group)
-
-	if err := runSudoCmd(sudoPassword, "chown", owner, cacheDir); err != nil {
+	if err := runSudoCmd(sudoPassword, "chown", "greeter:greeter", cacheDir); err != nil {
 		return fmt.Errorf("failed to set cache directory owner: %w", err)
 	}
 
-	if err := runSudoCmd(sudoPassword, "chmod", "755", cacheDir); err != nil {
+	if err := runSudoCmd(sudoPassword, "chmod", "750", cacheDir); err != nil {
 		return fmt.Errorf("failed to set cache directory permissions: %w", err)
 	}
-	logFunc(fmt.Sprintf("✓ Created cache directory %s (owner: %s, permissions: 755)", cacheDir, owner))
+	logFunc(fmt.Sprintf("✓ Created cache directory %s (owner: greeter:greeter, permissions: 750)", cacheDir))
 
 	return nil
 }
@@ -252,22 +231,20 @@ func SetupParentDirectoryACLs(logFunc func(string), sudoPassword string) error {
 		{filepath.Join(homeDir, ".local", "share"), ".local/share directory"},
 	}
 
-	owner := DetectGreeterGroup()
-
 	logFunc("\nSetting up parent directory ACLs for greeter user access...")
 
 	for _, dir := range parentDirs {
 		if _, err := os.Stat(dir.path); os.IsNotExist(err) {
-			if err := os.MkdirAll(dir.path, 0o755); err != nil {
+			if err := os.MkdirAll(dir.path, 0755); err != nil {
 				logFunc(fmt.Sprintf("⚠ Warning: Could not create %s: %v", dir.desc, err))
 				continue
 			}
 		}
 
 		// Set ACL to allow greeter user read+execute permission (for session discovery)
-		if err := runSudoCmd(sudoPassword, "setfacl", "-m", fmt.Sprintf("u:%s:rx", owner), dir.path); err != nil {
+		if err := runSudoCmd(sudoPassword, "setfacl", "-m", "u:greeter:rx", dir.path); err != nil {
 			logFunc(fmt.Sprintf("⚠ Warning: Failed to set ACL on %s: %v", dir.desc, err))
-			logFunc(fmt.Sprintf("  You may need to run manually: setfacl -m u:%s:x %s", owner, dir.path))
+			logFunc(fmt.Sprintf("  You may need to run manually: setfacl -m u:greeter:x %s", dir.path))
 			continue
 		}
 
@@ -291,19 +268,17 @@ func SetupDMSGroup(logFunc func(string), sudoPassword string) error {
 		return fmt.Errorf("failed to determine current user")
 	}
 
-	group := DetectGreeterGroup()
-
 	// Check if user is already in greeter group
 	groupsCmd := exec.Command("groups", currentUser)
 	groupsOutput, err := groupsCmd.Output()
-	if err == nil && strings.Contains(string(groupsOutput), group) {
-		logFunc(fmt.Sprintf("✓ %s is already in %s group", currentUser, group))
+	if err == nil && strings.Contains(string(groupsOutput), "greeter") {
+		logFunc(fmt.Sprintf("✓ %s is already in greeter group", currentUser))
 	} else {
 		// Add current user to greeter group for file access permissions
-		if err := runSudoCmd(sudoPassword, "usermod", "-aG", group, currentUser); err != nil {
-			return fmt.Errorf("failed to add %s to %s group: %w", currentUser, group, err)
+		if err := runSudoCmd(sudoPassword, "usermod", "-aG", "greeter", currentUser); err != nil {
+			return fmt.Errorf("failed to add %s to greeter group: %w", currentUser, err)
 		}
-		logFunc(fmt.Sprintf("✓ Added %s to %s group (logout/login required for changes to take effect)", currentUser, group))
+		logFunc(fmt.Sprintf("✓ Added %s to greeter group (logout/login required for changes to take effect)", currentUser))
 	}
 
 	configDirs := []struct {
@@ -320,13 +295,13 @@ func SetupDMSGroup(logFunc func(string), sudoPassword string) error {
 
 	for _, dir := range configDirs {
 		if _, err := os.Stat(dir.path); os.IsNotExist(err) {
-			if err := os.MkdirAll(dir.path, 0o755); err != nil {
+			if err := os.MkdirAll(dir.path, 0755); err != nil {
 				logFunc(fmt.Sprintf("⚠ Warning: Could not create %s: %v", dir.path, err))
 				continue
 			}
 		}
 
-		if err := runSudoCmd(sudoPassword, "chgrp", "-R", group, dir.path); err != nil {
+		if err := runSudoCmd(sudoPassword, "chgrp", "-R", "greeter", dir.path); err != nil {
 			logFunc(fmt.Sprintf("⚠ Warning: Failed to set group for %s: %v", dir.desc, err))
 			continue
 		}
@@ -347,7 +322,7 @@ func SetupDMSGroup(logFunc func(string), sudoPassword string) error {
 	return nil
 }
 
-func SyncDMSConfigs(dmsPath, compositor string, logFunc func(string), sudoPassword string) error {
+func SyncDMSConfigs(dmsPath string, logFunc func(string), sudoPassword string) error {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return fmt.Errorf("failed to get user home directory: %w", err)
@@ -380,14 +355,14 @@ func SyncDMSConfigs(dmsPath, compositor string, logFunc func(string), sudoPasswo
 	for _, link := range symlinks {
 		sourceDir := filepath.Dir(link.source)
 		if _, err := os.Stat(sourceDir); os.IsNotExist(err) {
-			if err := os.MkdirAll(sourceDir, 0o755); err != nil {
+			if err := os.MkdirAll(sourceDir, 0755); err != nil {
 				logFunc(fmt.Sprintf("⚠ Warning: Could not create directory %s: %v", sourceDir, err))
 				continue
 			}
 		}
 
 		if _, err := os.Stat(link.source); os.IsNotExist(err) {
-			if err := os.WriteFile(link.source, []byte("{}"), 0o644); err != nil {
+			if err := os.WriteFile(link.source, []byte("{}"), 0644); err != nil {
 				logFunc(fmt.Sprintf("⚠ Warning: Could not create %s: %v", link.source, err))
 				continue
 			}
@@ -403,351 +378,9 @@ func SyncDMSConfigs(dmsPath, compositor string, logFunc func(string), sudoPasswo
 		logFunc(fmt.Sprintf("✓ Synced %s", link.desc))
 	}
 
-	if strings.ToLower(compositor) != "niri" {
-		return nil
-	}
-
-	if err := syncNiriGreeterConfig(logFunc, sudoPassword); err != nil {
-		logFunc(fmt.Sprintf("⚠ Warning: Failed to sync niri greeter config: %v", err))
-	}
-
 	return nil
 }
 
-type niriGreeterSync struct {
-	processed   map[string]bool
-	nodes       []*document.Node
-	inputCount  int
-	outputCount int
-	cursorCount int
-	debugCount  int
-	cursorNode  *document.Node
-}
-
-func syncNiriGreeterConfig(logFunc func(string), sudoPassword string) error {
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return fmt.Errorf("failed to resolve user config directory: %w", err)
-	}
-
-	configPath := filepath.Join(configDir, "niri", "config.kdl")
-	if _, err := os.Stat(configPath); os.IsNotExist(err) {
-		logFunc("ℹ Niri config not found; skipping greeter niri sync")
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to stat niri config: %w", err)
-	}
-
-	extractor := &niriGreeterSync{
-		processed: make(map[string]bool),
-	}
-
-	if err := extractor.processFile(configPath); err != nil {
-		return err
-	}
-
-	if len(extractor.nodes) == 0 {
-		logFunc("ℹ No niri input/output sections found; skipping greeter niri sync")
-		return nil
-	}
-
-	content := extractor.render()
-	if strings.TrimSpace(content) == "" {
-		logFunc("ℹ No niri input/output content to sync; skipping greeter niri sync")
-		return nil
-	}
-
-	greeterDir := "/etc/greetd/niri"
-	greeterGroup := DetectGreeterGroup()
-	if err := runSudoCmd(sudoPassword, "mkdir", "-p", greeterDir); err != nil {
-		return fmt.Errorf("failed to create greetd niri directory: %w", err)
-	}
-	if err := runSudoCmd(sudoPassword, "chown", fmt.Sprintf("root:%s", greeterGroup), greeterDir); err != nil {
-		return fmt.Errorf("failed to set greetd niri directory ownership: %w", err)
-	}
-	if err := runSudoCmd(sudoPassword, "chmod", "755", greeterDir); err != nil {
-		return fmt.Errorf("failed to set greetd niri directory permissions: %w", err)
-	}
-
-	dmsTemp, err := os.CreateTemp("", "dms-greeter-niri-dms-*.kdl")
-	if err != nil {
-		return fmt.Errorf("failed to create temp file: %w", err)
-	}
-	defer os.Remove(dmsTemp.Name())
-
-	if _, err := dmsTemp.WriteString(content); err != nil {
-		_ = dmsTemp.Close()
-		return fmt.Errorf("failed to write temp niri config: %w", err)
-	}
-	if err := dmsTemp.Close(); err != nil {
-		return fmt.Errorf("failed to close temp niri config: %w", err)
-	}
-
-	dmsPath := filepath.Join(greeterDir, "dms.kdl")
-	if err := backupFileIfExists(sudoPassword, dmsPath, ".backup"); err != nil {
-		return fmt.Errorf("failed to backup %s: %w", dmsPath, err)
-	}
-	if err := runSudoCmd(sudoPassword, "install", "-o", "root", "-g", greeterGroup, "-m", "0644", dmsTemp.Name(), dmsPath); err != nil {
-		return fmt.Errorf("failed to install greetd niri dms config: %w", err)
-	}
-
-	mainContent := fmt.Sprintf("%s\ninclude \"%s\"\n", config.NiriGreeterConfig, dmsPath)
-	mainTemp, err := os.CreateTemp("", "dms-greeter-niri-main-*.kdl")
-	if err != nil {
-		return fmt.Errorf("failed to create temp file: %w", err)
-	}
-	defer os.Remove(mainTemp.Name())
-
-	if _, err := mainTemp.WriteString(mainContent); err != nil {
-		_ = mainTemp.Close()
-		return fmt.Errorf("failed to write temp niri main config: %w", err)
-	}
-	if err := mainTemp.Close(); err != nil {
-		return fmt.Errorf("failed to close temp niri main config: %w", err)
-	}
-
-	mainPath := filepath.Join(greeterDir, "config.kdl")
-	if err := backupFileIfExists(sudoPassword, mainPath, ".backup"); err != nil {
-		return fmt.Errorf("failed to backup %s: %w", mainPath, err)
-	}
-	if err := runSudoCmd(sudoPassword, "install", "-o", "root", "-g", greeterGroup, "-m", "0644", mainTemp.Name(), mainPath); err != nil {
-		return fmt.Errorf("failed to install greetd niri main config: %w", err)
-	}
-
-	if err := ensureGreetdNiriConfig(logFunc, sudoPassword, mainPath); err != nil {
-		logFunc(fmt.Sprintf("⚠ Warning: Failed to update greetd config for niri: %v", err))
-	}
-
-	logFunc(fmt.Sprintf("✓ Synced niri greeter config (%d input, %d output, %d cursor, %d debug) to %s", extractor.inputCount, extractor.outputCount, extractor.cursorCount, extractor.debugCount, dmsPath))
-	return nil
-}
-
-func ensureGreetdNiriConfig(logFunc func(string), sudoPassword string, niriConfigPath string) error {
-	configPath := "/etc/greetd/config.toml"
-	data, err := os.ReadFile(configPath)
-	if os.IsNotExist(err) {
-		logFunc("ℹ greetd config not found; skipping niri config wiring")
-		return nil
-	}
-	if err != nil {
-		return fmt.Errorf("failed to read greetd config: %w", err)
-	}
-
-	lines := strings.Split(string(data), "\n")
-	updated := false
-	for i, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if !strings.HasPrefix(trimmed, "command") {
-			continue
-		}
-
-		parts := strings.SplitN(trimmed, "=", 2)
-		if len(parts) != 2 {
-			continue
-		}
-
-		command := strings.Trim(strings.TrimSpace(parts[1]), "\"")
-		if !strings.Contains(command, "dms-greeter") {
-			continue
-		}
-		if !strings.Contains(command, "--command niri") {
-			continue
-		}
-		// Strip existing -C or --config and their arguments
-		command = stripConfigFlag(command)
-
-		newCommand := fmt.Sprintf("%s -C %s", command, niriConfigPath)
-		idx := strings.Index(line, "command")
-		leading := ""
-		if idx > 0 {
-			leading = line[:idx]
-		}
-		lines[i] = fmt.Sprintf("%scommand = \"%s\"", leading, newCommand)
-		updated = true
-		break
-	}
-
-	if !updated {
-		return nil
-	}
-
-	if err := backupFileIfExists(sudoPassword, configPath, ".backup"); err != nil {
-		return fmt.Errorf("failed to backup greetd config: %w", err)
-	}
-
-	tmpFile, err := os.CreateTemp("", "greetd-config-*.toml")
-	if err != nil {
-		return fmt.Errorf("failed to create temp greetd config: %w", err)
-	}
-	defer os.Remove(tmpFile.Name())
-
-	if _, err := tmpFile.WriteString(strings.Join(lines, "\n")); err != nil {
-		_ = tmpFile.Close()
-		return fmt.Errorf("failed to write temp greetd config: %w", err)
-	}
-	if err := tmpFile.Close(); err != nil {
-		return fmt.Errorf("failed to close temp greetd config: %w", err)
-	}
-
-	if err := runSudoCmd(sudoPassword, "mv", tmpFile.Name(), configPath); err != nil {
-		return fmt.Errorf("failed to update greetd config: %w", err)
-	}
-
-	logFunc(fmt.Sprintf("✓ Updated greetd config to use niri config %s", niriConfigPath))
-	return nil
-}
-
-func backupFileIfExists(sudoPassword string, path string, suffix string) error {
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		return nil
-	} else if err != nil {
-		return err
-	}
-
-	backupPath := fmt.Sprintf("%s%s-%s", path, suffix, time.Now().Format("20060102-150405"))
-	return runSudoCmd(sudoPassword, "cp", "-p", path, backupPath)
-}
-
-func (s *niriGreeterSync) processFile(filePath string) error {
-	absPath, err := filepath.Abs(filePath)
-	if err != nil {
-		return fmt.Errorf("failed to resolve path %s: %w", filePath, err)
-	}
-
-	if s.processed[absPath] {
-		return nil
-	}
-	s.processed[absPath] = true
-
-	data, err := os.ReadFile(absPath)
-	if err != nil {
-		return fmt.Errorf("failed to read %s: %w", absPath, err)
-	}
-
-	doc, err := kdl.Parse(strings.NewReader(string(data)))
-	if err != nil {
-		return fmt.Errorf("failed to parse KDL in %s: %w", absPath, err)
-	}
-
-	baseDir := filepath.Dir(absPath)
-	for _, node := range doc.Nodes {
-		name := node.Name.String()
-		switch name {
-		case "include":
-			if err := s.handleInclude(node, baseDir); err != nil {
-				return err
-			}
-		case "input":
-			s.nodes = append(s.nodes, node)
-			s.inputCount++
-		case "output":
-			s.nodes = append(s.nodes, node)
-			s.outputCount++
-		case "cursor":
-			if s.cursorNode == nil {
-				s.cursorNode = node
-				s.cursorNode.Children = dedupeCursorChildren(s.cursorNode.Children)
-				s.nodes = append(s.nodes, node)
-				s.cursorCount++
-			} else if len(node.Children) > 0 {
-				s.cursorNode.Children = mergeCursorChildren(s.cursorNode.Children, node.Children)
-			}
-		case "debug":
-			s.nodes = append(s.nodes, node)
-			s.debugCount++
-		}
-	}
-
-	return nil
-}
-
-func mergeCursorChildren(existing []*document.Node, incoming []*document.Node) []*document.Node {
-	if len(incoming) == 0 {
-		return existing
-	}
-
-	indexByName := make(map[string]int, len(existing))
-	for i, child := range existing {
-		indexByName[child.Name.String()] = i
-	}
-
-	for _, child := range incoming {
-		name := child.Name.String()
-		if idx, ok := indexByName[name]; ok {
-			existing[idx] = child
-			continue
-		}
-		indexByName[name] = len(existing)
-		existing = append(existing, child)
-	}
-
-	return existing
-}
-
-func dedupeCursorChildren(children []*document.Node) []*document.Node {
-	if len(children) == 0 {
-		return children
-	}
-
-	var result []*document.Node
-	indexByName := make(map[string]int, len(children))
-	for _, child := range children {
-		name := child.Name.String()
-		if idx, ok := indexByName[name]; ok {
-			result[idx] = child
-			continue
-		}
-		indexByName[name] = len(result)
-		result = append(result, child)
-	}
-
-	return result
-}
-
-func (s *niriGreeterSync) handleInclude(node *document.Node, baseDir string) error {
-	if len(node.Arguments) == 0 {
-		return nil
-	}
-
-	includePath := strings.Trim(node.Arguments[0].String(), "\"")
-	if includePath == "" {
-		return nil
-	}
-
-	fullPath := includePath
-	if !filepath.IsAbs(includePath) {
-		fullPath = filepath.Join(baseDir, includePath)
-	}
-
-	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to stat include %s: %w", fullPath, err)
-	}
-
-	return s.processFile(fullPath)
-}
-
-func (s *niriGreeterSync) render() string {
-	if len(s.nodes) == 0 {
-		return ""
-	}
-
-	var builder strings.Builder
-	for _, node := range s.nodes {
-		_, _ = node.WriteToOptions(&builder, document.NodeWriteOptions{
-			LeadingTrailingSpace: true,
-			NameAndType:          true,
-			Depth:                0,
-			Indent:               []byte("    "),
-			IgnoreFlags:          false,
-		})
-		builder.WriteString("\n")
-	}
-
-	return builder.String()
-}
-
 func ConfigureGreetd(dmsPath, compositor string, logFunc func(string), sudoPassword string) error {
 	configPath := "/etc/greetd/config.toml"
 
@@ -759,19 +392,17 @@ func ConfigureGreetd(dmsPath, compositor string, logFunc func(string), sudoPassw
 		logFunc(fmt.Sprintf("✓ Backed up existing config to %s", backupPath))
 	}
 
-	greeterUser := DetectGreeterGroup()
-
 	var configContent string
 	if data, err := os.ReadFile(configPath); err == nil {
 		configContent = string(data)
 	} else {
-		configContent = fmt.Sprintf(`[terminal]
+		configContent = `[terminal]
 vt = 1
 
 [default_session]
 
-user = "%s"
-`, greeterUser)
+user = "greeter"
+`
 	}
 
 	lines := strings.Split(configContent, "\n")
@@ -780,7 +411,7 @@ user = "%s"
 		trimmed := strings.TrimSpace(line)
 		if !strings.HasPrefix(trimmed, "command =") && !strings.HasPrefix(trimmed, "command=") {
 			if strings.HasPrefix(trimmed, "user =") || strings.HasPrefix(trimmed, "user=") {
-				newLines = append(newLines, fmt.Sprintf(`user = "%s"`, greeterUser))
+				newLines = append(newLines, `user = "greeter"`)
 			} else {
 				newLines = append(newLines, line)
 			}
@@ -824,7 +455,7 @@ user = "%s"
 	newConfig := strings.Join(finalLines, "\n")
 
 	tmpFile := "/tmp/greetd-config.toml"
-	if err := os.WriteFile(tmpFile, []byte(newConfig), 0o644); err != nil {
+	if err := os.WriteFile(tmpFile, []byte(newConfig), 0644); err != nil {
 		return fmt.Errorf("failed to write temp config: %w", err)
 	}
 
@@ -832,41 +463,10 @@ user = "%s"
 		return fmt.Errorf("failed to move config to /etc/greetd: %w", err)
 	}
 
-	logFunc(fmt.Sprintf("✓ Updated greetd configuration (user: %s, command: %s --command %s -p %s)", greeterUser, wrapperCmd, compositorLower, dmsPath))
+	logFunc(fmt.Sprintf("✓ Updated greetd configuration (user: greeter, command: %s --command %s -p %s)", wrapperCmd, compositorLower, dmsPath))
 	return nil
 }
 
-func stripConfigFlag(command string) string {
-	for _, flag := range []string{" -C ", " --config "} {
-		idx := strings.Index(command, flag)
-		if idx == -1 {
-			continue
-		}
-
-		before := command[:idx]
-		after := command[idx+len(flag):]
-
-		switch {
-		case strings.HasPrefix(after, `"`):
-			if end := strings.Index(after[1:], `"`); end != -1 {
-				after = after[end+2:]
-			} else {
-				after = ""
-			}
-		default:
-			if space := strings.Index(after, " "); space != -1 {
-				after = after[space:]
-			} else {
-				after = ""
-			}
-		}
-
-		command = strings.TrimSpace(before + after)
-	}
-
-	return command
-}
-
 func runSudoCmd(sudoPassword string, command string, args ...string) error {
 	var cmd *exec.Cmd
 

core/internal/keybinds/discovery_test.go

@@ -79,16 +79,16 @@ func TestFindJSONFiles(t *testing.T) {
 	txtFile := filepath.Join(tmpDir, "readme.txt")
 	subdir := filepath.Join(tmpDir, "subdir")
 
-	if err := os.WriteFile(file1, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(file1, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create file1: %v", err)
 	}
-	if err := os.WriteFile(file2, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(file2, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create file2: %v", err)
 	}
-	if err := os.WriteFile(txtFile, []byte("text"), 0o644); err != nil {
+	if err := os.WriteFile(txtFile, []byte("text"), 0644); err != nil {
 		t.Fatalf("Failed to create txt file: %v", err)
 	}
-	if err := os.MkdirAll(subdir, 0o755); err != nil {
+	if err := os.MkdirAll(subdir, 0755); err != nil {
 		t.Fatalf("Failed to create subdir: %v", err)
 	}
 
@@ -143,10 +143,10 @@ func TestFindJSONFilesMultiplePaths(t *testing.T) {
 	file1 := filepath.Join(tmpDir1, "app1.json")
 	file2 := filepath.Join(tmpDir2, "app2.json")
 
-	if err := os.WriteFile(file1, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(file1, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create file1: %v", err)
 	}
-	if err := os.WriteFile(file2, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(file2, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create file2: %v", err)
 	}
 
@@ -174,7 +174,7 @@ func TestAutoDiscoverProviders(t *testing.T) {
 }`
 
 	file := filepath.Join(tmpDir, "testapp.json")
-	if err := os.WriteFile(file, []byte(jsonContent), 0o644); err != nil {
+	if err := os.WriteFile(file, []byte(jsonContent), 0644); err != nil {
 		t.Fatalf("Failed to create test file: %v", err)
 	}
 
@@ -226,7 +226,7 @@ func TestAutoDiscoverProvidersNoFactory(t *testing.T) {
 	tmpDir := t.TempDir()
 
 	file := filepath.Join(tmpDir, "test.json")
-	if err := os.WriteFile(file, []byte("{}"), 0o644); err != nil {
+	if err := os.WriteFile(file, []byte("{}"), 0644); err != nil {
 		t.Fatalf("Failed to create test file: %v", err)
 	}
 

core/internal/keybinds/providers/hyprland.go

@@ -216,7 +216,7 @@ func (h *HyprlandProvider) SetBind(key, action, description string, options map[
 
 	overridePath := h.GetOverridePath()
 
-	if err := os.MkdirAll(filepath.Dir(overridePath), 0o755); err != nil {
+	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
 		return fmt.Errorf("failed to create dms directory: %w", err)
 	}
 
@@ -398,7 +398,7 @@ func (h *HyprlandProvider) getBindSortPriority(action string) int {
 func (h *HyprlandProvider) writeOverrideBinds(binds map[string]*hyprlandOverrideBind) error {
 	overridePath := h.GetOverridePath()
 	content := h.generateBindsContent(binds)
-	return os.WriteFile(overridePath, []byte(content), 0o644)
+	return os.WriteFile(overridePath, []byte(content), 0644)
 }
 
 func (h *HyprlandProvider) generateBindsContent(binds map[string]*hyprlandOverrideBind) string {

core/internal/keybinds/providers/hyprland_parser_test.go

@@ -187,7 +187,7 @@ bind = SUPER, right, movefocus, r
 bind = SUPER, T, exec, kitty # Terminal
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -245,7 +245,7 @@ bind = SUPER, B, exec, app2
 #/# = SUPER, C, exec, app3 # Custom comment
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -278,10 +278,10 @@ func TestHyprlandReadContentMultipleFiles(t *testing.T) {
 	content1 := "bind = SUPER, Q, killactive\n"
 	content2 := "bind = SUPER, T, exec, kitty\n"
 
-	if err := os.WriteFile(file1, []byte(content1), 0o644); err != nil {
+	if err := os.WriteFile(file1, []byte(content1), 0644); err != nil {
 		t.Fatalf("Failed to write file1: %v", err)
 	}
-	if err := os.WriteFile(file2, []byte(content2), 0o644); err != nil {
+	if err := os.WriteFile(file2, []byte(content2), 0644); err != nil {
 		t.Fatalf("Failed to write file2: %v", err)
 	}
 
@@ -328,13 +328,13 @@ func TestHyprlandReadContentWithTildeExpansion(t *testing.T) {
 	}
 
 	tmpSubdir := filepath.Join(homeDir, ".config", "test-hypr-"+t.Name())
-	if err := os.MkdirAll(tmpSubdir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpSubdir, 0755); err != nil {
 		t.Skip("Cannot create test directory in home")
 	}
 	defer os.RemoveAll(tmpSubdir)
 
 	configFile := filepath.Join(tmpSubdir, "test.conf")
-	if err := os.WriteFile(configFile, []byte("bind = SUPER, Q, killactive\n"), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte("bind = SUPER, Q, killactive\n"), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -381,7 +381,7 @@ bind = SUPER, Q, killactive
 bind = SUPER, T, exec, kitty
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/providers/hyprland_test.go

@@ -57,7 +57,7 @@ bind = SUPER, T, exec, kitty # Terminal
 bind = SUPER, 1, workspace, 1
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -134,7 +134,7 @@ func TestFormatKey(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := os.WriteFile(configFile, []byte(tt.content), 0o644); err != nil {
+			if err := os.WriteFile(configFile, []byte(tt.content), 0644); err != nil {
 				t.Fatalf("Failed to write test config: %v", err)
 			}
 
@@ -189,7 +189,7 @@ func TestDescriptionFallback(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := os.WriteFile(configFile, []byte(tt.content), 0o644); err != nil {
+			if err := os.WriteFile(configFile, []byte(tt.content), 0644); err != nil {
 				t.Fatalf("Failed to write test config: %v", err)
 			}
 

core/internal/keybinds/providers/mangowc.go

@@ -218,7 +218,7 @@ func (m *MangoWCProvider) SetBind(key, action, description string, options map[s
 
 	overridePath := m.GetOverridePath()
 
-	if err := os.MkdirAll(filepath.Dir(overridePath), 0o755); err != nil {
+	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
 		return fmt.Errorf("failed to create dms directory: %w", err)
 	}
 
@@ -360,7 +360,7 @@ func (m *MangoWCProvider) getBindSortPriority(action string) int {
 func (m *MangoWCProvider) writeOverrideBinds(binds map[string]*mangowcOverrideBind) error {
 	overridePath := m.GetOverridePath()
 	content := m.generateBindsContent(binds)
-	return os.WriteFile(overridePath, []byte(content), 0o644)
+	return os.WriteFile(overridePath, []byte(content), 0644)
 }
 
 func (m *MangoWCProvider) generateBindsContent(binds map[string]*mangowcOverrideBind) string {

core/internal/keybinds/providers/mangowc_parser.go

@@ -502,17 +502,17 @@ func (p *MangoWCParser) handleSource(line, baseDir string, keybinds *[]MangoWCKe
 		p.dmsProcessed = true
 	}
 
-	expanded, err := utils.ExpandPath(sourcePath)
+	fullPath := sourcePath
+	if !filepath.IsAbs(sourcePath) {
+		fullPath = filepath.Join(baseDir, sourcePath)
+	}
+
+	expanded, err := utils.ExpandPath(fullPath)
 	if err != nil {
 		return
 	}
 
-	fullPath := expanded
-	if !filepath.IsAbs(expanded) {
-		fullPath = filepath.Join(baseDir, expanded)
-	}
-
-	includedBinds, err := p.parseFileWithSource(fullPath)
+	includedBinds, err := p.parseFileWithSource(expanded)
 	if err != nil {
 		return
 	}
@@ -521,10 +521,33 @@ func (p *MangoWCParser) handleSource(line, baseDir string, keybinds *[]MangoWCKe
 }
 
 func (p *MangoWCParser) parseDMSBindsDirectly(dmsBindsPath string) []MangoWCKeyBinding {
-	keybinds, err := p.parseFileWithSource(dmsBindsPath)
+	data, err := os.ReadFile(dmsBindsPath)
 	if err != nil {
 		return nil
 	}
+
+	prevSource := p.currentSource
+	p.currentSource = dmsBindsPath
+
+	var keybinds []MangoWCKeyBinding
+	lines := strings.Split(string(data), "\n")
+
+	for lineNum, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if !strings.HasPrefix(trimmed, "bind") {
+			continue
+		}
+
+		kb := p.getKeybindAtLineContent(line, lineNum)
+		if kb == nil {
+			continue
+		}
+		kb.Source = dmsBindsPath
+		p.addBind(kb)
+		keybinds = append(keybinds, *kb)
+	}
+
+	p.currentSource = prevSource
 	p.dmsProcessed = true
 	return keybinds
 }

core/internal/keybinds/providers/mangowc_parser_test.go

@@ -238,7 +238,7 @@ bind=Ctrl,1,view,1,0
 bind=Ctrl,2,view,2,0
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -276,10 +276,10 @@ func TestMangoWCReadContentMultipleFiles(t *testing.T) {
 	content1 := "bind=ALT,q,killclient,\n"
 	content2 := "bind=Alt,t,spawn,kitty\n"
 
-	if err := os.WriteFile(file1, []byte(content1), 0o644); err != nil {
+	if err := os.WriteFile(file1, []byte(content1), 0644); err != nil {
 		t.Fatalf("Failed to write file1: %v", err)
 	}
-	if err := os.WriteFile(file2, []byte(content2), 0o644); err != nil {
+	if err := os.WriteFile(file2, []byte(content2), 0644); err != nil {
 		t.Fatalf("Failed to write file2: %v", err)
 	}
 
@@ -300,7 +300,7 @@ func TestMangoWCReadContentSingleFile(t *testing.T) {
 
 	content := "bind=ALT,q,killclient,\n"
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write config: %v", err)
 	}
 
@@ -347,13 +347,13 @@ func TestMangoWCReadContentWithTildeExpansion(t *testing.T) {
 	}
 
 	tmpSubdir := filepath.Join(homeDir, ".config", "test-mango-"+t.Name())
-	if err := os.MkdirAll(tmpSubdir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpSubdir, 0755); err != nil {
 		t.Skip("Cannot create test directory in home")
 	}
 	defer os.RemoveAll(tmpSubdir)
 
 	configFile := filepath.Join(tmpSubdir, "config.conf")
-	if err := os.WriteFile(configFile, []byte("bind=ALT,q,killclient,\n"), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte("bind=ALT,q,killclient,\n"), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -384,7 +384,7 @@ bind=ALT,q,killclient,
 bind=Alt,t,spawn,kitty
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -458,7 +458,7 @@ bind=Ctrl,2,view,2,0
 bind=Ctrl,3,view,3,0
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/providers/mangowc_test.go

@@ -223,7 +223,7 @@ bind=SUPER,n,switch_layout
 bind=ALT+SHIFT,X,incgaps,1
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -285,7 +285,7 @@ bind=ALT,Left,focusdir,left
 bind=Ctrl,1,view,1,0
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/providers/miracle.go

@@ -1,95 +0,0 @@
-package providers
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-)
-
-type MiracleProvider struct {
-	configPath string
-}
-
-func NewMiracleProvider(configPath string) *MiracleProvider {
-	if configPath == "" {
-		configDir, err := os.UserConfigDir()
-		if err == nil {
-			configPath = filepath.Join(configDir, "miracle-wm")
-		}
-	}
-	return &MiracleProvider{configPath: configPath}
-}
-
-func (m *MiracleProvider) Name() string {
-	return "miracle"
-}
-
-func (m *MiracleProvider) GetCheatSheet() (*keybinds.CheatSheet, error) {
-	config, err := ParseMiracleConfig(m.configPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse miracle-wm config: %w", err)
-	}
-
-	bindings := MiracleConfigToBindings(config)
-	categorizedBinds := make(map[string][]keybinds.Keybind)
-
-	for _, kb := range bindings {
-		category := m.categorizeAction(kb.Action)
-		bind := keybinds.Keybind{
-			Key:         m.formatKey(kb),
-			Description: kb.Comment,
-			Action:      kb.Action,
-		}
-		categorizedBinds[category] = append(categorizedBinds[category], bind)
-	}
-
-	return &keybinds.CheatSheet{
-		Title:    "Miracle WM Keybinds",
-		Provider: m.Name(),
-		Binds:    categorizedBinds,
-	}, nil
-}
-
-func (m *MiracleProvider) GetOverridePath() string {
-	expanded, err := utils.ExpandPath(m.configPath)
-	if err != nil {
-		return filepath.Join(m.configPath, "config.yaml")
-	}
-	return filepath.Join(expanded, "config.yaml")
-}
-
-func (m *MiracleProvider) formatKey(kb MiracleKeyBinding) string {
-	parts := make([]string, 0, len(kb.Mods)+1)
-	parts = append(parts, kb.Mods...)
-	parts = append(parts, kb.Key)
-	return strings.Join(parts, "+")
-}
-
-func (m *MiracleProvider) categorizeAction(action string) string {
-	switch {
-	case strings.HasPrefix(action, "select_workspace_") || strings.HasPrefix(action, "move_to_workspace_"):
-		return "Workspace"
-	case strings.Contains(action, "select_") || strings.Contains(action, "move_"):
-		return "Window"
-	case action == "toggle_resize" || strings.HasPrefix(action, "resize_"):
-		return "Window"
-	case action == "fullscreen" || action == "toggle_floating" || action == "quit_active_window" || action == "toggle_pinned_to_workspace":
-		return "Window"
-	case action == "toggle_tabbing" || action == "toggle_stacking" || action == "request_vertical" || action == "request_horizontal":
-		return "Layout"
-	case action == "quit_compositor":
-		return "System"
-	case action == "terminal":
-		return "Execute"
-	case strings.HasPrefix(action, "magnifier_"):
-		return "Accessibility"
-	case strings.HasPrefix(action, "dms ") || strings.Contains(action, "dms ipc"):
-		return "Execute"
-	default:
-		return "Execute"
-	}
-}

core/internal/keybinds/providers/miracle_parser.go

@@ -1,320 +0,0 @@
-package providers
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"gopkg.in/yaml.v3"
-)
-
-type MiracleConfig struct {
-	Terminal               string                  `yaml:"terminal"`
-	ActionKey              string                  `yaml:"action_key"`
-	DefaultActionOverrides []MiracleActionOverride `yaml:"default_action_overrides"`
-	CustomActions          []MiracleCustomAction   `yaml:"custom_actions"`
-}
-
-type MiracleActionOverride struct {
-	Name      string   `yaml:"name"`
-	Action    string   `yaml:"action"`
-	Modifiers []string `yaml:"modifiers"`
-	Key       string   `yaml:"key"`
-}
-
-type MiracleCustomAction struct {
-	Command   string   `yaml:"command"`
-	Action    string   `yaml:"action"`
-	Modifiers []string `yaml:"modifiers"`
-	Key       string   `yaml:"key"`
-}
-
-type MiracleKeyBinding struct {
-	Mods    []string
-	Key     string
-	Action  string
-	Comment string
-}
-
-var miracleDefaultBinds = []MiracleKeyBinding{
-	{Mods: []string{"Super"}, Key: "Return", Action: "terminal", Comment: "Open terminal"},
-	{Mods: []string{"Super"}, Key: "v", Action: "request_vertical", Comment: "Layout windows vertically"},
-	{Mods: []string{"Super"}, Key: "h", Action: "request_horizontal", Comment: "Layout windows horizontally"},
-	{Mods: []string{"Super"}, Key: "Up", Action: "select_up", Comment: "Select window above"},
-	{Mods: []string{"Super"}, Key: "Down", Action: "select_down", Comment: "Select window below"},
-	{Mods: []string{"Super"}, Key: "Left", Action: "select_left", Comment: "Select window left"},
-	{Mods: []string{"Super"}, Key: "Right", Action: "select_right", Comment: "Select window right"},
-	{Mods: []string{"Super", "Shift"}, Key: "Up", Action: "move_up", Comment: "Move window up"},
-	{Mods: []string{"Super", "Shift"}, Key: "Down", Action: "move_down", Comment: "Move window down"},
-	{Mods: []string{"Super", "Shift"}, Key: "Left", Action: "move_left", Comment: "Move window left"},
-	{Mods: []string{"Super", "Shift"}, Key: "Right", Action: "move_right", Comment: "Move window right"},
-	{Mods: []string{"Super"}, Key: "r", Action: "toggle_resize", Comment: "Toggle resize mode"},
-	{Mods: []string{"Super"}, Key: "f", Action: "fullscreen", Comment: "Toggle fullscreen"},
-	{Mods: []string{"Super", "Shift"}, Key: "q", Action: "quit_active_window", Comment: "Close window"},
-	{Mods: []string{"Super", "Shift"}, Key: "e", Action: "quit_compositor", Comment: "Exit compositor"},
-	{Mods: []string{"Super"}, Key: "Space", Action: "toggle_floating", Comment: "Toggle floating"},
-	{Mods: []string{"Super", "Shift"}, Key: "p", Action: "toggle_pinned_to_workspace", Comment: "Toggle pinned to workspace"},
-	{Mods: []string{"Super"}, Key: "w", Action: "toggle_tabbing", Comment: "Toggle tabbing layout"},
-	{Mods: []string{"Super"}, Key: "s", Action: "toggle_stacking", Comment: "Toggle stacking layout"},
-	{Mods: []string{"Super"}, Key: "1", Action: "select_workspace_0", Comment: "Workspace 1"},
-	{Mods: []string{"Super"}, Key: "2", Action: "select_workspace_1", Comment: "Workspace 2"},
-	{Mods: []string{"Super"}, Key: "3", Action: "select_workspace_2", Comment: "Workspace 3"},
-	{Mods: []string{"Super"}, Key: "4", Action: "select_workspace_3", Comment: "Workspace 4"},
-	{Mods: []string{"Super"}, Key: "5", Action: "select_workspace_4", Comment: "Workspace 5"},
-	{Mods: []string{"Super"}, Key: "6", Action: "select_workspace_5", Comment: "Workspace 6"},
-	{Mods: []string{"Super"}, Key: "7", Action: "select_workspace_6", Comment: "Workspace 7"},
-	{Mods: []string{"Super"}, Key: "8", Action: "select_workspace_7", Comment: "Workspace 8"},
-	{Mods: []string{"Super"}, Key: "9", Action: "select_workspace_8", Comment: "Workspace 9"},
-	{Mods: []string{"Super"}, Key: "0", Action: "select_workspace_9", Comment: "Workspace 10"},
-	{Mods: []string{"Super", "Shift"}, Key: "1", Action: "move_to_workspace_0", Comment: "Move to workspace 1"},
-	{Mods: []string{"Super", "Shift"}, Key: "2", Action: "move_to_workspace_1", Comment: "Move to workspace 2"},
-	{Mods: []string{"Super", "Shift"}, Key: "3", Action: "move_to_workspace_2", Comment: "Move to workspace 3"},
-	{Mods: []string{"Super", "Shift"}, Key: "4", Action: "move_to_workspace_3", Comment: "Move to workspace 4"},
-	{Mods: []string{"Super", "Shift"}, Key: "5", Action: "move_to_workspace_4", Comment: "Move to workspace 5"},
-	{Mods: []string{"Super", "Shift"}, Key: "6", Action: "move_to_workspace_5", Comment: "Move to workspace 6"},
-	{Mods: []string{"Super", "Shift"}, Key: "7", Action: "move_to_workspace_6", Comment: "Move to workspace 7"},
-	{Mods: []string{"Super", "Shift"}, Key: "8", Action: "move_to_workspace_7", Comment: "Move to workspace 8"},
-	{Mods: []string{"Super", "Shift"}, Key: "9", Action: "move_to_workspace_8", Comment: "Move to workspace 9"},
-	{Mods: []string{"Super", "Shift"}, Key: "0", Action: "move_to_workspace_9", Comment: "Move to workspace 10"},
-}
-
-func ParseMiracleConfig(configPath string) (*MiracleConfig, error) {
-	expanded, err := utils.ExpandPath(configPath)
-	if err != nil {
-		return nil, err
-	}
-
-	info, err := os.Stat(expanded)
-	if err != nil {
-		return nil, err
-	}
-
-	var configFile string
-	if info.IsDir() {
-		configFile = filepath.Join(expanded, "config.yaml")
-	} else {
-		configFile = expanded
-	}
-
-	data, err := os.ReadFile(configFile)
-	if err != nil {
-		return nil, err
-	}
-
-	var config MiracleConfig
-	if err := yaml.Unmarshal(data, &config); err != nil {
-		return nil, err
-	}
-
-	if config.ActionKey == "" {
-		config.ActionKey = "meta"
-	}
-
-	return &config, nil
-}
-
-func resolveMiracleModifier(mod, actionKey string) string {
-	switch mod {
-	case "primary":
-		return resolveActionKey(actionKey)
-	case "alt", "alt_left", "alt_right":
-		return "Alt"
-	case "shift", "shift_left", "shift_right":
-		return "Shift"
-	case "ctrl", "ctrl_left", "ctrl_right":
-		return "Ctrl"
-	case "meta", "meta_left", "meta_right":
-		return "Super"
-	default:
-		return mod
-	}
-}
-
-func resolveActionKey(actionKey string) string {
-	switch actionKey {
-	case "meta":
-		return "Super"
-	case "alt":
-		return "Alt"
-	case "ctrl":
-		return "Ctrl"
-	default:
-		return "Super"
-	}
-}
-
-func miracleKeyCodeToName(keyCode string) string {
-	name := strings.TrimPrefix(keyCode, "KEY_")
-	name = strings.ToLower(name)
-
-	switch name {
-	case "enter":
-		return "Return"
-	case "space":
-		return "Space"
-	case "up":
-		return "Up"
-	case "down":
-		return "Down"
-	case "left":
-		return "Left"
-	case "right":
-		return "Right"
-	case "tab":
-		return "Tab"
-	case "escape", "esc":
-		return "Escape"
-	case "delete":
-		return "Delete"
-	case "backspace":
-		return "BackSpace"
-	case "home":
-		return "Home"
-	case "end":
-		return "End"
-	case "pageup":
-		return "Page_Up"
-	case "pagedown":
-		return "Page_Down"
-	case "print":
-		return "Print"
-	case "pause":
-		return "Pause"
-	case "volumeup":
-		return "XF86AudioRaiseVolume"
-	case "volumedown":
-		return "XF86AudioLowerVolume"
-	case "mute":
-		return "XF86AudioMute"
-	case "micmute":
-		return "XF86AudioMicMute"
-	case "brightnessup":
-		return "XF86MonBrightnessUp"
-	case "brightnessdown":
-		return "XF86MonBrightnessDown"
-	case "kbdillumup":
-		return "XF86KbdBrightnessUp"
-	case "kbdillumdown":
-		return "XF86KbdBrightnessDown"
-	case "comma":
-		return "comma"
-	case "minus":
-		return "minus"
-	case "equal":
-		return "equal"
-	}
-
-	if len(name) == 1 {
-		return name
-	}
-
-	return name
-}
-
-func MiracleConfigToBindings(config *MiracleConfig) []MiracleKeyBinding {
-	overridden := make(map[string]bool)
-	var bindings []MiracleKeyBinding
-
-	for _, override := range config.DefaultActionOverrides {
-		mods := make([]string, 0, len(override.Modifiers))
-		for _, mod := range override.Modifiers {
-			mods = append(mods, resolveMiracleModifier(mod, config.ActionKey))
-		}
-
-		bindings = append(bindings, MiracleKeyBinding{
-			Mods:    mods,
-			Key:     miracleKeyCodeToName(override.Key),
-			Action:  override.Name,
-			Comment: miracleActionDescription(override.Name),
-		})
-		overridden[override.Name] = true
-	}
-
-	for _, def := range miracleDefaultBinds {
-		if overridden[def.Action] {
-			continue
-		}
-		bindings = append(bindings, def)
-	}
-
-	for _, custom := range config.CustomActions {
-		mods := make([]string, 0, len(custom.Modifiers))
-		for _, mod := range custom.Modifiers {
-			mods = append(mods, resolveMiracleModifier(mod, config.ActionKey))
-		}
-
-		bindings = append(bindings, MiracleKeyBinding{
-			Mods:    mods,
-			Key:     miracleKeyCodeToName(custom.Key),
-			Action:  custom.Command,
-			Comment: custom.Command,
-		})
-	}
-
-	return bindings
-}
-
-func miracleActionDescription(action string) string {
-	switch action {
-	case "terminal":
-		return "Open terminal"
-	case "request_vertical":
-		return "Layout windows vertically"
-	case "request_horizontal":
-		return "Layout windows horizontally"
-	case "select_up":
-		return "Select window above"
-	case "select_down":
-		return "Select window below"
-	case "select_left":
-		return "Select window left"
-	case "select_right":
-		return "Select window right"
-	case "move_up":
-		return "Move window up"
-	case "move_down":
-		return "Move window down"
-	case "move_left":
-		return "Move window left"
-	case "move_right":
-		return "Move window right"
-	case "toggle_resize":
-		return "Toggle resize mode"
-	case "fullscreen":
-		return "Toggle fullscreen"
-	case "quit_active_window":
-		return "Close window"
-	case "quit_compositor":
-		return "Exit compositor"
-	case "toggle_floating":
-		return "Toggle floating"
-	case "toggle_pinned_to_workspace":
-		return "Toggle pinned to workspace"
-	case "toggle_tabbing":
-		return "Toggle tabbing layout"
-	case "toggle_stacking":
-		return "Toggle stacking layout"
-	case "magnifier_on":
-		return "Enable magnifier"
-	case "magnifier_off":
-		return "Disable magnifier"
-	case "magnifier_increase_size":
-		return "Increase magnifier area"
-	case "magnifier_decrease_size":
-		return "Decrease magnifier area"
-	case "magnifier_increase_scale":
-		return "Increase magnifier scale"
-	case "magnifier_decrease_scale":
-		return "Decrease magnifier scale"
-	}
-
-	if num, ok := strings.CutPrefix(action, "select_workspace_"); ok {
-		return "Workspace " + num
-	}
-	if num, ok := strings.CutPrefix(action, "move_to_workspace_"); ok {
-		return "Move to workspace " + num
-	}
-
-	return action
-}

core/internal/keybinds/providers/niri.go

@@ -118,9 +118,6 @@ func (n *NiriProvider) categorizeByAction(action string) string {
 		return "Overview"
 	case action == "quit" ||
 		action == "power-off-monitors" ||
-		action == "power-on-monitors" ||
-		action == "suspend" ||
-		action == "do-screen-transition" ||
 		action == "toggle-keyboard-shortcuts-inhibit" ||
 		strings.Contains(action, "dpms"):
 		return "System"
@@ -154,16 +151,13 @@ func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string, co
 	}
 
 	bind := keybinds.Keybind{
-		Key:             keyStr,
-		Description:     kb.Description,
-		Action:          rawAction,
-		Subcategory:     subcategory,
-		Source:          source,
-		HideOnOverlay:   kb.HideOnOverlay,
-		CooldownMs:      kb.CooldownMs,
-		AllowWhenLocked: kb.AllowWhenLocked,
-		AllowInhibiting: kb.AllowInhibiting,
-		Repeat:          kb.Repeat,
+		Key:           keyStr,
+		Description:   kb.Description,
+		Action:        rawAction,
+		Subcategory:   subcategory,
+		Source:        source,
+		HideOnOverlay: kb.HideOnOverlay,
+		CooldownMs:    kb.CooldownMs,
 	}
 
 	if source == "dms" && conflicts != nil {
@@ -241,7 +235,7 @@ func (n *NiriProvider) SetBind(key, action, description string, options map[stri
 
 	overridePath := n.GetOverridePath()
 
-	if err := os.MkdirAll(filepath.Dir(overridePath), 0o755); err != nil {
+	if err := os.MkdirAll(filepath.Dir(overridePath), 0755); err != nil {
 		return fmt.Errorf("failed to create dms directory: %w", err)
 	}
 
@@ -341,18 +335,20 @@ func (n *NiriProvider) buildActionFromNode(bindNode *document.Node) string {
 		val := arg.ValueString()
 		if val == "" {
 			parts = append(parts, `""`)
-		} else if strings.ContainsAny(val, " \t") {
-			parts = append(parts, `"`+strings.ReplaceAll(val, `"`, `\"`)+`"`)
 		} else {
 			parts = append(parts, val)
 		}
 	}
 
 	if actionNode.Properties != nil {
-		for _, propName := range []string{"focus", "show-pointer", "write-to-disk", "skip-confirmation", "delay-ms"} {
-			if val, ok := actionNode.Properties.Get(propName); ok {
-				parts = append(parts, propName+"="+val.String())
-			}
+		if val, ok := actionNode.Properties.Get("focus"); ok {
+			parts = append(parts, "focus="+val.String())
+		}
+		if val, ok := actionNode.Properties.Get("show-pointer"); ok {
+			parts = append(parts, "show-pointer="+val.String())
+		}
+		if val, ok := actionNode.Properties.Get("write-to-disk"); ok {
+			parts = append(parts, "write-to-disk="+val.String())
 		}
 	}
 
@@ -376,9 +372,6 @@ func (n *NiriProvider) extractOptions(node *document.Node) map[string]any {
 	if val, ok := node.Properties.Get("allow-when-locked"); ok {
 		opts["allow-when-locked"] = val.String() == "true"
 	}
-	if val, ok := node.Properties.Get("allow-inhibiting"); ok {
-		opts["allow-inhibiting"] = val.String() == "true"
-	}
 	return opts
 }
 
@@ -412,9 +405,6 @@ func (n *NiriProvider) buildBindNode(bind *overrideBind) *document.Node {
 		if v, ok := bind.Options["allow-when-locked"]; ok && v == true {
 			node.AddProperty("allow-when-locked", true, "")
 		}
-		if v, ok := bind.Options["allow-inhibiting"]; ok && v == false {
-			node.AddProperty("allow-inhibiting", false, "")
-		}
 	}
 
 	if bind.Description != "" {
@@ -495,7 +485,7 @@ func (n *NiriProvider) writeOverrideBinds(binds map[string]*overrideBind) error
 		return err
 	}
 
-	return os.WriteFile(overridePath, []byte(content), 0o644)
+	return os.WriteFile(overridePath, []byte(content), 0644)
 }
 
 func (n *NiriProvider) getBindSortPriority(action string) int {

core/internal/keybinds/providers/niri_parser.go

@@ -12,17 +12,14 @@ import (
 )
 
 type NiriKeyBinding struct {
-	Mods            []string
-	Key             string
-	Action          string
-	Args            []string
-	Description     string
-	HideOnOverlay   bool
-	CooldownMs      int
-	AllowWhenLocked bool
-	AllowInhibiting *bool
-	Repeat          *bool
-	Source          string
+	Mods          []string
+	Key           string
+	Action        string
+	Args          []string
+	Description   string
+	HideOnOverlay bool
+	CooldownMs    int
+	Source        string
 }
 
 type NiriSection struct {
@@ -272,10 +269,8 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBin
 			args = append(args, arg.ValueString())
 		}
 		if actionNode.Properties != nil {
-			for _, propName := range []string{"focus", "show-pointer", "write-to-disk", "skip-confirmation", "delay-ms"} {
-				if val, ok := actionNode.Properties.Get(propName); ok {
-					args = append(args, propName+"="+val.String())
-				}
+			if val, ok := actionNode.Properties.Get("focus"); ok {
+				args = append(args, "focus="+val.String())
 			}
 		}
 	}
@@ -283,9 +278,6 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBin
 	var description string
 	var hideOnOverlay bool
 	var cooldownMs int
-	var allowWhenLocked bool
-	var allowInhibiting *bool
-	var repeat *bool
 	if node.Properties != nil {
 		if val, ok := node.Properties.Get("hotkey-overlay-title"); ok {
 			switch val.ValueString() {
@@ -298,31 +290,17 @@ func (p *NiriParser) parseKeybindNode(node *document.Node, _ string) *NiriKeyBin
 		if val, ok := node.Properties.Get("cooldown-ms"); ok {
 			cooldownMs, _ = strconv.Atoi(val.String())
 		}
-		if val, ok := node.Properties.Get("allow-when-locked"); ok {
-			allowWhenLocked = val.String() == "true"
-		}
-		if val, ok := node.Properties.Get("allow-inhibiting"); ok {
-			v := val.String() == "true"
-			allowInhibiting = &v
-		}
-		if val, ok := node.Properties.Get("repeat"); ok {
-			v := val.String() == "true"
-			repeat = &v
-		}
 	}
 
 	return &NiriKeyBinding{
-		Mods:            mods,
-		Key:             key,
-		Action:          action,
-		Args:            args,
-		Description:     description,
-		HideOnOverlay:   hideOnOverlay,
-		CooldownMs:      cooldownMs,
-		AllowWhenLocked: allowWhenLocked,
-		AllowInhibiting: allowInhibiting,
-		Repeat:          repeat,
-		Source:          p.currentSource,
+		Mods:          mods,
+		Key:           key,
+		Action:        action,
+		Args:          args,
+		Description:   description,
+		HideOnOverlay: hideOnOverlay,
+		CooldownMs:    cooldownMs,
+		Source:        p.currentSource,
 	}
 }
 

core/internal/keybinds/providers/niri_parser_test.go

@@ -53,7 +53,7 @@ func TestNiriParseBasicBinds(t *testing.T) {
     Mod+T hotkey-overlay-title="Open Terminal" { spawn "kitty"; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -112,7 +112,7 @@ func TestNiriParseRecentWindows(t *testing.T) {
     }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -148,7 +148,7 @@ func TestNiriParseRecentWindows(t *testing.T) {
 func TestNiriParseInclude(t *testing.T) {
 	tmpDir := t.TempDir()
 	subDir := filepath.Join(tmpDir, "dms")
-	if err := os.MkdirAll(subDir, 0o755); err != nil {
+	if err := os.MkdirAll(subDir, 0755); err != nil {
 		t.Fatalf("Failed to create subdir: %v", err)
 	}
 
@@ -165,10 +165,10 @@ include "dms/binds.kdl"
 }
 `
 
-	if err := os.WriteFile(mainConfig, []byte(mainContent), 0o644); err != nil {
+	if err := os.WriteFile(mainConfig, []byte(mainContent), 0644); err != nil {
 		t.Fatalf("Failed to write main config: %v", err)
 	}
-	if err := os.WriteFile(includeConfig, []byte(includeContent), 0o644); err != nil {
+	if err := os.WriteFile(includeConfig, []byte(includeContent), 0644); err != nil {
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
@@ -185,7 +185,7 @@ include "dms/binds.kdl"
 func TestNiriParseIncludeOverride(t *testing.T) {
 	tmpDir := t.TempDir()
 	subDir := filepath.Join(tmpDir, "dms")
-	if err := os.MkdirAll(subDir, 0o755); err != nil {
+	if err := os.MkdirAll(subDir, 0755); err != nil {
 		t.Fatalf("Failed to create subdir: %v", err)
 	}
 
@@ -202,10 +202,10 @@ include "dms/binds.kdl"
 }
 `
 
-	if err := os.WriteFile(mainConfig, []byte(mainContent), 0o644); err != nil {
+	if err := os.WriteFile(mainConfig, []byte(mainContent), 0644); err != nil {
 		t.Fatalf("Failed to write main config: %v", err)
 	}
-	if err := os.WriteFile(includeConfig, []byte(includeContent), 0o644); err != nil {
+	if err := os.WriteFile(includeConfig, []byte(includeContent), 0644); err != nil {
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
@@ -246,10 +246,10 @@ include "other.kdl"
 include "config.kdl"
 `
 
-	if err := os.WriteFile(mainConfig, []byte(mainContent), 0o644); err != nil {
+	if err := os.WriteFile(mainConfig, []byte(mainContent), 0644); err != nil {
 		t.Fatalf("Failed to write main config: %v", err)
 	}
-	if err := os.WriteFile(otherConfig, []byte(otherContent), 0o644); err != nil {
+	if err := os.WriteFile(otherConfig, []byte(otherContent), 0644); err != nil {
 		t.Fatalf("Failed to write other config: %v", err)
 	}
 
@@ -272,7 +272,7 @@ func TestNiriParseMissingInclude(t *testing.T) {
 }
 include "nonexistent/file.kdl"
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -301,7 +301,7 @@ input {
     }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -348,7 +348,7 @@ func TestNiriBindOverrideBehavior(t *testing.T) {
     Mod+T hotkey-overlay-title="Third" { spawn "third"; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -386,7 +386,7 @@ func TestNiriBindOverrideBehavior(t *testing.T) {
 func TestNiriBindOverrideWithIncludes(t *testing.T) {
 	tmpDir := t.TempDir()
 	subDir := filepath.Join(tmpDir, "custom")
-	if err := os.MkdirAll(subDir, 0o755); err != nil {
+	if err := os.MkdirAll(subDir, 0755); err != nil {
 		t.Fatalf("Failed to create subdir: %v", err)
 	}
 
@@ -409,10 +409,10 @@ binds {
 }
 `
 
-	if err := os.WriteFile(mainConfig, []byte(mainContent), 0o644); err != nil {
+	if err := os.WriteFile(mainConfig, []byte(mainContent), 0644); err != nil {
 		t.Fatalf("Failed to write main config: %v", err)
 	}
-	if err := os.WriteFile(includeConfig, []byte(includeContent), 0o644); err != nil {
+	if err := os.WriteFile(includeConfig, []byte(includeContent), 0644); err != nil {
 		t.Fatalf("Failed to write include config: %v", err)
 	}
 
@@ -471,7 +471,7 @@ func TestNiriParseMultipleArgs(t *testing.T) {
     }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -508,7 +508,7 @@ func TestNiriParseNumericWorkspaceBinds(t *testing.T) {
     Mod+Shift+1 hotkey-overlay-title="Move to Workspace 1" { move-column-to-workspace 1; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -550,7 +550,7 @@ func TestNiriParseQuotedStringArgs(t *testing.T) {
     Super+Shift+Minus hotkey-overlay-title="Adjust Window Height -10%" { set-window-height "-10%"; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -586,7 +586,7 @@ func TestNiriParseActionWithProperties(t *testing.T) {
     Alt+Tab { next-window scope="output"; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/providers/niri_test.go

@@ -27,7 +27,7 @@ func TestNiriProviderGetCheatSheet(t *testing.T) {
     Mod+Shift+E { quit; }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -312,7 +312,7 @@ func TestNiriGenerateBindsContentRoundTrip(t *testing.T) {
 
 	tmpDir := t.TempDir()
 	configFile := filepath.Join(tmpDir, "config.kdl")
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write temp file: %v", err)
 	}
 
@@ -351,12 +351,12 @@ func TestNiriEmptyArgsPreservation(t *testing.T) {
 
 	tmpDir := t.TempDir()
 	dmsDir := filepath.Join(tmpDir, "dms")
-	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+	if err := os.MkdirAll(dmsDir, 0755); err != nil {
 		t.Fatalf("Failed to create dms directory: %v", err)
 	}
 
 	bindsFile := filepath.Join(dmsDir, "binds.kdl")
-	if err := os.WriteFile(bindsFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(bindsFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write binds file: %v", err)
 	}
 
@@ -428,7 +428,7 @@ recent-windows {
     }
 }
 `
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -621,7 +621,7 @@ func TestNiriGenerateWorkspaceBindsRoundTrip(t *testing.T) {
 
 	tmpDir := t.TempDir()
 	configFile := filepath.Join(tmpDir, "config.kdl")
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write temp file: %v", err)
 	}
 

core/internal/keybinds/providers/sway.go

@@ -3,7 +3,6 @@ package providers
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
@@ -19,21 +18,14 @@ func NewSwayProvider(configPath string) *SwayProvider {
 	_, scrollEnvSet := os.LookupEnv("SCROLLSOCK")
 
 	if configPath == "" {
-		configDir, err := os.UserConfigDir()
-		if err != nil {
-			configDir = ""
-		}
 		if scrollEnvSet {
-			if configDir != "" {
-				configPath = filepath.Join(configDir, "scroll")
-			}
+			configPath = "$HOME/.config/scroll"
 			isScroll = true
 		} else {
-			if configDir != "" {
-				configPath = filepath.Join(configDir, "sway")
-			}
+			configPath = "$HOME/.config/sway"
 		}
 	} else {
+		// Determine isScroll based on the provided config path
 		isScroll = strings.Contains(configPath, "scroll")
 	}
 
@@ -44,16 +36,16 @@ func NewSwayProvider(configPath string) *SwayProvider {
 }
 
 func (s *SwayProvider) Name() string {
-	if s == nil {
-		if os.Getenv("SCROLLSOCK") != "" {
-			return "scroll"
-		}
-		return "sway"
-	}
-
-	if s.isScroll {
+	if s != nil && s.isScroll {
 		return "scroll"
 	}
+	if s == nil {
+		_, ok := os.LookupEnv("SCROLLSOCK")
+		if ok {
+			return "scroll"
+		}
+	}
+
 	return "sway"
 }
 

core/internal/keybinds/providers/sway_parser_test.go

@@ -200,7 +200,7 @@ bindsym $mod+t exec $term
 bindsym $mod+d exec $menu
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -247,7 +247,7 @@ bindsym $mod+Right focus right
 bindsym $mod+t exec kitty # Terminal
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -328,13 +328,13 @@ func TestSwayReadContentWithTildeExpansion(t *testing.T) {
 	}
 
 	tmpSubdir := filepath.Join(homeDir, ".config", "test-sway-"+t.Name())
-	if err := os.MkdirAll(tmpSubdir, 0o755); err != nil {
+	if err := os.MkdirAll(tmpSubdir, 0755); err != nil {
 		t.Skip("Cannot create test directory in home")
 	}
 	defer os.RemoveAll(tmpSubdir)
 
 	configFile := filepath.Join(tmpSubdir, "config")
-	if err := os.WriteFile(configFile, []byte("bindsym Mod4+q kill\n"), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte("bindsym Mod4+q kill\n"), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -365,7 +365,7 @@ bindsym Mod4+q kill
 bindsym Mod4+t exec kitty
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -404,7 +404,7 @@ bindsym $mod+2 workspace number 2
 bindsym $mod+Shift+1 move container to workspace number 1
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/providers/sway_test.go

@@ -15,13 +15,8 @@ func TestSwayProviderName(t *testing.T) {
 
 func TestSwayProviderDefaultPath(t *testing.T) {
 	provider := NewSwayProvider("")
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		t.Skip("UserConfigDir not available")
-	}
-	expected := filepath.Join(configDir, "sway")
-	if provider.configPath != expected {
-		t.Errorf("configPath = %q, want %q", provider.configPath, expected)
+	if provider.configPath != "$HOME/.config/sway" {
+		t.Errorf("configPath = %q, want %q", provider.configPath, "$HOME/.config/sway")
 	}
 }
 
@@ -195,7 +190,7 @@ bindsym $mod+s layout stacking
 bindsym $mod+w layout tabbed
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 
@@ -258,7 +253,7 @@ bindsym $mod+f fullscreen toggle
 bindsym $mod+1 workspace number 1
 `
 
-	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+	if err := os.WriteFile(configFile, []byte(content), 0644); err != nil {
 		t.Fatalf("Failed to write test config: %v", err)
 	}
 

core/internal/keybinds/types.go

@@ -1,18 +1,15 @@
 package keybinds
 
 type Keybind struct {
-	Key             string   `json:"key"`
-	Description     string   `json:"desc"`
-	Action          string   `json:"action,omitempty"`
-	Subcategory     string   `json:"subcat,omitempty"`
-	Source          string   `json:"source,omitempty"`
-	HideOnOverlay   bool     `json:"hideOnOverlay,omitempty"`
-	CooldownMs      int      `json:"cooldownMs,omitempty"`
-	Flags           string   `json:"flags,omitempty"` // Hyprland bind flags: e=repeat, l=locked, r=release, o=long-press
-	AllowWhenLocked bool     `json:"allowWhenLocked,omitempty"`
-	AllowInhibiting *bool    `json:"allowInhibiting,omitempty"` // nil=default(true), false=explicitly disabled
-	Repeat          *bool    `json:"repeat,omitempty"`          // nil=default(true), false=explicitly disabled
-	Conflict        *Keybind `json:"conflict,omitempty"`
+	Key           string   `json:"key"`
+	Description   string   `json:"desc"`
+	Action        string   `json:"action,omitempty"`
+	Subcategory   string   `json:"subcat,omitempty"`
+	Source        string   `json:"source,omitempty"`
+	HideOnOverlay bool     `json:"hideOnOverlay,omitempty"`
+	CooldownMs    int      `json:"cooldownMs,omitempty"`
+	Flags         string   `json:"flags,omitempty"` // Hyprland bind flags: e=repeat, l=locked, r=release, o=long-press
+	Conflict      *Keybind `json:"conflict,omitempty"`
 }
 
 type DMSBindsStatus struct {

core/internal/matugen/matugen.go

@@ -3,7 +3,6 @@ package matugen
 import (
 	"encoding/json"
 	"fmt"
-	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -11,12 +10,10 @@ import (
 	"strings"
 	"sync"
 	"syscall"
-	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/dank16"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
-	"github.com/lucasb-eyer/go-colorful"
 )
 
 type ColorMode string
@@ -33,7 +30,6 @@ const (
 	TemplateKindTerminal
 	TemplateKindGTK
 	TemplateKindVSCode
-	TemplateKindEmacs
 )
 
 type TemplateDef struct {
@@ -66,7 +62,6 @@ var templateRegistry = []TemplateDef{
 	{ID: "dgop", Commands: []string{"dgop"}, ConfigFile: "dgop.toml"},
 	{ID: "kcolorscheme", ConfigFile: "kcolorscheme.toml", RunUnconditionally: true},
 	{ID: "vscode", Kind: TemplateKindVSCode},
-	{ID: "emacs", Commands: []string{"emacs"}, ConfigFile: "emacs.toml", Kind: TemplateKindEmacs},
 }
 
 func (c *ColorMode) GTKTheme() string {
@@ -79,10 +74,8 @@ func (c *ColorMode) GTKTheme() string {
 }
 
 var (
-	matugenVersionMu   sync.Mutex
-	matugenVersionOK   bool
+	matugenVersionOnce sync.Once
 	matugenSupportsCOE bool
-	matugenIsV4        bool
 )
 
 type Options struct {
@@ -154,7 +147,7 @@ func Run(opts Options) error {
 		opts.AppChecker = utils.DefaultAppChecker{}
 	}
 
-	if err := os.MkdirAll(opts.StateDir, 0o755); err != nil {
+	if err := os.MkdirAll(opts.StateDir, 0755); err != nil {
 		return fmt.Errorf("failed to create state dir: %w", err)
 	}
 
@@ -256,22 +249,8 @@ func buildOnce(opts *Options) error {
 		}
 	}
 
-	if isDMSGTKActive(opts.ConfigDir) {
-		switch opts.Mode {
-		case ColorModeLight:
-			syncAccentColor(primaryLight)
-		default:
-			syncAccentColor(primaryDark)
-		}
-		refreshGTK(opts.Mode)
-		refreshGTK4()
-	}
-
-	if !opts.ShouldSkipTemplate("qt6ct") && appExists(opts.AppChecker, []string{"qt6ct"}, nil) {
-		refreshQt6ct()
-	}
-
-	signalTerminals(opts)
+	refreshGTK(opts.ConfigDir, opts.Mode)
+	signalTerminals()
 
 	return nil
 }
@@ -336,10 +315,6 @@ output_path = '%s'
 			appendVSCodeConfig(cfgFile, "cursor", filepath.Join(homeDir, ".cursor/extensions"), opts.ShellDir)
 			appendVSCodeConfig(cfgFile, "windsurf", filepath.Join(homeDir, ".windsurf/extensions"), opts.ShellDir)
 			appendVSCodeConfig(cfgFile, "vscode-insiders", filepath.Join(homeDir, ".vscode-insiders/extensions"), opts.ShellDir)
-		case TemplateKindEmacs:
-			if utils.EmacsConfigDir() != "" {
-				appendConfig(opts, cfgFile, tmpl.Commands, tmpl.Flatpaks, tmpl.ConfigFile)
-			}
 		default:
 			appendConfig(opts, cfgFile, tmpl.Commands, tmpl.Flatpaks, tmpl.ConfigFile)
 		}
@@ -438,7 +413,7 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkC
 
 		modified := strings.ReplaceAll(string(origData), ".default.", ".dark.")
 		tmpPath := filepath.Join(tmpDir, templateName)
-		if err := os.WriteFile(tmpPath, []byte(modified), 0o644); err != nil {
+		if err := os.WriteFile(tmpPath, []byte(modified), 0644); err != nil {
 			continue
 		}
 
@@ -497,9 +472,6 @@ func substituteVars(content, shellDir string) string {
 	result = strings.ReplaceAll(result, "'CONFIG_DIR/", "'"+utils.XDGConfigHome()+"/")
 	result = strings.ReplaceAll(result, "'DATA_DIR/", "'"+utils.XDGDataHome()+"/")
 	result = strings.ReplaceAll(result, "'CACHE_DIR/", "'"+utils.XDGCacheHome()+"/")
-	if emacsDir := utils.EmacsConfigDir(); emacsDir != "" {
-		result = strings.ReplaceAll(result, "'EMACS_DIR/", "'"+emacsDir+"/")
-	}
 	return result
 }
 
@@ -520,159 +492,66 @@ func extractTOMLSection(content, startMarker, endMarker string) string {
 	return content[startIdx : startIdx+endIdx]
 }
 
-type matugenFlags struct {
-	supportsCOE bool
-	isV4        bool
+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 detectMatugenVersion() (matugenFlags, error) {
-	matugenVersionMu.Lock()
-	defer matugenVersionMu.Unlock()
-
-	if matugenVersionOK {
-		return matugenFlags{matugenSupportsCOE, matugenIsV4}, nil
-	}
-
-	return detectMatugenVersionLocked()
-}
-
-func redetectMatugenVersion(old matugenFlags) (matugenFlags, bool) {
-	matugenVersionMu.Lock()
-	defer matugenVersionMu.Unlock()
-
-	matugenVersionOK = false
-	flags, err := detectMatugenVersionLocked()
-	if err != nil {
-		return old, false
-	}
-	changed := flags.supportsCOE != old.supportsCOE || flags.isV4 != old.isV4
-	return flags, changed
-}
-
-func detectMatugenVersionLocked() (matugenFlags, error) {
-	cmd := exec.Command("matugen", "--version")
-	output, err := cmd.Output()
-	if err != nil {
-		return matugenFlags{}, fmt.Errorf("failed to get matugen version: %w", err)
-	}
-
-	versionStr := strings.TrimSpace(string(output))
-	versionStr = strings.TrimPrefix(versionStr, "matugen ")
-
-	parts := strings.Split(versionStr, ".")
-	if len(parts) < 2 {
-		return matugenFlags{}, fmt.Errorf("unexpected matugen version format: %q", versionStr)
-	}
-
-	major, err := strconv.Atoi(parts[0])
-	if err != nil {
-		return matugenFlags{}, fmt.Errorf("failed to parse matugen major version %q: %w", parts[0], err)
-	}
-
-	minor, err := strconv.Atoi(parts[1])
-	if err != nil {
-		return matugenFlags{}, fmt.Errorf("failed to parse matugen minor version %q: %w", parts[1], err)
-	}
-
-	matugenSupportsCOE = major > 3 || (major == 3 && minor >= 1)
-	matugenIsV4 = major >= 4
-	matugenVersionOK = true
+func runMatugen(args []string) error {
+	checkMatugenVersion()
 
 	if matugenSupportsCOE {
-		log.Infof("Matugen %s supports --continue-on-error", versionStr)
-	}
-	if matugenIsV4 {
-		log.Infof("Matugen %s: using v4 flags", versionStr)
-	}
-	return matugenFlags{matugenSupportsCOE, matugenIsV4}, nil
-}
-
-func buildMatugenArgs(baseArgs []string, flags matugenFlags) []string {
-	args := make([]string, 0, len(baseArgs)+4)
-	if flags.supportsCOE {
-		args = append(args, "--continue-on-error")
-	}
-	args = append(args, baseArgs...)
-	if flags.isV4 {
-		args = append(args, "--source-color-index", "0")
-	}
-	return args
-}
-
-func runMatugen(baseArgs []string) error {
-	flags, err := detectMatugenVersion()
-	if err != nil {
-		return err
+		args = append([]string{"--continue-on-error"}, args...)
 	}
 
-	args := buildMatugenArgs(baseArgs, flags)
 	cmd := exec.Command("matugen", args...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	runErr := cmd.Run()
-	if runErr == nil {
-		return nil
-	}
-
-	log.Warnf("Matugen failed (v4=%v): %v", flags.isV4, runErr)
-
-	newFlags, changed := redetectMatugenVersion(flags)
-	if !changed {
-		return runErr
-	}
-
-	log.Warnf("Matugen version changed (v4: %v -> %v), retrying", flags.isV4, newFlags.isV4)
-	args = buildMatugenArgs(baseArgs, newFlags)
-	retryCmd := exec.Command("matugen", args...)
-	retryCmd.Stdout = os.Stdout
-	retryCmd.Stderr = os.Stderr
-	return retryCmd.Run()
+	return cmd.Run()
 }
 
 func runMatugenDryRun(opts *Options) (string, error) {
-	flags, err := detectMatugenVersion()
-	if err != nil {
-		return "", err
-	}
-
-	output, dryErr := execDryRun(opts, flags)
-	if dryErr == nil {
-		return output, nil
-	}
-
-	log.Warnf("Matugen dry-run failed (v4=%v): %v", flags.isV4, dryErr)
-
-	newFlags, changed := redetectMatugenVersion(flags)
-	if !changed {
-		return "", dryErr
-	}
-
-	log.Warnf("Matugen version changed (v4: %v -> %v), retrying dry-run", flags.isV4, newFlags.isV4)
-	return execDryRun(opts, newFlags)
-}
-
-func execDryRun(opts *Options, flags matugenFlags) (string, error) {
-	var baseArgs []string
+	var args []string
 	switch opts.Kind {
 	case "hex":
-		baseArgs = []string{"color", "hex", opts.Value}
+		args = []string{"color", "hex", opts.Value}
 	default:
-		baseArgs = []string{opts.Kind, opts.Value}
-	}
-	baseArgs = append(baseArgs, "-m", "dark", "-t", opts.MatugenType, "--json", "hex", "--dry-run")
-	if flags.isV4 {
-		baseArgs = append(baseArgs, "--source-color-index", "0", "--old-json-output")
+		args = []string{opts.Kind, opts.Value}
 	}
+	args = append(args, "-m", "dark", "-t", opts.MatugenType, "--json", "hex", "--dry-run")
 
-	cmd := exec.Command("matugen", baseArgs...)
-	var stderr strings.Builder
-	cmd.Stderr = &stderr
+	cmd := exec.Command("matugen", args...)
 	output, err := cmd.Output()
 	if err != nil {
-		if stderr.Len() > 0 {
-			return "", fmt.Errorf("matugen %v failed (v4=%v): %s", baseArgs, flags.isV4, strings.TrimSpace(stderr.String()))
-		}
-		return "", fmt.Errorf("matugen %v failed (v4=%v): %w", baseArgs, flags.isV4, err)
+		return "", err
 	}
 	return strings.ReplaceAll(string(output), "\n", ""), nil
 }
@@ -737,73 +616,40 @@ func generateDank16Variants(primaryDark, primaryLight, surface string, mode Colo
 	return dank16.GenerateVariantJSON(variantColors)
 }
 
-func isDMSGTKActive(configDir string) bool {
+func refreshGTK(configDir string, mode ColorMode) {
 	gtkCSS := filepath.Join(configDir, "gtk-3.0", "gtk.css")
 
 	info, err := os.Lstat(gtkCSS)
 	if err != nil {
-		return false
+		return
 	}
 
+	shouldRun := false
 	if info.Mode()&os.ModeSymlink != 0 {
 		target, err := os.Readlink(gtkCSS)
-		return err == nil && strings.Contains(target, "dank-colors.css")
-	}
-
-	data, err := os.ReadFile(gtkCSS)
-	return err == nil && strings.Contains(string(data), "dank-colors.css")
-}
-
-func refreshGTK(mode ColorMode) {
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "gtk-theme", ""); err != nil {
-		log.Warnf("Failed to reset gtk-theme: %v", err)
-	}
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "gtk-theme", mode.GTKTheme()); err != nil {
-		log.Warnf("Failed to set gtk-theme: %v", err)
-	}
-}
-
-func refreshGTK4() {
-	output, err := utils.GsettingsGet("org.gnome.desktop.interface", "color-scheme")
-	if err != nil {
-		return
-	}
-	current := strings.Trim(output, "'")
-
-	var toggle string
-	if current == "prefer-dark" {
-		toggle = "default"
+		if err == nil && strings.Contains(target, "dank-colors.css") {
+			shouldRun = true
+		}
 	} else {
-		toggle = "prefer-dark"
+		data, err := os.ReadFile(gtkCSS)
+		if err == nil && strings.Contains(string(data), "dank-colors.css") {
+			shouldRun = true
+		}
 	}
 
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "color-scheme", toggle); err != nil {
-		log.Warnf("Failed to toggle color-scheme for GTK4 refresh: %v", err)
+	if !shouldRun {
 		return
 	}
-	time.Sleep(50 * time.Millisecond)
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "color-scheme", current); err != nil {
-		log.Warnf("Failed to restore color-scheme for GTK4 refresh: %v", err)
-	}
+
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", "").Run()
+	exec.Command("gsettings", "set", "org.gnome.desktop.interface", "gtk-theme", mode.GTKTheme()).Run()
 }
 
-func refreshQt6ct() {
-	confPath := filepath.Join(utils.XDGConfigHome(), "qt6ct", "qt6ct.conf")
-	now := time.Now()
-	if err := os.Chtimes(confPath, now, now); err != nil {
-		log.Warnf("Failed to touch qt6ct.conf: %v", err)
-	}
-}
-
-func signalTerminals(opts *Options) {
-	if !opts.ShouldSkipTemplate("kitty") && appExists(opts.AppChecker, []string{"kitty"}, nil) {
-		signalByName("kitty", syscall.SIGUSR1)
-		signalByName(".kitty-wrapped", syscall.SIGUSR1)
-	}
-	if !opts.ShouldSkipTemplate("ghostty") && appExists(opts.AppChecker, []string{"ghostty"}, nil) {
-		signalByName("ghostty", syscall.SIGUSR2)
-		signalByName(".ghostty-wrappe", syscall.SIGUSR2)
-	}
+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) {
@@ -832,59 +678,8 @@ func syncColorScheme(mode ColorMode) {
 		scheme = "default"
 	}
 
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "color-scheme", scheme); err != nil {
-		log.Warnf("Failed to sync color-scheme: %v", err)
-	}
-}
-
-var adwaitaAccents = []struct {
-	name   string
-	colors []colorful.Color
-}{
-	{"blue", hexColors("#3f8ae5", "#438de6", "#a4caee")},
-	{"green", hexColors("#26a269", "#39ac76", "#81d5ad")},
-	{"orange", hexColors("#f17738", "#ff7800", "#ffc994")},
-	{"pink", hexColors("#e4358a", "#e64392", "#f9b3d5")},
-	{"purple", hexColors("#954ab5", "#9c46b9", "#d099d6")},
-	{"red", hexColors("#e84053", "#e01b24", "#f2a1a5")},
-	{"slate", hexColors("#557b9f", "#6a8daf", "#b4c6d6")},
-	{"teal", hexColors("#129eb0", "#2190a4", "#7bdff4")},
-	{"yellow", hexColors("#cbac10", "#d4b411", "#f5c211")},
-}
-
-func hexColors(hexes ...string) []colorful.Color {
-	out := make([]colorful.Color, len(hexes))
-	for i, h := range hexes {
-		out[i], _ = colorful.Hex(h)
-	}
-	return out
-}
-
-func closestAdwaitaAccent(primaryHex string) string {
-	c, err := colorful.Hex(primaryHex)
-	if err != nil {
-		return "blue"
-	}
-
-	best := "blue"
-	bestDist := math.MaxFloat64
-	for _, a := range adwaitaAccents {
-		for _, ref := range a.colors {
-			d := c.DistanceCIEDE2000(ref)
-			if d < bestDist {
-				bestDist = d
-				best = a.name
-			}
-		}
-	}
-	return best
-}
-
-func syncAccentColor(primaryHex string) {
-	accent := closestAdwaitaAccent(primaryHex)
-	log.Infof("Setting GNOME accent color: %s", accent)
-	if err := utils.GsettingsSet("org.gnome.desktop.interface", "accent-color", accent); err != nil {
-		log.Warnf("Failed to set accent-color: %v", err)
+	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()
 	}
 }
 
@@ -909,8 +704,6 @@ func CheckTemplates(checker utils.AppChecker) []TemplateCheck {
 			detected = true
 		case tmpl.Kind == TemplateKindVSCode:
 			detected = checkVSCodeExtension(homeDir)
-		case tmpl.Kind == TemplateKindEmacs:
-			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks) && utils.EmacsConfigDir() != ""
 		default:
 			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks)
 		}

core/internal/matugen/matugen_test.go

@@ -15,13 +15,13 @@ func TestAppendConfigBinaryExists(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "test config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -58,13 +58,13 @@ func TestAppendConfigBinaryDoesNotExist(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "test config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -99,13 +99,13 @@ func TestAppendConfigFlatpakExists(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "zen config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -139,13 +139,13 @@ func TestAppendConfigFlatpakDoesNotExist(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "test config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -180,13 +180,13 @@ func TestAppendConfigBothExist(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "zen config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -220,13 +220,13 @@ func TestAppendConfigNeitherExists(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "test config content"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -261,13 +261,13 @@ func TestAppendConfigNoChecks(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 
 	testConfig := "always include"
 	configPath := filepath.Join(configsDir, "test.toml")
-	if err := os.WriteFile(configPath, []byte(testConfig), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
 		t.Fatalf("failed to write config: %v", err)
 	}
 
@@ -298,7 +298,7 @@ func TestAppendConfigFileDoesNotExist(t *testing.T) {
 
 	shellDir := filepath.Join(tempDir, "shell")
 	configsDir := filepath.Join(shellDir, "matugen", "configs")
-	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+	if err := os.MkdirAll(configsDir, 0755); err != nil {
 		t.Fatalf("failed to create configs dir: %v", err)
 	}
 

core/internal/notify/notify.go

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

core/internal/plugins/manager.go

@@ -116,12 +116,12 @@ func (m *Manager) Install(plugin Plugin) error {
 		return fmt.Errorf("plugin already installed: %s", plugin.Name)
 	}
 
-	if err := m.fs.MkdirAll(m.pluginsDir, 0o755); err != nil {
+	if err := m.fs.MkdirAll(m.pluginsDir, 0755); err != nil {
 		return fmt.Errorf("failed to create plugins directory: %w", err)
 	}
 
 	reposDir := filepath.Join(m.pluginsDir, ".repos")
-	if err := m.fs.MkdirAll(reposDir, 0o755); err != nil {
+	if err := m.fs.MkdirAll(reposDir, 0755); err != nil {
 		return fmt.Errorf("failed to create repos directory: %w", err)
 	}
 
@@ -168,7 +168,7 @@ func (m *Manager) Install(plugin Plugin) error {
 
 		metaPath := pluginPath + ".meta"
 		metaContent := fmt.Sprintf("repo=%s\npath=%s\nrepodir=%s", plugin.Repo, plugin.Path, repoName)
-		if err := afero.WriteFile(m.fs, metaPath, []byte(metaContent), 0o644); err != nil {
+		if err := afero.WriteFile(m.fs, metaPath, []byte(metaContent), 0644); err != nil {
 			return fmt.Errorf("failed to write metadata: %w", err)
 		}
 	} else {

core/internal/plugins/manager_test.go

@@ -66,7 +66,7 @@ func TestIsInstalled(t *testing.T) {
 
 		plugin := Plugin{ID: "test-plugin", Name: "TestPlugin"}
 		pluginPath := filepath.Join(pluginsDir, plugin.ID)
-		err := fs.MkdirAll(pluginPath, 0o755)
+		err := fs.MkdirAll(pluginPath, 0755)
 		require.NoError(t, err)
 
 		installed, err := manager.IsInstalled(plugin)
@@ -100,7 +100,7 @@ func TestInstall(t *testing.T) {
 				cloneCalled = true
 				assert.Equal(t, filepath.Join(pluginsDir, plugin.ID), path)
 				assert.Equal(t, plugin.Repo, url)
-				return fs.MkdirAll(path, 0o755)
+				return fs.MkdirAll(path, 0755)
 			},
 		}
 		manager.gitClient = mockGit
@@ -118,7 +118,7 @@ func TestInstall(t *testing.T) {
 
 		plugin := Plugin{ID: "test-plugin", Name: "TestPlugin"}
 		pluginPath := filepath.Join(pluginsDir, plugin.ID)
-		err := fs.MkdirAll(pluginPath, 0o755)
+		err := fs.MkdirAll(pluginPath, 0755)
 		require.NoError(t, err)
 
 		err = manager.Install(plugin)
@@ -137,7 +137,7 @@ func TestManagerUpdate(t *testing.T) {
 
 		plugin := Plugin{ID: "test-plugin", Name: "TestPlugin"}
 		pluginPath := filepath.Join(pluginsDir, plugin.ID)
-		err := fs.MkdirAll(pluginPath, 0o755)
+		err := fs.MkdirAll(pluginPath, 0755)
 		require.NoError(t, err)
 
 		pullCalled := false
@@ -171,7 +171,7 @@ func TestUninstall(t *testing.T) {
 
 		plugin := Plugin{ID: "test-plugin", Name: "TestPlugin"}
 		pluginPath := filepath.Join(pluginsDir, plugin.ID)
-		err := fs.MkdirAll(pluginPath, 0o755)
+		err := fs.MkdirAll(pluginPath, 0755)
 		require.NoError(t, err)
 
 		err = manager.Uninstall(plugin)
@@ -195,14 +195,14 @@ func TestListInstalled(t *testing.T) {
 	t.Run("lists installed plugins", func(t *testing.T) {
 		manager, fs, pluginsDir := setupTestManager(t)
 
-		err := fs.MkdirAll(filepath.Join(pluginsDir, "Plugin1"), 0o755)
+		err := fs.MkdirAll(filepath.Join(pluginsDir, "Plugin1"), 0755)
 		require.NoError(t, err)
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin1", "plugin.json"), []byte(`{"id":"Plugin1"}`), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin1", "plugin.json"), []byte(`{"id":"Plugin1"}`), 0644)
 		require.NoError(t, err)
 
-		err = fs.MkdirAll(filepath.Join(pluginsDir, "Plugin2"), 0o755)
+		err = fs.MkdirAll(filepath.Join(pluginsDir, "Plugin2"), 0755)
 		require.NoError(t, err)
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin2", "plugin.json"), []byte(`{"id":"Plugin2"}`), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin2", "plugin.json"), []byte(`{"id":"Plugin2"}`), 0644)
 		require.NoError(t, err)
 
 		installed, err := manager.ListInstalled()
@@ -223,15 +223,15 @@ func TestListInstalled(t *testing.T) {
 	t.Run("ignores files and .repos directory", func(t *testing.T) {
 		manager, fs, pluginsDir := setupTestManager(t)
 
-		err := fs.MkdirAll(pluginsDir, 0o755)
+		err := fs.MkdirAll(pluginsDir, 0755)
 		require.NoError(t, err)
-		err = fs.MkdirAll(filepath.Join(pluginsDir, "Plugin1"), 0o755)
+		err = fs.MkdirAll(filepath.Join(pluginsDir, "Plugin1"), 0755)
 		require.NoError(t, err)
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin1", "plugin.json"), []byte(`{"id":"Plugin1"}`), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "Plugin1", "plugin.json"), []byte(`{"id":"Plugin1"}`), 0644)
 		require.NoError(t, err)
-		err = fs.MkdirAll(filepath.Join(pluginsDir, ".repos"), 0o755)
+		err = fs.MkdirAll(filepath.Join(pluginsDir, ".repos"), 0755)
 		require.NoError(t, err)
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "README.md"), []byte("test"), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "README.md"), []byte("test"), 0644)
 		require.NoError(t, err)
 
 		installed, err := manager.ListInstalled()

core/internal/plugins/registry.go

@@ -27,7 +27,6 @@ type Plugin struct {
 	Distro       []string `json:"distro"`
 	Screenshot   string   `json:"screenshot,omitempty"`
 	RequiresDMS  string   `json:"requires_dms,omitempty"`
-	Featured     bool     `json:"featured,omitempty"`
 }
 
 type GitClient interface {
@@ -148,7 +147,7 @@ func (r *Registry) Update() error {
 	}
 
 	if !exists {
-		if err := r.fs.MkdirAll(filepath.Dir(r.cacheDir), 0o755); err != nil {
+		if err := r.fs.MkdirAll(filepath.Dir(r.cacheDir), 0755); err != nil {
 			return fmt.Errorf("failed to create cache directory: %w", err)
 		}
 
@@ -163,7 +162,7 @@ func (r *Registry) Update() error {
 				return fmt.Errorf("failed to remove corrupted registry: %w", err)
 			}
 
-			if err := r.fs.MkdirAll(filepath.Dir(r.cacheDir), 0o755); err != nil {
+			if err := r.fs.MkdirAll(filepath.Dir(r.cacheDir), 0755); err != nil {
 				return fmt.Errorf("failed to create cache directory: %w", err)
 			}
 

core/internal/plugins/registry_test.go

@@ -63,13 +63,13 @@ func setupTestRegistry(t *testing.T) (*Registry, afero.Fs, string) {
 
 func createTestPlugin(t *testing.T, fs afero.Fs, dir string, filename string, plugin Plugin) {
 	pluginsDir := filepath.Join(dir, "plugins")
-	err := fs.MkdirAll(pluginsDir, 0o755)
+	err := fs.MkdirAll(pluginsDir, 0755)
 	require.NoError(t, err)
 
 	data, err := json.Marshal(plugin)
 	require.NoError(t, err)
 
-	err = afero.WriteFile(fs, filepath.Join(pluginsDir, filename), data, 0o644)
+	err = afero.WriteFile(fs, filepath.Join(pluginsDir, filename), data, 0644)
 	require.NoError(t, err)
 }
 
@@ -118,10 +118,10 @@ func TestLoadPlugins(t *testing.T) {
 		registry, fs, tmpDir := setupTestRegistry(t)
 
 		pluginsDir := filepath.Join(tmpDir, "plugins")
-		err := fs.MkdirAll(pluginsDir, 0o755)
+		err := fs.MkdirAll(pluginsDir, 0755)
 		require.NoError(t, err)
 
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "README.md"), []byte("# Test"), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "README.md"), []byte("# Test"), 0644)
 		require.NoError(t, err)
 
 		plugin := Plugin{
@@ -146,7 +146,7 @@ func TestLoadPlugins(t *testing.T) {
 		registry, fs, tmpDir := setupTestRegistry(t)
 
 		pluginsDir := filepath.Join(tmpDir, "plugins")
-		err := fs.MkdirAll(filepath.Join(pluginsDir, "subdir"), 0o755)
+		err := fs.MkdirAll(filepath.Join(pluginsDir, "subdir"), 0755)
 		require.NoError(t, err)
 
 		plugin := Plugin{
@@ -170,10 +170,10 @@ func TestLoadPlugins(t *testing.T) {
 		registry, fs, tmpDir := setupTestRegistry(t)
 
 		pluginsDir := filepath.Join(tmpDir, "plugins")
-		err := fs.MkdirAll(pluginsDir, 0o755)
+		err := fs.MkdirAll(pluginsDir, 0755)
 		require.NoError(t, err)
 
-		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "invalid.json"), []byte("{invalid json}"), 0o644)
+		err = afero.WriteFile(fs, filepath.Join(pluginsDir, "invalid.json"), []byte("{invalid json}"), 0644)
 		require.NoError(t, err)
 
 		plugin := Plugin{
@@ -303,7 +303,7 @@ func TestUpdate(t *testing.T) {
 			Distro:       []string{"any"},
 		}
 
-		err := fs.MkdirAll(tmpDir, 0o755)
+		err := fs.MkdirAll(tmpDir, 0755)
 		require.NoError(t, err)
 
 		pullCalled := false

core/internal/plugins/search.go

@@ -67,9 +67,6 @@ func FilterByCapability(capability string, plugins []Plugin) []Plugin {
 
 func SortByFirstParty(plugins []Plugin) []Plugin {
 	sort.SliceStable(plugins, func(i, j int) bool {
-		if plugins[i].Featured != plugins[j].Featured {
-			return plugins[i].Featured
-		}
 		isFirstPartyI := strings.HasPrefix(plugins[i].Repo, "https://github.com/AvengeMedia")
 		isFirstPartyJ := strings.HasPrefix(plugins[j].Repo, "https://github.com/AvengeMedia")
 		if isFirstPartyI != isFirstPartyJ {

core/internal/proto/ext_workspace/workspace.go

@@ -258,7 +258,7 @@ func (i *ExtWorkspaceManagerV1) Dispatch(opcode uint32, fd int, data []byte) {
 		l := 0
 		objectID := client.Uint32(data[l : l+4])
 		proxy := i.Context().GetProxy(objectID)
-		if proxy != nil && !proxy.IsZombie() {
+		if proxy != nil {
 			e.WorkspaceGroup = proxy.(*ExtWorkspaceGroupHandleV1)
 		} else {
 			groupHandle := &ExtWorkspaceGroupHandleV1{}
@@ -278,7 +278,7 @@ func (i *ExtWorkspaceManagerV1) Dispatch(opcode uint32, fd int, data []byte) {
 		l := 0
 		objectID := client.Uint32(data[l : l+4])
 		proxy := i.Context().GetProxy(objectID)
-		if proxy != nil && !proxy.IsZombie() {
+		if proxy != nil {
 			e.Workspace = proxy.(*ExtWorkspaceHandleV1)
 		} else {
 			wsHandle := &ExtWorkspaceHandleV1{}

core/internal/screenshot/compositor.go

@@ -21,7 +21,6 @@ const (
 	CompositorNiri
 	CompositorDWL
 	CompositorScroll
-	CompositorMiracle
 )
 
 var detectedCompositor Compositor = -1
@@ -35,7 +34,6 @@ func DetectCompositor() Compositor {
 	niriSocket := os.Getenv("NIRI_SOCKET")
 	swaySocket := os.Getenv("SWAYSOCK")
 	scrollSocket := os.Getenv("SCROLLSOCK")
-	miracleSocket := os.Getenv("MIRACLESOCK")
 
 	switch {
 	case niriSocket != "":
@@ -48,11 +46,7 @@ func DetectCompositor() Compositor {
 			detectedCompositor = CompositorScroll
 			return detectedCompositor
 		}
-	case miracleSocket != "":
-		if _, err := os.Stat(miracleSocket); err == nil {
-			detectedCompositor = CompositorMiracle
-			return detectedCompositor
-		}
+
 	case swaySocket != "":
 		if _, err := os.Stat(swaySocket); err == nil {
 			detectedCompositor = CompositorSway
@@ -266,25 +260,6 @@ func getScrollFocusedMonitor() string {
 	return ""
 }
 
-func getMiracleFocusedMonitor() string {
-	output, err := exec.Command("miraclemsg", "-t", "get_workspaces").Output()
-	if err != nil {
-		return ""
-	}
-
-	var workspaces []swayWorkspace
-	if err := json.Unmarshal(output, &workspaces); err != nil {
-		return ""
-	}
-
-	for _, ws := range workspaces {
-		if ws.Focused {
-			return ws.Output
-		}
-	}
-	return ""
-}
-
 type niriWorkspace struct {
 	Output    string `json:"output"`
 	IsFocused bool   `json:"is_focused"`
@@ -432,8 +407,6 @@ func GetFocusedMonitor() string {
 		return getSwayFocusedMonitor()
 	case CompositorScroll:
 		return getScrollFocusedMonitor()
-	case CompositorMiracle:
-		return getMiracleFocusedMonitor()
 	case CompositorNiri:
 		return getNiriFocusedMonitor()
 	case CompositorDWL:

core/internal/screenshot/encode.go

@@ -107,7 +107,7 @@ func GetOutputDir() string {
 
 	if xdgPics := getXDGPicturesDir(); xdgPics != "" {
 		screenshotDir := filepath.Join(xdgPics, "Screenshots")
-		if err := os.MkdirAll(screenshotDir, 0o755); err == nil {
+		if err := os.MkdirAll(screenshotDir, 0755); err == nil {
 			return screenshotDir
 		}
 		return xdgPics

core/internal/screenshot/region.go

@@ -108,7 +108,7 @@ func NewRegionSelector(s *Screenshoter) *RegionSelector {
 		screenshoter:       s,
 		outputs:            make(map[uint32]*WaylandOutput),
 		preCapture:         make(map[*WaylandOutput]*PreCapture),
-		showCapturedCursor: s.config.Cursor == CursorOn,
+		showCapturedCursor: true,
 	}
 }
 

core/internal/screenshot/screenshot.go

@@ -453,7 +453,10 @@ func (s *Screenshoter) blitBuffer(dst, src *ShmBuffer, dstX, dstY int, yInverted
 }
 
 func (s *Screenshoter) captureWholeOutput(output *WaylandOutput) (*CaptureResult, error) {
-	cursor := int32(s.config.Cursor)
+	cursor := int32(0)
+	if s.config.IncludeCursor {
+		cursor = 1
+	}
 
 	frame, err := s.screencopy.CaptureOutput(cursor, output.wlOutput)
 	if err != nil {
@@ -621,7 +624,10 @@ func (s *Screenshoter) captureRegionOnOutput(output *WaylandOutput, region Regio
 		}
 	}
 
-	cursor := int32(s.config.Cursor)
+	cursor := int32(0)
+	if s.config.IncludeCursor {
+		cursor = 1
+	}
 
 	frame, err := s.screencopy.CaptureOutputRegion(cursor, output.wlOutput, localX, localY, w, h)
 	if err != nil {

core/internal/screenshot/state.go

@@ -39,7 +39,7 @@ func LoadState() (*PersistentState, error) {
 func SaveState(state *PersistentState) error {
 	path := getStateFilePath()
 	dir := filepath.Dir(path)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
+	if err := os.MkdirAll(dir, 0755); err != nil {
 		return err
 	}
 
@@ -47,7 +47,7 @@ func SaveState(state *PersistentState) error {
 	if err != nil {
 		return err
 	}
-	return os.WriteFile(path, data, 0o644)
+	return os.WriteFile(path, data, 0644)
 }
 
 func GetLastRegion() Region {

core/internal/screenshot/theme.go

@@ -3,11 +3,11 @@ package screenshot
 import (
 	"encoding/json"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
 
 type ThemeColors struct {
@@ -83,11 +83,12 @@ func getColorsFilePath() string {
 }
 
 func isLightMode() bool {
-	scheme, err := utils.GsettingsGet("org.gnome.desktop.interface", "color-scheme")
+	out, err := exec.Command("gsettings", "get", "org.gnome.desktop.interface", "color-scheme").Output()
 	if err != nil {
 		return false
 	}
 
+	scheme := strings.TrimSpace(string(out))
 	switch scheme {
 	case "'prefer-light'", "'default'":
 		return true

core/internal/screenshot/types.go

@@ -19,13 +19,6 @@ const (
 	FormatPPM
 )
 
-type CursorMode int
-
-const (
-	CursorOff CursorMode = iota
-	CursorOn
-)
-
 type Region struct {
 	X      int32  `json:"x"`
 	Y      int32  `json:"y"`
@@ -49,29 +42,29 @@ type Output struct {
 }
 
 type Config struct {
-	Mode       Mode
-	OutputName string
-	Cursor     CursorMode
-	Format     Format
-	Quality    int
-	OutputDir  string
-	Filename   string
-	Clipboard  bool
-	SaveFile   bool
-	Notify     bool
-	Stdout     bool
+	Mode          Mode
+	OutputName    string
+	IncludeCursor bool
+	Format        Format
+	Quality       int
+	OutputDir     string
+	Filename      string
+	Clipboard     bool
+	SaveFile      bool
+	Notify        bool
+	Stdout        bool
 }
 
 func DefaultConfig() Config {
 	return Config{
-		Mode:      ModeRegion,
-		Cursor:    CursorOff,
-		Format:    FormatPNG,
-		Quality:   90,
-		OutputDir: "",
-		Filename:  "",
-		Clipboard: true,
-		SaveFile:  true,
-		Notify:    true,
+		Mode:          ModeRegion,
+		IncludeCursor: false,
+		Format:        FormatPNG,
+		Quality:       90,
+		OutputDir:     "",
+		Filename:      "",
+		Clipboard:     true,
+		SaveFile:      true,
+		Notify:        true,
 	}
 }