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

@@ -7,32 +7,32 @@ body:
     attributes:
       value: |
         ## DankMaterialShell Bug Report
-        Limit your report to one issue per submission unless similarly related
-  - type: dropdown
+        Limit your report to one issue per submission unless closely related
+  - 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
-    attributes:
-      label: Was this your original Installation method?
-      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 details tags 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/go-ci.yml

@@ -26,7 +26,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install flatpak
         run: sudo apt update && sudo apt install -y flatpak
@@ -38,7 +38,7 @@ jobs:
         run: sudo flatpak install -y org.freedesktop.Platform/x86_64/24.08 app.zen_browser.zen
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
           go-version-file: ./core/go.mod
 

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

@@ -1,4 +1,4 @@
-name: Nix flake and NixOS tests
+name: Check nix flake
 
 on:
   pull_request:
@@ -9,35 +9,15 @@ on:
 jobs:
   check-flake:
     runs-on: ubuntu-latest
-    timeout-minutes: 120
     steps:
 
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31
-        with:
-          enable_kvm: true
-          extra_nix_config: |
-            system-features = nixos-test benchmark big-parallel kvm
 
       - name: Check the flake
-        run: nix flake check -L
-
-      - name: Run NixOS module test
-        run: nix build .#nixosTests.x86_64-linux.nixos-module -L
-
-      - name: Run NixOS service start test
-        run: nix build .#nixosTests.x86_64-linux.nixos-service-start-module -L
-
-      - name: Run greeter niri test
-        run: nix build .#nixosTests.x86_64-linux.greeter-niri-module -L
-
-      - name: Run home-manager module test
-        run: nix build .#nixosTests.x86_64-linux.home-manager-module -L
-
-      - name: Run niri home-manager module test
-        run: nix build .#nixosTests.x86_64-linux.niri-home-module -L
+        run: nix flake check

.github/workflows/prek.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install flatpak
         run: sudo apt update && sudo apt install -y flatpak
@@ -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@v6
-        with:
-          go-version-file: core/go.mod
-
       - name: run pre-commit hooks
         uses: j178/prek-action@v1

.github/workflows/release.yml

@@ -32,13 +32,13 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           ref: ${{ inputs.tag }}
           fetch-depth: 0
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
           go-version-file: ./core/go.mod
 
@@ -106,7 +106,7 @@ jobs:
 
       - name: Upload artifacts (${{ matrix.arch }})
         if: matrix.arch == 'arm64'
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: core-assets-${{ matrix.arch }}
           path: |
@@ -120,7 +120,7 @@ jobs:
 
       - name: Upload artifacts with completions
         if: matrix.arch == 'amd64'
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: core-assets-${{ matrix.arch }}
           path: |
@@ -147,7 +147,7 @@ jobs:
   #         private-key: ${{ secrets.APP_PRIVATE_KEY }}
 
   #     - name: Checkout
-  #       uses: actions/checkout@v6
+  #       uses: actions/checkout@v4
   #       with:
   #         token: ${{ steps.app_token.outputs.token }}
   #         fetch-depth: 0
@@ -181,7 +181,7 @@ jobs:
       TAG: ${{ inputs.tag }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           ref: ${{ inputs.tag }}
           fetch-depth: 0
@@ -191,13 +191,8 @@ jobs:
           git fetch origin --force tag ${TAG}
           git checkout ${TAG}
 
-      - name: Set up Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: ./core/go.mod
-
       - name: Download core artifacts
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@v4
         with:
           pattern: core-assets-*
           merge-multiple: true
@@ -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-copr.yml

@@ -46,7 +46,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Determine version
         id: version
@@ -134,7 +134,7 @@ jobs:
           rpm -qpi "$SRPM"
 
       - name: Upload SRPM artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.package }}-stable-srpm-${{ steps.version.outputs.version }}
           path: ${{ steps.build.outputs.srpm_path }}

.github/workflows/run-obs.yml

@@ -4,21 +4,19 @@ on:
   workflow_dispatch:
     inputs:
       package:
-        description: "Package to update"
-        required: true
-        type: choice
-        options:
-          - dms
-          - dms-greeter
-          - 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:
@@ -32,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -58,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 "")
 
@@ -73,27 +70,12 @@ jobs:
             fi
           }
 
-          # Helper function to check dms-greeter stable tag
-          check_dms_greeter_stable() {
-            LATEST_TAG=$(curl -s https://api.github.com/repos/AvengeMedia/DankMaterialShell/releases/latest | grep '"tag_name"' | sed 's/.*"tag_name": "\([^"]*\)".*/\1/' || echo "")
-            local OBS_SPEC=$(curl -s -u "$OBS_USERNAME:$OBS_PASSWORD" "https://api.opensuse.org/source/home:AvengeMedia:danklinux/dms-greeter/dms-greeter.spec" 2>/dev/null || echo "")
-            local OBS_VERSION=$(echo "$OBS_SPEC" | grep "^Version:" | awk '{print $2}' | xargs | sed 's/^v//')
-
-            if [[ -n "$LATEST_TAG" && "$LATEST_TAG" == "v$OBS_VERSION" ]]; then
-              echo "📋 dms-greeter: Tag $LATEST_TAG already exists, skipping"
-              return 1  # No update needed
-            else
-              echo "📋 dms-greeter: New tag ${LATEST_TAG:-unknown} (OBS has ${OBS_VERSION:-none})"
-              return 0  # Update needed
-            fi
-          }
-
           # Main logic
           REBUILD="${{ github.event.inputs.rebuild_release }}"
 
-          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]] && [[ -z "${{ github.event.inputs.package }}" ]]; then
-            # Run from tag with no package specified - update both stable packages
-            echo "packages=dms dms-greeter" >> $GITHUB_OUTPUT
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            # Tag push - always update stable package
+            echo "packages=dms" >> $GITHUB_OUTPUT
             VERSION="${GITHUB_REF#refs/tags/}"
             echo "version=$VERSION" >> $GITHUB_OUTPUT
             echo "has_updates=true" >> $GITHUB_OUTPUT
@@ -119,18 +101,10 @@ jobs:
               echo "🔄 Manual rebuild requested: $PKG (db$REBUILD)"
 
             elif [[ "$PKG" == "all" ]]; then
-              # Check each stable package and build list of those needing updates
+              # Check each package and build list of those needing updates
               PACKAGES_TO_UPDATE=()
-              if check_dms_stable; then
-                PACKAGES_TO_UPDATE+=("dms")
-                if [[ -n "$LATEST_TAG" ]]; then
-                  echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
-                fi
-              fi
-              if check_dms_greeter_stable; then
-                PACKAGES_TO_UPDATE+=("dms-greeter")
-                [[ -n "$LATEST_TAG" ]] && echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
-              fi
+              check_dms_git && PACKAGES_TO_UPDATE+=("dms-git")
+              check_dms_stable && PACKAGES_TO_UPDATE+=("dms")
 
               if [[ ${#PACKAGES_TO_UPDATE[@]} -gt 0 ]]; then
                 echo "packages=${PACKAGES_TO_UPDATE[*]}" >> $GITHUB_OUTPUT
@@ -139,7 +113,7 @@ jobs:
               else
                 echo "packages=" >> $GITHUB_OUTPUT
                 echo "has_updates=false" >> $GITHUB_OUTPUT
-                echo "✓ Both packages up to date"
+                echo "✓ All packages up to date"
               fi
 
             elif [[ "$PKG" == "dms-git" ]]; then
@@ -155,21 +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
-              fi
-
-            elif [[ "$PKG" == "dms-greeter" ]]; then
-              if check_dms_greeter_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
@@ -195,22 +154,19 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Wait before OBS upload
-        run: sleep 3
-
       - name: Determine packages to update
         id: packages
         run: |
-          # Use check-updates outputs when available
-          if [[ -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 }}"
+          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 "Triggered by tag: $VERSION"
           elif [[ "${{ github.event_name }}" == "schedule" ]]; then
             # Scheduled run - dms-git only
             echo "packages=${{ needs.check-updates.outputs.packages }}" >> $GITHUB_OUTPUT
@@ -218,21 +174,39 @@ jobs:
           elif [[ -n "${{ github.event.inputs.package }}" ]]; then
             # Manual workflow dispatch
 
-            # Determine version for dms stable and dms-greeter using the API
-            # GITHUB_REF is unreliable when "Use workflow from" a tag; API works from any ref
-            if [[ "${{ github.event.inputs.package }}" == "dms" ]] || [[ "${{ github.event.inputs.package }}" == "dms-greeter" ]] || [[ "${{ github.event.inputs.package }}" == "all" ]]; then
+            # Determine version for dms stable
+            if [[ "${{ github.event.inputs.package }}" == "dms" ]]; then
+              # For explicit dms selection, require tag_version
+              if [[ -n "${{ github.event.inputs.tag_version }}" ]]; then
+                VERSION="${{ github.event.inputs.tag_version }}"
+                echo "version=$VERSION" >> $GITHUB_OUTPUT
+                echo "Using specified tag: $VERSION"
+              else
+                echo "ERROR: tag_version is required when package=dms"
+                echo "Please specify a tag version (e.g., v1.0.2) or use package=all for auto-detection"
+                exit 1
+              fi
+            elif [[ "${{ github.event.inputs.package }}" == "all" ]]; then
+              # For "all", auto-detect if tag_version not specified
+              if [[ -n "${{ github.event.inputs.tag_version }}" ]]; then
+                VERSION="${{ github.event.inputs.tag_version }}"
+                echo "version=$VERSION" >> $GITHUB_OUTPUT
+                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 "")
                 if [[ -n "$LATEST_TAG" ]]; then
                   echo "version=$LATEST_TAG" >> $GITHUB_OUTPUT
-                echo "Using latest release from API: $LATEST_TAG"
+                  echo "Auto-detected latest release: $LATEST_TAG"
                 else
-                echo "ERROR: Could not fetch latest release from API"
+                  echo "ERROR: Could not auto-detect latest release"
                   exit 1
                 fi
               fi
+            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
@@ -241,13 +215,10 @@ 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
-        if: contains(steps.packages.outputs.packages, 'dms-git')
+        if: contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all'
         run: |
           COMMIT_HASH=$(git rev-parse --short=8 HEAD)
           COMMIT_COUNT=$(git rev-list --count HEAD)
@@ -268,7 +239,7 @@ jobs:
           } > distro/opensuse/dms-git.spec
 
       - name: Update Debian dms-git changelog version
-        if: contains(steps.packages.outputs.packages, 'dms-git')
+        if: contains(steps.packages.outputs.packages, 'dms-git') || steps.packages.outputs.packages == 'all'
         run: |
           COMMIT_HASH=$(git rev-parse --short=8 HEAD)
           COMMIT_COUNT=$(git rev-list --count HEAD)
@@ -286,20 +257,21 @@ jobs:
             echo " -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE"
           } > "distro/debian/dms-git/debian/changelog"
 
-      - name: Update stable version (dms + dms-greeter)
+      - name: Update dms stable version
         if: steps.packages.outputs.version != ''
         run: |
           VERSION="${{ steps.packages.outputs.version }}"
           VERSION_NO_V="${VERSION#v}"
-          PACKAGES="${{ steps.packages.outputs.packages }}"
           echo "==> Updating packaging files to version: $VERSION_NO_V"
 
-          # Update dms spec and changelog when dms is in the upload list
-          if [[ "$PACKAGES" == *"dms"* ]]; then
+          # Update spec file
           sed -i "s/^Version:.*/Version:        $VERSION_NO_V/" distro/opensuse/dms.spec
-            UPDATED_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1)
-            echo "✓ dms spec now shows Version: $UPDATED_VERSION"
 
+          # Verify the update
+          UPDATED_VERSION=$(grep -oP '^Version:\s+\K[0-9.]+' distro/opensuse/dms.spec | head -1)
+          echo "✓ Spec file now shows Version: $UPDATED_VERSION"
+
+          # Single changelog entry (full history on OBS website)
           DATE_STR=$(date "+%a %b %d %Y")
           LOCAL_SPEC_HEAD=$(sed -n '1,/%changelog/{ /%changelog/d; p }' distro/opensuse/dms.spec)
           {
@@ -309,6 +281,19 @@ jobs:
             echo "- Update to stable $VERSION release"
           } > distro/opensuse/dms.spec
 
+          # Update Debian _service files (both tar_scm and download_url formats)
+          for service in distro/debian/*/_service; do
+            if [[ -f "$service" ]]; then
+              # Update tar_scm revision parameter (for dms-git)
+              sed -i "s|<param name=\"revision\">v[0-9.]*</param>|<param name=\"revision\">$VERSION</param>|" "$service"
+
+              # Update download_url paths (for dms stable)
+              sed -i "s|/v[0-9.]\+/|/$VERSION/|g" "$service"
+              sed -i "s|/tags/v[0-9.]\+\.tar\.gz|/tags/$VERSION.tar.gz|g" "$service"
+            fi
+          done
+
+          # Update Debian changelog for dms stable (single entry, history on OBS website)
           if [[ -f "distro/debian/dms/debian/changelog" ]]; then
             CHANGELOG_DATE=$(date -R)
             {
@@ -318,38 +303,13 @@ jobs:
               echo ""
               echo " -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE"
             } > "distro/debian/dms/debian/changelog"
-              echo "✓ Updated dms changelog to ${VERSION_NO_V}db1"
+            echo "✓ Updated Debian changelog to ${VERSION_NO_V}db1"
           fi
-          fi
-
-          # Update dms-greeter changelog when dms-greeter is in the upload list
-          if [[ "$PACKAGES" == *"dms-greeter"* ]] && [[ -f "distro/debian/dms-greeter/debian/changelog" ]]; then
-            CHANGELOG_DATE=$(date -R)
-            {
-              echo "dms-greeter (${VERSION_NO_V}db1) unstable; urgency=medium"
-              echo ""
-              echo "  * Update to $VERSION stable release"
-              echo ""
-              echo " -- Avenge Media <AvengeMedia.US@gmail.com>  $CHANGELOG_DATE"
-            } > "distro/debian/dms-greeter/debian/changelog"
-            echo "✓ Updated dms-greeter changelog to ${VERSION_NO_V}db1"
-          fi
-
-          # Update Debian _service files for packages in upload list (download_url paths)
-          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, dms-greeter 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
 
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version-file: ./core/go.mod
+          go-version: "1.24"
 
       - name: Install OSC
         run: |
@@ -368,7 +328,6 @@ jobs:
           chmod 600 ~/.config/osc/oscrc
 
       - name: Upload to OBS
-        id: upload
         env:
           REBUILD_RELEASE: ${{ github.event.inputs.rebuild_release }}
           TAG_VERSION: ${{ steps.packages.outputs.version }}
@@ -377,8 +336,6 @@ jobs:
 
           if [[ -z "$PACKAGES" ]]; then
             echo "✓ No packages need uploading. All up to date!"
-            echo "uploaded_packages=" >> $GITHUB_OUTPUT
-            echo "skipped_packages=" >> $GITHUB_OUTPUT
             exit 0
           fi
 
@@ -388,10 +345,7 @@ jobs:
             echo "==> Version being uploaded: ${{ steps.packages.outputs.version }}"
           fi
 
-          UPLOADED_PACKAGES=()
-          SKIPPED_PACKAGES=()
-
-          # PACKAGES can be space-separated list (e.g., "dms dms-greeter" from "all" check)
+          # PACKAGES can be space-separated list (e.g., "dms-git dms" from "all" check)
           # Loop through each package and upload
           for PKG in $PACKAGES; do
             echo ""
@@ -402,37 +356,13 @@ jobs:
             fi
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 
-            LOG_FILE=$(mktemp)
-            set +e
             if [[ "$PKG" == "dms-git" ]]; then
-              bash distro/scripts/obs-upload.sh dms-git "Automated git update" >"$LOG_FILE" 2>&1
+              bash distro/scripts/obs-upload.sh dms-git "Automated git update"
             else
-              bash distro/scripts/obs-upload.sh "$PKG" "$MESSAGE" >"$LOG_FILE" 2>&1
+              bash distro/scripts/obs-upload.sh "$PKG" "$MESSAGE"
             fi
-            STATUS=$?
-            set -e
-
-            cat "$LOG_FILE"
-
-            if [[ $STATUS -ne 0 ]]; then
-              rm -f "$LOG_FILE"
-              echo "❌ Upload failed for $PKG"
-              exit $STATUS
-            fi
-
-            if grep -Eq "Exiting gracefully \(no changes needed\)|No changes needed for this package\. Exiting gracefully\." "$LOG_FILE"; then
-              echo "ℹ️  $PKG is already up to date. Skipped."
-              SKIPPED_PACKAGES+=("$PKG")
-            else
-              UPLOADED_PACKAGES+=("$PKG")
-            fi
-
-            rm -f "$LOG_FILE"
           done
 
-          echo "uploaded_packages=${UPLOADED_PACKAGES[*]}" >> $GITHUB_OUTPUT
-          echo "skipped_packages=${SKIPPED_PACKAGES[*]}" >> $GITHUB_OUTPUT
-
       - name: Summary
         if: always()
         run: |
@@ -446,59 +376,20 @@ jobs:
             echo "" >> $GITHUB_STEP_SUMMARY
             echo "All packages are current. Run completed successfully." >> $GITHUB_STEP_SUMMARY
           else
-            UPLOADED_PACKAGES="${{ steps.upload.outputs.uploaded_packages }}"
-            SKIPPED_PACKAGES="${{ steps.upload.outputs.skipped_packages }}"
-            TOTAL_COUNT=$(wc -w <<<"$PACKAGES" | tr -d ' ')
-            UPLOADED_COUNT=0
-            SKIPPED_COUNT=0
-            if [[ -n "$UPLOADED_PACKAGES" ]]; then
-              UPLOADED_COUNT=$(wc -w <<<"$UPLOADED_PACKAGES" | tr -d ' ')
-            fi
-            if [[ -n "$SKIPPED_PACKAGES" ]]; then
-              SKIPPED_COUNT=$(wc -w <<<"$SKIPPED_PACKAGES" | tr -d ' ')
-            fi
-            in_list() {
-              local item="$1"
-              local list="$2"
-              [[ " $list " == *" $item "* ]]
-            }
-
-            if [[ "${{ job.status }}" == "success" ]]; then
-              echo "**Status:** ✅ Completed successfully" >> $GITHUB_STEP_SUMMARY
-            else
-              echo "**Status:** ❌ Completed with errors" >> $GITHUB_STEP_SUMMARY
-            fi
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "**Processed:** $TOTAL_COUNT package(s)" >> $GITHUB_STEP_SUMMARY
-            echo "**Uploaded:** $UPLOADED_COUNT package(s)" >> $GITHUB_STEP_SUMMARY
-            echo "**Skipped (up to date):** $SKIPPED_COUNT package(s)" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "**Packages:**" >> $GITHUB_STEP_SUMMARY
+            echo "**Packages Uploaded:**" >> $GITHUB_STEP_SUMMARY
             echo "" >> $GITHUB_STEP_SUMMARY
 
             for PKG in $PACKAGES; do
-              STATUS_ICON="✅"
-              STATUS_TEXT="uploaded"
-              if in_list "$PKG" "$SKIPPED_PACKAGES"; then
-                STATUS_ICON="ℹ️"
-                STATUS_TEXT="up to date (skipped)"
-              elif ! in_list "$PKG" "$UPLOADED_PACKAGES"; then
-                STATUS_ICON="❌"
-                STATUS_TEXT="failed"
-              fi
-
               case "$PKG" in
                 dms)
-                  echo "- $STATUS_ICON **dms** ($STATUS_TEXT) → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms/dms)" >> $GITHUB_STEP_SUMMARY
+                  echo "- ✅ **dms** → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms/dms)" >> $GITHUB_STEP_SUMMARY
                   ;;
                 dms-git)
-                  echo "- $STATUS_ICON **dms-git** ($STATUS_TEXT) → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms-git/dms-git)" >> $GITHUB_STEP_SUMMARY
-                  ;;
-                dms-greeter)
-                  echo "- $STATUS_ICON **dms-greeter** ($STATUS_TEXT) → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:danklinux/dms-greeter)" >> $GITHUB_STEP_SUMMARY
+                  echo "- ✅ **dms-git** → [View builds](https://build.opensuse.org/package/show/home:AvengeMedia:dms-git/dms-git)" >> $GITHUB_STEP_SUMMARY
                   ;;
               esac
             done
+
             echo "" >> $GITHUB_STEP_SUMMARY
 
             if [[ -n "${{ github.event.inputs.rebuild_release }}" ]]; then

.github/workflows/run-ppa.yml

@@ -4,21 +4,15 @@ on:
   workflow_dispatch:
     inputs:
       package:
-        description: "Package to upload"
-        required: true
-        type: choice
-        options:
-          - dms
-          - dms-greeter
-          - dms-git
-          - all
-        default: "dms"
+        description: "Package to upload (dms, dms-git, dms-greeter, or all)"
+        required: false
+        default: "dms-git"
       rebuild_release:
         description: "Release number for rebuilds (e.g., 2, 3, 4 for ppa2, ppa3, ppa4)"
         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:
@@ -31,7 +25,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -145,7 +139,7 @@ jobs:
             fi
           else
             # Fallback
-            echo "packages=dms" >> $GITHUB_OUTPUT
+            echo "packages=dms-git" >> $GITHUB_OUTPUT
             echo "has_updates=true" >> $GITHUB_OUTPUT
           fi
 
@@ -157,14 +151,14 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version-file: ./core/go.mod
+          go-version: "1.24"
           cache: false
 
       - name: Install build dependencies
@@ -215,7 +209,7 @@ jobs:
             echo "✓ Using rebuild release number: ppa$REBUILD_RELEASE"
           fi
 
-          # PACKAGES can be space-separated list (e.g., "dms-git dms dms-greeter" from "all" check)
+          # PACKAGES can be space-separated list (e.g., "dms-git dms" from "all" check)
           # Loop through each package and upload
           for PKG in $PACKAGES; do
             # Map package to PPA name
@@ -242,11 +236,7 @@ jobs:
               echo "🔄 Using rebuild release number: ppa$REBUILD_RELEASE"
             fi
             echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-            # ppa-upload.sh uploads to questing + resolute when series is omitted
-            if ! bash distro/scripts/ppa-upload.sh "$PKG" "$PPA_NAME" "" ${REBUILD_RELEASE:+"$REBUILD_RELEASE"}; then
-              echo "::error::Upload failed for $PKG"
-              exit 1
-            fi
+            bash distro/scripts/ppa-upload.sh "$PKG" "$PPA_NAME" questing ${REBUILD_RELEASE:+"$REBUILD_RELEASE"}
           done
 
       - name: Summary

.github/workflows/stable.yml

@@ -20,7 +20,7 @@ jobs:
           private-key: ${{ secrets.APP_PRIVATE_KEY }}
 
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           token: ${{ steps.app_token.outputs.token }}

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

@@ -24,7 +24,7 @@ jobs:
           private-key: ${{ secrets.APP_PRIVATE_KEY }}
 
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           token: ${{ steps.app_token.outputs.token }}
@@ -40,7 +40,7 @@ jobs:
             echo "Build succeeded, no hash update needed"
             exit 0
           fi
-          new_hash=$(echo "$output" | grep -oP "got:\s+\K\S+" | head -n1 || true)
+          new_hash=$(echo "$output" | grep -oP "got:\s+\K\S+" | head -n1)
           [ -n "$new_hash" ] || { echo "Could not extract new vendorHash"; echo "$output"; exit 1; }
           current_hash=$(grep -oP 'vendorHash = "\K[^"]+' flake.nix)
           [ "$current_hash" = "$new_hash" ] && { echo "vendorHash already up to date"; exit 0; }
@@ -59,8 +59,8 @@ jobs:
             git config user.email "dms-ci[bot]@users.noreply.github.com"
             git add flake.nix
             git commit -m "nix: update vendorHash for go.mod changes" || exit 0
-            git pull --rebase origin ${{ github.ref_name }}
-            git push https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git HEAD:${{ github.ref_name }}
+            git pull --rebase origin master
+            git push https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git HEAD:master
           else
             echo "No changes to flake.nix"
           fi

.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,26 +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
-  - repo: local
-    hooks:
-      - id: no-console-in-qml
-        name: no console.* in QML (use Log service)
-        entry: bash -c 'if grep -nE "console\.(log|error|info|warn|debug)" "$@"; then echo "Use the Log service (log.info/warn/error/debug/fatal) instead of console.*" >&2; exit 1; fi' --
-        language: system
-        files: ^quickshell/.*\.qml$
-        exclude: ^quickshell/(Services/Log\.qml$|dms-plugins/|PLUGINS/)
+        args: [-e, SC2164, -e, SC2001, -e, SC2012, -e, SC2317]

CHANGELOG.MD

@@ -1,23 +1,5 @@
 This file is more of a quick reference so I know what to account for before next releases.
 
-# 1.5.0
-- Overhauled shadows
-- App ID changed to com.danklinux.dms - breaking for window rules
-- Greeter stuff
-- Terminal mux
-- Locale overrides
-- new neovim theming
-
-# 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"
 }
 ```
 
@@ -86,9 +53,7 @@ touch .qmlls.ini
 
 4. Restart dms to generate the `.qmlls.ini` file
 
-5. Run `make lint-qml` from the repo root to lint QML entrypoints (requires the `.qmlls.ini` generated above). The script needs the **Qt 6** `qmllint`; it checks `qmllint6`, Fedora's `qmllint-qt6`, `/usr/lib/qt6/bin/qmllint`, then `qmllint` in `PATH`. If your Qt 6 binary lives elsewhere, set `QMLLINT=/path/to/qmllint`.
-
-6. Make your changes, test, and open a pull request.
+5. Make your changes, test, and open a pull request.
 
 ### I18n/Localization
 

Makefile

@@ -18,7 +18,7 @@ SHELL_INSTALL_DIR=$(DATA_DIR)/quickshell/dms
 ASSETS_DIR=assets
 APPLICATIONS_DIR=$(DATA_DIR)/applications
 
-.PHONY: all build clean lint-qml install install-bin install-shell install-completions install-systemd install-icon install-desktop uninstall uninstall-bin uninstall-shell uninstall-completions uninstall-systemd uninstall-icon uninstall-desktop help
+.PHONY: all build clean install install-bin install-shell install-completions install-systemd install-icon install-desktop uninstall uninstall-bin uninstall-shell uninstall-completions uninstall-systemd uninstall-icon uninstall-desktop help
 
 all: build
 
@@ -32,9 +32,6 @@ clean:
 	@$(MAKE) -C $(CORE_DIR) clean
 	@echo "Clean complete"
 
-lint-qml:
-	@./quickshell/scripts/qmllint-entrypoints.sh
-
 # Installation targets
 install-bin:
 	@echo "Installing $(BINARY_NAME) to $(INSTALL_DIR)..."
@@ -46,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:
@@ -61,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:
@@ -79,7 +77,7 @@ install-desktop:
 	@update-desktop-database -q $(APPLICATIONS_DIR) 2>/dev/null || true
 	@echo "Desktop entry installed"
 
-install: install-bin install-shell install-completions install-systemd install-icon install-desktop
+install: build install-bin install-shell install-completions install-systemd install-icon install-desktop
 	@echo ""
 	@echo "Installation complete!"
 	@echo ""
@@ -133,7 +131,6 @@ help:
 	@echo "  all (default)        - Build the DMS binary"
 	@echo "  build                - Same as 'all'"
 	@echo "  clean                - Clean build artifacts"
-	@echo "  lint-qml             - Run qmllint on shell entrypoints using the Quickshell tooling VFS"
 	@echo ""
 	@echo "Install:"
 	@echo "  install              - Build and install everything (requires sudo)"

README.md

@@ -13,13 +13,13 @@ Built with [Quickshell](https://quickshell.org/) and [Go](https://go.dev/)
 [![GitHub stars](https://img.shields.io/github/stars/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=ffd700)](https://github.com/AvengeMedia/DankMaterialShell/stargazers)
 [![GitHub License](https://img.shields.io/github/license/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=b9c8da)](https://github.com/AvengeMedia/DankMaterialShell/blob/master/LICENSE)
 [![GitHub release](https://img.shields.io/github/v/release/AvengeMedia/DankMaterialShell?style=for-the-badge&labelColor=101418&color=9ccbfb)](https://github.com/AvengeMedia/DankMaterialShell/releases)
-[![Arch version](https://img.shields.io/archlinux/v/extra/x86_64/dms-shell?style=for-the-badge&labelColor=101418&color=9ccbfb)](https://archlinux.org/packages/extra/x86_64/dms-shell/)
+[![AUR version](https://img.shields.io/aur/version/dms-shell-bin?style=for-the-badge&labelColor=101418&color=9ccbfb)](https://aur.archlinux.org/packages/dms-shell-bin)
 [![AUR version (git)](<https://img.shields.io/aur/version/dms-shell-git?style=for-the-badge&labelColor=101418&color=9ccbfb&label=AUR%20(git)>)](https://aur.archlinux.org/packages/dms-shell-git)
 [![Ko-Fi donate](https://img.shields.io/badge/donate-kofi?style=for-the-badge&logo=ko-fi&logoColor=ffffff&label=ko-fi&labelColor=101418&color=f16061&link=https%3A%2F%2Fko-fi.com%2Fdanklinux)](https://ko-fi.com/danklinux)
 
 </div>
 
-DankMaterialShell is a complete desktop shell for [niri](https://github.com/YaLTeR/niri), [Hyprland](https://hyprland.org/), [MangoWC](https://github.com/DreamMaoMao/mangowc), [Sway](https://swaywm.org), [labwc](https://labwc.github.io/), [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/.mockery.yml

@@ -28,12 +28,6 @@ packages:
       outpkg: mocks_brightness
     interfaces:
       DBusConn:
-  github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation:
-    config:
-      dir: "internal/mocks/geolocation"
-      outpkg: mocks_geolocation
-    interfaces:
-      Client:
   github.com/AvengeMedia/DankMaterialShell/core/internal/server/network:
     config:
       dir: "internal/mocks/network"

core/.pre-commit-config.yaml

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

core/Makefile

@@ -63,19 +63,19 @@ endif
 
 build-all: build dankinstall
 
-install:
+install: build
 	@echo "Installing $(BINARY_NAME) to $(INSTALL_DIR)..."
 	@install -D -m 755 $(BUILD_DIR)/$(BINARY_NAME) $(INSTALL_DIR)/$(BINARY_NAME)
 	@echo "Installation complete"
 
-install-all:
+install-all: build-all
 	@echo "Installing $(BINARY_NAME) to $(INSTALL_DIR)..."
 	@install -D -m 755 $(BUILD_DIR)/$(BINARY_NAME) $(INSTALL_DIR)/$(BINARY_NAME)
 	@echo "Installing $(BINARY_NAME_INSTALL) to $(INSTALL_DIR)..."
 	@install -D -m 755 $(BUILD_DIR)/$(BINARY_NAME_INSTALL) $(INSTALL_DIR)/$(BINARY_NAME_INSTALL)
 	@echo "Installation complete"
 
-install-dankinstall:
+install-dankinstall: dankinstall
 	@echo "Installing $(BINARY_NAME_INSTALL) to $(INSTALL_DIR)..."
 	@install -D -m 755 $(BUILD_DIR)/$(BINARY_NAME_INSTALL) $(INSTALL_DIR)/$(BINARY_NAME_INSTALL)
 	@echo "Installation complete"

core/README.md

@@ -10,7 +10,7 @@ Go-based backend for DankMaterialShell providing system integration, IPC, and in
 Command-line interface and daemon for shell management and system control.
 
 **dankinstall**
-Distribution-aware installer for deploying DMS and compositor configurations on Arch, Fedora, Debian, Ubuntu, openSUSE, and Gentoo. Supports both an interactive TUI and a headless (unattended) mode via CLI flags.
+Distribution-aware installer with TUI for deploying DMS and compositor configurations on Arch, Fedora, Debian, Ubuntu, openSUSE, and Gentoo.
 
 ## System Integration
 
@@ -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:**
 
@@ -147,50 +147,10 @@ go-wayland-scanner -i internal/proto/xml/wlr-gamma-control-unstable-v1.xml \
 
 ## Installation via dankinstall
 
-**Interactive (TUI):**
-
 ```bash
 curl -fsSL https://install.danklinux.com | sh
 ```
 
-**Headless (unattended):**
-
-Headless mode requires cached sudo credentials. Run `sudo -v` first:
-
-```bash
-sudo -v && curl -fsSL https://install.danklinux.com | sh -s -- -c niri -t ghostty -y
-sudo -v && curl -fsSL https://install.danklinux.com | sh -s -- -c hyprland -t kitty --include-deps dms-greeter -y
-```
-
-| Flag | Short | Description |
-|------|-------|-------------|
-| `--compositor <niri|hyprland>` | `-c` | Compositor/WM to install (required for headless) |
-| `--term <ghostty|kitty|alacritty>` | `-t` | Terminal emulator (required for headless) |
-| `--include-deps <name,...>` | | Enable optional dependencies (e.g. `dms-greeter`) |
-| `--exclude-deps <name,...>` | | Skip specific dependencies |
-| `--replace-configs <name,...>` | | Replace specific configuration files (mutually exclusive with `--replace-configs-all`) |
-| `--replace-configs-all` | | Replace all configuration files (mutually exclusive with `--replace-configs`) |
-| `--yes` | `-y` | Required for headless mode — confirms installation without interactive prompts |
-
-Headless mode requires `--yes` to proceed; without it, the installer exits with an error.
-Configuration files are not replaced by default unless `--replace-configs` or `--replace-configs-all` is specified.
-`dms-greeter` is disabled by default; use `--include-deps dms-greeter` to enable it.
-
-When no flags are provided, `dankinstall` launches the interactive TUI.
-
-### Headless mode validation rules
-
-Headless mode activates when `--compositor` or `--term` is provided.
-
-- Both `--compositor` and `--term` are required; providing only one results in an error.
-- Headless-only flags (`--include-deps`, `--exclude-deps`, `--replace-configs`, `--replace-configs-all`, `--yes`) are rejected in TUI mode.
-- Positional arguments are not accepted.
-
-### Log file location
-
-`dankinstall` writes logs to `/tmp` by default.
-Set the `DANKINSTALL_LOG_DIR` environment variable to override the log directory.
-
 ## Supported Distributions
 
 Arch, Fedora, Debian, Ubuntu, openSUSE, Gentoo (and derivatives)

core/cmd/dankinstall/main.go

@@ -3,152 +3,20 @@ package main
 import (
 	"fmt"
 	"os"
-	"strings"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/headless"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/tui"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/spf13/cobra"
 )
 
 var Version = "dev"
 
-// Flag variables bound via pflag
-var (
-	compositor        string
-	term              string
-	includeDeps       []string
-	excludeDeps       []string
-	replaceConfigs    []string
-	replaceConfigsAll bool
-	yes               bool
-)
-
-var rootCmd = &cobra.Command{
-	Use:   "dankinstall",
-	Short: "Install DankMaterialShell and its dependencies",
-	Long: `dankinstall sets up DankMaterialShell with your chosen compositor and terminal.
-
-Without flags, it launches an interactive TUI. Providing either --compositor
-or --term activates headless (unattended) mode, which requires both flags.
-
-Headless mode requires cached sudo credentials. Run 'sudo -v' beforehand, or
-configure passwordless sudo for your user.`,
-	Args:          cobra.NoArgs,
-	RunE:          runDankinstall,
-	SilenceErrors: true,
-	SilenceUsage:  true,
-}
-
-func init() {
-	rootCmd.Flags().StringVarP(&compositor, "compositor", "c", "", "Compositor/WM to install: niri or hyprland (enables headless mode)")
-	rootCmd.Flags().StringVarP(&term, "term", "t", "", "Terminal emulator to install: ghostty, kitty, or alacritty (enables headless mode)")
-	rootCmd.Flags().StringSliceVar(&includeDeps, "include-deps", []string{}, "Optional deps to enable (e.g. dms-greeter)")
-	rootCmd.Flags().StringSliceVar(&excludeDeps, "exclude-deps", []string{}, "Deps to skip during installation")
-	rootCmd.Flags().StringSliceVar(&replaceConfigs, "replace-configs", []string{}, "Deploy only named configs (e.g. niri,ghostty)")
-	rootCmd.Flags().BoolVar(&replaceConfigsAll, "replace-configs-all", false, "Deploy and replace all configurations")
-	rootCmd.Flags().BoolVarP(&yes, "yes", "y", false, "Auto-confirm all prompts")
-}
-
 func main() {
 	if os.Getuid() == 0 {
 		fmt.Fprintln(os.Stderr, "Error: dankinstall must not be run as root")
 		os.Exit(1)
 	}
 
-	if err := rootCmd.Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func runDankinstall(cmd *cobra.Command, args []string) error {
-	headlessMode := compositor != "" || term != ""
-
-	if !headlessMode {
-		// Reject headless-only flags when running in TUI mode.
-		headlessOnly := []string{
-			"include-deps",
-			"exclude-deps",
-			"replace-configs",
-			"replace-configs-all",
-			"yes",
-		}
-		var set []string
-		for _, name := range headlessOnly {
-			if cmd.Flags().Changed(name) {
-				set = append(set, "--"+name)
-			}
-		}
-		if len(set) > 0 {
-			return fmt.Errorf("flags %s are only valid in headless mode (requires both --compositor and --term)", strings.Join(set, ", "))
-		}
-	}
-
-	if headlessMode {
-		return runHeadless()
-	}
-	return runTUI()
-}
-
-func runHeadless() error {
-	// Validate required flags
-	if compositor == "" {
-		return fmt.Errorf("--compositor is required for headless mode (niri or hyprland)")
-	}
-	if term == "" {
-		return fmt.Errorf("--term is required for headless mode (ghostty, kitty, or alacritty)")
-	}
-
-	cfg := headless.Config{
-		Compositor:        compositor,
-		Terminal:          term,
-		IncludeDeps:       includeDeps,
-		ExcludeDeps:       excludeDeps,
-		ReplaceConfigs:    replaceConfigs,
-		ReplaceConfigsAll: replaceConfigsAll,
-		Yes:               yes,
-	}
-
-	runner := headless.NewRunner(cfg)
-
-	// Set up file logging
-	fileLogger, err := log.NewFileLogger()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Warning: Failed to create log file: %v\n", err)
-	}
-
-	if fileLogger != nil {
-		fmt.Printf("Logging to: %s\n", fileLogger.GetLogPath())
-		fileLogger.StartListening(runner.GetLogChan())
-		defer func() {
-			if err := fileLogger.Close(); err != nil {
-				fmt.Fprintf(os.Stderr, "Warning: Failed to close log file: %v\n", err)
-			}
-		}()
-	} else {
-		// Drain the log channel to prevent blocking sends from deadlocking
-		// downstream components (distros, config deployer) that write to it.
-		// Use an explicit stop signal because this code does not own the
-		// runner log channel and cannot assume it will be closed.
-		defer drainLogChan(runner.GetLogChan())()
-	}
-
-	if err := runner.Run(); err != nil {
-		if fileLogger != nil {
-			fmt.Fprintf(os.Stderr, "\nFull logs are available at: %s\n", fileLogger.GetLogPath())
-		}
-		return err
-	}
-
-	if fileLogger != nil {
-		fmt.Printf("\nFull logs are available at: %s\n", fileLogger.GetLogPath())
-	}
-	return nil
-}
-
-func runTUI() error {
 	fileLogger, err := log.NewFileLogger()
 	if err != nil {
 		fmt.Printf("Warning: Failed to create log file: %v\n", err)
@@ -170,50 +38,18 @@ func runTUI() error {
 
 	if fileLogger != nil {
 		fileLogger.StartListening(model.GetLogChan())
-	} else {
-		// Drain the log channel to prevent blocking sends from deadlocking
-		// downstream components (distros, config deployer) that write to it.
-		// Use an explicit stop signal because this code does not own the
-		// model log channel and cannot assume it will be closed.
-		defer drainLogChan(model.GetLogChan())()
 	}
 
 	p := tea.NewProgram(model, tea.WithAltScreen())
 	if _, err := p.Run(); err != nil {
+		fmt.Printf("Error running program: %v\n", err)
 		if logFilePath != "" {
-			fmt.Fprintf(os.Stderr, "\nFull logs are available at: %s\n", logFilePath)
+			fmt.Printf("\nFull logs are available at: %s\n", logFilePath)
 		}
-		return fmt.Errorf("error running program: %w", err)
+		os.Exit(1)
 	}
 
 	if logFilePath != "" {
 		fmt.Printf("\nFull logs are available at: %s\n", logFilePath)
 	}
-	return nil
-}
-
-// drainLogChan starts a goroutine that discards all messages from logCh,
-// preventing blocking sends from deadlocking downstream components. It returns
-// a cleanup function that signals the goroutine to stop and waits for it to
-// exit. Callers should defer the returned function.
-func drainLogChan(logCh <-chan string) func() {
-	drainStop := make(chan struct{})
-	drainDone := make(chan struct{})
-	go func() {
-		defer close(drainDone)
-		for {
-			select {
-			case <-drainStop:
-				return
-			case _, ok := <-logCh:
-				if !ok {
-					return
-				}
-			}
-		}
-	}()
-	return func() {
-		close(drainStop)
-		<-drainDone
-	}
 }

core/cmd/dms/assets/cli-policy.default.json

@@ -1,10 +0,0 @@
-{
-  "policy_version": 1,
-  "blocked_commands": [
-    "greeter install",
-    "greeter enable",
-    "greeter uninstall",
-    "setup"
-  ],
-  "message": "This command is disabled on immutable/image-based systems. Use your distro-native workflow for system-level changes."
-}

core/cmd/dms/commands_auth.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	sharedpam "github.com/AvengeMedia/DankMaterialShell/core/internal/pam"
-	"github.com/spf13/cobra"
-)
-
-var authCmd = &cobra.Command{
-	Use:   "auth",
-	Short: "Manage DMS authentication sync",
-	Long:  "Manage shared PAM/authentication setup for DMS greeter and lock screen",
-}
-
-var authSyncCmd = &cobra.Command{
-	Use:     "sync",
-	Short:   "Sync DMS authentication configuration",
-	Long:    "Apply shared PAM/authentication changes for the lock screen and greeter based on current DMS settings",
-	PreRunE: preRunPrivileged,
-	Run: func(cmd *cobra.Command, args []string) {
-		yes, _ := cmd.Flags().GetBool("yes")
-		term, _ := cmd.Flags().GetBool("terminal")
-		if term {
-			if err := syncAuthInTerminal(yes); err != nil {
-				log.Fatalf("Error launching auth sync in terminal: %v", err)
-			}
-			return
-		}
-		if err := syncAuth(yes); err != nil {
-			log.Fatalf("Error syncing authentication: %v", err)
-		}
-	},
-}
-
-func init() {
-	authSyncCmd.Flags().BoolP("yes", "y", false, "Non-interactive mode: skip prompts")
-	authSyncCmd.Flags().BoolP("terminal", "t", false, "Run auth sync in a new terminal (for entering sudo password)")
-}
-
-func syncAuth(nonInteractive bool) error {
-	if !nonInteractive {
-		fmt.Println("=== DMS Authentication Sync ===")
-		fmt.Println()
-	}
-
-	logFunc := func(msg string) {
-		fmt.Println(msg)
-	}
-
-	if err := sharedpam.SyncAuthConfig(logFunc, "", sharedpam.SyncAuthOptions{}); err != nil {
-		return err
-	}
-
-	if !nonInteractive {
-		fmt.Println("\n=== Authentication Sync Complete ===")
-		fmt.Println("\nAuthentication changes have been applied.")
-	}
-
-	return nil
-}
-
-func syncAuthInTerminal(nonInteractive bool) error {
-	syncFlags := make([]string, 0, 1)
-	if nonInteractive {
-		syncFlags = append(syncFlags, "--yes")
-	}
-
-	shellSyncCmd := "dms auth sync"
-	if len(syncFlags) > 0 {
-		shellSyncCmd += " " + strings.Join(syncFlags, " ")
-	}
-	shellCmd := shellSyncCmd + `; echo; echo "Authentication sync finished. Closing in 3 seconds..."; sleep 3`
-	return runCommandInTerminal(shellCmd)
-}

core/cmd/dms/commands_blur.go

@@ -1,40 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/blur"
-	"github.com/spf13/cobra"
-)
-
-var blurCmd = &cobra.Command{
-	Use:   "blur",
-	Short: "Background blur utilities",
-}
-
-var blurCheckCmd = &cobra.Command{
-	Use:   "check",
-	Short: "Check if the compositor supports background blur (ext-background-effect-v1)",
-	Args:  cobra.NoArgs,
-	Run:   runBlurCheck,
-}
-
-func init() {
-	blurCmd.AddCommand(blurCheckCmd)
-}
-
-func runBlurCheck(cmd *cobra.Command, args []string) {
-	supported, err := blur.ProbeSupport()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-
-	switch supported {
-	case true:
-		fmt.Println("supported")
-	default:
-		fmt.Println("unsupported")
-	}
-}

core/cmd/dms/commands_brightness.go

@@ -236,7 +236,6 @@ func runBrightnessSet(cmd *cobra.Command, args []string) {
 			defer ddc.Close()
 			time.Sleep(100 * time.Millisecond)
 			if err := ddc.SetBrightnessWithExponent(deviceID, percent, exponential, exponent, nil); err == nil {
-				ddc.WaitPending()
 				fmt.Printf("Set %s to %d%%\n", deviceID, percent)
 				return
 			}

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")
 
@@ -222,49 +214,15 @@ func init() {
 
 func runClipCopy(cmd *cobra.Command, args []string) {
 	var data []byte
-	copyFromStdin := false
 
-	switch {
-	case len(args) > 0:
+	if len(args) > 0 {
 		data = []byte(args[0])
-	case clipCopyDownload || clipCopyType == "__multi__":
+	} else {
 		var err error
 		data, err = io.ReadAll(os.Stdin)
 		if err != nil {
 			log.Fatalf("read stdin: %v", err)
 		}
-	default:
-		copyFromStdin = true
-	}
-
-	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 copyFromStdin {
-		if err := clipboard.CopyReader(os.Stdin, clipCopyType, clipCopyForeground, clipCopyPasteOnce); err != nil {
-			log.Fatalf("copy: %v", err)
-		}
-		return
 	}
 
 	if err := clipboard.CopyOpts(data, clipCopyType, clipCopyForeground, clipCopyPasteOnce); err != nil {
@@ -272,40 +230,6 @@ func runClipCopy(cmd *cobra.Command, args []string) {
 	}
 }
 
-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 {
@@ -340,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{
@@ -486,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)
 		}
@@ -769,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])
@@ -824,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,
 	})
@@ -892,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_colorpicker.go

@@ -37,9 +37,6 @@ Output format flags (mutually exclusive, default: --hex):
   --cmyk - CMYK values (C% M% Y% K%)
   --json - JSON with all formats
 
-Optional:
-  --raw - Removes ANSI escape codes and background colors. Use this when piping to other commands
-
 Examples:
   dms color pick                # Pick color, output as hex
   dms color pick --rgb          # Output as RGB
@@ -56,7 +53,6 @@ func init() {
 	colorPickCmd.Flags().Bool("hsv", false, "Output as HSV (H S% V%)")
 	colorPickCmd.Flags().Bool("cmyk", false, "Output as CMYK (C% M% Y% K%)")
 	colorPickCmd.Flags().Bool("json", false, "Output all formats as JSON")
-	colorPickCmd.Flags().Bool("raw", false, "Removes ANSI escape codes and background colors. Use this when piping to other commands")
 	colorPickCmd.Flags().StringVarP(&colorOutputFmt, "output-format", "o", "", "Custom output format template")
 	colorPickCmd.Flags().BoolVarP(&colorAutocopy, "autocopy", "a", false, "Copy result to clipboard")
 	colorPickCmd.Flags().BoolVarP(&colorLowercase, "lowercase", "l", false, "Output hex in lowercase")
@@ -117,15 +113,7 @@ func runColorPick(cmd *cobra.Command, args []string) {
 
 	if jsonOutput {
 		fmt.Println(output)
-		return
-	}
-
-	if raw, _ := cmd.Flags().GetBool("raw"); raw {
-		fmt.Printf("%s\n", output)
-		return
-	}
-
-	if color.IsDark() {
+	} else if color.IsDark() {
 		fmt.Printf("\033[48;2;%d;%d;%dm\033[97m %s \033[0m\n", color.R, color.G, color.B, output)
 	} else {
 		fmt.Printf("\033[48;2;%d;%d;%dm\033[30m %s \033[0m\n", color.R, color.G, color.B, output)

core/cmd/dms/commands_common.go

@@ -26,17 +26,6 @@ var runCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		daemon, _ := cmd.Flags().GetBool("daemon")
 		session, _ := cmd.Flags().GetBool("session")
-		if v, _ := cmd.Flags().GetString("log-level"); v != "" {
-			if err := os.Setenv("DMS_LOG_LEVEL", v); err != nil {
-				log.Fatalf("Failed to set DMS_LOG_LEVEL: %v", err)
-			}
-		}
-		if v, _ := cmd.Flags().GetString("log-file"); v != "" {
-			if err := os.Setenv("DMS_LOG_FILE", v); err != nil {
-				log.Fatalf("Failed to set DMS_LOG_FILE: %v", err)
-			}
-		}
-		log.ApplyEnvOverrides()
 		if daemon {
 			runShellDaemon(session)
 		} else {
@@ -75,8 +64,10 @@ 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)
 		return getShellIPCCompletions(args, toComplete), cobra.ShellCompDirectiveNoFileComp
@@ -86,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",
@@ -527,17 +511,9 @@ func getCommonCommands() []*cobra.Command {
 		colorCmd,
 		screenshotCmd,
 		notifyActionCmd,
-		notifyCmd,
-		genericNotifyActionCmd,
 		matugenCmd,
 		clipboardCmd,
-		chromaCmd,
 		doctorCmd,
 		configCmd,
-		dlCmd,
-		randrCmd,
-		blurCmd,
-		trashCmd,
-		systemCmd,
 	}
 }

core/cmd/dms/commands_doctor.go

@@ -11,8 +11,6 @@ import (
 	"slices"
 	"strings"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/blur"
-	"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"
@@ -83,7 +81,7 @@ func (ds *DoctorStatus) OKCount() int {
 }
 
 var (
-	quickshellVersionRegex = regexp.MustCompile(`(?i)quickshell (\d+\.\d+\.\d+)`)
+	quickshellVersionRegex = regexp.MustCompile(`quickshell (\d+\.\d+\.\d+)`)
 	hyprlandVersionRegex   = regexp.MustCompile(`v?(\d+\.\d+\.\d+)`)
 	niriVersionRegex       = regexp.MustCompile(`niri (\d+\.\d+)`)
 	swayVersionRegex       = regexp.MustCompile(`sway version (\d+\.\d+)`)
@@ -91,7 +89,6 @@ var (
 	wayfireVersionRegex    = regexp.MustCompile(`wayfire (\d+\.\d+)`)
 	labwcVersionRegex      = regexp.MustCompile(`labwc (\d+\.\d+\.\d+)`)
 	mangowcVersionRegex    = regexp.MustCompile(`mango (\d+\.\d+\.\d+)`)
-	miracleVersionRegex    = regexp.MustCompile(`miracle-wm v?(\d+\.\d+\.\d+)`)
 )
 
 var doctorCmd = &cobra.Command{
@@ -104,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
@@ -197,7 +192,7 @@ func (r checkResult) toJSON() checkResultJSON {
 }
 
 func runDoctor(cmd *cobra.Command, args []string) {
-	if !doctorJSON && !doctorCopy {
+	if !doctorJSON {
 		printDoctorHeader()
 	}
 
@@ -215,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)
 	}
@@ -470,7 +457,6 @@ func checkWindowManagers() []checkResult {
 		{"Wayfire", "wayfire", "--version", wayfireVersionRegex, []string{"wayfire"}},
 		{"labwc", "labwc", "--version", labwcVersionRegex, []string{"labwc"}},
 		{"mangowc", "mango", "-v", mangowcVersionRegex, []string{"mango"}},
-		{"Miracle WM", "miracle-wm", "--version", miracleVersionRegex, []string{"miracle-wm"}},
 	}
 
 	var results []checkResult
@@ -503,7 +489,7 @@ func checkWindowManagers() []checkResult {
 		results = append(results, checkResult{
 			catCompositor, "Compositor", statusError,
 			"No supported Wayland compositor found",
-			"Install Hyprland, niri, Sway, River, Wayfire, or miracle-wm",
+			"Install Hyprland, niri, Sway, River, or Wayfire",
 			doctorDocsURL + "#compositor-checks",
 		})
 	}
@@ -512,24 +498,9 @@ func checkWindowManagers() []checkResult {
 		results = append(results, checkResult{catCompositor, "Active", statusInfo, wm, "", doctorDocsURL + "#compositor"})
 	}
 
-	results = append(results, checkCompositorBlurSupport())
-
 	return results
 }
 
-func checkCompositorBlurSupport() checkResult {
-	supported, err := blur.ProbeSupport()
-	if err != nil {
-		return checkResult{catCompositor, "Background Blur", statusInfo, "Unable to verify", err.Error(), doctorDocsURL + "#compositor-checks"}
-	}
-
-	if supported {
-		return checkResult{catCompositor, "Background Blur", statusOK, "Supported", "Compositor supports ext-background-effect-v1", doctorDocsURL + "#compositor-checks"}
-	}
-
-	return checkResult{catCompositor, "Background Blur", statusWarn, "Unsupported", "Compositor does not support ext-background-effect-v1", doctorDocsURL + "#compositor-checks"}
-}
-
 func getVersionFromCommand(cmd, arg string, regex *regexp.Regexp) string {
 	output, err := exec.Command(cmd, arg).CombinedOutput()
 	if err != nil && len(output) == 0 {
@@ -553,8 +524,6 @@ func detectRunningWM() string {
 		return "Hyprland"
 	case os.Getenv("NIRI_SOCKET") != "":
 		return "niri"
-	case os.Getenv("MIRACLESOCK") != "":
-		return "Miracle WM"
 	case os.Getenv("XDG_CURRENT_DESKTOP") != "":
 		return os.Getenv("XDG_CURRENT_DESKTOP")
 	}
@@ -573,7 +542,6 @@ func checkQuickshellFeatures() ([]checkResult, bool) {
 	qmlContent := `
 import QtQuick
 import Quickshell
-import Quickshell.Wayland
 
 ShellRoot {
 	id: root
@@ -582,7 +550,6 @@ ShellRoot {
 	property bool idleMonitorAvailable: false
 	property bool idleInhibitorAvailable: false
 	property bool shortcutInhibitorAvailable: false
-	property bool backgroundBlurAvailable: false
 
 	Timer {
 		interval: 50
@@ -600,18 +567,16 @@ ShellRoot {
 
 			try {
 				var testItem = Qt.createQmlObject(
-					'import Quickshell; import Quickshell.Wayland; import QtQuick; QtObject { ' +
+					'import Quickshell.Wayland; import QtQuick; QtObject { ' +
 					'readonly property bool hasIdleMonitor: typeof IdleMonitor !== "undefined"; ' +
 					'readonly property bool hasIdleInhibitor: typeof IdleInhibitor !== "undefined"; ' +
-					'readonly property bool hasShortcutInhibitor: typeof ShortcutInhibitor !== "undefined"; ' +
-					'readonly property bool hasBackgroundBlur: typeof BackgroundEffect !== "undefined" ' +
+					'readonly property bool hasShortcutInhibitor: typeof ShortcutInhibitor !== "undefined" ' +
 					'}',
 					root
 				)
 				root.idleMonitorAvailable = testItem.hasIdleMonitor
 				root.idleInhibitorAvailable = testItem.hasIdleInhibitor
 				root.shortcutInhibitorAvailable = testItem.hasShortcutInhibitor
-				root.backgroundBlurAvailable = testItem.hasBackgroundBlur
 				testItem.destroy()
 			} catch (e) {}
 
@@ -620,15 +585,13 @@ ShellRoot {
 			console.warn(root.idleInhibitorAvailable ? "FEATURE:IdleInhibitor:OK" : "FEATURE:IdleInhibitor:UNAVAILABLE")
 			console.warn(root.shortcutInhibitorAvailable ? "FEATURE:ShortcutInhibitor:OK" : "FEATURE:ShortcutInhibitor:UNAVAILABLE")
 
-			console.warn(root.backgroundBlurAvailable ? "FEATURE:BackgroundBlur:OK" : "FEATURE:BackgroundBlur:UNAVAILABLE")
-
 			Quickshell.execDetached(["kill", "-TERM", String(Quickshell.processId)])
 		}
 	}
 }
 `
 
-	if err := os.WriteFile(testScript, []byte(qmlContent), 0o644); err != nil {
+	if err := os.WriteFile(testScript, []byte(qmlContent), 0644); err != nil {
 		return nil, false
 	}
 
@@ -642,7 +605,6 @@ ShellRoot {
 		{"IdleMonitor", "Idle detection"},
 		{"IdleInhibitor", "Prevent idle/sleep"},
 		{"ShortcutInhibitor", "Allow shortcut management (niri)"},
-		{"BackgroundBlur", "Background blur API support in Quickshell"},
 	}
 
 	var results []checkResult
@@ -676,120 +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"
-
-	pluginDirs := findQtPluginDirs()
-	if len(pluginDirs) == 0 {
-		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},
-		}
-	}
-
-	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
-		var foundDirs []string
-		for _, pluginDir := range pluginDirs {
-			imageFormatsDir := filepath.Join(pluginDir, "imageformats")
-			for _, p := range c.plugins {
-				if _, err := os.Stat(filepath.Join(imageFormatsDir, p.file)); err == nil {
-					if !slices.Contains(found, p.format) {
-						found = append(found, p.format)
-					}
-					if !slices.Contains(foundDirs, imageFormatsDir) {
-						foundDirs = append(foundDirs, imageFormatsDir)
-					}
-				}
-			}
-		}
-
-		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, ", "), strings.Join(foundDirs, ":"))
-			}
-			result = checkResult{catOptionalFeatures, c.name, statusOK, fmt.Sprintf("Installed (%d formats)", len(found)), details, url}
-		}
-		results = append(results, result)
-	}
-
-	return results
-}
-
-func findQtPluginDirs() []string {
-	var dirs []string
-
-	addDir := func(dir string) {
-		if dir != "" {
-			if _, err := os.Stat(filepath.Join(dir, "imageformats")); err == nil {
-				dirs = append(dirs, dir)
-			}
-		}
-	}
-
-	// Check all paths in QT_PLUGIN_PATH env var (used by NixOS and custom setups)
-	if envPath := os.Getenv("QT_PLUGIN_PATH"); envPath != "" {
-		for dir := range strings.SplitSeq(envPath, ":") {
-			addDir(dir)
-		}
-	}
-
-	// Try qtpaths
-	for _, cmd := range []string{"qtpaths6", "qtpaths"} {
-		if output, err := exec.Command(cmd, "-query", "QT_INSTALL_PLUGINS").Output(); err == nil {
-			addDir(strings.TrimSpace(string(output)))
-		}
-	}
-
-	// 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",
-	} {
-		addDir(dir)
-	}
-
-	return dirs
-}
-
 func detectNetworkBackend(stackResult *network.DetectResult) string {
 	switch stackResult.Backend {
 	case network.BackendNetworkManager:
@@ -830,31 +678,13 @@ 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"}
-	terminals = slices.DeleteFunc(terminals, func(t string) bool {
-		return !utils.CommandExists(t)
-	})
-
-	if len(terminals) > 0 {
-		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusOK, strings.Join(terminals, ", "), "", optionalFeaturesURL})
+	if idx := slices.IndexFunc(terminals, utils.CommandExists); idx >= 0 {
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusOK, terminals[idx], "", optionalFeaturesURL})
 	} else {
-		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusWarn, "None found", "Install ghostty, kitty, foot or alacritty", optionalFeaturesURL})
+		results = append(results, checkResult{catOptionalFeatures, "Terminal", statusWarn, "None found", "Install ghostty, kitty, or alacritty", optionalFeaturesURL})
 	}
 
 	networkResult, err := network.DetectNetworkStack()
@@ -922,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)"
 		}
@@ -1099,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")
-			}
-			fmt.Fprintf(&sb, "**%s**\n", r.category.String())
-			currentCategory = r.category
-		}
-
-		fmt.Fprintf(&sb, "- [%s] %s: %s\n", r.status, r.name, r.message)
-
-		if doctorVerbose && r.details != "" {
-			fmt.Fprintf(&sb, "  - %s\n", r.details)
-		}
-	}
-
-	var ds DoctorStatus
-	for _, r := range results {
-		ds.Add(r)
-	}
-
-	sb.WriteString("\n---\n")
-	fmt.Fprintf(&sb, "**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_features.go

@@ -4,7 +4,6 @@ package main
 
 import (
 	"bufio"
-	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -16,7 +15,6 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/distros"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/errdefs"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
 	"github.com/spf13/cobra"
@@ -111,37 +109,16 @@ func updateArchLinux() error {
 	}
 
 	var packageName string
-	var isAUR bool
-	if isArchPackageInstalled("dms-shell") {
-		packageName = "dms-shell"
+	if isArchPackageInstalled("dms-shell-bin") {
+		packageName = "dms-shell-bin"
 	} else if isArchPackageInstalled("dms-shell-git") {
 		packageName = "dms-shell-git"
-		isAUR = true
-	} else if isArchPackageInstalled("dms-shell-bin") {
-		packageName = "dms-shell-bin"
-		isAUR = true
 	} else {
-		fmt.Println("Info: No dms-shell package found.")
+		fmt.Println("Info: Neither dms-shell-bin nor dms-shell-git package found.")
 		fmt.Println("Info: Falling back to git-based update method...")
 		return updateOtherDistros()
 	}
 
-	if !isAUR {
-		fmt.Printf("This will update %s using pacman.\n", packageName)
-		if !confirmUpdate() {
-			return errdefs.ErrUpdateCancelled
-		}
-
-		fmt.Printf("\nRunning: pacman -S %s\n", packageName)
-		if err := privesc.Run(context.Background(), "", "pacman", "-S", "--noconfirm", packageName); err != nil {
-			fmt.Printf("Error: Failed to update using pacman: %v\n", err)
-			return err
-		}
-
-		fmt.Println("dms successfully updated")
-		return nil
-	}
-
 	var helper string
 	var updateCmd *exec.Cmd
 
@@ -477,7 +454,11 @@ func updateDMSBinary() error {
 
 	fmt.Printf("Installing to %s...\n", currentPath)
 
-	if err := privesc.Run(context.Background(), "", "install", "-m", "0755", decompressedPath, currentPath); err != nil {
+	replaceCmd := exec.Command("sudo", "install", "-m", "0755", decompressedPath, currentPath)
+	replaceCmd.Stdin = os.Stdin
+	replaceCmd.Stdout = os.Stdout
+	replaceCmd.Stderr = os.Stderr
+	if err := replaceCmd.Run(); err != nil {
 		return fmt.Errorf("failed to replace binary: %w", err)
 	}
 

core/cmd/dms/commands_greeter_test.go

@@ -1,87 +0,0 @@
-package main
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-
-	sharedpam "github.com/AvengeMedia/DankMaterialShell/core/internal/pam"
-)
-
-func TestSyncGreeterConfigsAndAuthDelegatesSharedAuth(t *testing.T) {
-	origGreeterConfigSyncFn := greeterConfigSyncFn
-	origSharedAuthSyncFn := sharedAuthSyncFn
-	t.Cleanup(func() {
-		greeterConfigSyncFn = origGreeterConfigSyncFn
-		sharedAuthSyncFn = origSharedAuthSyncFn
-	})
-
-	var calls []string
-	greeterConfigSyncFn = func(dmsPath, compositor string, logFunc func(string), sudoPassword string) error {
-		if dmsPath != "/tmp/dms" {
-			t.Fatalf("unexpected dmsPath %q", dmsPath)
-		}
-		if compositor != "niri" {
-			t.Fatalf("unexpected compositor %q", compositor)
-		}
-		if sudoPassword != "" {
-			t.Fatalf("expected empty sudoPassword, got %q", sudoPassword)
-		}
-		calls = append(calls, "configs")
-		return nil
-	}
-
-	var gotOptions sharedpam.SyncAuthOptions
-	sharedAuthSyncFn = func(logFunc func(string), sudoPassword string, options sharedpam.SyncAuthOptions) error {
-		if sudoPassword != "" {
-			t.Fatalf("expected empty sudoPassword, got %q", sudoPassword)
-		}
-		gotOptions = options
-		calls = append(calls, "auth")
-		return nil
-	}
-
-	err := syncGreeterConfigsAndAuth("/tmp/dms", "niri", func(string) {}, sharedpam.SyncAuthOptions{
-		ForceGreeterAuth: true,
-	}, func() {
-		calls = append(calls, "before-auth")
-	})
-	if err != nil {
-		t.Fatalf("syncGreeterConfigsAndAuth returned error: %v", err)
-	}
-
-	wantCalls := []string{"configs", "before-auth", "auth"}
-	if !reflect.DeepEqual(calls, wantCalls) {
-		t.Fatalf("call order = %v, want %v", calls, wantCalls)
-	}
-	if !gotOptions.ForceGreeterAuth {
-		t.Fatalf("expected ForceGreeterAuth to be true, got %+v", gotOptions)
-	}
-}
-
-func TestSyncGreeterConfigsAndAuthStopsOnConfigError(t *testing.T) {
-	origGreeterConfigSyncFn := greeterConfigSyncFn
-	origSharedAuthSyncFn := sharedAuthSyncFn
-	t.Cleanup(func() {
-		greeterConfigSyncFn = origGreeterConfigSyncFn
-		sharedAuthSyncFn = origSharedAuthSyncFn
-	})
-
-	greeterConfigSyncFn = func(string, string, func(string), string) error {
-		return errors.New("config sync failed")
-	}
-
-	authCalled := false
-	sharedAuthSyncFn = func(func(string), string, sharedpam.SyncAuthOptions) error {
-		authCalled = true
-		return nil
-	}
-
-	err := syncGreeterConfigsAndAuth("/tmp/dms", "niri", func(string) {}, sharedpam.SyncAuthOptions{}, nil)
-	if err == nil || err.Error() != "config sync failed" {
-		t.Fatalf("expected config sync error, got %v", err)
-	}
-	if authCalled {
-		t.Fatal("expected auth sync not to run after config sync failure")
-	}
-}

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,36 +81,25 @@ 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"))
+	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"))
+	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("")
 	if err := registry.Register(niriProvider); err != nil {
@@ -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_matugen.go

@@ -3,9 +3,7 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"os"
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
@@ -57,11 +55,10 @@ func init() {
 		cmd.Flags().Bool("sync-mode-with-portal", false, "Sync color scheme with GNOME portal")
 		cmd.Flags().Bool("terminals-always-dark", false, "Force terminal themes to dark variant")
 		cmd.Flags().String("skip-templates", "", "Comma-separated list of templates to skip")
-		cmd.Flags().Float64("contrast", 0, "Contrast value from -1 to 1 (0 = standard)")
 	}
 
 	matugenQueueCmd.Flags().Bool("wait", true, "Wait for completion")
-	matugenQueueCmd.Flags().Duration("timeout", 90*time.Second, "Timeout for waiting")
+	matugenQueueCmd.Flags().Duration("timeout", 30*time.Second, "Timeout for waiting")
 }
 
 func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
@@ -78,7 +75,6 @@ func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
 	syncModeWithPortal, _ := cmd.Flags().GetBool("sync-mode-with-portal")
 	terminalsAlwaysDark, _ := cmd.Flags().GetBool("terminals-always-dark")
 	skipTemplates, _ := cmd.Flags().GetString("skip-templates")
-	contrast, _ := cmd.Flags().GetFloat64("contrast")
 
 	return matugen.Options{
 		StateDir:            stateDir,
@@ -89,7 +85,6 @@ func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
 		Mode:                matugen.ColorMode(mode),
 		IconTheme:           iconTheme,
 		MatugenType:         matugenType,
-		Contrast:            contrast,
 		RunUserTemplates:    runUserTemplates,
 		StockColors:         stockColors,
 		SyncModeWithPortal:  syncModeWithPortal,
@@ -100,11 +95,7 @@ func buildMatugenOptions(cmd *cobra.Command) matugen.Options {
 
 func runMatugenGenerate(cmd *cobra.Command, args []string) {
 	opts := buildMatugenOptions(cmd)
-	err := matugen.Run(opts)
-	switch {
-	case errors.Is(err, matugen.ErrNoChanges):
-		os.Exit(2)
-	case err != nil:
+	if err := matugen.Run(opts); err != nil {
 		log.Fatalf("Theme generation failed: %v", err)
 	}
 }
@@ -131,7 +122,6 @@ func runMatugenQueue(cmd *cobra.Command, args []string) {
 			"syncModeWithPortal":  opts.SyncModeWithPortal,
 			"terminalsAlwaysDark": opts.TerminalsAlwaysDark,
 			"skipTemplates":       opts.SkipTemplates,
-			"contrast":            opts.Contrast,
 			"wait":                wait,
 		},
 	}
@@ -139,11 +129,7 @@ func runMatugenQueue(cmd *cobra.Command, args []string) {
 	if !wait {
 		if err := sendServerRequestFireAndForget(request); err != nil {
 			log.Info("Server unavailable, running synchronously")
-			err := matugen.Run(opts)
-			switch {
-			case errors.Is(err, matugen.ErrNoChanges):
-				os.Exit(2)
-			case err != nil:
+			if err := matugen.Run(opts); err != nil {
 				log.Fatalf("Theme generation failed: %v", err)
 			}
 			return
@@ -160,15 +146,11 @@ func runMatugenQueue(cmd *cobra.Command, args []string) {
 		resp, ok := tryServerRequest(request)
 		if !ok {
 			log.Info("Server unavailable, running synchronously")
-			err := matugen.Run(opts)
-			switch {
-			case errors.Is(err, matugen.ErrNoChanges):
-				resultCh <- matugen.ErrNoChanges
-			case err != nil:
+			if err := matugen.Run(opts); err != nil {
 				resultCh <- err
-			default:
-				resultCh <- nil
+				return
 			}
+			resultCh <- nil
 			return
 		}
 		if resp.Error != "" {
@@ -180,10 +162,7 @@ func runMatugenQueue(cmd *cobra.Command, args []string) {
 
 	select {
 	case err := <-resultCh:
-		switch {
-		case errors.Is(err, matugen.ErrNoChanges):
-			os.Exit(2)
-		case err != nil:
+		if err != nil {
 			log.Fatalf("Theme generation failed: %v", err)
 		}
 		fmt.Println("Theme generation completed")

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

@@ -1,58 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/spf13/cobra"
-)
-
-var randrCmd = &cobra.Command{
-	Use:   "randr",
-	Short: "Query output display information",
-	Long:  "Query Wayland compositor for output names, scales, resolutions and refresh rates via zwlr-output-management",
-	Run:   runRandr,
-}
-
-func init() {
-	randrCmd.Flags().Bool("json", false, "Output in JSON format")
-}
-
-type randrJSON struct {
-	Outputs []randrOutput `json:"outputs"`
-}
-
-func runRandr(cmd *cobra.Command, args []string) {
-	outputs, err := queryRandr()
-	if err != nil {
-		log.Fatalf("%v", err)
-	}
-
-	jsonFlag, _ := cmd.Flags().GetBool("json")
-
-	if jsonFlag {
-		data, err := json.Marshal(randrJSON{Outputs: outputs})
-		if err != nil {
-			log.Fatalf("failed to marshal JSON: %v", err)
-		}
-		fmt.Println(string(data))
-		return
-	}
-
-	for i, out := range outputs {
-		if i > 0 {
-			fmt.Println()
-		}
-		status := "enabled"
-		if !out.Enabled {
-			status = "disabled"
-		}
-		fmt.Printf("%s (%s)\n", out.Name, status)
-		fmt.Printf("  Scale:      %.4g\n", out.Scale)
-		fmt.Printf("  Resolution: %dx%d\n", out.Width, out.Height)
-		if out.Refresh > 0 {
-			fmt.Printf("  Refresh:    %.2f Hz\n", float64(out.Refresh)/1000.0)
-		}
-	}
-}

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

@@ -14,7 +14,7 @@ import (
 
 var (
 	ssOutputName    string
-	ssCursor      string
+	ssIncludeCursor bool
 	ssFormat        string
 	ssQuality       int
 	ssOutputDir     string
@@ -22,8 +22,6 @@ var (
 	ssNoClipboard   bool
 	ssNoFile        bool
 	ssNoNotify      bool
-	ssNoConfirm   bool
-	ssReset       bool
 	ssStdout        bool
 )
 
@@ -52,11 +50,9 @@ Examples:
   dms screenshot output -o DP-1      # Specific output
   dms screenshot window              # Focused window (Hyprland)
   dms screenshot last                # Last region (pre-selected)
-  dms screenshot --reset             # Reset last region pre-selection
   dms screenshot --no-clipboard      # Save file only
   dms screenshot --no-file           # Clipboard only
-  dms screenshot --no-confirm        # Region capture on mouse release
-  dms screenshot --cursor=on         # Include cursor
+  dms screenshot --cursor            # Include cursor
   dms screenshot -f jpg -q 85        # JPEG with quality 85`,
 }
 
@@ -115,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")
@@ -123,8 +119,6 @@ func init() {
 	screenshotCmd.PersistentFlags().BoolVar(&ssNoClipboard, "no-clipboard", false, "Don't copy to clipboard")
 	screenshotCmd.PersistentFlags().BoolVar(&ssNoFile, "no-file", false, "Don't save to file")
 	screenshotCmd.PersistentFlags().BoolVar(&ssNoNotify, "no-notify", false, "Don't show notification")
-	screenshotCmd.PersistentFlags().BoolVar(&ssNoConfirm, "no-confirm", false, "Region mode: capture on mouse release without Enter/Space confirmation")
-	screenshotCmd.PersistentFlags().BoolVar(&ssReset, "reset", false, "Reset saved last-region preselection before capturing")
 	screenshotCmd.PersistentFlags().BoolVar(&ssStdout, "stdout", false, "Output image to stdout (for piping to swappy, etc.)")
 
 	screenshotCmd.AddCommand(ssRegionCmd)
@@ -142,14 +136,10 @@ 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
-	config.NoConfirm = ssNoConfirm
-	config.Reset = ssReset
 	config.Stdout = ssStdout
 
 	if ssOutputDir != "" {

core/cmd/dms/commands_setup.go

@@ -4,16 +4,12 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 
 	"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/privesc"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/spf13/cobra"
 )
 
@@ -21,7 +17,6 @@ var setupCmd = &cobra.Command{
 	Use:   "setup",
 	Short: "Deploy DMS configurations",
 	Long:  "Deploy compositor and terminal configurations with interactive prompts",
-	PersistentPreRunE: preRunPrivileged,
 	Run: func(cmd *cobra.Command, args []string) {
 		if err := runSetup(); err != nil {
 			log.Fatalf("Error during setup: %v", err)
@@ -29,248 +24,9 @@ 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 ===")
 
-	ensureInputGroup()
-
 	wm, wmSelected := promptCompositor()
 	terminal, terminalSelected := promptTerminal()
 	useSystemd := promptSystemd()
@@ -344,37 +100,6 @@ func runSetup() error {
 	return nil
 }
 
-// Add user to the input group for the evdev manager for inut state tracking.
-// Caps Lock OSD and the Caps Lock bar indicator.
-func ensureInputGroup() {
-	if !utils.HasGroup("input") {
-		return
-	}
-	currentUser := os.Getenv("USER")
-	if currentUser == "" {
-		currentUser = os.Getenv("LOGNAME")
-	}
-	if currentUser == "" {
-		return
-	}
-	out, err := execGroups(currentUser)
-	if err == nil && strings.Contains(out, "input") {
-		fmt.Printf("✓ %s is already in the input group (Caps Lock OSD enabled)\n", currentUser)
-		return
-	}
-	fmt.Println("Adding user to input group for Caps Lock OSD support...")
-	if err := privesc.Run(context.Background(), "", "usermod", "-aG", "input", currentUser); err != nil {
-		fmt.Printf("⚠ Could not add %s to input group (Caps Lock OSD will be unavailable): %v\n", currentUser, err)
-	} else {
-		fmt.Printf("✓ Added %s to input group (logout/login required to take effect)\n", currentUser)
-	}
-}
-
-func execGroups(user string) (string, error) {
-	out, err := exec.Command("groups", user).Output()
-	return string(out), err
-}
-
 func promptCompositor() (deps.WindowManager, bool) {
 	fmt.Println("Select compositor:")
 	fmt.Println("1) Niri")

core/cmd/dms/commands_system.go

@@ -1,277 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/sysupdate"
-	"github.com/spf13/cobra"
-)
-
-var systemCmd = &cobra.Command{
-	Use:   "system",
-	Short: "System operations",
-	Long:  "System-level operations (updates, etc.). Runs against installed package managers directly; does not require the DMS server.",
-}
-
-var systemUpdateCmd = &cobra.Command{
-	Use:   "update",
-	Short: "Apply or list system updates",
-	Long: `Apply or list system updates across detected package managers.
-
-Default behavior is to apply available updates after prompting for confirmation.
-Use --check to list updates without applying.
-
-Examples:
-  dms system update --check                  # list available updates
-  dms system update                          # apply updates (interactive prompt)
-  dms system update --noconfirm              # apply updates without prompting
-  dms system update --dry                    # simulate without changing anything
-  dms system update --no-flatpak --noconfirm # apply system updates only
-  dms system update --interval 3600          # set the server poll interval to 1h`,
-	Run: runSystemUpdate,
-}
-
-var (
-	sysUpdateCheck      bool
-	sysUpdateNoConfirm  bool
-	sysUpdateDry        bool
-	sysUpdateJSON       bool
-	sysUpdateNoFlatpak  bool
-	sysUpdateNoAUR      bool
-	sysUpdateIntervalS  int
-	sysUpdateListPmTime = 5 * time.Minute
-)
-
-func init() {
-	systemUpdateCmd.Flags().BoolVar(&sysUpdateCheck, "check", false, "List available updates without applying")
-	systemUpdateCmd.Flags().BoolVarP(&sysUpdateNoConfirm, "noconfirm", "y", false, "Apply updates without prompting")
-	systemUpdateCmd.Flags().BoolVar(&sysUpdateDry, "dry", false, "Simulate the upgrade without applying changes")
-	systemUpdateCmd.Flags().BoolVar(&sysUpdateJSON, "json", false, "Output as JSON (with --check)")
-	systemUpdateCmd.Flags().BoolVar(&sysUpdateNoFlatpak, "no-flatpak", false, "Skip the Flatpak overlay")
-	systemUpdateCmd.Flags().BoolVar(&sysUpdateNoAUR, "no-aur", false, "Skip the AUR (paru/yay only)")
-	systemUpdateCmd.Flags().IntVar(&sysUpdateIntervalS, "interval", -1, "Set the DMS server poll interval in seconds and exit (requires running server)")
-
-	systemCmd.AddCommand(systemUpdateCmd)
-}
-
-func runSystemUpdate(cmd *cobra.Command, args []string) {
-	switch {
-	case sysUpdateIntervalS >= 0:
-		runSystemUpdateSetInterval(sysUpdateIntervalS)
-	case sysUpdateCheck:
-		runSystemUpdateCheck()
-	default:
-		runSystemUpdateApply()
-	}
-}
-
-func selectBackends(ctx context.Context) []sysupdate.Backend {
-	sel := sysupdate.Select(ctx)
-	backends := sel.All()
-	if !sysUpdateNoFlatpak {
-		return backends
-	}
-	out := backends[:0]
-	for _, b := range backends {
-		if b.Repo() == sysupdate.RepoFlatpak {
-			continue
-		}
-		out = append(out, b)
-	}
-	return out
-}
-
-func runSystemUpdateCheck() {
-	ctx, cancel := context.WithTimeout(context.Background(), sysUpdateListPmTime)
-	defer cancel()
-
-	backends := selectBackends(ctx)
-	if len(backends) == 0 {
-		log.Fatal("No supported package manager found")
-	}
-
-	type backendResult struct {
-		ID       string              `json:"id"`
-		Display  string              `json:"displayName"`
-		Packages []sysupdate.Package `json:"packages"`
-	}
-	var results []backendResult
-	var allPkgs []sysupdate.Package
-	var firstErr error
-
-	for _, b := range backends {
-		pkgs, err := b.CheckUpdates(ctx)
-		if err != nil && firstErr == nil {
-			firstErr = fmt.Errorf("%s: %w", b.ID(), err)
-		}
-		results = append(results, backendResult{ID: b.ID(), Display: b.DisplayName(), Packages: pkgs})
-		allPkgs = append(allPkgs, pkgs...)
-	}
-
-	if sysUpdateJSON {
-		out, _ := json.MarshalIndent(map[string]any{
-			"backends": results,
-			"packages": allPkgs,
-			"error":    errOrEmpty(firstErr),
-			"count":    len(allPkgs),
-		}, "", "  ")
-		fmt.Println(string(out))
-		return
-	}
-
-	printBackends(backends)
-	fmt.Printf("Updates: %d\n", len(allPkgs))
-	if firstErr != nil {
-		fmt.Printf("Error:   %v\n", firstErr)
-	}
-	if len(allPkgs) == 0 {
-		return
-	}
-	fmt.Println()
-	for _, p := range allPkgs {
-		fmt.Printf("  [%s] %s  %s -> %s\n", p.Repo, p.Name, defaultIfEmpty(p.FromVersion, "?"), defaultIfEmpty(p.ToVersion, "?"))
-	}
-}
-
-func runSystemUpdateApply() {
-	checkCtx, checkCancel := context.WithTimeout(context.Background(), sysUpdateListPmTime)
-	defer checkCancel()
-
-	backends := selectBackends(checkCtx)
-	if len(backends) == 0 {
-		log.Fatal("No supported package manager found")
-	}
-
-	pkgs, firstErr := collectUpdates(checkCtx, backends)
-	if firstErr != nil {
-		fmt.Printf("Warning: %v\n\n", firstErr)
-	}
-
-	printBackends(backends)
-	fmt.Printf("Updates: %d\n", len(pkgs))
-	if len(pkgs) == 0 {
-		fmt.Println("Nothing to upgrade.")
-		return
-	}
-	fmt.Println()
-	for _, p := range pkgs {
-		fmt.Printf("  [%s] %s  %s -> %s\n", p.Repo, p.Name, defaultIfEmpty(p.FromVersion, "?"), defaultIfEmpty(p.ToVersion, "?"))
-	}
-	fmt.Println()
-
-	if !sysUpdateNoConfirm && !sysUpdateDry {
-		if !promptYesNo("Proceed with upgrade? [y/N]: ") {
-			fmt.Println("Aborted.")
-			return
-		}
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
-	defer cancel()
-
-	opts := sysupdate.UpgradeOptions{
-		IncludeFlatpak: !sysUpdateNoFlatpak,
-		IncludeAUR:     !sysUpdateNoAUR,
-		DryRun:         sysUpdateDry,
-	}
-
-	onLine := func(line string) { fmt.Println(line) }
-	for _, b := range backends {
-		fmt.Printf("\n== %s ==\n", b.DisplayName())
-		if err := b.Upgrade(ctx, opts, onLine); err != nil {
-			log.Fatalf("%s upgrade failed: %v", b.ID(), err)
-		}
-	}
-	if sysUpdateDry {
-		fmt.Println("\nDry run complete (no changes applied).")
-		return
-	}
-	fmt.Println("\nUpgrade complete.")
-}
-
-func collectUpdates(ctx context.Context, backends []sysupdate.Backend) ([]sysupdate.Package, error) {
-	var all []sysupdate.Package
-	var firstErr error
-	for _, b := range backends {
-		pkgs, err := b.CheckUpdates(ctx)
-		if err != nil && firstErr == nil {
-			firstErr = fmt.Errorf("%s: %w", b.ID(), err)
-		}
-		all = append(all, pkgs...)
-	}
-	return all, firstErr
-}
-
-func runSystemUpdateSetInterval(seconds int) {
-	resp, err := sendServerRequest(models.Request{
-		ID:     1,
-		Method: "sysupdate.setInterval",
-		Params: map[string]any{"seconds": float64(seconds)},
-	})
-	if err != nil {
-		log.Fatalf("Failed: %v (is dms server running?)", err)
-	}
-	if resp.Error != "" {
-		log.Fatalf("Error: %s", resp.Error)
-	}
-	fmt.Printf("Interval set to %d seconds.\n", seconds)
-}
-
-func promptYesNo(prompt string) bool {
-	if !stdinIsTTY() {
-		log.Fatal("Refusing to apply updates non-interactively. Re-run with --noconfirm or --check.")
-	}
-	fmt.Print(prompt)
-	reader := bufio.NewReader(os.Stdin)
-	line, err := reader.ReadString('\n')
-	if err != nil {
-		return false
-	}
-	switch strings.ToLower(strings.TrimSpace(line)) {
-	case "y", "yes":
-		return true
-	default:
-		return false
-	}
-}
-
-func printBackends(backends []sysupdate.Backend) {
-	if len(backends) == 0 {
-		return
-	}
-	names := make([]string, 0, len(backends))
-	for _, b := range backends {
-		names = append(names, b.DisplayName())
-	}
-	fmt.Printf("Backends: %s\n", strings.Join(names, ", "))
-}
-
-func stdinIsTTY() bool {
-	fi, err := os.Stdin.Stat()
-	if err != nil {
-		return false
-	}
-	return (fi.Mode() & os.ModeCharDevice) != 0
-}
-
-func errOrEmpty(err error) string {
-	if err == nil {
-		return ""
-	}
-	return err.Error()
-}
-
-func defaultIfEmpty(s, def string) string {
-	if s == "" {
-		return def
-	}
-	return s
-}

core/cmd/dms/commands_trash.go

@@ -1,122 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/trash"
-	"github.com/spf13/cobra"
-)
-
-var trashCmd = &cobra.Command{
-	Use:   "trash",
-	Short: "Manage the user's trash (XDG Trash spec 1.0)",
-}
-
-var trashPutCmd = &cobra.Command{
-	Use:   "put <path...>",
-	Short: "Move files or directories into the trash",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   runTrashPut,
-}
-
-var trashListCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List trashed items across all known trash directories",
-	Run:   runTrashList,
-}
-
-var trashCountCmd = &cobra.Command{
-	Use:   "count",
-	Short: "Print the total number of trashed items",
-	Run:   runTrashCount,
-}
-
-var trashEmptyCmd = &cobra.Command{
-	Use:   "empty",
-	Short: "Permanently delete every trashed item",
-	Run:   runTrashEmpty,
-}
-
-var trashRestoreCmd = &cobra.Command{
-	Use:   "restore <name>",
-	Short: "Restore a trashed item to its original location",
-	Args:  cobra.ExactArgs(1),
-	Run:   runTrashRestore,
-}
-
-var (
-	trashJSONOutput bool
-	trashRestoreDir string
-)
-
-func init() {
-	trashListCmd.Flags().BoolVar(&trashJSONOutput, "json", false, "Output as JSON")
-	trashRestoreCmd.Flags().StringVar(&trashRestoreDir, "trash-dir", "", "Trash directory containing the item (default: home trash)")
-	trashCmd.AddCommand(trashPutCmd, trashListCmd, trashCountCmd, trashEmptyCmd, trashRestoreCmd)
-}
-
-func runTrashPut(cmd *cobra.Command, args []string) {
-	var failed int
-	for _, p := range args {
-		if _, err := trash.Put(p); err != nil {
-			log.Errorf("trash %s: %v", p, err)
-			failed++
-			continue
-		}
-		fmt.Println(p)
-	}
-	if failed > 0 {
-		os.Exit(1)
-	}
-}
-
-func runTrashList(cmd *cobra.Command, args []string) {
-	entries, err := trash.List()
-	if err != nil {
-		log.Fatalf("list trash: %v", err)
-	}
-
-	if trashJSONOutput {
-		if entries == nil {
-			entries = []trash.Entry{}
-		}
-		out, _ := json.MarshalIndent(entries, "", "  ")
-		fmt.Println(string(out))
-		return
-	}
-
-	if len(entries) == 0 {
-		fmt.Println("Trash is empty")
-		return
-	}
-	for _, e := range entries {
-		marker := "F"
-		if e.IsDir {
-			marker = "D"
-		}
-		fmt.Printf("%s  %s  %s  %s\n", marker, e.DeletionDate, e.Name, e.OriginalPath)
-	}
-}
-
-func runTrashCount(cmd *cobra.Command, args []string) {
-	n, err := trash.Count()
-	if err != nil {
-		log.Fatalf("count trash: %v", err)
-	}
-	fmt.Println(n)
-}
-
-func runTrashEmpty(cmd *cobra.Command, args []string) {
-	if err := trash.Empty(); err != nil {
-		log.Fatalf("empty trash: %v", err)
-	}
-}
-
-func runTrashRestore(cmd *cobra.Command, args []string) {
-	if err := trash.Restore(args[0], trashRestoreDir); err != nil {
-		log.Fatalf("restore: %v", err)
-	}
-}

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

@@ -1,285 +0,0 @@
-package main
-
-import (
-	"bufio"
-	_ "embed"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
-	"github.com/spf13/cobra"
-)
-
-const (
-	cliPolicyPackagedPath = "/usr/share/dms/cli-policy.json"
-	cliPolicyAdminPath    = "/etc/dms/cli-policy.json"
-)
-
-var (
-	immutablePolicyOnce sync.Once
-	immutablePolicy     immutableCommandPolicy
-	immutablePolicyErr  error
-)
-
-//go:embed assets/cli-policy.default.json
-var defaultCLIPolicyJSON []byte
-
-type immutableCommandPolicy struct {
-	ImmutableSystem bool
-	ImmutableReason string
-	BlockedCommands []string
-	Message         string
-}
-
-type cliPolicyFile struct {
-	PolicyVersion   int       `json:"policy_version"`
-	ImmutableSystem *bool     `json:"immutable_system"`
-	BlockedCommands *[]string `json:"blocked_commands"`
-	Message         *string   `json:"message"`
-}
-
-func normalizeCommandSpec(raw string) string {
-	normalized := strings.ToLower(strings.TrimSpace(raw))
-	normalized = strings.TrimPrefix(normalized, "dms ")
-	return strings.Join(strings.Fields(normalized), " ")
-}
-
-func normalizeBlockedCommands(raw []string) []string {
-	normalized := make([]string, 0, len(raw))
-	seen := make(map[string]bool)
-
-	for _, cmd := range raw {
-		spec := normalizeCommandSpec(cmd)
-		if spec == "" || seen[spec] {
-			continue
-		}
-		seen[spec] = true
-		normalized = append(normalized, spec)
-	}
-
-	return normalized
-}
-
-func commandBlockedByPolicy(commandPath string, blocked []string) bool {
-	normalizedPath := normalizeCommandSpec(commandPath)
-	if normalizedPath == "" {
-		return false
-	}
-
-	for _, entry := range blocked {
-		spec := normalizeCommandSpec(entry)
-		if spec == "" {
-			continue
-		}
-		if normalizedPath == spec || strings.HasPrefix(normalizedPath, spec+" ") {
-			return true
-		}
-	}
-
-	return false
-}
-
-func loadPolicyFile(path string) (*cliPolicyFile, error) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, fmt.Errorf("failed to read %s: %w", path, err)
-	}
-
-	var policy cliPolicyFile
-	if err := json.Unmarshal(data, &policy); err != nil {
-		return nil, fmt.Errorf("failed to parse %s: %w", path, err)
-	}
-
-	return &policy, nil
-}
-
-func mergePolicyFile(base *immutableCommandPolicy, path string) error {
-	policyFile, err := loadPolicyFile(path)
-	if err != nil {
-		return err
-	}
-	if policyFile == nil {
-		return nil
-	}
-
-	if policyFile.ImmutableSystem != nil {
-		base.ImmutableSystem = *policyFile.ImmutableSystem
-	}
-	if policyFile.BlockedCommands != nil {
-		base.BlockedCommands = normalizeBlockedCommands(*policyFile.BlockedCommands)
-	}
-	if policyFile.Message != nil {
-		msg := strings.TrimSpace(*policyFile.Message)
-		if msg != "" {
-			base.Message = msg
-		}
-	}
-
-	return nil
-}
-
-func readOSReleaseMap(path string) map[string]string {
-	values := make(map[string]string)
-
-	file, err := os.Open(path)
-	if err != nil {
-		return values
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		parts := strings.SplitN(line, "=", 2)
-		if len(parts) != 2 {
-			continue
-		}
-		key := strings.ToUpper(strings.TrimSpace(parts[0]))
-		value := strings.Trim(strings.TrimSpace(parts[1]), "\"")
-		values[key] = strings.ToLower(value)
-	}
-
-	return values
-}
-
-func hasAnyToken(text string, tokens ...string) bool {
-	if text == "" {
-		return false
-	}
-	for _, token := range tokens {
-		if strings.Contains(text, token) {
-			return true
-		}
-	}
-	return false
-}
-
-func detectImmutableSystem() (bool, string) {
-	if _, err := os.Stat("/run/ostree-booted"); err == nil {
-		return true, "/run/ostree-booted is present"
-	}
-
-	osRelease := readOSReleaseMap("/etc/os-release")
-	if len(osRelease) == 0 {
-		return false, ""
-	}
-
-	id := osRelease["ID"]
-	idLike := osRelease["ID_LIKE"]
-	variantID := osRelease["VARIANT_ID"]
-	name := osRelease["NAME"]
-	prettyName := osRelease["PRETTY_NAME"]
-
-	immutableIDs := map[string]bool{
-		"bluefin":       true,
-		"bazzite":       true,
-		"silverblue":    true,
-		"kinoite":       true,
-		"sericea":       true,
-		"onyx":          true,
-		"aurora":        true,
-		"fedora-iot":    true,
-		"fedora-coreos": true,
-	}
-	if immutableIDs[id] {
-		return true, "os-release ID=" + id
-	}
-
-	markers := []string{"silverblue", "kinoite", "sericea", "onyx", "bazzite", "bluefin", "aurora", "ostree", "atomic"}
-	if hasAnyToken(variantID, markers...) {
-		return true, "os-release VARIANT_ID=" + variantID
-	}
-	if hasAnyToken(idLike, "ostree", "rpm-ostree") {
-		return true, "os-release ID_LIKE=" + idLike
-	}
-	if hasAnyToken(name, markers...) || hasAnyToken(prettyName, markers...) {
-		return true, "os-release identifies an atomic/ostree variant"
-	}
-
-	return false, ""
-}
-
-func getImmutablePolicy() (*immutableCommandPolicy, error) {
-	immutablePolicyOnce.Do(func() {
-		detectedImmutable, reason := detectImmutableSystem()
-		immutablePolicy = immutableCommandPolicy{
-			ImmutableSystem: detectedImmutable,
-			ImmutableReason: reason,
-			BlockedCommands: []string{"greeter install", "greeter enable", "setup"},
-			Message:         "This command is disabled on immutable/image-based systems. Use your distro-native workflow for system-level changes.",
-		}
-
-		var defaultPolicy cliPolicyFile
-		if err := json.Unmarshal(defaultCLIPolicyJSON, &defaultPolicy); err != nil {
-			immutablePolicyErr = fmt.Errorf("failed to parse embedded default CLI policy: %w", err)
-			return
-		}
-		if defaultPolicy.BlockedCommands != nil {
-			immutablePolicy.BlockedCommands = normalizeBlockedCommands(*defaultPolicy.BlockedCommands)
-		}
-		if defaultPolicy.Message != nil {
-			msg := strings.TrimSpace(*defaultPolicy.Message)
-			if msg != "" {
-				immutablePolicy.Message = msg
-			}
-		}
-
-		if err := mergePolicyFile(&immutablePolicy, cliPolicyPackagedPath); err != nil {
-			immutablePolicyErr = err
-			return
-		}
-		if err := mergePolicyFile(&immutablePolicy, cliPolicyAdminPath); err != nil {
-			immutablePolicyErr = err
-			return
-		}
-	})
-
-	if immutablePolicyErr != nil {
-		return nil, immutablePolicyErr
-	}
-	return &immutablePolicy, nil
-}
-
-func requireMutableSystemCommand(cmd *cobra.Command, _ []string) error {
-	policy, err := getImmutablePolicy()
-	if err != nil {
-		return err
-	}
-	if !policy.ImmutableSystem {
-		return nil
-	}
-
-	commandPath := normalizeCommandSpec(cmd.CommandPath())
-	if !commandBlockedByPolicy(commandPath, policy.BlockedCommands) {
-		return nil
-	}
-
-	reason := ""
-	if policy.ImmutableReason != "" {
-		reason = "Detected immutable system: " + policy.ImmutableReason + "\n"
-	}
-
-	return fmt.Errorf("%s%s\nCommand: dms %s\nPolicy files:\n  %s\n  %s", reason, policy.Message, commandPath, cliPolicyPackagedPath, cliPolicyAdminPath)
-}
-
-// preRunPrivileged combines the immutable-system check with a privesc tool
-// selection prompt (shown only when multiple tools are available and the
-// $DMS_PRIVESC env var isn't set).
-func preRunPrivileged(cmd *cobra.Command, args []string) error {
-	if err := requireMutableSystemCommand(cmd, args); err != nil {
-		return err
-	}
-	if _, err := privesc.PromptCLI(os.Stdout, os.Stdin); err != nil {
-		return err
-	}
-	return nil
-}

core/cmd/dms/main.go

@@ -5,7 +5,6 @@ package main
 import (
 	"os"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 )
 
@@ -15,27 +14,27 @@ func init() {
 	runCmd.Flags().BoolP("daemon", "d", false, "Run in daemon mode")
 	runCmd.Flags().Bool("daemon-child", false, "Internal flag for daemon child process")
 	runCmd.Flags().Bool("session", false, "Session managed (like as a systemd unit)")
-	runCmd.Flags().String("log-level", "", "Log level: debug, info, warn, error, fatal (overrides DMS_LOG_LEVEL)")
-	runCmd.Flags().String("log-file", "", "Append logs to this file in addition to stderr (overrides DMS_LOG_FILE)")
 	runCmd.Flags().MarkHidden("daemon-child")
 
-	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd)
-	authCmd.AddCommand(authSyncCmd)
-	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
+	// Add subcommands to greeter
+	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd)
+
+	// Add subcommands to update
 	updateCmd.AddCommand(updateCheckCmd)
+
+	// Add subcommands to plugins
 	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)
+
+	// Add common commands to root
 	rootCmd.AddCommand(getCommonCommands()...)
 
-	rootCmd.AddCommand(authCmd)
 	rootCmd.AddCommand(updateCmd)
 
 	rootCmd.SetHelpTemplate(getHelpTemplate())
 }
 
 func main() {
-	clipboard.MaybeServeAndExit()
-
-	if os.Geteuid() == 0 && !isReadOnlyCommand(os.Args) {
+	if os.Geteuid() == 0 {
 		log.Fatal("This program should not be run as root. Exiting.")
 	}
 

core/cmd/dms/main_distro.go

@@ -5,34 +5,33 @@ package main
 import (
 	"os"
 
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 )
 
 var Version = "dev"
 
 func init() {
+	// Add flags
 	runCmd.Flags().BoolP("daemon", "d", false, "Run in daemon mode")
 	runCmd.Flags().Bool("daemon-child", false, "Internal flag for daemon child process")
 	runCmd.Flags().Bool("session", false, "Session managed (like as a systemd unit)")
-	runCmd.Flags().String("log-level", "", "Log level: debug, info, warn, error, fatal (overrides DMS_LOG_LEVEL)")
-	runCmd.Flags().String("log-file", "", "Append logs to this file in addition to stderr (overrides DMS_LOG_FILE)")
 	runCmd.Flags().MarkHidden("daemon-child")
 
-	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd)
-	authCmd.AddCommand(authSyncCmd)
-	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
+	// Add subcommands to greeter
+	greeterCmd.AddCommand(greeterSyncCmd, greeterEnableCmd, greeterStatusCmd)
+
+	// Add subcommands to plugins
 	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)
+
+	// Add common commands to root
 	rootCmd.AddCommand(getCommonCommands()...)
-	rootCmd.AddCommand(authCmd)
 
 	rootCmd.SetHelpTemplate(getHelpTemplate())
 }
 
 func main() {
-	clipboard.MaybeServeAndExit()
-
-	if os.Geteuid() == 0 && !isReadOnlyCommand(os.Args) {
+	// Block root
+	if os.Geteuid() == 0 {
 		log.Fatal("This program should not be run as root. Exiting.")
 	}
 

core/cmd/dms/randr_client.go

@@ -1,172 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/wlr_output_management"
-	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
-)
-
-type randrOutput struct {
-	Name    string  `json:"name"`
-	Scale   float64 `json:"scale"`
-	Width   int32   `json:"width"`
-	Height  int32   `json:"height"`
-	Refresh int32   `json:"refresh"`
-	Enabled bool    `json:"enabled"`
-}
-
-type randrHead struct {
-	name          string
-	enabled       bool
-	scale         float64
-	currentModeID uint32
-	modeIDs       []uint32
-}
-
-type randrMode struct {
-	width   int32
-	height  int32
-	refresh int32
-}
-
-type randrClient struct {
-	display *wlclient.Display
-	ctx     *wlclient.Context
-	manager *wlr_output_management.ZwlrOutputManagerV1
-	heads   map[uint32]*randrHead
-	modes   map[uint32]*randrMode
-	done    bool
-	err     error
-}
-
-func queryRandr() ([]randrOutput, error) {
-	display, err := wlclient.Connect("")
-	if err != nil {
-		return nil, fmt.Errorf("failed to connect to Wayland: %w", err)
-	}
-
-	c := &randrClient{
-		display: display,
-		ctx:     display.Context(),
-		heads:   make(map[uint32]*randrHead),
-		modes:   make(map[uint32]*randrMode),
-	}
-	defer c.ctx.Close()
-
-	registry, err := display.GetRegistry()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get registry: %w", err)
-	}
-
-	registry.SetGlobalHandler(func(e wlclient.RegistryGlobalEvent) {
-		if e.Interface == wlr_output_management.ZwlrOutputManagerV1InterfaceName {
-			mgr := wlr_output_management.NewZwlrOutputManagerV1(c.ctx)
-			version := min(e.Version, 4)
-
-			mgr.SetHeadHandler(func(e wlr_output_management.ZwlrOutputManagerV1HeadEvent) {
-				c.handleHead(e)
-			})
-
-			mgr.SetDoneHandler(func(e wlr_output_management.ZwlrOutputManagerV1DoneEvent) {
-				c.done = true
-			})
-
-			if err := registry.Bind(e.Name, e.Interface, version, mgr); err == nil {
-				c.manager = mgr
-			}
-		}
-	})
-
-	// First roundtrip: discover globals and bind manager
-	syncCallback, err := display.Sync()
-	if err != nil {
-		return nil, fmt.Errorf("failed to sync display: %w", err)
-	}
-	syncCallback.SetDoneHandler(func(e wlclient.CallbackDoneEvent) {
-		if c.manager == nil {
-			c.err = fmt.Errorf("zwlr_output_manager_v1 protocol not supported by compositor")
-			c.done = true
-		}
-		// Otherwise wait for manager's DoneHandler
-	})
-
-	for !c.done {
-		if err := c.ctx.Dispatch(); err != nil {
-			return nil, fmt.Errorf("dispatch error: %w", err)
-		}
-	}
-
-	if c.err != nil {
-		return nil, c.err
-	}
-
-	return c.buildOutputs(), nil
-}
-
-func (c *randrClient) handleHead(e wlr_output_management.ZwlrOutputManagerV1HeadEvent) {
-	handle := e.Head
-	headID := handle.ID()
-
-	head := &randrHead{
-		modeIDs: make([]uint32, 0),
-	}
-	c.heads[headID] = head
-
-	handle.SetNameHandler(func(e wlr_output_management.ZwlrOutputHeadV1NameEvent) {
-		head.name = e.Name
-	})
-
-	handle.SetEnabledHandler(func(e wlr_output_management.ZwlrOutputHeadV1EnabledEvent) {
-		head.enabled = e.Enabled != 0
-	})
-
-	handle.SetScaleHandler(func(e wlr_output_management.ZwlrOutputHeadV1ScaleEvent) {
-		head.scale = e.Scale
-	})
-
-	handle.SetCurrentModeHandler(func(e wlr_output_management.ZwlrOutputHeadV1CurrentModeEvent) {
-		head.currentModeID = e.Mode.ID()
-	})
-
-	handle.SetModeHandler(func(e wlr_output_management.ZwlrOutputHeadV1ModeEvent) {
-		modeHandle := e.Mode
-		modeID := modeHandle.ID()
-
-		head.modeIDs = append(head.modeIDs, modeID)
-
-		mode := &randrMode{}
-		c.modes[modeID] = mode
-
-		modeHandle.SetSizeHandler(func(e wlr_output_management.ZwlrOutputModeV1SizeEvent) {
-			mode.width = e.Width
-			mode.height = e.Height
-		})
-
-		modeHandle.SetRefreshHandler(func(e wlr_output_management.ZwlrOutputModeV1RefreshEvent) {
-			mode.refresh = e.Refresh
-		})
-	})
-}
-
-func (c *randrClient) buildOutputs() []randrOutput {
-	outputs := make([]randrOutput, 0, len(c.heads))
-
-	for _, head := range c.heads {
-		out := randrOutput{
-			Name:    head.name,
-			Scale:   head.scale,
-			Enabled: head.enabled,
-		}
-
-		if mode, ok := c.modes[head.currentModeID]; ok {
-			out.Width = mode.width
-			out.Height = mode.height
-			out.Refresh = mode.refresh
-		}
-
-		outputs = append(outputs, out)
-	}
-
-	return outputs
-}

core/cmd/dms/shell.go

@@ -80,16 +80,6 @@ func getRuntimeDir() string {
 	return os.TempDir()
 }
 
-func appendLogEnv(env []string) []string {
-	if v := os.Getenv("DMS_LOG_LEVEL"); v != "" {
-		env = append(env, "DMS_LOG_LEVEL="+v)
-	}
-	if v := os.Getenv("DMS_LOG_FILE"); v != "" {
-		env = append(env, "DMS_LOG_FILE="+v)
-	}
-	return env
-}
-
 func hasSystemdRun() bool {
 	_, err := exec.LookPath("systemd-run")
 	return err == nil
@@ -202,9 +192,6 @@ func runShellInteractive(session bool) {
 		}
 	}
 
-	// ! TODO - remove when QS 0.3 is up and we can use the pragma
-	cmd.Env = append(cmd.Env, "QS_APP_ID=com.danklinux.dms")
-
 	if isSessionManaged && hasSystemdRun() {
 		cmd.Env = append(cmd.Env, "DMS_DEFAULT_LAUNCH_PREFIX=systemd-run --user --scope")
 	}
@@ -223,11 +210,9 @@ 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.Env = appendLogEnv(cmd.Env)
-
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -447,9 +432,6 @@ func runShellDaemon(session bool) {
 		}
 	}
 
-	// ! TODO - remove when QS 0.3 is up and we can use the pragma
-	cmd.Env = append(cmd.Env, "QS_APP_ID=com.danklinux.dms")
-
 	if isSessionManaged && hasSystemdRun() {
 		cmd.Env = append(cmd.Env, "DMS_DEFAULT_LAUNCH_PREFIX=systemd-run --user --scope")
 	}
@@ -468,11 +450,9 @@ 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")
 	}
 
-	cmd.Env = appendLogEnv(cmd.Env)
-
 	devNull, err := os.OpenFile("/dev/null", os.O_RDWR, 0)
 	if err != nil {
 		log.Fatalf("Error opening /dev/null: %v", err)
@@ -636,47 +616,11 @@ func getShellIPCCompletions(args []string, _ string) []string {
 	return nil
 }
 
-func getFirstDMSPID() (int, bool) {
-	dir := getRuntimeDir()
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return 0, false
-	}
-
-	for _, entry := range entries {
-		if !strings.HasPrefix(entry.Name(), "danklinux-") || !strings.HasSuffix(entry.Name(), ".pid") {
-			continue
-		}
-
-		data, err := os.ReadFile(filepath.Join(dir, entry.Name()))
-		if err != nil {
-			continue
-		}
-
-		pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
-		if err != nil {
-			continue
-		}
-
-		proc, err := os.FindProcess(pid)
-		if err != nil {
-			continue
-		}
-
-		if proc.Signal(syscall.Signal(0)) != nil {
-			continue
-		}
-
-		return pid, true
-	}
-
-	return 0, false
-}
-
 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" {
@@ -684,21 +628,10 @@ func runShellIPCCommand(args []string) {
 	}
 
 	cmdArgs := []string{"ipc"}
-
-	switch pid, ok := getFirstDMSPID(); {
-	case ok:
-		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
-	default:
-		if err := findConfig(nil, nil); err != nil {
-			log.Fatalf("Error finding config: %v", err)
-		}
-		// ! TODO - remove check when QS 0.3 is released
 	if qsHasAnyDisplay() {
 		cmdArgs = append(cmdArgs, "--any-display")
 	}
 	cmdArgs = append(cmdArgs, "-p", configPath)
-	}
-
 	cmdArgs = append(cmdArgs, args...)
 	cmd := exec.Command("qs", cmdArgs...)
 	cmd.Stdin = os.Stdin
@@ -709,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/cmd/dms/utils.go

@@ -7,20 +7,12 @@ import (
 	"strings"
 )
 
-// isReadOnlyCommand returns true if the CLI args indicate a command that is
-// safe to run as root (e.g. shell completion, help).
-func isReadOnlyCommand(args []string) bool {
-	for _, arg := range args[1:] {
-		if strings.HasPrefix(arg, "-") {
-			continue
+func findCommandPath(cmd string) (string, error) {
+	path, err := exec.LookPath(cmd)
+	if err != nil {
+		return "", fmt.Errorf("command '%s' not found in PATH", cmd)
 	}
-		switch arg {
-		case "completion", "help", "__complete":
-			return true
-		}
-		return false
-	}
-	return false
+	return path, nil
 }
 
 func isArchPackageInstalled(packageName string) bool {

core/go.mod

@@ -1,87 +1,72 @@
 module github.com/AvengeMedia/DankMaterialShell/core
 
-go 1.26.0
-
-toolchain go1.26.1
+go 1.24.6
 
 require (
 	github.com/Wifx/gonetworkmanager/v2 v2.2.0
-	github.com/alecthomas/chroma/v2 v2.24.0
-	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 v1.0.0
+	github.com/charmbracelet/log v0.4.2
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/godbus/dbus/v5 v5.2.2
 	github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83
 	github.com/pilebones/go-udev v0.9.1
-	github.com/sblinch/kdl-go v0.0.0-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/yeqown/go-qrcode/v2 v2.2.5
-	github.com/yeqown/go-qrcode/writer/standard v1.3.0
-	github.com/yuin/goldmark v1.8.2
-	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-20260410095643-746e56fc9e2f
-	golang.org/x/image v0.39.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.4.1 // indirect
-	github.com/clipperhouse/displaywidth v0.11.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
-	github.com/cloudflare/circl v1.6.3 // indirect
+	github.com/ProtonMail/go-crypto v1.3.0 // 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.12.0 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/fogleman/gg v1.3.0 // indirect
 	github.com/go-git/gcfg/v2 v2.0.2 // indirect
-	github.com/go-git/go-billy/v6 v6.0.0-20260424211911-732291493fb8 // 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/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
-	github.com/kevinburke/ssh_config v1.6.0 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // 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/pkg/errors v0.9.1 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/stretchr/objx v0.5.3 // indirect
-	github.com/yeqown/reedsolomon v1.0.0 // indirect
-	golang.org/x/crypto v0.50.0 // indirect
-	golang.org/x/net v0.53.0 // indirect
-	golang.org/x/sync v0.20.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.3 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/harmonica v0.2.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.7 // 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-alpha.2
+	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.4.0
-	github.com/mattn/go-isatty v0.0.22
+	github.com/lucasb-eyer/go-colorful v1.3.0
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.23 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/termenv v0.16.0
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	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.43.0
-	golang.org/x/text v0.36.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

@@ -1,17 +1,9 @@
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-github.com/ProtonMail/go-crypto v1.4.1 h1:9RfcZHqEQUvP8RzecWEUafnZVtEvrBVL9BiF67IQOfM=
-github.com/ProtonMail/go-crypto v1.4.1/go.mod h1:e1OaTyu5SYVrO9gKOEhTc+5UcXtTUa+P3uLudwcgPqo=
+github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=
+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.24.0 h1:zrg+k0tAaVbM8whaT2hR5DOUqAdopsDaH998EGi6Llk=
-github.com/alecthomas/chroma/v2 v2.24.0/go.mod h1:l+ohZ9xRXIbGe7cIW+YZgOGbvuVLjMps/FYN/CwuabI=
-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,93 +12,104 @@ 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.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=
-github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
+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 v1.0.0 h1:HVVVMmfOorfj3BA9i8X8UL69Hoz9lI0PYwXfJvOdRc4=
-github.com/charmbracelet/log v1.0.0/go.mod h1:uYgY3SmLpwJWxmlrPwXvzVYujxis1vAKRV/0VQB7yWA=
-github.com/charmbracelet/x/ansi v0.11.7 h1:kzv1kJvjg2S3r9KHo8hDdHFQLEqn4RBCb39dAYC84jI=
-github.com/charmbracelet/x/ansi v0.11.7/go.mod h1:9qGpnAVYz+8ACONkZBUWPtL7lulP9No6p1epAihUZwQ=
-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/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
+github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
+github.com/charmbracelet/x/ansi v0.11.2 h1:XAG3FSjiVtFvgEgGrNBkCNNYrsucAt8c6bfxHyROLLs=
+github.com/charmbracelet/x/ansi v0.11.2/go.mod h1:9tY2bzX5SiJCU0iWyskjBeI2BRQfvPqI+J760Mjf+Rg=
+github.com/charmbracelet/x/ansi v0.11.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.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
-github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
-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.12.0 h1:0j4c5qQmnC6XOWNjP3PIXURXN2gWx76rd3KvgdPkCz8=
-github.com/dlclark/regexp2 v1.12.0/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=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
-github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
-github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 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-20260424211911-732291493fb8 h1:QRpwB1ans3fB3Cmeuog1ATzvXg/xhqubqiQi97xNO6E=
-github.com/go-git/go-billy/v6 v6.0.0-20260424211911-732291493fb8/go.mod h1:CdBVp7CXl9l3sOyNEog46cP1Pvx/hjCe9AD0mtaIUYU=
-github.com/go-git/go-git-fixtures/v6 v6.0.0-20260405195209-b16dd39735e0 h1:XoTsdvaghuVfIr7HpNTmFDLu2nz3I2iGqyn6Uk6MkJc=
-github.com/go-git/go-git-fixtures/v6 v6.0.0-20260405195209-b16dd39735e0/go.mod h1:1Lr7/vYEYyl6Ir9Ku0tKrCIRreM5zovv0Jdx2MPSM4s=
-github.com/go-git/go-git/v6 v6.0.0-alpha.2 h1:T3loNtDuAixNzXtlQxZhnYiYpaQ3CA4vn9RssAniEeI=
-github.com/go-git/go-git/v6 v6.0.0-alpha.2/go.mod h1:oCD3i19CTz7gBpeb11ZZqL91WzqbMq9avn5KpUYy/Ak=
+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/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
-github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83 h1:B+A58zGFuDrvEZpPN+yS6swJA0nzqgZvDzgl/OPyefU=
 github.com/holoplot/go-evdev v0.0.0-20250804134636-ab1d56a1fe83/go.mod h1:iHAf8OIncO2gcQ8XOjS7CMJ2aPbX2Bs0wl5pZyanEqk=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 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=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
-github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
-github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
-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-runewidth v0.0.23 h1:7ykA0T0jkPpzSvMS5i9uoNn2Xy3R383f9HDx3RybWcw=
-github.com/mattn/go-runewidth v0.0.23/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
+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.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=
 github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
@@ -117,21 +120,23 @@ github.com/pilebones/go-udev v0.9.1 h1:uN72M1C1fgzhsVmBGEM8w9RD1JY4iVsPZpr+Z6rb3
 github.com/pilebones/go-udev v0.9.1/go.mod h1:Bgcl07crebF3JSeS4+nuaRvhWFdCeFoBhXXeAp93XNo=
 github.com/pjbgf/sha1cd v0.5.0 h1:a+UkboSi1znleCDUNT3M5YxjOnN1fz2FhN48FlwCxs0=
 github.com/pjbgf/sha1cd v0.5.0/go.mod h1:lhpGlyHLpQZoxMv8HcgXvZEhcGs0PG/vsZnEJ7H0iCM=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+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=
@@ -141,47 +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/yeqown/go-qrcode/v2 v2.2.5 h1:HCOe2bSjkhZyYoyyNaXNzh4DJZll6inVJQQw+8228Zk=
-github.com/yeqown/go-qrcode/v2 v2.2.5/go.mod h1:uHpt9CM0V1HeXLz+Wg5MN50/sI/fQhfkZlOM+cOTHxw=
-github.com/yeqown/go-qrcode/writer/standard v1.3.0 h1:chdyhEfRtUPgQtuPeaWVGQ/TQx4rE1PqeoW3U+53t34=
-github.com/yeqown/go-qrcode/writer/standard v1.3.0/go.mod h1:O4MbzsotGCvy8upYPCR91j81dr5XLT7heuljcNXW+oQ=
-github.com/yeqown/reedsolomon v1.0.0 h1:x1h/Ej/uJnNu8jaX7GLHBWmZKCAWjEJTetkqaabr4B0=
-github.com/yeqown/reedsolomon v1.0.0/go.mod h1:P76zpcn2TCuL0ul1Fso373qHRc69LKwAw/Iy6g1WiiM=
-github.com/yuin/goldmark v1.4.15/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yuin/goldmark v1.8.2 h1:kEGpgqJXdgbkhcOgBxkC0X0PmoPG1ZyoZ117rDVp4zE=
-github.com/yuin/goldmark v1.8.2/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.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
-golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
-golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
-golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
-golang.org/x/image v0.39.0 h1:skVYidAEVKgn8lZ602XO75asgXBgLj9G/FE3RbuPFww=
-golang.org/x/image v0.39.0/go.mod h1:sIbmppfU+xFLPIG0FoVUTvyBMmgng1/XAMhQ2ft0hpA=
-golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
-golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+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.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
-golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
-golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
-golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
-golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/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 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 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/blur/probe.go

@@ -1,35 +0,0 @@
-package blur
-
-import (
-	wlhelpers "github.com/AvengeMedia/DankMaterialShell/core/internal/wayland/client"
-	client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
-)
-
-const extBackgroundEffectInterface = "ext_background_effect_manager_v1"
-
-func ProbeSupport() (bool, error) {
-	display, err := client.Connect("")
-	if err != nil {
-		return false, err
-	}
-	defer display.Context().Close()
-
-	registry, err := display.GetRegistry()
-	if err != nil {
-		return false, err
-	}
-
-	found := false
-	registry.SetGlobalHandler(func(e client.RegistryGlobalEvent) {
-		switch e.Interface {
-		case extBackgroundEffectInterface:
-			found = true
-		}
-	})
-
-	if err := wlhelpers.Roundtrip(display, display.Context()); err != nil {
-		return false, err
-	}
-
-	return found, nil
-}

core/internal/clipboard/clipboard.go

@@ -5,196 +5,55 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"syscall"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/proto/ext_data_control"
 	wlclient "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 )
 
-const envServe = "_DMS_CLIPBOARD_SERVE"
-const envMime = "_DMS_CLIPBOARD_MIME"
-const envPasteOnce = "_DMS_CLIPBOARD_PASTE_ONCE"
-const envCacheFile = "_DMS_CLIPBOARD_CACHE"
-
-// MaybeServeAndExit intercepts before cobra when re-exec'd as a clipboard
-// child. Reads source data into memory, deletes any cache file, then serves.
-func MaybeServeAndExit() {
-	if os.Getenv(envServe) == "" {
-		return
-	}
-
-	mimeType := os.Getenv(envMime)
-	pasteOnce := os.Getenv(envPasteOnce) == "1"
-	cachePath := os.Getenv(envCacheFile)
-
-	var data []byte
-	var err error
-
-	switch {
-	case cachePath != "":
-		data, err = os.ReadFile(cachePath)
-		os.Remove(cachePath)
-	default:
-		data, err = io.ReadAll(os.Stdin)
-	}
-
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "clipboard: read source: %v\n", err)
-		os.Exit(1)
-	}
-
-	if err := serveClipboard(data, mimeType, pasteOnce); err != nil {
-		fmt.Fprintf(os.Stderr, "clipboard: serve: %v\n", err)
-		os.Exit(1)
-	}
-	os.Exit(0)
-}
-
 func Copy(data []byte, mimeType string) error {
-	return copyForkCached(data, mimeType, false)
+	return CopyOpts(data, mimeType, false, false)
 }
 
 func CopyOpts(data []byte, mimeType string, foreground, pasteOnce bool) error {
-	if foreground {
-		return serveClipboard(data, mimeType, pasteOnce)
-	}
-	return copyForkCached(data, mimeType, pasteOnce)
-}
-
-func CopyReader(data io.Reader, mimeType string, foreground, pasteOnce bool) error {
-	if foreground {
-		buf, err := io.ReadAll(data)
-		if err != nil {
-			return fmt.Errorf("read source: %w", err)
-		}
-		return serveClipboard(buf, mimeType, pasteOnce)
-	}
+	if !foreground {
 		return copyFork(data, mimeType, pasteOnce)
 	}
+	return copyServe(data, mimeType, pasteOnce)
+}
 
-func newForkCmd(mimeType string, pasteOnce bool, extra ...string) *exec.Cmd {
-	cmd := exec.Command(os.Args[0])
+func copyFork(data []byte, mimeType string, pasteOnce bool) error {
+	args := []string{os.Args[0], "cl", "copy", "--foreground"}
+	if pasteOnce {
+		args = append(args, "--paste-once")
+	}
+	args = append(args, "--type", mimeType)
+
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = nil
+	cmd.Stdout = nil
 	cmd.Stderr = nil
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
-	cmd.Env = append(os.Environ(),
-		envServe+"=1",
-		envMime+"="+mimeType,
-	)
-	if pasteOnce {
-		cmd.Env = append(cmd.Env, envPasteOnce+"=1")
-	}
-	cmd.Env = append(cmd.Env, extra...)
-	return cmd
-}
 
-func waitReady(cmd *exec.Cmd) error {
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return fmt.Errorf("stdout pipe: %w", err)
-	}
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("start: %w", err)
-	}
-	var buf [1]byte
-	if _, err := stdout.Read(buf[:]); err != nil {
-		return fmt.Errorf("waiting for clipboard ready: %w", err)
-	}
-	return nil
-}
-
-func copyForkCached(data []byte, mimeType string, pasteOnce bool) error {
-	cacheFile, err := createClipboardCacheFile()
-	if err != nil {
-		return fmt.Errorf("create cache file: %w", err)
-	}
-	cachePath := cacheFile.Name()
-
-	if _, err := cacheFile.Write(data); err != nil {
-		cacheFile.Close()
-		os.Remove(cachePath)
-		return fmt.Errorf("write cache file: %w", err)
-	}
-	if err := cacheFile.Close(); err != nil {
-		os.Remove(cachePath)
-		return fmt.Errorf("close cache file: %w", err)
-	}
-
-	cmd := newForkCmd(mimeType, pasteOnce, envCacheFile+"="+cachePath)
-	cmd.Stdin = nil
-	if err := waitReady(cmd); err != nil {
-		os.Remove(cachePath)
-		return err
-	}
-	return nil
-}
-
-func copyFork(data io.Reader, mimeType string, pasteOnce bool) error {
-	cmd := newForkCmd(mimeType, pasteOnce)
-
-	switch src := data.(type) {
-	case *os.File:
-		cmd.Stdin = src
-		return waitReady(cmd)
-
-	default:
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		return fmt.Errorf("stdin pipe: %w", err)
 	}
 
-		stdout, err := cmd.StdoutPipe()
-		if err != nil {
-			return fmt.Errorf("stdout pipe: %w", err)
-		}
-
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("start: %w", err)
 	}
-		if _, err := io.Copy(stdin, data); err != nil {
+
+	if _, err := stdin.Write(data); err != nil {
 		stdin.Close()
 		return fmt.Errorf("write stdin: %w", err)
 	}
-		if err := stdin.Close(); err != nil {
-			return fmt.Errorf("close stdin: %w", err)
-		}
+	stdin.Close()
 
-		var buf [1]byte
-		if _, err := stdout.Read(buf[:]); err != nil {
-			return fmt.Errorf("waiting for clipboard ready: %w", err)
-		}
 	return nil
 }
-}
 
-func signalReady() {
-	if os.Getenv(envServe) == "" {
-		return
-	}
-	os.Stdout.Write([]byte{1})
-}
-
-func createClipboardCacheFile() (*os.File, error) {
-	preferredDirs := []string{}
-
-	if cacheDir, err := os.UserCacheDir(); err == nil {
-		preferredDirs = append(preferredDirs, filepath.Join(cacheDir, "dms", "clipboard"))
-	}
-	preferredDirs = append(preferredDirs, "/var/tmp/dms/clipboard")
-
-	for _, dir := range preferredDirs {
-		if err := os.MkdirAll(dir, 0o700); err != nil {
-			continue
-		}
-		cachedData, err := os.CreateTemp(dir, "dms-clipboard-*")
-		if err == nil {
-			return cachedData, nil
-		}
-	}
-	return os.CreateTemp("", "dms-clipboard-*")
-}
-
-func serveClipboard(data []byte, mimeType string, pasteOnce bool) error {
+func copyServe(data []byte, mimeType string, pasteOnce bool) error {
 	display, err := wlclient.Connect("")
 	if err != nil {
 		return fmt.Errorf("wayland connect: %w", err)
@@ -236,10 +95,12 @@ func serveClipboard(data []byte, mimeType string, pasteOnce bool) error {
 	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")
 	}
@@ -280,10 +141,10 @@ func serveClipboard(data []byte, mimeType string, pasteOnce bool) error {
 	pasted := make(chan struct{}, 1)
 
 	source.SetSendHandler(func(e ext_data_control.ExtDataControlSourceV1SendEvent) {
-		_ = syscall.SetNonblock(e.Fd, false)
+		defer syscall.Close(e.Fd)
 		file := os.NewFile(uintptr(e.Fd), "pipe")
 		defer file.Close()
-		_, _ = file.Write(data)
+		file.Write(data)
 		select {
 		case pasted <- struct{}{}:
 		default:
@@ -299,7 +160,6 @@ func serveClipboard(data []byte, mimeType string, pasteOnce bool) error {
 	}
 
 	display.Roundtrip()
-	signalReady()
 
 	for {
 		select {
@@ -470,161 +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) {
-		_ = syscall.SetNonblock(e.Fd, false)
-		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"
@@ -15,7 +14,6 @@ import (
 type ClipboardChange struct {
 	Data     []byte
 	MimeType string
-	MimeTypes []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/colorpicker/picker.go

@@ -39,10 +39,11 @@ type LayerSurface struct {
 	wlSurface   *client.Surface
 	layerSurf   *wlr_layer_shell.ZwlrLayerSurfaceV1
 	viewport    *wp_viewporter.WpViewport
-	wlPools     [2]*client.ShmPool
-	wlBuffers   [2]*client.Buffer
-	slotBusy    [2]bool
-	needsRedraw bool
+	wlPool      *client.ShmPool
+	wlBuffer    *client.Buffer
+	bufferBusy  bool
+	oldPool     *client.ShmPool
+	oldBuffer   *client.Buffer
 	scopyBuffer *client.Buffer
 	configured  bool
 	hidden      bool
@@ -135,7 +136,6 @@ func (p *Picker) Run() (*Color, error) {
 			break
 		}
 
-		p.flushRedraws()
 		p.checkDone()
 	}
 
@@ -164,15 +164,6 @@ func (p *Picker) checkDone() {
 	}
 }
 
-func (p *Picker) flushRedraws() {
-	for _, ls := range p.surfaces {
-		if !ls.needsRedraw {
-			continue
-		}
-		p.redrawSurface(ls)
-	}
-}
-
 func (p *Picker) connect() error {
 	display, err := client.Connect("")
 	if err != nil {
@@ -516,45 +507,47 @@ func (p *Picker) captureForSurface(ls *LayerSurface) {
 }
 
 func (p *Picker) redrawSurface(ls *LayerSurface) {
-	slot := ls.state.FrontIndex()
-	if ls.slotBusy[slot] {
-		ls.needsRedraw = true
-		return
-	}
-
 	var renderBuf *ShmBuffer
-	switch {
-	case ls.hidden:
+	if ls.hidden {
 		renderBuf = ls.state.RedrawScreenOnly()
-	default:
+	} else {
 		renderBuf = ls.state.Redraw()
 	}
 	if renderBuf == nil {
 		return
 	}
 
-	ls.needsRedraw = false
+	if ls.oldBuffer != nil {
+		ls.oldBuffer.Destroy()
+		ls.oldBuffer = nil
+	}
+	if ls.oldPool != nil {
+		ls.oldPool.Destroy()
+		ls.oldPool = nil
+	}
+
+	ls.oldPool = ls.wlPool
+	ls.oldBuffer = ls.wlBuffer
+	ls.wlPool = nil
+	ls.wlBuffer = nil
 
-	if ls.wlPools[slot] == nil {
 	pool, err := p.shm.CreatePool(renderBuf.Fd(), int32(renderBuf.Size()))
 	if err != nil {
 		return
 	}
-		ls.wlPools[slot] = pool
+	ls.wlPool = pool
 
 	wlBuffer, err := pool.CreateBuffer(0, int32(renderBuf.Width), int32(renderBuf.Height), int32(renderBuf.Stride), uint32(ls.state.ScreenFormat()))
 	if err != nil {
 		return
 	}
-		ls.wlBuffers[slot] = wlBuffer
+	ls.wlBuffer = wlBuffer
 
-		s := slot
+	lsRef := ls
 	wlBuffer.SetReleaseHandler(func(e client.BufferReleaseEvent) {
-			ls.slotBusy[s] = false
+		lsRef.bufferBusy = false
 	})
-	}
-
-	ls.slotBusy[slot] = true
+	ls.bufferBusy = true
 
 	logicalW, logicalH := ls.state.LogicalSize()
 	if logicalW == 0 || logicalH == 0 {
@@ -573,7 +566,7 @@ func (p *Picker) redrawSurface(ls *LayerSurface) {
 		}
 		_ = ls.wlSurface.SetBufferScale(bufferScale)
 	}
-	_ = ls.wlSurface.Attach(ls.wlBuffers[slot], 0, 0)
+	_ = ls.wlSurface.Attach(wlBuffer, 0, 0)
 	_ = ls.wlSurface.Damage(0, 0, int32(logicalW), int32(logicalH))
 	_ = ls.wlSurface.Commit()
 
@@ -641,7 +634,7 @@ func (p *Picker) setupPointerHandlers() {
 		}
 
 		p.activeSurface.state.OnPointerMotion(e.SurfaceX, e.SurfaceY)
-		p.activeSurface.needsRedraw = true
+		p.redrawSurface(p.activeSurface)
 	})
 
 	p.pointer.SetLeaveHandler(func(e client.PointerLeaveEvent) {
@@ -662,7 +655,7 @@ func (p *Picker) setupPointerHandlers() {
 			return
 		}
 		p.activeSurface.state.OnPointerMotion(e.SurfaceX, e.SurfaceY)
-		p.activeSurface.needsRedraw = true
+		p.redrawSurface(p.activeSurface)
 	})
 
 	p.pointer.SetButtonHandler(func(e client.PointerButtonEvent) {
@@ -686,13 +679,17 @@ func (p *Picker) cleanup() {
 		if ls.scopyBuffer != nil {
 			ls.scopyBuffer.Destroy()
 		}
-		for i := range ls.wlBuffers {
-			if ls.wlBuffers[i] != nil {
-				ls.wlBuffers[i].Destroy()
+		if ls.oldBuffer != nil {
+			ls.oldBuffer.Destroy()
 		}
-			if ls.wlPools[i] != nil {
-				ls.wlPools[i].Destroy()
+		if ls.oldPool != nil {
+			ls.oldPool.Destroy()
 		}
+		if ls.wlBuffer != nil {
+			ls.wlBuffer.Destroy()
+		}
+		if ls.wlPool != nil {
+			ls.wlPool.Destroy()
 		}
 		if ls.viewport != nil {
 			ls.viewport.Destroy()

core/internal/colorpicker/state.go

@@ -274,12 +274,6 @@ func (s *SurfaceState) FrontRenderBuffer() *ShmBuffer {
 	return s.renderBufs[s.front]
 }
 
-func (s *SurfaceState) FrontIndex() int {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.front
-}
-
 func (s *SurfaceState) SwapBuffers() {
 	s.mu.Lock()
 	s.front ^= 1

core/internal/config/deployer.go

@@ -62,31 +62,12 @@ func (cd *ConfigDeployer) DeployConfigurationsSelectiveWithReinstalls(ctx contex
 func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm deps.WindowManager, terminal deps.Terminal, installedDeps []deps.Dependency, replaceConfigs map[string]bool, reinstallItems map[string]bool, useSystemd bool) ([]DeploymentResult, error) {
 	var results []DeploymentResult
 
-	// Primary config file paths used to detect fresh installs.
-	configPrimaryPaths := map[string]string{
-		"Niri":      filepath.Join(os.Getenv("HOME"), ".config", "niri", "config.kdl"),
-		"Hyprland":  filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.conf"),
-		"Ghostty":   filepath.Join(os.Getenv("HOME"), ".config", "ghostty", "config"),
-		"Kitty":     filepath.Join(os.Getenv("HOME"), ".config", "kitty", "kitty.conf"),
-		"Alacritty": filepath.Join(os.Getenv("HOME"), ".config", "alacritty", "alacritty.toml"),
-	}
-
 	shouldReplaceConfig := func(configType string) bool {
 		if replaceConfigs == nil {
 			return true
 		}
 		replace, exists := replaceConfigs[configType]
-		if !exists || replace {
-			return true
-		}
-		// Config is explicitly set to "don't replace" — but still deploy
-		// if the config file doesn't exist yet (fresh install scenario).
-		if primaryPath, ok := configPrimaryPaths[configType]; ok {
-			if _, err := os.Stat(primaryPath); os.IsNotExist(err) {
-				return true
-			}
-		}
-		return false
+		return !exists || replace
 	}
 
 	switch wm {
@@ -145,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
 	}
@@ -169,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
 		}
@@ -204,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
 	}
@@ -230,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))
@@ -258,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
 	}
@@ -274,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
 	}
@@ -296,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
 	}
@@ -322,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
 	}
@@ -338,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
 	}
@@ -359,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
 	}
@@ -373,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
 	}
@@ -394,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
 	}
@@ -410,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
 	}
@@ -431,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
 	}
@@ -458,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")
@@ -499,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
 	}
@@ -523,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
 		}
@@ -558,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
 	}
@@ -583,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))
@@ -617,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")
@@ -663,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")
@@ -678,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",
@@ -696,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

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"context"
 	"os"
 	"path/filepath"
 	"testing"
@@ -221,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()
@@ -423,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)
@@ -601,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()
@@ -625,168 +624,3 @@ func TestAlacrittyConfigDeployment(t *testing.T) {
 		assert.Contains(t, string(newContent), "decorations = \"None\"")
 	})
 }
-
-func TestShouldReplaceConfigDeployIfMissing(t *testing.T) {
-	allFalse := map[string]bool{
-		"Niri":      false,
-		"Hyprland":  false,
-		"Ghostty":   false,
-		"Kitty":     false,
-		"Alacritty": false,
-	}
-
-	t.Run("replaceConfigs nil deploys config", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "dankinstall-replace-nil-test")
-		require.NoError(t, err)
-		defer os.RemoveAll(tempDir)
-
-		originalHome := os.Getenv("HOME")
-		os.Setenv("HOME", tempDir)
-		defer os.Setenv("HOME", originalHome)
-
-		logChan := make(chan string, 100)
-		cd := NewConfigDeployer(logChan)
-
-		results, err := cd.DeployConfigurationsSelectiveWithReinstalls(
-			context.Background(),
-			deps.WindowManagerNiri,
-			deps.TerminalGhostty,
-			nil, // installedDeps
-			nil, // replaceConfigs
-			nil, // reinstallItems
-		)
-		require.NoError(t, err)
-
-		// With replaceConfigs=nil, all configs should be deployed
-		hasDeployed := false
-		for _, r := range results {
-			if r.Deployed {
-				hasDeployed = true
-				break
-			}
-		}
-		assert.True(t, hasDeployed, "expected at least one config to be deployed when replaceConfigs is nil")
-	})
-
-	t.Run("replaceConfigs all false and config missing deploys config", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "dankinstall-replace-missing-test")
-		require.NoError(t, err)
-		defer os.RemoveAll(tempDir)
-
-		originalHome := os.Getenv("HOME")
-		os.Setenv("HOME", tempDir)
-		defer os.Setenv("HOME", originalHome)
-
-		logChan := make(chan string, 100)
-		cd := NewConfigDeployer(logChan)
-
-		results, err := cd.DeployConfigurationsSelectiveWithReinstalls(
-			context.Background(),
-			deps.WindowManagerNiri,
-			deps.TerminalGhostty,
-			nil,      // installedDeps
-			allFalse, // replaceConfigs — all false
-			nil,      // reinstallItems
-		)
-		require.NoError(t, err)
-
-		// Config files don't exist on disk, so they should still be deployed
-		hasDeployed := false
-		for _, r := range results {
-			if r.Deployed {
-				hasDeployed = true
-				break
-			}
-		}
-		assert.True(t, hasDeployed, "expected configs to be deployed when files are missing, even with replaceConfigs all false")
-	})
-
-	t.Run("replaceConfigs false and config exists skips config", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "dankinstall-replace-exists-test")
-		require.NoError(t, err)
-		defer os.RemoveAll(tempDir)
-
-		originalHome := os.Getenv("HOME")
-		os.Setenv("HOME", tempDir)
-		defer os.Setenv("HOME", originalHome)
-
-		// Create the Ghostty primary config file so shouldReplaceConfig returns false
-		ghosttyPath := filepath.Join(tempDir, ".config", "ghostty", "config")
-		err = os.MkdirAll(filepath.Dir(ghosttyPath), 0o755)
-		require.NoError(t, err)
-		err = os.WriteFile(ghosttyPath, []byte("# existing ghostty config\n"), 0o644)
-		require.NoError(t, err)
-
-		// Also create the Niri primary config file
-		niriPath := filepath.Join(tempDir, ".config", "niri", "config.kdl")
-		err = os.MkdirAll(filepath.Dir(niriPath), 0o755)
-		require.NoError(t, err)
-		err = os.WriteFile(niriPath, []byte("// existing niri config\n"), 0o644)
-		require.NoError(t, err)
-
-		logChan := make(chan string, 100)
-		cd := NewConfigDeployer(logChan)
-
-		results, err := cd.DeployConfigurationsSelectiveWithReinstalls(
-			context.Background(),
-			deps.WindowManagerNiri,
-			deps.TerminalGhostty,
-			nil,      // installedDeps
-			allFalse, // replaceConfigs — all false
-			nil,      // reinstallItems
-		)
-		require.NoError(t, err)
-
-		// Both Niri and Ghostty config files exist, so with all false they should be skipped
-		for _, r := range results {
-			assert.Fail(t, "expected no configs to be deployed", "got deployed config: %s", r.ConfigType)
-		}
-	})
-
-	t.Run("replaceConfigs true and config exists deploys config", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "dankinstall-replace-true-test")
-		require.NoError(t, err)
-		defer os.RemoveAll(tempDir)
-
-		originalHome := os.Getenv("HOME")
-		os.Setenv("HOME", tempDir)
-		defer os.Setenv("HOME", originalHome)
-
-		// Create the Ghostty primary config file
-		ghosttyPath := filepath.Join(tempDir, ".config", "ghostty", "config")
-		err = os.MkdirAll(filepath.Dir(ghosttyPath), 0o755)
-		require.NoError(t, err)
-		err = os.WriteFile(ghosttyPath, []byte("# existing ghostty config\n"), 0o644)
-		require.NoError(t, err)
-
-		logChan := make(chan string, 100)
-		cd := NewConfigDeployer(logChan)
-
-		replaceConfigs := map[string]bool{
-			"Niri":      false,
-			"Hyprland":  false,
-			"Ghostty":   true, // explicitly true
-			"Kitty":     false,
-			"Alacritty": false,
-		}
-
-		results, err := cd.DeployConfigurationsSelectiveWithReinstalls(
-			context.Background(),
-			deps.WindowManagerNiri,
-			deps.TerminalGhostty,
-			nil,            // installedDeps
-			replaceConfigs, // Ghostty=true, rest=false
-			nil,            // reinstallItems
-		)
-		require.NoError(t, err)
-
-		// Ghostty should be deployed because replaceConfigs["Ghostty"]=true
-		foundGhostty := false
-		for _, r := range results {
-			if r.ConfigType == "Ghostty" && r.Deployed {
-				foundGhostty = true
-			}
-		}
-		assert.True(t, foundGhostty, "expected Ghostty config to be deployed when replaceConfigs is true")
-	})
-}

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
@@ -137,7 +131,7 @@ bind = SUPER, bracketright, layoutmsg, preselect r
 
 # === Sizing & Layout ===
 bind = SUPER, R, layoutmsg, togglesplit
-bind = SUPER CTRL, F, resizeactive, exact 100% 100%
+bind = SUPER CTRL, F, resizeactive, exact 100%
 
 # === Move/resize windows with mainMod + LMB/RMB and dragging ===
 bindmd = SUPER, mouse:272, Move window, movewindow

core/internal/config/embedded/hyprland.conf

@@ -81,6 +81,7 @@ master {
 misc {
     disable_hyprland_logo = true
     disable_splash_rendering = true
+    vrr = 1
 }
 
 # ==================
@@ -94,16 +95,13 @@ windowrule = tile on, match:class ^(gnome-control-center)$
 windowrule = tile on, match:class ^(pavucontrol)$
 windowrule = tile on, match:class ^(nm-connection-editor)$
 
-windowrule = float on, match:class ^(org\.gnome\.Calculator)$
 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)$
 
@@ -112,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

@@ -224,19 +224,14 @@ window-rule {
     open-floating false
 }
 window-rule {
-    match app-id=r#"^org\.gnome\.Calculator$"#
     match app-id=r#"^gnome-calculator$"#
     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"
@@ -253,7 +248,6 @@ window-rule {
 // Open dms windows as floating by default
 window-rule {
     match app-id=r#"org.quickshell$"#
-    match app-id=r#"com.danklinux.dms$"#
     open-floating true
 }
 debug {

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

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 func init() {
@@ -27,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)
 	})
@@ -45,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 {
@@ -98,7 +91,6 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 	dependencies = append(dependencies, a.detectGit())
 	dependencies = append(dependencies, a.detectWindowManager(wm))
 	dependencies = append(dependencies, a.detectQuickshell())
-	dependencies = append(dependencies, a.detectDMSGreeter())
 	dependencies = append(dependencies, a.detectXDGPortal())
 	dependencies = append(dependencies, a.detectAccountsService())
 
@@ -126,52 +118,12 @@ func (a *ArchDistribution) detectAccountsService() deps.Dependency {
 	return a.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", a.packageInstalled("accountsservice"))
 }
 
-func (a *ArchDistribution) detectDMSGreeter() deps.Dependency {
-	return a.detectOptionalPackage("dms-greeter", "DankMaterialShell greetd greeter", a.packageInstalled("greetd-dms-greeter-git"))
-}
-
 func (a *ArchDistribution) packageInstalled(pkg string) bool {
 	cmd := exec.Command("pacman", "-Q", pkg)
 	err := cmd.Run()
 	return err == nil
 }
 
-// parseSRCINFODeps reads a .SRCINFO file and returns runtime dep and makedep package
-func parseSRCINFODeps(srcinfoPath string) (deps []string, makedeps []string, err error) {
-	data, err := os.ReadFile(srcinfoPath)
-	if err != nil {
-		return nil, nil, err
-	}
-	for _, line := range strings.Split(string(data), "\n") {
-		line = strings.TrimSpace(line)
-		var pkg string
-		var target *[]string
-		switch {
-		case strings.HasPrefix(line, "makedepends = "):
-			pkg = strings.TrimPrefix(line, "makedepends = ")
-			target = &makedeps
-		case strings.HasPrefix(line, "depends = "):
-			pkg = strings.TrimPrefix(line, "depends = ")
-			target = &deps
-		default:
-			continue
-		}
-		// Strip version constraint (>=, <=, >, <, =) and colon-descriptions
-		if idx := strings.IndexAny(pkg, "><:="); idx >= 0 {
-			pkg = pkg[:idx]
-		}
-		pkg = strings.TrimSpace(pkg)
-		if pkg != "" {
-			*target = append(*target, pkg)
-		}
-	}
-	return deps, makedeps, nil
-}
-
-func (a *ArchDistribution) isInSystemRepo(pkg string) bool {
-	return exec.Command("pacman", "-Si", pkg).Run() == nil
-}
-
 func (a *ArchDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
 	return a.GetPackageMappingWithVariants(wm, make(map[string]deps.PackageVariant))
 }
@@ -181,7 +133,6 @@ func (a *ArchDistribution) GetPackageMappingWithVariants(wm deps.WindowManager,
 		"dms (DankMaterialShell)": a.getDMSMapping(variants["dms (DankMaterialShell)"]),
 		"git":                     {Name: "git", Repository: RepoTypeSystem},
 		"quickshell":              a.getQuickshellMapping(variants["quickshell"]),
-		"dms-greeter":             {Name: "greetd-dms-greeter-git", Repository: RepoTypeAUR},
 		"matugen":                 a.getMatugenMapping(variants["matugen"]),
 		"dgop":                    {Name: "dgop", Repository: RepoTypeSystem},
 		"ghostty":                 {Name: "ghostty", Repository: RepoTypeSystem},
@@ -243,7 +194,11 @@ func (a *ArchDistribution) getDMSMapping(variant deps.PackageVariant) PackageMap
 		return PackageMapping{Name: "dms-shell-git", Repository: RepoTypeAUR}
 	}
 
-	return PackageMapping{Name: "dms-shell", Repository: RepoTypeSystem}
+	if a.packageInstalled("dms-shell-bin") {
+		return PackageMapping{Name: "dms-shell-bin", Repository: RepoTypeAUR}
+	}
+
+	return PackageMapping{Name: "dms-shell-bin", Repository: RepoTypeAUR}
 }
 
 func (a *ArchDistribution) detectXwaylandSatellite() deps.Dependency {
@@ -293,7 +248,7 @@ func (a *ArchDistribution) InstallPrerequisites(ctx context.Context, sudoPasswor
 		LogOutput:   "Installing base-devel development tools",
 	}
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, "pacman -S --needed --noconfirm base-devel")
+	cmd := ExecSudoCommand(ctx, sudoPassword, "pacman -S --needed --noconfirm base-devel")
 	if err := a.runWithProgress(cmd, progressChan, PhasePrerequisites, 0.08, 0.10); err != nil {
 		return fmt.Errorf("failed to install base-devel: %w", err)
 	}
@@ -325,13 +280,6 @@ func (a *ArchDistribution) InstallPackages(ctx context.Context, dependencies []d
 
 	systemPkgs, aurPkgs, manualPkgs, variantMap := a.categorizePackages(dependencies, wm, reinstallFlags, disabledFlags)
 
-	if slices.Contains(aurPkgs, "quickshell-git") && slices.Contains(systemPkgs, "dms-shell") {
-		if err := a.preinstallQuickshellGit(ctx, sudoPassword, progressChan); err != nil {
-			return fmt.Errorf("failed to preinstall quickshell-git: %w", err)
-		}
-		aurPkgs = slices.DeleteFunc(aurPkgs, func(p string) bool { return p == "quickshell-git" })
-	}
-
 	// Phase 3: System Packages
 	if len(systemPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
@@ -449,37 +397,6 @@ func (a *ArchDistribution) categorizePackages(dependencies []deps.Dependency, wm
 	return systemPkgs, aurPkgs, manualPkgs, variantMap
 }
 
-func (a *ArchDistribution) preinstallQuickshellGit(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	if a.packageInstalled("quickshell-git") {
-		return nil
-	}
-
-	if a.packageInstalled("quickshell") {
-		progressChan <- InstallProgressMsg{
-			Phase:       PhaseAURPackages,
-			Progress:    0.15,
-			Step:        "Removing stable quickshell...",
-			IsComplete:  false,
-			NeedsSudo:   true,
-			CommandInfo: "sudo pacman -Rdd --noconfirm quickshell",
-			LogOutput:   "Removing stable quickshell so quickshell-git can be installed",
-		}
-		cmd := privesc.ExecCommand(ctx, sudoPassword, "pacman -Rdd --noconfirm quickshell")
-		if err := a.runWithProgress(cmd, progressChan, PhaseAURPackages, 0.15, 0.18); err != nil {
-			return fmt.Errorf("failed to remove stable quickshell: %w", err)
-		}
-	}
-
-	progressChan <- InstallProgressMsg{
-		Phase:       PhaseAURPackages,
-		Progress:    0.18,
-		Step:        "Building quickshell-git before system packages...",
-		IsComplete:  false,
-		CommandInfo: "Installing quickshell-git ahead of dms-shell to avoid conflict",
-	}
-	return a.installSingleAURPackage(ctx, "quickshell-git", sudoPassword, progressChan, 0.18, 0.32)
-}
-
 func (a *ArchDistribution) installSystemPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	if len(packages) == 0 {
 		return nil
@@ -488,9 +405,6 @@ func (a *ArchDistribution) installSystemPackages(ctx context.Context, packages [
 	a.log(fmt.Sprintf("Installing system packages: %s", strings.Join(packages, ", ")))
 
 	args := []string{"pacman", "-S", "--needed", "--noconfirm"}
-	if slices.Contains(packages, "dms-shell") {
-		args = append(args, "--assume-installed", "dms-shell-compositor=1")
-	}
 	args = append(args, packages...)
 
 	progressChan <- InstallProgressMsg{
@@ -502,7 +416,7 @@ func (a *ArchDistribution) installSystemPackages(ctx context.Context, packages [
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	return a.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60)
 }
 
@@ -514,10 +428,29 @@ func (a *ArchDistribution) installAURPackages(ctx context.Context, packages []st
 	a.log(fmt.Sprintf("Installing AUR packages manually: %s", strings.Join(packages, ", ")))
 
 	hasNiri := false
+	hasQuickshell := false
 	for _, pkg := range packages {
 		if pkg == "niri-git" {
 			hasNiri = true
 		}
+		if pkg == "quickshell" || pkg == "quickshell-git" {
+			hasQuickshell = true
+		}
+	}
+
+	// If quickshell is in the list, always reinstall google-breakpad first
+	if hasQuickshell {
+		progressChan <- InstallProgressMsg{
+			Phase:       PhaseAURPackages,
+			Progress:    0.63,
+			Step:        "Reinstalling google-breakpad for quickshell...",
+			IsComplete:  false,
+			CommandInfo: "Reinstalling prerequisite AUR package for quickshell",
+		}
+
+		if err := a.installSingleAURPackage(ctx, "google-breakpad", sudoPassword, progressChan, 0.63, 0.65); err != nil {
+			return fmt.Errorf("failed to reinstall google-breakpad prerequisite for quickshell: %w", err)
+		}
 	}
 
 	// If niri is in the list, install makepkg-git-lfs-proto first if not already installed
@@ -578,7 +511,7 @@ func (a *ArchDistribution) reorderAURPackages(packages []string) []string {
 	var dmsShell []string
 
 	for _, pkg := range packages {
-		if pkg == "dms-shell-git" {
+		if pkg == "dms-shell-git" || pkg == "dms-shell-bin" {
 			dmsShell = append(dmsShell, pkg)
 		} else {
 			isDep := false
@@ -598,16 +531,6 @@ func (a *ArchDistribution) reorderAURPackages(packages []string) []string {
 }
 
 func (a *ArchDistribution) installSingleAURPackage(ctx context.Context, pkg, sudoPassword string, progressChan chan<- InstallProgressMsg, startProgress, endProgress float64) error {
-	return a.installSingleAURPackageInternal(ctx, pkg, sudoPassword, progressChan, startProgress, endProgress, make(map[string]bool))
-}
-
-func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context, pkg, sudoPassword string, progressChan chan<- InstallProgressMsg, startProgress, endProgress float64, visited map[string]bool) error {
-	if visited[pkg] {
-		a.log(fmt.Sprintf("Skipping %s (already being installed, cycle detected)", pkg))
-		return nil
-	}
-	visited[pkg] = true
-
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return fmt.Errorf("failed to get user home directory: %w", err)
@@ -659,7 +582,7 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 		}
 	}
 
-	if pkg == "dms-shell-git" {
+	if pkg == "dms-shell-git" || pkg == "dms-shell-bin" {
 		srcinfoPath := filepath.Join(packageDir, ".SRCINFO")
 		depsToRemove := []string{
 			"depends = quickshell",
@@ -681,66 +604,54 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 		return fmt.Errorf("failed to remove optdepends from .SRCINFO for %s: %w", pkg, err)
 	}
 
-	srcinfoPath = filepath.Join(packageDir, ".SRCINFO")
-	{
+	// Skip dependency installation for dms-shell-git and dms-shell-bin
+	// since we manually manage those dependencies
+	if pkg != "dms-shell-git" && pkg != "dms-shell-bin" {
+		// Pre-install dependencies from .SRCINFO
 		progressChan <- InstallProgressMsg{
 			Phase:       PhaseAURPackages,
 			Progress:    startProgress + 0.3*(endProgress-startProgress),
-			Step:        fmt.Sprintf("Resolving dependencies for %s...", pkg),
+			Step:        fmt.Sprintf("Installing dependencies for %s...", pkg),
 			IsComplete:  false,
-			CommandInfo: "Classifying dependencies as system or AUR",
+			CommandInfo: "Installing package dependencies and makedepends",
 		}
 
-		runtimeDeps, makeDeps, err := parseSRCINFODeps(srcinfoPath)
-		if err != nil {
-			return fmt.Errorf("failed to parse .SRCINFO for %s: %w", pkg, err)
+		// Install dependencies and makedepends explicitly
+		srcinfoPath = filepath.Join(packageDir, ".SRCINFO")
+
+		depsCmd := exec.CommandContext(ctx, "bash", "-c",
+			fmt.Sprintf(`
+				deps=$(grep "depends = " "%s" | grep -v "makedepends" | sed 's/.*depends = //' | tr '\n' ' ' | sed 's/[[:space:]]*$//')
+				if [[ "%s" == *"quickshell"* ]]; then
+					deps=$(echo "$deps" | sed 's/google-breakpad//g' | sed 's/  / /g' | sed 's/^ *//g' | sed 's/ *$//g')
+				fi
+				if [ ! -z "$deps" ] && [ "$deps" != " " ]; then
+					echo '%s' | sudo -S pacman -S --needed --noconfirm $deps
+				fi
+			`, srcinfoPath, pkg, sudoPassword))
+
+		if err := a.runWithProgress(depsCmd, progressChan, PhaseAURPackages, startProgress+0.3*(endProgress-startProgress), startProgress+0.35*(endProgress-startProgress)); err != nil {
+			return fmt.Errorf("FAILED to install runtime dependencies for %s: %w", pkg, err)
 		}
 
-		seen := make(map[string]bool)
-		var systemPkgs []string
-		var aurPkgs []string
+		makedepsCmd := exec.CommandContext(ctx, "bash", "-c",
+			fmt.Sprintf(`
+				makedeps=$(grep -E "^[[:space:]]*makedepends = " "%s" | sed 's/^[[:space:]]*makedepends = //' | tr '\n' ' ')
+				if [ ! -z "$makedeps" ]; then
+					echo '%s' | sudo -S pacman -S --needed --noconfirm $makedeps
+				fi
+			`, srcinfoPath, sudoPassword))
 
-		for _, dep := range append(runtimeDeps, makeDeps...) {
-			if seen[dep] || a.packageInstalled(dep) {
-				continue
+		if err := a.runWithProgress(makedepsCmd, progressChan, PhaseAURPackages, startProgress+0.35*(endProgress-startProgress), startProgress+0.4*(endProgress-startProgress)); err != nil {
+			return fmt.Errorf("FAILED to install make dependencies for %s: %w", pkg, err)
 		}
-			seen[dep] = true
-			if a.isInSystemRepo(dep) {
-				systemPkgs = append(systemPkgs, dep)
 	} else {
-				aurPkgs = append(aurPkgs, dep)
-			}
-		}
-
-		if len(systemPkgs) > 0 {
-			progressChan <- InstallProgressMsg{
-				Phase:       PhaseAURPackages,
-				Progress:    startProgress + 0.32*(endProgress-startProgress),
-				Step:        fmt.Sprintf("Installing %d system dependencies for %s...", len(systemPkgs), pkg),
-				IsComplete:  false,
-				CommandInfo: fmt.Sprintf("sudo pacman -S --needed --noconfirm %s", strings.Join(systemPkgs, " ")),
-			}
-			if err := a.installSystemPackages(ctx, systemPkgs, sudoPassword, progressChan); err != nil {
-				return fmt.Errorf("failed to install system dependencies for %s: %w", pkg, err)
-			}
-		}
-
-		for _, aurDep := range aurPkgs {
-			a.log(fmt.Sprintf("Dependency %s is AUR-only, building from source...", aurDep))
 		progressChan <- InstallProgressMsg{
 			Phase:      PhaseAURPackages,
 			Progress:   startProgress + 0.35*(endProgress-startProgress),
-				Step:        fmt.Sprintf("Installing AUR dependency %s for %s...", aurDep, pkg),
+			Step:       fmt.Sprintf("Skipping dependency installation for %s (manually managed)...", pkg),
 			IsComplete: false,
-				CommandInfo: fmt.Sprintf("Building AUR dependency: %s", aurDep),
-			}
-			if err := a.installSingleAURPackageInternal(ctx, aurDep, sudoPassword, progressChan,
-				startProgress+0.35*(endProgress-startProgress),
-				startProgress+0.39*(endProgress-startProgress),
-				visited,
-			); err != nil {
-				return fmt.Errorf("failed to install AUR dependency %s for %s: %w", aurDep, pkg, err)
-			}
+			LogOutput:  fmt.Sprintf("Dependencies for %s are installed separately", pkg),
 		}
 	}
 
@@ -754,7 +665,7 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 
 	buildCmd := exec.CommandContext(ctx, "makepkg", "--noconfirm")
 	buildCmd.Dir = packageDir
-	buildCmd.Env = append(os.Environ(), "PKGEXT=.pkg.tar")
+	buildCmd.Env = append(os.Environ(), "PKGEXT=.pkg.tar") // Disable compression for speed
 
 	if err := a.runWithProgress(buildCmd, progressChan, PhaseAURPackages, startProgress+0.4*(endProgress-startProgress), startProgress+0.7*(endProgress-startProgress)); err != nil {
 		return fmt.Errorf("failed to build %s: %w", pkg, err)
@@ -769,9 +680,42 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 		CommandInfo: "sudo pacman -U built-package",
 	}
 
+	// Find .pkg.tar* files - for split packages, install the base and any installed compositor variants
 	var files []string
+	if pkg == "dms-shell-git" || pkg == "dms-shell-bin" {
+		// For DMS split packages, install base package
+		pattern := filepath.Join(packageDir, fmt.Sprintf("%s-%s*.pkg.tar*", pkg, "*"))
+		matches, err := filepath.Glob(pattern)
+		if err == nil {
+			for _, match := range matches {
+				basename := filepath.Base(match)
+				// Always include base package
+				if !strings.Contains(basename, "hyprland") && !strings.Contains(basename, "niri") {
+					files = append(files, match)
+				}
+			}
+		}
+
+		// Also update compositor-specific packages if they're installed
+		if strings.HasSuffix(pkg, "-git") {
+			if a.packageInstalled("dms-shell-hyprland-git") {
+				hyprlandPattern := filepath.Join(packageDir, "dms-shell-hyprland-git-*.pkg.tar*")
+				if hyprlandMatches, err := filepath.Glob(hyprlandPattern); err == nil && len(hyprlandMatches) > 0 {
+					files = append(files, hyprlandMatches[0])
+				}
+			}
+			if a.packageInstalled("dms-shell-niri-git") {
+				niriPattern := filepath.Join(packageDir, "dms-shell-niri-git-*.pkg.tar*")
+				if niriMatches, err := filepath.Glob(niriPattern); err == nil && len(niriMatches) > 0 {
+					files = append(files, niriMatches[0])
+				}
+			}
+		}
+	} else {
+		// For other packages, install all built packages
 		matches, _ := filepath.Glob(filepath.Join(packageDir, "*.pkg.tar*"))
 		files = matches
+	}
 
 	if len(files) == 0 {
 		return fmt.Errorf("no package files found after building %s", pkg)
@@ -780,7 +724,7 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 	installArgs := []string{"pacman", "-U", "--noconfirm"}
 	installArgs = append(installArgs, files...)
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(installArgs, " "))
+	installCmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(installArgs, " "))
 
 	fileNames := make([]string, len(files))
 	for i, f := range files {

core/internal/distros/base.go

@@ -14,7 +14,6 @@ import (
 	"time"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/version"
 )
 
@@ -56,6 +55,27 @@ func (b *BaseDistribution) logError(message string, err error) {
 	b.log(errorMsg)
 }
 
+// escapeSingleQuotes escapes single quotes in a string for safe use in bash single-quoted strings.
+// It replaces each ' with '\” which closes the quote, adds an escaped quote, and reopens the quote.
+// This prevents shell injection and syntax errors when passwords contain single quotes or apostrophes.
+func escapeSingleQuotes(s string) string {
+	return strings.ReplaceAll(s, "'", "'\\''")
+}
+
+// MakeSudoCommand creates a command string that safely passes password to sudo.
+// This helper escapes special characters in the password to prevent shell injection
+// and syntax errors when passwords contain single quotes, apostrophes, or other special chars.
+func MakeSudoCommand(sudoPassword string, command string) string {
+	return fmt.Sprintf("echo '%s' | sudo -S %s", escapeSingleQuotes(sudoPassword), command)
+}
+
+// ExecSudoCommand creates an exec.Cmd that runs a command with sudo using the provided password.
+// The password is properly escaped to prevent shell injection and syntax errors.
+func ExecSudoCommand(ctx context.Context, sudoPassword string, command string) *exec.Cmd {
+	cmdStr := MakeSudoCommand(sudoPassword, command)
+	return exec.CommandContext(ctx, "bash", "-c", cmdStr)
+}
+
 func (b *BaseDistribution) detectCommand(name, description string) deps.Dependency {
 	status := deps.StatusMissing
 	if b.commandExists(name) {
@@ -82,19 +102,6 @@ func (b *BaseDistribution) detectPackage(name, description string, installed boo
 	}
 }
 
-func (b *BaseDistribution) detectOptionalPackage(name, description string, installed bool) deps.Dependency {
-	status := deps.StatusMissing
-	if installed {
-		status = deps.StatusInstalled
-	}
-	return deps.Dependency{
-		Name:        name,
-		Status:      status,
-		Description: description,
-		Required:    false,
-	}
-}
-
 func (b *BaseDistribution) detectGit() deps.Dependency {
 	return b.detectCommand("git", "Version control system")
 }
@@ -527,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)
 	}
 
@@ -548,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)
 	}
 
@@ -587,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)
 	}
 
@@ -598,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)
 	}
 
@@ -690,7 +697,7 @@ func (b *BaseDistribution) installDMSBinary(ctx context.Context, sudoPassword st
 	}
 
 	// Install to /usr/local/bin
-	installCmd := privesc.ExecCommand(ctx, sudoPassword,
+	installCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("cp %s /usr/local/bin/dms", binaryPath))
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install DMS binary: %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

@@ -4,10 +4,10 @@ import (
 	"context"
 	"fmt"
 	"os/exec"
+	"runtime"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 func init() {
@@ -61,7 +61,6 @@ func (d *DebianDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, d.detectGit())
 	dependencies = append(dependencies, d.detectWindowManager(wm))
 	dependencies = append(dependencies, d.detectQuickshell())
-	dependencies = append(dependencies, d.detectDMSGreeter())
 	dependencies = append(dependencies, d.detectXDGPortal())
 	dependencies = append(dependencies, d.detectAccountsService())
 
@@ -87,32 +86,10 @@ func (d *DebianDistribution) detectAccountsService() deps.Dependency {
 	return d.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", d.packageInstalled("accountsservice"))
 }
 
-func (d *DebianDistribution) detectDMSGreeter() deps.Dependency {
-	return d.detectOptionalPackage("dms-greeter", "DankMaterialShell greetd greeter", d.packageInstalled("dms-greeter"))
-}
-
 func (d *DebianDistribution) packageInstalled(pkg string) bool {
-	return debianPackageInstalledPrecisely(pkg)
-}
-
-func debianPackageInstalledPrecisely(pkg string) bool {
-	cmd := exec.Command("dpkg-query", "-W", "-f=${db:Status-Status}", pkg)
-	output, err := cmd.Output()
-	if err != nil {
-		return false
-	}
-	return strings.TrimSpace(string(output)) == "installed"
-}
-
-func debianRepoArchitecture(arch string) string {
-	switch arch {
-	case "amd64", "x86_64":
-		return "amd64"
-	case "arm64", "aarch64":
-		return "arm64"
-	default:
-		return arch
-	}
+	cmd := exec.Command("dpkg", "-l", pkg)
+	err := cmd.Run()
+	return err == nil
 }
 
 func (d *DebianDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
@@ -131,7 +108,6 @@ func (d *DebianDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		// DMS packages from OBS with variant support
 		"dms (DankMaterialShell)": d.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"quickshell":              d.getQuickshellMapping(variants["quickshell"]),
-		"dms-greeter":             {Name: "dms-greeter", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"ghostty":                 {Name: "ghostty", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
@@ -183,7 +159,7 @@ func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 		LogOutput:  "Updating APT package lists",
 	}
 
-	updateCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get update")
+	updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
 	if err := d.runWithProgress(updateCmd, progressChan, PhasePrerequisites, 0.06, 0.07); err != nil {
 		return fmt.Errorf("failed to update package lists: %w", err)
 	}
@@ -200,7 +176,7 @@ func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 
 	checkCmd := exec.CommandContext(ctx, "dpkg", "-l", "build-essential")
 	if err := checkCmd.Run(); err != nil {
-		cmd := privesc.ExecCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y build-essential")
+		cmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y build-essential")
 		if err := d.runWithProgress(cmd, progressChan, PhasePrerequisites, 0.08, 0.09); err != nil {
 			return fmt.Errorf("failed to install build-essential: %w", err)
 		}
@@ -212,12 +188,12 @@ func (d *DebianDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 		Step:        "Installing development dependencies...",
 		IsComplete:  false,
 		NeedsSudo:   true,
-		CommandInfo: "sudo apt-get install -y curl wget git cmake ninja-build pkg-config gnupg libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev",
+		CommandInfo: "sudo apt-get install -y curl wget git cmake ninja-build pkg-config libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev",
 		LogOutput:   "Installing additional development tools",
 	}
 
-	devToolsCmd := privesc.ExecCommand(ctx, sudoPassword,
-		"DEBIAN_FRONTEND=noninteractive apt-get install -y curl wget git cmake ninja-build pkg-config gnupg libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev libjpeg-dev libpugixml-dev")
+	devToolsCmd := ExecSudoCommand(ctx, sudoPassword,
+		"DEBIAN_FRONTEND=noninteractive apt-get install -y curl wget git cmake ninja-build pkg-config libxcb-cursor-dev libglib2.0-dev libpolkit-agent-1-dev libjpeg-dev libpugixml-dev")
 	if err := d.runWithProgress(devToolsCmd, progressChan, PhasePrerequisites, 0.10, 0.12); err != nil {
 		return fmt.Errorf("failed to install development tools: %w", err)
 	}
@@ -397,14 +373,6 @@ func (d *DebianDistribution) extractPackageNames(packages []PackageMapping) []st
 	return names
 }
 
-func (d *DebianDistribution) aptInstallArgs(packages []string, minimal bool) []string {
-	args := []string{"DEBIAN_FRONTEND=noninteractive", "apt-get", "install", "-y"}
-	if minimal {
-		args = append(args, "--no-install-recommends")
-	}
-	return append(args, packages...)
-}
-
 func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []PackageMapping, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	enabledRepos := make(map[string]bool)
 
@@ -442,7 +410,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 			keyringPath := fmt.Sprintf("/etc/apt/keyrings/%s.gpg", repoName)
 
 			// Create keyrings directory if it doesn't exist
-			mkdirCmd := privesc.ExecCommand(ctx, sudoPassword, "mkdir -p /etc/apt/keyrings")
+			mkdirCmd := ExecSudoCommand(ctx, sudoPassword, "mkdir -p /etc/apt/keyrings")
 			if err := mkdirCmd.Run(); err != nil {
 				d.log(fmt.Sprintf("Warning: failed to create keyrings directory: %v", err))
 			}
@@ -456,13 +424,13 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 			}
 
 			keyCmd := fmt.Sprintf("bash -c 'rm -f %s && curl -fsSL %s/Release.key | gpg --batch --dearmor -o %s'", keyringPath, baseURL, keyringPath)
-			cmd := privesc.ExecCommand(ctx, sudoPassword, keyCmd)
+			cmd := ExecSudoCommand(ctx, sudoPassword, keyCmd)
 			if err := d.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.18, 0.20); err != nil {
 				return fmt.Errorf("failed to add OBS GPG key for %s: %w", pkg.RepoURL, err)
 			}
 
 			// Add repository
-			repoLine := fmt.Sprintf("deb [signed-by=%s arch=%s] %s/ /", keyringPath, debianRepoArchitecture(osInfo.Architecture), baseURL)
+			repoLine := fmt.Sprintf("deb [signed-by=%s, arch=%s] %s/ /", keyringPath, runtime.GOARCH, baseURL)
 
 			progressChan <- InstallProgressMsg{
 				Phase:       PhaseSystemPackages,
@@ -472,7 +440,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 				CommandInfo: fmt.Sprintf("echo '%s' | sudo tee %s", repoLine, listFile),
 			}
 
-			addRepoCmd := privesc.ExecCommand(ctx, sudoPassword,
+			addRepoCmd := ExecSudoCommand(ctx, sudoPassword,
 				fmt.Sprintf("bash -c \"echo '%s' | tee %s\"", repoLine, listFile))
 			if err := d.runWithProgress(addRepoCmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
 				return fmt.Errorf("failed to add OBS repo %s: %w", pkg.RepoURL, err)
@@ -492,7 +460,7 @@ func (d *DebianDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Packa
 			CommandInfo: "sudo apt-get update",
 		}
 
-		updateCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get update")
+		updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
 		if err := d.runWithProgress(updateCmd, progressChan, PhaseSystemPackages, 0.25, 0.27); err != nil {
 			return fmt.Errorf("failed to update package lists after adding OBS repos: %w", err)
 		}
@@ -508,46 +476,20 @@ func (d *DebianDistribution) installAPTPackages(ctx context.Context, packages []
 
 	d.log(fmt.Sprintf("Installing APT packages: %s", strings.Join(packages, ", ")))
 
-	groups := orderedMinimalInstallGroups(packages)
-	totalGroups := len(groups)
+	args := []string{"DEBIAN_FRONTEND=noninteractive", "apt-get", "install", "-y"}
+	args = append(args, packages...)
 
-	groupIndex := 0
-	installGroup := func(groupPackages []string, minimal bool) error {
-		if len(groupPackages) == 0 {
-			return nil
-		}
-
-		groupIndex++
-		startProgress := 0.40
-		endProgress := 0.60
-		if totalGroups > 1 {
-			if groupIndex == 1 {
-				endProgress = 0.50
-			} else {
-				startProgress = 0.50
-			}
-		}
-
-		args := d.aptInstallArgs(groupPackages, minimal)
 	progressChan <- InstallProgressMsg{
 		Phase:       PhaseSystemPackages,
-			Progress:    startProgress,
+		Progress:    0.40,
 		Step:        "Installing system packages...",
 		IsComplete:  false,
 		NeedsSudo:   true,
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-		cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
-		return d.runWithProgress(cmd, progressChan, PhaseSystemPackages, startProgress, endProgress)
-	}
-
-	for _, group := range groups {
-		if err := installGroup(group.packages, group.minimal); err != nil {
-			return err
-		}
-	}
-	return nil
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return d.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60)
 }
 
 func (d *DebianDistribution) installBuildDependencies(ctx context.Context, manualPkgs []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -626,7 +568,7 @@ func (d *DebianDistribution) installBuildDependencies(ctx context.Context, manua
 	args := []string{"apt-get", "install", "-y"}
 	args = append(args, depList...)
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	return d.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.80, 0.82)
 }
 
@@ -644,7 +586,7 @@ func (d *DebianDistribution) installRust(ctx context.Context, sudoPassword strin
 		CommandInfo: "sudo apt-get install rustup",
 	}
 
-	rustupInstallCmd := privesc.ExecCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y rustup")
+	rustupInstallCmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y rustup")
 	if err := d.runWithProgress(rustupInstallCmd, progressChan, PhaseSystemPackages, 0.82, 0.83); err != nil {
 		return fmt.Errorf("failed to install rustup: %w", err)
 	}
@@ -683,7 +625,7 @@ func (d *DebianDistribution) installGo(ctx context.Context, sudoPassword string,
 		CommandInfo: "sudo apt-get install golang-go",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y golang-go")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "DEBIAN_FRONTEND=noninteractive apt-get install -y golang-go")
 	return d.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.87, 0.90)
 }
 

core/internal/distros/fedora.go

@@ -7,16 +7,12 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 func init() {
 	Register("fedora", "#0B57A4", FamilyFedora, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewFedoraDistribution(config, logChan)
 	})
-	Register("evernight", "#72B8DC", FamilyFedora, func(config DistroConfig, logChan chan<- string) Distribution {
-		return NewFedoraDistribution(config, logChan)
-	})
 	Register("nobara", "#0B57A4", FamilyFedora, func(config DistroConfig, logChan chan<- string) Distribution {
 		return NewFedoraDistribution(config, logChan)
 	})
@@ -79,7 +75,6 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, f.detectGit())
 	dependencies = append(dependencies, f.detectWindowManager(wm))
 	dependencies = append(dependencies, f.detectQuickshell())
-	dependencies = append(dependencies, f.detectDMSGreeter())
 	dependencies = append(dependencies, f.detectXDGPortal())
 	dependencies = append(dependencies, f.detectAccountsService())
 
@@ -125,7 +120,6 @@ func (f *FedoraDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 
 		// COPR packages
 		"quickshell":              f.getQuickshellMapping(variants["quickshell"]),
-		"dms-greeter":             {Name: "dms-greeter", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
 		"matugen":                 {Name: "matugen", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
 		"dms (DankMaterialShell)": f.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"dgop":                    {Name: "dgop", Repository: RepoTypeCOPR, RepoURL: "avengemedia/danklinux"},
@@ -197,10 +191,6 @@ func (f *FedoraDistribution) detectAccountsService() deps.Dependency {
 	}
 }
 
-func (f *FedoraDistribution) detectDMSGreeter() deps.Dependency {
-	return f.detectOptionalPackage("dms-greeter", "DankMaterialShell greetd greeter", f.packageInstalled("dms-greeter"))
-}
-
 func (f *FedoraDistribution) getPrerequisites() []string {
 	return []string{
 		"dnf-plugins-core",
@@ -255,7 +245,7 @@ func (f *FedoraDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 
 	args := []string{"dnf", "install", "-y"}
 	args = append(args, missingPkgs...)
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		f.logError("failed to install prerequisites", err)
@@ -438,7 +428,7 @@ func (f *FedoraDistribution) enableCOPRRepos(ctx context.Context, coprPkgs []Pac
 				CommandInfo: fmt.Sprintf("sudo dnf copr enable -y %s", pkg.RepoURL),
 			}
 
-			cmd := privesc.ExecCommand(ctx, sudoPassword,
+			cmd := ExecSudoCommand(ctx, sudoPassword,
 				fmt.Sprintf("dnf copr enable -y %s 2>&1", pkg.RepoURL))
 			output, err := cmd.CombinedOutput()
 			if err != nil {
@@ -462,7 +452,7 @@ func (f *FedoraDistribution) enableCOPRRepos(ctx context.Context, coprPkgs []Pac
 					CommandInfo: fmt.Sprintf("echo \"priority=1\" | sudo tee -a %s", repoFile),
 				}
 
-				priorityCmd := privesc.ExecCommand(ctx, sudoPassword,
+				priorityCmd := ExecSudoCommand(ctx, sudoPassword,
 					fmt.Sprintf("bash -c 'echo \"priority=1\" | tee -a %s'", repoFile))
 				priorityOutput, err := priorityCmd.CombinedOutput()
 				if err != nil {
@@ -485,7 +475,28 @@ func (f *FedoraDistribution) installDNFPackages(ctx context.Context, packages []
 
 	f.log(fmt.Sprintf("Installing DNF packages: %s", strings.Join(packages, ", ")))
 
-	return f.installDNFGroups(ctx, packages, sudoPassword, progressChan, PhaseSystemPackages, "Installing system packages...", 0.40, 0.60)
+	args := []string{"dnf", "install", "-y"}
+
+	for _, pkg := range packages {
+		if pkg == "niri" || pkg == "niri-git" {
+			args = append(args, "--setopt=install_weak_deps=False")
+			break
+		}
+	}
+
+	args = append(args, packages...)
+
+	progressChan <- InstallProgressMsg{
+		Phase:       PhaseSystemPackages,
+		Progress:    0.40,
+		Step:        "Installing system packages...",
+		IsComplete:  false,
+		NeedsSudo:   true,
+		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
+	}
+
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return f.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60)
 }
 
 func (f *FedoraDistribution) installCOPRPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -495,57 +506,26 @@ func (f *FedoraDistribution) installCOPRPackages(ctx context.Context, packages [
 
 	f.log(fmt.Sprintf("Installing COPR packages: %s", strings.Join(packages, ", ")))
 
-	return f.installDNFGroups(ctx, packages, sudoPassword, progressChan, PhaseAURPackages, "Installing COPR packages...", 0.70, 0.85)
-}
-
-func (f *FedoraDistribution) dnfInstallArgs(packages []string, minimal bool) []string {
 	args := []string{"dnf", "install", "-y"}
-	if minimal {
+
+	for _, pkg := range packages {
+		if pkg == "niri" || pkg == "niri-git" {
 			args = append(args, "--setopt=install_weak_deps=False")
-	}
-	return append(args, packages...)
-}
-
-func (f *FedoraDistribution) installDNFGroups(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg, phase InstallPhase, step string, startProgress float64, endProgress float64) error {
-	groups := orderedMinimalInstallGroups(packages)
-	totalGroups := len(groups)
-
-	groupIndex := 0
-	installGroup := func(groupPackages []string, minimal bool) error {
-		if len(groupPackages) == 0 {
-			return nil
-		}
-
-		groupIndex++
-		groupStart := startProgress
-		groupEnd := endProgress
-		if totalGroups > 1 {
-			midpoint := startProgress + ((endProgress - startProgress) / 2)
-			if groupIndex == 1 {
-				groupEnd = midpoint
-			} else {
-				groupStart = midpoint
+			break
 		}
 	}
 
-		args := f.dnfInstallArgs(groupPackages, minimal)
+	args = append(args, packages...)
+
 	progressChan <- InstallProgressMsg{
-			Phase:       phase,
-			Progress:    groupStart,
-			Step:        step,
+		Phase:       PhaseAURPackages,
+		Progress:    0.70,
+		Step:        "Installing COPR packages...",
 		IsComplete:  false,
 		NeedsSudo:   true,
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-		cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
-		return f.runWithProgress(cmd, progressChan, phase, groupStart, groupEnd)
-	}
-
-	for _, group := range groups {
-		if err := installGroup(group.packages, group.minimal); err != nil {
-			return err
-		}
-	}
-	return nil
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return f.runWithProgress(cmd, progressChan, PhaseAURPackages, 0.70, 0.85)
 }

core/internal/distros/gentoo.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 var GentooGlobalUseFlags = []string{
@@ -202,9 +201,9 @@ func (g *GentooDistribution) setGlobalUseFlags(ctx context.Context, sudoPassword
 
 	var cmd *exec.Cmd
 	if hasUse {
-		cmd = privesc.ExecCommand(ctx, sudoPassword, fmt.Sprintf("sed -i 's/^USE=\"\\(.*\\)\"/USE=\"\\1 %s\"/' /etc/portage/make.conf", useFlags))
+		cmd = ExecSudoCommand(ctx, sudoPassword, fmt.Sprintf("sed -i 's/^USE=\"\\(.*\\)\"/USE=\"\\1 %s\"/' /etc/portage/make.conf", useFlags))
 	} else {
-		cmd = privesc.ExecCommand(ctx, sudoPassword, fmt.Sprintf("bash -c \"echo 'USE=\\\"%s\\\"' >> /etc/portage/make.conf\"", useFlags))
+		cmd = ExecSudoCommand(ctx, sudoPassword, fmt.Sprintf("bash -c \"echo 'USE=\\\"%s\\\"' >> /etc/portage/make.conf\"", useFlags))
 	}
 
 	output, err := cmd.CombinedOutput()
@@ -282,7 +281,7 @@ func (g *GentooDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 		LogOutput:   "Syncing Portage tree with emerge --sync",
 	}
 
-	syncCmd := privesc.ExecCommand(ctx, sudoPassword, "emerge --sync --quiet")
+	syncCmd := ExecSudoCommand(ctx, sudoPassword, "emerge --sync --quiet")
 	syncOutput, syncErr := syncCmd.CombinedOutput()
 	if syncErr != nil {
 		g.log(fmt.Sprintf("emerge --sync output: %s", string(syncOutput)))
@@ -303,7 +302,7 @@ func (g *GentooDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 
 	args := []string{"emerge", "--ask=n", "--quiet"}
 	args = append(args, missingPkgs...)
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		g.logError("failed to install prerequisites", err)
@@ -504,14 +503,14 @@ func (g *GentooDistribution) installPortagePackages(ctx context.Context, package
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	return g.runWithProgressTimeout(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60, 0)
 }
 
 func (g *GentooDistribution) setPackageUseFlags(ctx context.Context, packageName, useFlags, sudoPassword string) error {
 	packageUseDir := "/etc/portage/package.use"
 
-	mkdirCmd := privesc.ExecCommand(ctx, sudoPassword,
+	mkdirCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("mkdir -p %s", packageUseDir))
 	if output, err := mkdirCmd.CombinedOutput(); err != nil {
 		g.log(fmt.Sprintf("mkdir output: %s", string(output)))
@@ -525,7 +524,7 @@ func (g *GentooDistribution) setPackageUseFlags(ctx context.Context, packageName
 	if checkExistingCmd.Run() == nil {
 		g.log(fmt.Sprintf("Updating USE flags for %s from existing entry", packageName))
 		escapedPkg := strings.ReplaceAll(packageName, "/", "\\/")
-		replaceCmd := privesc.ExecCommand(ctx, sudoPassword,
+		replaceCmd := ExecSudoCommand(ctx, sudoPassword,
 			fmt.Sprintf("sed -i '/^%s /d' %s/danklinux; exit_code=$?; exit $exit_code", escapedPkg, packageUseDir))
 		if output, err := replaceCmd.CombinedOutput(); err != nil {
 			g.log(fmt.Sprintf("sed delete output: %s", string(output)))
@@ -533,7 +532,7 @@ func (g *GentooDistribution) setPackageUseFlags(ctx context.Context, packageName
 		}
 	}
 
-	appendCmd := privesc.ExecCommand(ctx, sudoPassword,
+	appendCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("bash -c \"echo '%s' >> %s/danklinux\"", useFlagLine, packageUseDir))
 
 	output, err := appendCmd.CombinedOutput()
@@ -558,7 +557,7 @@ func (g *GentooDistribution) syncGURURepo(ctx context.Context, sudoPassword stri
 	}
 
 	// Enable GURU repository
-	enableCmd := privesc.ExecCommand(ctx, sudoPassword,
+	enableCmd := ExecSudoCommand(ctx, sudoPassword,
 		"eselect repository enable guru 2>&1; exit_code=$?; exit $exit_code")
 	output, err := enableCmd.CombinedOutput()
 
@@ -590,7 +589,7 @@ func (g *GentooDistribution) syncGURURepo(ctx context.Context, sudoPassword stri
 		LogOutput:   "Syncing GURU repository",
 	}
 
-	syncCmd := privesc.ExecCommand(ctx, sudoPassword,
+	syncCmd := ExecSudoCommand(ctx, sudoPassword,
 		"emaint sync --repo guru 2>&1; exit_code=$?; exit $exit_code")
 	syncOutput, syncErr := syncCmd.CombinedOutput()
 
@@ -623,7 +622,7 @@ func (g *GentooDistribution) setPackageAcceptKeywords(ctx context.Context, packa
 
 	acceptKeywordsDir := "/etc/portage/package.accept_keywords"
 
-	mkdirCmd := privesc.ExecCommand(ctx, sudoPassword,
+	mkdirCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("mkdir -p %s", acceptKeywordsDir))
 	if output, err := mkdirCmd.CombinedOutput(); err != nil {
 		g.log(fmt.Sprintf("mkdir output: %s", string(output)))
@@ -637,7 +636,7 @@ func (g *GentooDistribution) setPackageAcceptKeywords(ctx context.Context, packa
 	if checkExistingCmd.Run() == nil {
 		g.log(fmt.Sprintf("Updating accept keywords for %s from existing entry", packageName))
 		escapedPkg := strings.ReplaceAll(packageName, "/", "\\/")
-		replaceCmd := privesc.ExecCommand(ctx, sudoPassword,
+		replaceCmd := ExecSudoCommand(ctx, sudoPassword,
 			fmt.Sprintf("sed -i '/^%s /d' %s/danklinux; exit_code=$?; exit $exit_code", escapedPkg, acceptKeywordsDir))
 		if output, err := replaceCmd.CombinedOutput(); err != nil {
 			g.log(fmt.Sprintf("sed delete output: %s", string(output)))
@@ -645,7 +644,7 @@ func (g *GentooDistribution) setPackageAcceptKeywords(ctx context.Context, packa
 		}
 	}
 
-	appendCmd := privesc.ExecCommand(ctx, sudoPassword,
+	appendCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("bash -c \"echo '%s' >> %s/danklinux\"", keywordLine, acceptKeywordsDir))
 
 	output, err := appendCmd.CombinedOutput()
@@ -696,6 +695,6 @@ func (g *GentooDistribution) installGURUPackages(ctx context.Context, packages [
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	return g.runWithProgressTimeout(cmd, progressChan, PhaseAURPackages, 0.70, 0.85, 0)
 }

core/internal/distros/interface.go

@@ -55,7 +55,6 @@ const (
 	PhaseAURPackages
 	PhaseCursorTheme
 	PhaseConfiguration
-	PhaseGreeterSetup
 	PhaseComplete
 )
 

core/internal/distros/manual_packages.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 // ManualPackageInstaller provides methods for installing packages from source
@@ -144,7 +143,7 @@ func (m *ManualPackageInstaller) installDgop(ctx context.Context, sudoPassword s
 		CommandInfo: "sudo make install",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "make install")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "make install")
 	installCmd.Dir = tmpDir
 	if err := installCmd.Run(); err != nil {
 		m.logError("failed to install dgop", err)
@@ -214,7 +213,7 @@ func (m *ManualPackageInstaller) installNiri(ctx context.Context, sudoPassword s
 		CommandInfo: "dpkg -i niri.deb",
 	}
 
-	installDebCmd := privesc.ExecCommand(ctx, sudoPassword,
+	installDebCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("dpkg -i %s/target/debian/niri_*.deb", buildDir))
 
 	output, err := installDebCmd.CombinedOutput()
@@ -325,7 +324,7 @@ func (m *ManualPackageInstaller) installQuickshell(ctx context.Context, variant
 		CommandInfo: "sudo cmake --install build",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "cmake --install build")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "cmake --install build")
 	installCmd.Dir = tmpDir
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install quickshell: %w", err)
@@ -388,7 +387,7 @@ func (m *ManualPackageInstaller) installHyprland(ctx context.Context, sudoPasswo
 		CommandInfo: "sudo make install",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "make install")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "make install")
 	installCmd.Dir = tmpDir
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install Hyprland: %w", err)
@@ -454,7 +453,7 @@ func (m *ManualPackageInstaller) installGhostty(ctx context.Context, sudoPasswor
 		CommandInfo: "sudo cp zig-out/bin/ghostty /usr/local/bin/",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword,
+	installCmd := ExecSudoCommand(ctx, sudoPassword,
 		fmt.Sprintf("cp %s/zig-out/bin/ghostty /usr/local/bin/", tmpDir))
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install Ghostty: %w", err)
@@ -493,11 +492,16 @@ func (m *ManualPackageInstaller) installMatugen(ctx context.Context, sudoPasswor
 		CommandInfo: fmt.Sprintf("sudo cp %s %s", sourcePath, targetPath),
 	}
 
-	if err := privesc.Run(ctx, sudoPassword, "cp", sourcePath, targetPath); err != nil {
+	copyCmd := exec.CommandContext(ctx, "sudo", "-S", "cp", sourcePath, targetPath)
+	copyCmd.Stdin = strings.NewReader(sudoPassword + "\n")
+	if err := copyCmd.Run(); err != nil {
 		return fmt.Errorf("failed to copy matugen to /usr/local/bin: %w", err)
 	}
 
-	if err := privesc.Run(ctx, sudoPassword, "chmod", "+x", targetPath); err != nil {
+	// Make it executable
+	chmodCmd := exec.CommandContext(ctx, "sudo", "-S", "chmod", "+x", targetPath)
+	chmodCmd.Stdin = strings.NewReader(sudoPassword + "\n")
+	if err := chmodCmd.Run(); err != nil {
 		return fmt.Errorf("failed to make matugen executable: %w", err)
 	}
 
@@ -642,11 +646,15 @@ func (m *ManualPackageInstaller) installXwaylandSatellite(ctx context.Context, s
 		CommandInfo: fmt.Sprintf("sudo cp %s %s", sourcePath, targetPath),
 	}
 
-	if err := privesc.Run(ctx, sudoPassword, "cp", sourcePath, targetPath); err != nil {
+	copyCmd := exec.CommandContext(ctx, "sudo", "-S", "cp", sourcePath, targetPath)
+	copyCmd.Stdin = strings.NewReader(sudoPassword + "\n")
+	if err := copyCmd.Run(); err != nil {
 		return fmt.Errorf("failed to copy xwayland-satellite to /usr/local/bin: %w", err)
 	}
 
-	if err := privesc.Run(ctx, sudoPassword, "chmod", "+x", targetPath); err != nil {
+	chmodCmd := exec.CommandContext(ctx, "sudo", "-S", "chmod", "+x", targetPath)
+	chmodCmd.Stdin = strings.NewReader(sudoPassword + "\n")
+	if err := chmodCmd.Run(); err != nil {
 		return fmt.Errorf("failed to make xwayland-satellite executable: %w", err)
 	}
 

core/internal/distros/minimal_install.go

@@ -1,44 +0,0 @@
-package distros
-
-type minimalInstallGroup struct {
-	packages []string
-	minimal  bool
-}
-
-func shouldPreferMinimalInstall(pkg string) bool {
-	switch pkg {
-	case "niri", "niri-git":
-		return true
-	default:
-		return false
-	}
-}
-
-func splitMinimalInstallPackages(packages []string) (normal []string, minimal []string) {
-	for _, pkg := range packages {
-		if shouldPreferMinimalInstall(pkg) {
-			minimal = append(minimal, pkg)
-			continue
-		}
-		normal = append(normal, pkg)
-	}
-	return normal, minimal
-}
-
-func orderedMinimalInstallGroups(packages []string) []minimalInstallGroup {
-	normal, minimal := splitMinimalInstallPackages(packages)
-	groups := make([]minimalInstallGroup, 0, 2)
-	if len(minimal) > 0 {
-		groups = append(groups, minimalInstallGroup{
-			packages: minimal,
-			minimal:  true,
-		})
-	}
-	if len(normal) > 0 {
-		groups = append(groups, minimalInstallGroup{
-			packages: normal,
-			minimal:  false,
-		})
-	}
-	return groups
-}

core/internal/distros/opensuse.go

@@ -6,11 +6,9 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"slices"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 func init() {
@@ -31,8 +29,6 @@ type OpenSUSEDistribution struct {
 	config DistroConfig
 }
 
-const openSUSENiriWaylandServerPackage = "libwayland-server0"
-
 func NewOpenSUSEDistribution(config DistroConfig, logChan chan<- string) *OpenSUSEDistribution {
 	base := NewBaseDistribution(logChan)
 	return &OpenSUSEDistribution{
@@ -75,7 +71,6 @@ func (o *OpenSUSEDistribution) DetectDependenciesWithTerminal(ctx context.Contex
 	dependencies = append(dependencies, o.detectGit())
 	dependencies = append(dependencies, o.detectWindowManager(wm))
 	dependencies = append(dependencies, o.detectQuickshell())
-	dependencies = append(dependencies, o.detectDMSGreeter())
 	dependencies = append(dependencies, o.detectXDGPortal())
 	dependencies = append(dependencies, o.detectAccountsService())
 
@@ -105,10 +100,6 @@ func (o *OpenSUSEDistribution) packageInstalled(pkg string) bool {
 	return err == nil
 }
 
-func (o *OpenSUSEDistribution) detectDMSGreeter() deps.Dependency {
-	return o.detectOptionalPackage("dms-greeter", "DankMaterialShell greetd greeter", o.packageInstalled("dms-greeter"))
-}
-
 func (o *OpenSUSEDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
 	return o.GetPackageMappingWithVariants(wm, make(map[string]deps.PackageVariant))
 }
@@ -125,7 +116,6 @@ func (o *OpenSUSEDistribution) GetPackageMappingWithVariants(wm deps.WindowManag
 		// DMS packages from OBS
 		"dms (DankMaterialShell)": o.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"quickshell":              o.getQuickshellMapping(variants["quickshell"]),
-		"dms-greeter":             {Name: "dms-greeter", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"ghostty":                 {Name: "ghostty", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"matugen":                 {Name: "matugen", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypeOBS, RepoURL: "home:AvengeMedia:danklinux"},
@@ -203,7 +193,35 @@ func (o *OpenSUSEDistribution) detectAccountsService() deps.Dependency {
 }
 
 func (o *OpenSUSEDistribution) getPrerequisites() []string {
-	return []string{}
+	return []string{
+		"make",
+		"unzip",
+		"gcc",
+		"gcc-c++",
+		"cmake",
+		"ninja",
+		"pkgconf-pkg-config",
+		"git",
+		"qt6-base-devel",
+		"qt6-declarative-devel",
+		"qt6-declarative-private-devel",
+		"qt6-shadertools",
+		"qt6-shadertools-devel",
+		"qt6-wayland-devel",
+		"qt6-waylandclient-private-devel",
+		"spirv-tools-devel",
+		"cli11-devel",
+		"wayland-protocols-devel",
+		"libgbm-devel",
+		"libdrm-devel",
+		"pipewire-devel",
+		"jemalloc-devel",
+		"wayland-utils",
+		"Mesa-libGLESv3-devel",
+		"pam-devel",
+		"glib2-devel",
+		"polkit-devel",
+	}
 }
 
 func (o *OpenSUSEDistribution) InstallPrerequisites(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -251,7 +269,7 @@ func (o *OpenSUSEDistribution) InstallPrerequisites(ctx context.Context, sudoPas
 
 	args := []string{"zypper", "install", "-y"}
 	args = append(args, missingPkgs...)
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		o.logError("failed to install prerequisites", err)
@@ -273,10 +291,6 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 		LogOutput:  "Starting prerequisite check...",
 	}
 
-	if err := o.disableInstallMediaRepos(ctx, sudoPassword, progressChan); err != nil {
-		return fmt.Errorf("failed to disable install media repositories: %w", err)
-	}
-
 	if err := o.InstallPrerequisites(ctx, sudoPassword, progressChan); err != nil {
 		return fmt.Errorf("failed to install prerequisites: %w", err)
 	}
@@ -307,7 +321,7 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 			NeedsSudo:  true,
 			LogOutput:  fmt.Sprintf("Installing system packages: %s", strings.Join(systemPkgs, ", ")),
 		}
-		if err := o.installZypperPackages(ctx, systemPkgs, sudoPassword, progressChan, PhaseSystemPackages, "Installing system packages...", 0.40, 0.60); err != nil {
+		if err := o.installZypperPackages(ctx, systemPkgs, sudoPassword, progressChan); err != nil {
 			return fmt.Errorf("failed to install zypper packages: %w", err)
 		}
 	}
@@ -322,7 +336,7 @@ func (o *OpenSUSEDistribution) InstallPackages(ctx context.Context, dependencies
 			IsComplete: false,
 			LogOutput:  fmt.Sprintf("Installing OBS packages: %s", strings.Join(obsPkgNames, ", ")),
 		}
-		if err := o.installZypperPackages(ctx, obsPkgNames, sudoPassword, progressChan, PhaseAURPackages, "Installing OBS packages...", 0.70, 0.85); err != nil {
+		if err := o.installZypperPackages(ctx, obsPkgNames, sudoPassword, progressChan); err != nil {
 			return fmt.Errorf("failed to install OBS packages: %w", err)
 		}
 	}
@@ -412,32 +426,9 @@ func (o *OpenSUSEDistribution) categorizePackages(dependencies []deps.Dependency
 		}
 	}
 
-	systemPkgs = o.appendMissingSystemPackages(systemPkgs, openSUSENiriRuntimePackages(wm, disabledFlags))
-
 	return systemPkgs, obsPkgs, manualPkgs, variantMap
 }
 
-func openSUSENiriRuntimePackages(wm deps.WindowManager, disabledFlags map[string]bool) []string {
-	if wm != deps.WindowManagerNiri || disabledFlags["niri"] {
-		return nil
-	}
-
-	return []string{openSUSENiriWaylandServerPackage}
-}
-
-func (o *OpenSUSEDistribution) appendMissingSystemPackages(systemPkgs []string, extraPkgs []string) []string {
-	for _, pkg := range extraPkgs {
-		if slices.Contains(systemPkgs, pkg) || o.packageInstalled(pkg) {
-			continue
-		}
-
-		o.log(fmt.Sprintf("Adding openSUSE runtime package: %s", pkg))
-		systemPkgs = append(systemPkgs, pkg)
-	}
-
-	return systemPkgs
-}
-
 func (o *OpenSUSEDistribution) extractPackageNames(packages []PackageMapping) []string {
 	names := make([]string, len(packages))
 	for i, pkg := range packages {
@@ -487,7 +478,7 @@ func (o *OpenSUSEDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Pac
 				CommandInfo: fmt.Sprintf("sudo zypper addrepo %s", repoURL),
 			}
 
-			cmd := privesc.ExecCommand(ctx, sudoPassword,
+			cmd := ExecSudoCommand(ctx, sudoPassword,
 				fmt.Sprintf("zypper addrepo -f %s", repoURL))
 			if err := o.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
 				o.log(fmt.Sprintf("OBS repo %s add failed (may already exist): %v", pkg.RepoURL, err))
@@ -508,7 +499,7 @@ func (o *OpenSUSEDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Pac
 			CommandInfo: "sudo zypper --gpg-auto-import-keys refresh",
 		}
 
-		refreshCmd := privesc.ExecCommand(ctx, sudoPassword, "zypper --gpg-auto-import-keys refresh")
+		refreshCmd := ExecSudoCommand(ctx, sudoPassword, "zypper --gpg-auto-import-keys refresh")
 		if err := o.runWithProgress(refreshCmd, progressChan, PhaseSystemPackages, 0.25, 0.27); err != nil {
 			return fmt.Errorf("failed to refresh repositories: %w", err)
 		}
@@ -517,146 +508,27 @@ func (o *OpenSUSEDistribution) enableOBSRepos(ctx context.Context, obsPkgs []Pac
 	return nil
 }
 
-func isOpenSUSEInstallMediaURI(uri string) bool {
-	normalizedURI := strings.ToLower(strings.TrimSpace(uri))
-
-	return strings.HasPrefix(normalizedURI, "cd:/") ||
-		strings.HasPrefix(normalizedURI, "dvd:/") ||
-		strings.HasPrefix(normalizedURI, "hd:/") ||
-		strings.HasPrefix(normalizedURI, "iso:/")
-}
-
-func parseZypperInstallMediaAliases(output string) []string {
-	var aliases []string
-
-	for _, line := range strings.Split(output, "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || !strings.Contains(line, "|") {
-			continue
-		}
-
-		parts := strings.Split(line, "|")
-		if len(parts) < 7 {
-			continue
-		}
-
-		for i := range parts {
-			parts[i] = strings.TrimSpace(parts[i])
-		}
-
-		alias := parts[1]
-		enabled := strings.ToLower(parts[3])
-		uri := parts[len(parts)-1]
-
-		if alias == "" || strings.EqualFold(alias, "alias") {
-			continue
-		}
-		if enabled != "" && enabled != "yes" {
-			continue
-		}
-		if !isOpenSUSEInstallMediaURI(uri) {
-			continue
-		}
-
-		aliases = append(aliases, alias)
-	}
-
-	return aliases
-}
-
-func (o *OpenSUSEDistribution) disableInstallMediaRepos(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
-	listCmd := exec.CommandContext(ctx, "zypper", "repos", "-u")
-	output, err := listCmd.CombinedOutput()
-	if err != nil {
-		o.log(fmt.Sprintf("Warning: failed to list zypper repositories: %s", strings.TrimSpace(string(output))))
-		return fmt.Errorf("failed to list zypper repositories: %w", err)
-	}
-
-	aliases := parseZypperInstallMediaAliases(string(output))
-	if len(aliases) == 0 {
-		return nil
-	}
-
-	o.log(fmt.Sprintf("Disabling install media repositories: %s", strings.Join(aliases, ", ")))
-	progressChan <- InstallProgressMsg{
-		Phase:       PhasePrerequisites,
-		Progress:    0.055,
-		Step:        "Disabling install media repositories...",
-		IsComplete:  false,
-		NeedsSudo:   true,
-		CommandInfo: fmt.Sprintf("sudo zypper modifyrepo -d %s", strings.Join(aliases, " ")),
-		LogOutput:   fmt.Sprintf("Disabling install media repositories: %s", strings.Join(aliases, ", ")),
-	}
-
-	for _, alias := range aliases {
-		cmd := privesc.ExecCommand(ctx, sudoPassword, fmt.Sprintf("zypper modifyrepo -d '%s'", privesc.EscapeSingleQuotes(alias)))
-		repoOutput, err := cmd.CombinedOutput()
-		if err != nil {
-			o.log(fmt.Sprintf("Failed to disable install media repo %s: %s", alias, strings.TrimSpace(string(repoOutput))))
-			return fmt.Errorf("failed to disable install media repo %s: %w", alias, err)
-		}
-		o.log(fmt.Sprintf("Disabled install media repo %s: %s", alias, strings.TrimSpace(string(repoOutput))))
-	}
-
-	return nil
-}
-
-func (o *OpenSUSEDistribution) zypperInstallArgs(packages []string, minimal bool) []string {
-	args := []string{"zypper", "install", "-y"}
-	if minimal {
-		args = append(args, "--no-recommends")
-	}
-	return append(args, packages...)
-}
-
-func (o *OpenSUSEDistribution) installZypperPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg, phase InstallPhase, step string, startProgress float64, endProgress float64) error {
+func (o *OpenSUSEDistribution) installZypperPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	if len(packages) == 0 {
 		return nil
 	}
 
 	o.log(fmt.Sprintf("Installing zypper packages: %s", strings.Join(packages, ", ")))
 
-	groups := orderedMinimalInstallGroups(packages)
-	totalGroups := len(groups)
+	args := []string{"zypper", "install", "-y"}
+	args = append(args, packages...)
 
-	groupIndex := 0
-	installGroup := func(groupPackages []string, minimal bool) error {
-		if len(groupPackages) == 0 {
-			return nil
-		}
-
-		groupIndex++
-		groupStart := startProgress
-		groupEnd := endProgress
-		if totalGroups > 1 {
-			midpoint := startProgress + ((endProgress - startProgress) / 2)
-			if groupIndex == 1 {
-				groupEnd = midpoint
-			} else {
-				groupStart = midpoint
-			}
-		}
-
-		args := o.zypperInstallArgs(groupPackages, minimal)
 	progressChan <- InstallProgressMsg{
-			Phase:       phase,
-			Progress:    groupStart,
-			Step:        step,
+		Phase:       PhaseSystemPackages,
+		Progress:    0.40,
+		Step:        "Installing system packages...",
 		IsComplete:  false,
 		NeedsSudo:   true,
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-		cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
-		return o.runWithProgress(cmd, progressChan, phase, groupStart, groupEnd)
-	}
-
-	for _, group := range groups {
-		if err := installGroup(group.packages, group.minimal); err != nil {
-			return err
-		}
-	}
-	return nil
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return o.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60)
 }
 
 func (o *OpenSUSEDistribution) installQuickshell(ctx context.Context, variant deps.PackageVariant, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -668,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)
@@ -704,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)
 	}
 
@@ -775,7 +647,7 @@ func (o *OpenSUSEDistribution) installQuickshell(ctx context.Context, variant de
 		CommandInfo: "sudo cmake --install build",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "cmake --install build")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "cmake --install build")
 	installCmd.Dir = tmpDir
 	if err := installCmd.Run(); err != nil {
 		return fmt.Errorf("failed to install quickshell: %w", err)
@@ -799,7 +671,7 @@ func (o *OpenSUSEDistribution) installRust(ctx context.Context, sudoPassword str
 		CommandInfo: "sudo zypper install rustup",
 	}
 
-	rustupInstallCmd := privesc.ExecCommand(ctx, sudoPassword, "zypper install -y rustup")
+	rustupInstallCmd := ExecSudoCommand(ctx, sudoPassword, "zypper install -y rustup")
 	if err := o.runWithProgress(rustupInstallCmd, progressChan, PhaseSystemPackages, 0.82, 0.83); err != nil {
 		return fmt.Errorf("failed to install rustup: %w", err)
 	}

core/internal/distros/ubuntu.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
 )
 
 func init() {
@@ -64,7 +63,6 @@ func (u *UbuntuDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 	dependencies = append(dependencies, u.detectGit())
 	dependencies = append(dependencies, u.detectWindowManager(wm))
 	dependencies = append(dependencies, u.detectQuickshell())
-	dependencies = append(dependencies, u.detectDMSGreeter())
 	dependencies = append(dependencies, u.detectXDGPortal())
 	dependencies = append(dependencies, u.detectAccountsService())
 
@@ -96,12 +94,10 @@ func (u *UbuntuDistribution) detectAccountsService() deps.Dependency {
 	return u.detectPackage("accountsservice", "D-Bus interface for user account query and manipulation", u.packageInstalled("accountsservice"))
 }
 
-func (u *UbuntuDistribution) detectDMSGreeter() deps.Dependency {
-	return u.detectOptionalPackage("dms-greeter", "DankMaterialShell greetd greeter", u.packageInstalled("dms-greeter"))
-}
-
 func (u *UbuntuDistribution) packageInstalled(pkg string) bool {
-	return debianPackageInstalledPrecisely(pkg)
+	cmd := exec.Command("dpkg", "-l", pkg)
+	err := cmd.Run()
+	return err == nil
 }
 
 func (u *UbuntuDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
@@ -120,7 +116,6 @@ func (u *UbuntuDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 		// DMS packages from PPAs
 		"dms (DankMaterialShell)": u.getDmsMapping(variants["dms (DankMaterialShell)"]),
 		"quickshell":              u.getQuickshellMapping(variants["quickshell"]),
-		"dms-greeter":             {Name: "dms-greeter", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 		"matugen":                 {Name: "matugen", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 		"dgop":                    {Name: "dgop", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
 		"ghostty":                 {Name: "ghostty", Repository: RepoTypePPA, RepoURL: "ppa:avengemedia/danklinux"},
@@ -178,7 +173,7 @@ func (u *UbuntuDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 		LogOutput:  "Updating APT package lists",
 	}
 
-	updateCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get update")
+	updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
 	if err := u.runWithProgress(updateCmd, progressChan, PhasePrerequisites, 0.06, 0.07); err != nil {
 		return fmt.Errorf("failed to update package lists: %w", err)
 	}
@@ -196,7 +191,7 @@ func (u *UbuntuDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 	checkCmd := exec.CommandContext(ctx, "dpkg", "-l", "build-essential")
 	if err := checkCmd.Run(); err != nil {
 		// Not installed, install it
-		cmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get install -y build-essential")
+		cmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y build-essential")
 		if err := u.runWithProgress(cmd, progressChan, PhasePrerequisites, 0.08, 0.09); err != nil {
 			return fmt.Errorf("failed to install build-essential: %w", err)
 		}
@@ -212,7 +207,7 @@ func (u *UbuntuDistribution) InstallPrerequisites(ctx context.Context, sudoPassw
 		LogOutput:   "Installing additional development tools",
 	}
 
-	devToolsCmd := privesc.ExecCommand(ctx, sudoPassword,
+	devToolsCmd := ExecSudoCommand(ctx, sudoPassword,
 		"apt-get install -y curl wget git cmake ninja-build pkg-config libglib2.0-dev libpolkit-agent-1-dev")
 	if err := u.runWithProgress(devToolsCmd, progressChan, PhasePrerequisites, 0.10, 0.12); err != nil {
 		return fmt.Errorf("failed to install development tools: %w", err)
@@ -399,7 +394,7 @@ func (u *UbuntuDistribution) extractPackageNames(packages []PackageMapping) []st
 func (u *UbuntuDistribution) enablePPARepos(ctx context.Context, ppaPkgs []PackageMapping, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	enabledRepos := make(map[string]bool)
 
-	installPPACmd := privesc.ExecCommand(ctx, sudoPassword,
+	installPPACmd := ExecSudoCommand(ctx, sudoPassword,
 		"apt-get install -y software-properties-common")
 	if err := u.runWithProgress(installPPACmd, progressChan, PhaseSystemPackages, 0.15, 0.17); err != nil {
 		return fmt.Errorf("failed to install software-properties-common: %w", err)
@@ -417,7 +412,7 @@ func (u *UbuntuDistribution) enablePPARepos(ctx context.Context, ppaPkgs []Packa
 				CommandInfo: fmt.Sprintf("sudo add-apt-repository -y %s", pkg.RepoURL),
 			}
 
-			cmd := privesc.ExecCommand(ctx, sudoPassword,
+			cmd := ExecSudoCommand(ctx, sudoPassword,
 				fmt.Sprintf("add-apt-repository -y %s", pkg.RepoURL))
 			if err := u.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.20, 0.22); err != nil {
 				u.logError(fmt.Sprintf("failed to enable PPA repo %s", pkg.RepoURL), err)
@@ -438,7 +433,7 @@ func (u *UbuntuDistribution) enablePPARepos(ctx context.Context, ppaPkgs []Packa
 			CommandInfo: "sudo apt-get update",
 		}
 
-		updateCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get update")
+		updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
 		if err := u.runWithProgress(updateCmd, progressChan, PhaseSystemPackages, 0.25, 0.27); err != nil {
 			return fmt.Errorf("failed to update package lists after adding PPAs: %w", err)
 		}
@@ -453,7 +448,21 @@ func (u *UbuntuDistribution) installAPTPackages(ctx context.Context, packages []
 	}
 
 	u.log(fmt.Sprintf("Installing APT packages: %s", strings.Join(packages, ", ")))
-	return u.installAPTGroups(ctx, packages, sudoPassword, progressChan, PhaseSystemPackages, "Installing system packages...", 0.40, 0.60)
+
+	args := []string{"apt-get", "install", "-y"}
+	args = append(args, packages...)
+
+	progressChan <- InstallProgressMsg{
+		Phase:       PhaseSystemPackages,
+		Progress:    0.40,
+		Step:        "Installing system packages...",
+		IsComplete:  false,
+		NeedsSudo:   true,
+		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
+	}
+
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return u.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.40, 0.60)
 }
 
 func (u *UbuntuDistribution) installPPAPackages(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -462,59 +471,21 @@ func (u *UbuntuDistribution) installPPAPackages(ctx context.Context, packages []
 	}
 
 	u.log(fmt.Sprintf("Installing PPA packages: %s", strings.Join(packages, ", ")))
-	return u.installAPTGroups(ctx, packages, sudoPassword, progressChan, PhaseAURPackages, "Installing PPA packages...", 0.70, 0.85)
-}
 
-func (u *UbuntuDistribution) aptInstallArgs(packages []string, minimal bool) []string {
-	args := []string{"DEBIAN_FRONTEND=noninteractive", "apt-get", "install", "-y"}
-	if minimal {
-		args = append(args, "--no-install-recommends")
-	}
-	return append(args, packages...)
-}
+	args := []string{"apt-get", "install", "-y"}
+	args = append(args, packages...)
 
-func (u *UbuntuDistribution) installAPTGroups(ctx context.Context, packages []string, sudoPassword string, progressChan chan<- InstallProgressMsg, phase InstallPhase, step string, startProgress float64, endProgress float64) error {
-	groups := orderedMinimalInstallGroups(packages)
-	totalGroups := len(groups)
-
-	groupIndex := 0
-	installGroup := func(groupPackages []string, minimal bool) error {
-		if len(groupPackages) == 0 {
-			return nil
-		}
-
-		groupIndex++
-		groupStart := startProgress
-		groupEnd := endProgress
-		if totalGroups > 1 {
-			midpoint := startProgress + ((endProgress - startProgress) / 2)
-			if groupIndex == 1 {
-				groupEnd = midpoint
-			} else {
-				groupStart = midpoint
-			}
-		}
-
-		args := u.aptInstallArgs(groupPackages, minimal)
 	progressChan <- InstallProgressMsg{
-			Phase:       phase,
-			Progress:    groupStart,
-			Step:        step,
+		Phase:       PhaseAURPackages,
+		Progress:    0.70,
+		Step:        "Installing PPA packages...",
 		IsComplete:  false,
 		NeedsSudo:   true,
 		CommandInfo: fmt.Sprintf("sudo %s", strings.Join(args, " ")),
 	}
 
-		cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
-		return u.runWithProgress(cmd, progressChan, phase, groupStart, groupEnd)
-	}
-
-	for _, group := range groups {
-		if err := installGroup(group.packages, group.minimal); err != nil {
-			return err
-		}
-	}
-	return nil
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
+	return u.runWithProgress(cmd, progressChan, PhaseAURPackages, 0.70, 0.85)
 }
 
 func (u *UbuntuDistribution) installBuildDependencies(ctx context.Context, manualPkgs []string, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
@@ -592,7 +563,7 @@ func (u *UbuntuDistribution) installBuildDependencies(ctx context.Context, manua
 	args := []string{"apt-get", "install", "-y"}
 	args = append(args, depList...)
 
-	cmd := privesc.ExecCommand(ctx, sudoPassword, strings.Join(args, " "))
+	cmd := ExecSudoCommand(ctx, sudoPassword, strings.Join(args, " "))
 	return u.runWithProgress(cmd, progressChan, PhaseSystemPackages, 0.80, 0.82)
 }
 
@@ -610,7 +581,7 @@ func (u *UbuntuDistribution) installRust(ctx context.Context, sudoPassword strin
 		CommandInfo: "sudo apt-get install rustup",
 	}
 
-	rustupInstallCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get install -y rustup")
+	rustupInstallCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y rustup")
 	if err := u.runWithProgress(rustupInstallCmd, progressChan, PhaseSystemPackages, 0.82, 0.83); err != nil {
 		return fmt.Errorf("failed to install rustup: %w", err)
 	}
@@ -650,7 +621,7 @@ func (u *UbuntuDistribution) installGo(ctx context.Context, sudoPassword string,
 		CommandInfo: "sudo add-apt-repository ppa:longsleep/golang-backports",
 	}
 
-	addPPACmd := privesc.ExecCommand(ctx, sudoPassword,
+	addPPACmd := ExecSudoCommand(ctx, sudoPassword,
 		"add-apt-repository -y ppa:longsleep/golang-backports")
 	if err := u.runWithProgress(addPPACmd, progressChan, PhaseSystemPackages, 0.87, 0.88); err != nil {
 		return fmt.Errorf("failed to add Go PPA: %w", err)
@@ -665,7 +636,7 @@ func (u *UbuntuDistribution) installGo(ctx context.Context, sudoPassword string,
 		CommandInfo: "sudo apt-get update",
 	}
 
-	updateCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get update")
+	updateCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get update")
 	if err := u.runWithProgress(updateCmd, progressChan, PhaseSystemPackages, 0.88, 0.89); err != nil {
 		return fmt.Errorf("failed to update package lists after adding Go PPA: %w", err)
 	}
@@ -679,7 +650,7 @@ func (u *UbuntuDistribution) installGo(ctx context.Context, sudoPassword string,
 		CommandInfo: "sudo apt-get install golang-go",
 	}
 
-	installCmd := privesc.ExecCommand(ctx, sudoPassword, "apt-get install -y golang-go")
+	installCmd := ExecSudoCommand(ctx, sudoPassword, "apt-get install -y golang-go")
 	return u.runWithProgress(installCmd, progressChan, PhaseSystemPackages, 0.89, 0.90)
 }
 

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/geolocation/client.go

@@ -1,42 +0,0 @@
-package geolocation
-
-import "github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-
-func NewClient() Client {
-	geoclueClient, err := newGeoClueClient()
-	if err != nil {
-		log.Warnf("GeoClue2 unavailable: %v", err)
-		return newSeededIpClient()
-	}
-
-	loc, _ := geoclueClient.GetLocation()
-	if loc.Latitude != 0 || loc.Longitude != 0 {
-		log.Info("Using GeoClue2 location")
-		return geoclueClient
-	}
-
-	log.Info("GeoClue2 has no fix yet, seeding with IP location")
-	ipLoc, err := fetchIPLocation()
-	if err != nil {
-		log.Warnf("IP location seed failed: %v", err)
-		return geoclueClient
-	}
-
-	log.Info("Seeded GeoClue2 with IP location")
-	geoclueClient.SeedLocation(Location{Latitude: ipLoc.Latitude, Longitude: ipLoc.Longitude})
-	return geoclueClient
-}
-
-func newSeededIpClient() *IpClient {
-	client := newIpClient()
-	ipLoc, err := fetchIPLocation()
-	if err != nil {
-		log.Warnf("IP location also failed: %v", err)
-		return client
-	}
-
-	log.Info("Using IP location")
-	client.currLocation.Latitude = ipLoc.Latitude
-	client.currLocation.Longitude = ipLoc.Longitude
-	return client
-}

core/internal/geolocation/client_geoclue.go

@@ -1,243 +0,0 @@
-package geolocation
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
-	"github.com/AvengeMedia/DankMaterialShell/core/pkg/dbusutil"
-	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
-	"github.com/godbus/dbus/v5"
-)
-
-const (
-	dbusGeoClueService   = "org.freedesktop.GeoClue2"
-	dbusGeoCluePath      = "/org/freedesktop/GeoClue2"
-	dbusGeoClueInterface = dbusGeoClueService
-
-	dbusGeoClueManagerPath      = dbusGeoCluePath + "/Manager"
-	dbusGeoClueManagerInterface = dbusGeoClueInterface + ".Manager"
-	dbusGeoClueManagerGetClient = dbusGeoClueManagerInterface + ".GetClient"
-
-	dbusGeoClueClientInterface       = dbusGeoClueInterface + ".Client"
-	dbusGeoClueClientDesktopId       = dbusGeoClueClientInterface + ".DesktopId"
-	dbusGeoClueClientTimeThreshold   = dbusGeoClueClientInterface + ".TimeThreshold"
-	dbusGeoClueClientTimeStart       = dbusGeoClueClientInterface + ".Start"
-	dbusGeoClueClientTimeStop        = dbusGeoClueClientInterface + ".Stop"
-	dbusGeoClueClientLocationUpdated = dbusGeoClueClientInterface + ".LocationUpdated"
-
-	dbusGeoClueLocationInterface = dbusGeoClueInterface + ".Location"
-	dbusGeoClueLocationLatitude  = dbusGeoClueLocationInterface + ".Latitude"
-	dbusGeoClueLocationLongitude = dbusGeoClueLocationInterface + ".Longitude"
-)
-
-type GeoClueClient struct {
-	currLocation  *Location
-	locationMutex sync.RWMutex
-
-	dbusConn   *dbus.Conn
-	clientPath dbus.ObjectPath
-	signals    chan *dbus.Signal
-
-	stopChan chan struct{}
-	sigWG    sync.WaitGroup
-
-	subscribers syncmap.Map[string, chan Location]
-}
-
-func newGeoClueClient() (*GeoClueClient, error) {
-	dbusConn, err := dbus.ConnectSystemBus()
-	if err != nil {
-		return nil, fmt.Errorf("system bus connection failed: %w", err)
-	}
-
-	c := &GeoClueClient{
-		dbusConn: dbusConn,
-		stopChan: make(chan struct{}),
-		signals:  make(chan *dbus.Signal, 256),
-
-		currLocation: &Location{
-			Latitude:  0.0,
-			Longitude: 0.0,
-		},
-	}
-
-	if err := c.setupClient(); err != nil {
-		dbusConn.Close()
-		return nil, err
-	}
-
-	if err := c.startSignalPump(); err != nil {
-		return nil, err
-	}
-
-	return c, nil
-}
-
-func (c *GeoClueClient) Close() {
-	close(c.stopChan)
-
-	c.sigWG.Wait()
-
-	if c.signals != nil {
-		c.dbusConn.RemoveSignal(c.signals)
-		close(c.signals)
-	}
-
-	c.subscribers.Range(func(key string, ch chan Location) bool {
-		close(ch)
-		c.subscribers.Delete(key)
-		return true
-	})
-
-	if c.dbusConn != nil {
-		c.dbusConn.Close()
-	}
-}
-
-func (c *GeoClueClient) Subscribe(id string) chan Location {
-	ch := make(chan Location, 64)
-	c.subscribers.Store(id, ch)
-	return ch
-}
-
-func (c *GeoClueClient) Unsubscribe(id string) {
-	if ch, ok := c.subscribers.LoadAndDelete(id); ok {
-		close(ch)
-	}
-}
-
-func (c *GeoClueClient) setupClient() error {
-	managerObj := c.dbusConn.Object(dbusGeoClueService, dbusGeoClueManagerPath)
-
-	if err := managerObj.Call(dbusGeoClueManagerGetClient, 0).Store(&c.clientPath); err != nil {
-		return fmt.Errorf("failed to create GeoClue2 client: %w", err)
-	}
-
-	clientObj := c.dbusConn.Object(dbusGeoClueService, c.clientPath)
-	if err := clientObj.SetProperty(dbusGeoClueClientDesktopId, "dms"); err != nil {
-		return fmt.Errorf("failed to set desktop ID: %w", err)
-	}
-
-	if err := clientObj.SetProperty(dbusGeoClueClientTimeThreshold, uint(10)); err != nil {
-		return fmt.Errorf("failed to set time threshold: %w", err)
-	}
-
-	return nil
-}
-
-func (c *GeoClueClient) startSignalPump() error {
-	c.dbusConn.Signal(c.signals)
-
-	if err := c.dbusConn.AddMatchSignal(
-		dbus.WithMatchObjectPath(c.clientPath),
-		dbus.WithMatchInterface(dbusGeoClueClientInterface),
-		dbus.WithMatchSender(dbusGeoClueClientLocationUpdated),
-	); err != nil {
-		return err
-	}
-
-	c.sigWG.Add(1)
-	go func() {
-		defer c.sigWG.Done()
-
-		clientObj := c.dbusConn.Object(dbusGeoClueService, c.clientPath)
-		clientObj.Call(dbusGeoClueClientTimeStart, 0)
-		defer clientObj.Call(dbusGeoClueClientTimeStop, 0)
-
-		for {
-			select {
-			case <-c.stopChan:
-				return
-			case sig, ok := <-c.signals:
-				if !ok {
-					return
-				}
-				if sig == nil {
-					continue
-				}
-
-				c.handleSignal(sig)
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (c *GeoClueClient) handleSignal(sig *dbus.Signal) {
-	switch sig.Name {
-	case dbusGeoClueClientLocationUpdated:
-		if len(sig.Body) != 2 {
-			return
-		}
-
-		newLocationPath, ok := sig.Body[1].(dbus.ObjectPath)
-		if !ok {
-			return
-		}
-
-		if err := c.handleLocationUpdated(newLocationPath); err != nil {
-			log.Warn("GeoClue: Failed to handle location update: %v", err)
-			return
-		}
-	}
-}
-
-func (c *GeoClueClient) handleLocationUpdated(path dbus.ObjectPath) error {
-	locationObj := c.dbusConn.Object(dbusGeoClueService, path)
-
-	lat, err := locationObj.GetProperty(dbusGeoClueLocationLatitude)
-	if err != nil {
-		return err
-	}
-
-	long, err := locationObj.GetProperty(dbusGeoClueLocationLongitude)
-	if err != nil {
-		return err
-	}
-
-	c.locationMutex.Lock()
-	c.currLocation.Latitude = dbusutil.AsOr(lat, 0.0)
-	c.currLocation.Longitude = dbusutil.AsOr(long, 0.0)
-	c.locationMutex.Unlock()
-
-	c.notifySubscribers()
-	return nil
-}
-
-func (c *GeoClueClient) notifySubscribers() {
-	currentLocation, err := c.GetLocation()
-	if err != nil {
-		return
-	}
-
-	c.subscribers.Range(func(key string, ch chan Location) bool {
-		select {
-		case ch <- currentLocation:
-		default:
-			log.Warn("GeoClue: subscriber channel full, dropping update")
-		}
-		return true
-	})
-}
-
-func (c *GeoClueClient) SeedLocation(loc Location) {
-	c.locationMutex.Lock()
-	defer c.locationMutex.Unlock()
-	c.currLocation.Latitude = loc.Latitude
-	c.currLocation.Longitude = loc.Longitude
-}
-
-func (c *GeoClueClient) GetLocation() (Location, error) {
-	c.locationMutex.RLock()
-	defer c.locationMutex.RUnlock()
-	if c.currLocation == nil {
-		return Location{
-			Latitude:  0.0,
-			Longitude: 0.0,
-		}, nil
-	}
-	stateCopy := *c.currLocation
-	return stateCopy, nil
-}

core/internal/geolocation/client_ip.go

@@ -1,91 +0,0 @@
-package geolocation
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"time"
-)
-
-type IpClient struct {
-	currLocation *Location
-}
-
-type ipLocationResult struct {
-	Location
-	City string
-}
-
-type ipAPIResponse struct {
-	Status string  `json:"status"`
-	Lat    float64 `json:"lat"`
-	Lon    float64 `json:"lon"`
-	City   string  `json:"city"`
-}
-
-func newIpClient() *IpClient {
-	return &IpClient{
-		currLocation: &Location{},
-	}
-}
-
-func (c *IpClient) Subscribe(id string) chan Location {
-	ch := make(chan Location, 1)
-	if location, err := c.GetLocation(); err == nil {
-		ch <- location
-	}
-	return ch
-}
-
-func (c *IpClient) Unsubscribe(id string) {}
-
-func (c *IpClient) Close() {}
-
-func (c *IpClient) GetLocation() (Location, error) {
-	if c.currLocation.Latitude != 0 || c.currLocation.Longitude != 0 {
-		return *c.currLocation, nil
-	}
-
-	result, err := fetchIPLocation()
-	if err != nil {
-		return Location{}, err
-	}
-
-	c.currLocation.Latitude = result.Latitude
-	c.currLocation.Longitude = result.Longitude
-	return *c.currLocation, nil
-}
-
-func fetchIPLocation() (ipLocationResult, error) {
-	client := &http.Client{Timeout: 10 * time.Second}
-
-	resp, err := client.Get("http://ip-api.com/json/")
-	if err != nil {
-		return ipLocationResult{}, fmt.Errorf("failed to fetch IP location: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return ipLocationResult{}, fmt.Errorf("ip-api.com returned status %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return ipLocationResult{}, fmt.Errorf("failed to read response: %w", err)
-	}
-
-	var data ipAPIResponse
-	if err := json.Unmarshal(body, &data); err != nil {
-		return ipLocationResult{}, fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	if data.Status == "fail" || (data.Lat == 0 && data.Lon == 0) {
-		return ipLocationResult{}, fmt.Errorf("ip-api.com returned no location data")
-	}
-
-	return ipLocationResult{
-		Location: Location{Latitude: data.Lat, Longitude: data.Lon},
-		City:     data.City,
-	}, nil
-}

core/internal/geolocation/types.go

@@ -1,15 +0,0 @@
-package geolocation
-
-type Location struct {
-	Latitude  float64
-	Longitude float64
-}
-
-type Client interface {
-	GetLocation() (Location, error)
-
-	Subscribe(id string) chan Location
-	Unsubscribe(id string)
-
-	Close()
-}

core/internal/greeter/assets/apparmor/usr.bin.dms-greeter

@@ -1,91 +0,0 @@
-# AppArmor profile for dms-greeter
-#
-# Managed by DMS — regenerated on every `dms greeter install` / `dms greeter sync`.
-# Manual edits will be overwritten on next sync.
-#
-# Mode: complain  (denials are logged, nothing is blocked)
-# To switch to enforce after validating with `aa-logprof`:
-#   sudo aa-enforce /etc/apparmor.d/usr.bin.dms-greeter
-#
-#include <tunables/global>
-
-profile dms-greeter /usr/bin/dms-greeter flags=(complain) {
-  #include <abstractions/base>
-  #include <abstractions/bash>
-
-  # The launcher script itself
-  /usr/bin/dms-greeter r,
-
-  # Cache directory — created by dms greeter sync/enable with greeter:greeter ownership
-  /var/cache/dms-greeter/     rw,
-  /var/cache/dms-greeter/**   rwlk,
-
-  # DMS config — packaged path
-  /usr/share/quickshell/dms-greeter/    r,
-  /usr/share/quickshell/dms-greeter/**  r,
-  /usr/share/quickshell/               r,
-  /usr/share/quickshell/**             r,
-
-  # DMS config — system and user overrides
-  /etc/dms/    r,
-  /etc/dms/**  r,
-  /usr/share/dms/    r,
-  /usr/share/dms/**  r,
-  /home/*/.config/quickshell/    r,
-  /home/*/.config/quickshell/**  r,
-  /root/.config/quickshell/     r,
-  /root/.config/quickshell/**   r,
-
-  # greetd / PAM — read-only for session setup
-  /etc/greetd/    r,
-  /etc/greetd/**  r,
-  /etc/pam.d/     r,
-  /etc/pam.d/**   r,
-  /usr/lib/pam.d/ r,
-  /usr/lib/pam.d/** r,
-
-  # Compositor binaries — run unconfined so each compositor uses its own profile
-  /usr/bin/niri        Ux,
-  /usr/bin/hyprland    Ux,
-  /usr/bin/Hyprland    Ux,
-  /usr/bin/sway        Ux,
-  /usr/bin/labwc       Ux,
-  /usr/bin/scroll      Ux,
-  /usr/bin/miracle-wm  Ux,
-  /usr/bin/mango       Ux,
-
-  # Quickshell — run unconfined (has its own compositor profile on some distros)
-  /usr/bin/qs          Ux,
-  /usr/bin/quickshell  Ux,
-
-  # Wayland / XDG runtime (pipewire, wireplumber, wayland socket)
-  /run/user/[0-9]*/               rw,
-  /run/user/[0-9]*/**             rw,
-
-  # DRM / GPU devices (required for Wayland compositor startup)
-  /dev/dri/      r,
-  /dev/dri/*     rw,
-  /dev/udmabuf   rw,
-
-  # Input devices
-  /dev/input/    r,
-  /dev/input/*   r,
-
-  # Systemd journal / logging
-  /run/systemd/journal/socket  rw,
-  /dev/log                     rw,
-
-  # Shell helper binaries invoked by the launcher script
-  /usr/bin/env      ix,
-  /usr/bin/mkdir    ix,
-  /usr/bin/cat      ix,
-  /usr/bin/grep     ix,
-  /usr/bin/dirname  ix,
-  /usr/bin/basename ix,
-  /usr/bin/command  ix,
-  /bin/env          ix,
-  /bin/mkdir        ix,
-
-  # Signal management (compositor lifecycle)
-  signal (send, receive) set=("term", "int", "hup", "kill"),
-}