Fix ArchUpdater error codes, revert TrayMenu

TrayMenu: reverted it to the old PopupPanel for ignored
ArchUpdater: paru error code 1 = no updates available

Modules/ArchUpdaterPanel/ArchUpdaterPanel.qml

@@ -68,7 +68,8 @@ NPanel {
 
       // Update summary (only show when packages are available)
       NText {
-        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed && !ArchUpdaterService.aurBusy
+        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed
+                 && !ArchUpdaterService.checkFailed && !ArchUpdaterService.aurBusy
                  && ArchUpdaterService.totalUpdates > 0
         text: ArchUpdaterService.totalUpdates + " package" + (ArchUpdaterService.totalUpdates !== 1 ? "s" : "") + " can be updated"
         font.pointSize: Style.fontSizeL * scaling
@@ -79,7 +80,8 @@ NPanel {
 
       // Package selection info (only show when not updating and have packages)
       NText {
-        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed && !ArchUpdaterService.aurBusy
+        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed
+                 && !ArchUpdaterService.checkFailed && !ArchUpdaterService.aurBusy
                  && ArchUpdaterService.totalUpdates > 0
         text: ArchUpdaterService.selectedPackagesCount + " of " + ArchUpdaterService.totalUpdates + " packages selected"
         font.pointSize: Style.fontSizeS * scaling
@@ -127,6 +129,58 @@ NPanel {
         } // Spacer
       }
 
+      // Check failed state (AUR down, network issues, etc.)
+      Item {
+        Layout.fillWidth: true
+        Layout.fillHeight: true
+        visible: ArchUpdaterService.checkFailed && !ArchUpdaterService.updateInProgress
+                 && !ArchUpdaterService.updateFailed
+
+        ColumnLayout {
+          anchors.centerIn: parent
+          spacing: Style.marginM * scaling
+
+          NIcon {
+            text: "error"
+            font.pointSize: Style.fontSizeXXXL * scaling
+            color: Color.mError
+            Layout.alignment: Qt.AlignHCenter
+          }
+
+          NText {
+            text: "Cannot check for updates"
+            font.pointSize: Style.fontSizeL * scaling
+            color: Color.mOnSurface
+            Layout.alignment: Qt.AlignHCenter
+          }
+
+          NText {
+            text: ArchUpdaterService.lastCheckError
+                  || "AUR helper is unavailable or network connection failed. This could be due to AUR being down, network issues, or missing AUR helper (yay/paru)."
+            font.pointSize: Style.fontSizeNormal * scaling
+            color: Color.mOnSurfaceVariant
+            Layout.alignment: Qt.AlignHCenter
+            horizontalAlignment: Text.AlignHCenter
+            wrapMode: Text.Wrap
+            Layout.maximumWidth: 280 * scaling
+          }
+
+          // Prominent refresh button
+          NIconButton {
+            icon: "refresh"
+            tooltipText: "Try checking again"
+            sizeRatio: 1.2
+            colorBg: Color.mPrimary
+            colorFg: Color.mOnPrimary
+            onClicked: {
+              ArchUpdaterService.forceRefresh()
+            }
+            Layout.alignment: Qt.AlignHCenter
+            Layout.topMargin: Style.marginL * scaling
+          }
+        }
+      }
+
       // Update failed state
       Item {
         Layout.fillWidth: true
@@ -181,7 +235,8 @@ NPanel {
       Item {
         Layout.fillWidth: true
         Layout.fillHeight: true
-        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed && !ArchUpdaterService.aurBusy
+        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed
+                 && !ArchUpdaterService.checkFailed && !ArchUpdaterService.aurBusy
                  && ArchUpdaterService.totalUpdates === 0
 
         ColumnLayout {
@@ -251,7 +306,8 @@ NPanel {
 
       // Package list (only show when not in any special state)
       NBox {
-        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed && !ArchUpdaterService.aurBusy
+        visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed
+                 && !ArchUpdaterService.checkFailed && !ArchUpdaterService.aurBusy
                  && ArchUpdaterService.totalUpdates > 0
         Layout.fillWidth: true
         Layout.fillHeight: true
@@ -340,6 +396,7 @@ NPanel {
       // Action buttons (only show when not updating)
       RowLayout {
         visible: !ArchUpdaterService.updateInProgress && !ArchUpdaterService.updateFailed
+                 && !ArchUpdaterService.checkFailed
         Layout.fillWidth: true
         spacing: Style.marginL * scaling
 

Modules/Bar/Extras/TrayMenu.qml

@@ -6,21 +6,29 @@ import qs.Commons
 import qs.Services
 import qs.Widgets
 
-NPanel {
+PopupWindow {
   id: root
-
-  objectName: "trayMenu"
-
-  panelWidth: 180 * scaling
-  panelHeight: 220 * scaling
-  panelAnchorRight: true
-
   property QsMenuHandle menu
   property var anchorItem: null
   property real anchorX
   property real anchorY
   property bool isSubMenu: false
-  property bool isHovered: false
+  property bool isHovered: rootMouseArea.containsMouse
+  property ShellScreen screen
+  property real scaling: screen ? ScalingService.scale(screen) : 1.0
+
+  readonly property int menuWidth: 180
+
+  implicitWidth: menuWidth * scaling
+
+  // Use the content height of the Flickable for implicit height
+  implicitHeight: Math.min(screen ? screen.height * 0.9 : Screen.height * 0.9,
+                           flickable.contentHeight + (Style.marginS * 2 * scaling))
+  visible: false
+  color: Color.transparent
+  anchor.item: anchorItem
+  anchor.rect.x: anchorX
+  anchor.rect.y: anchorY - (isSubMenu ? 0 : 4)
 
   function showAt(item, x, y) {
     if (!item) {
@@ -28,16 +36,27 @@ NPanel {
       return
     }
 
+    if (!opener.children || opener.children.values.length === 0) {
+      //Logger.warn("TrayMenu", "Menu not ready, delaying show")
+      Qt.callLater(() => showAt(item, x, y))
+      return
+    }
+
     anchorItem = item
     anchorX = x
     anchorY = y
 
-    // Use NPanel's open method instead of PopupWindow's visible
+    visible = true
-    open(screen)
+    forceActiveFocus()
+
+    // Force update after showing.
+    Qt.callLater(() => {
+                   root.anchor.updateAnchor()
+                 })
   }
 
   function hideMenu() {
-    close()
+    visible = false
 
     // Clean up all submenus recursively
     for (var i = 0; i < columnLayout.children.length; i++) {
@@ -50,18 +69,16 @@ NPanel {
     }
   }
 
-  panelContent: Rectangle {
-    color: Color.transparent
-    anchors.fill: parent
-    anchors.margins: Style.marginS * scaling
-
   // Full-sized, transparent MouseArea to track the mouse.
   MouseArea {
     id: rootMouseArea
     anchors.fill: parent
     hoverEnabled: true
-      onEntered: root.isHovered = true
+  }
-      onExited: root.isHovered = false
+
+  Item {
+    anchors.fill: parent
+    Keys.onEscapePressed: root.hideMenu()
   }
 
   QsMenuOpener {
@@ -69,18 +86,12 @@ NPanel {
     menu: root.menu
   }
 
-    Component.onCompleted: {
+  Rectangle {
-      if (menu && opener.children && opener.children.values.length === 0) {
+    anchors.fill: parent
-        // Menu not ready, try again later
+    color: Color.mSurface
-        Qt.callLater(() => {
+    border.color: Color.mOutline
-                       if (opener.children && opener.children.values.length > 0) {
+    border.width: Math.max(1, Style.borderS * scaling)
-                         // Menu is now ready
+    radius: Style.radiusM * scaling
-                         root.menuItemCount = opener.children.values.length
-                       }
-                     })
-      } else if (opener.children && opener.children.values.length > 0) {
-        root.menuItemCount = opener.children.values.length
-      }
   }
 
   Flickable {
@@ -141,12 +152,10 @@ NPanel {
                 Layout.fillWidth: true
                 color: (modelData?.enabled
                         ?? true) ? (mouseArea.containsMouse ? Color.mOnTertiary : Color.mOnSurface) : Color.mOnSurfaceVariant
-                  text: modelData?.text !== "" ? modelData?.text.replace(/[\n\r]+/g, ' ').replace(/\s+/g,
+                text: modelData?.text !== "" ? modelData?.text.replace(/[\n\r]+/g, ' ') : "..."
-                                                                                                  ' ').trim() : "..."
                 font.pointSize: Style.fontSizeS * scaling
                 verticalAlignment: Text.AlignVCenter
-                  wrapMode: Text.NoWrap
+                wrapMode: Text.WordWrap
-                  elide: Text.ElideRight
               }
 
               Image {
@@ -200,17 +209,29 @@ NPanel {
                     entry.subMenu.destroy()
                   }
 
-                    // Create submenu using the same TrayMenu component
+                  // Need a slight overlap so that menu don't close when moving the mouse to a submenu
+                  const submenuWidth = menuWidth * scaling // Assuming a similar width as the parent
+                  const overlap = 4 * scaling // A small overlap to bridge the mouse path
+
+                  // Check if there's enough space on the right
+                  const globalPos = entry.mapToGlobal(0, 0)
+                  const openLeft = (globalPos.x + entry.width + submenuWidth > (screen ? screen.width : Screen.width))
+
+                  // Position with overlap
+                  const anchorX = openLeft ? -submenuWidth + overlap : entry.width - overlap
+
+                  // Create submenu
                   entry.subMenu = Qt.createComponent("TrayMenu.qml").createObject(root, {
                                                                                     "menu": modelData,
                                                                                     "anchorItem": entry,
-                                                                                      "anchorX": entry.width,
+                                                                                    "anchorX": anchorX,
                                                                                     "anchorY": 0,
-                                                                                      "isSubMenu": true
+                                                                                    "isSubMenu": true,
+                                                                                    "screen": screen
                                                                                   })
 
                   if (entry.subMenu) {
-                      entry.subMenu.open(screen)
+                    entry.subMenu.showAt(entry, anchorX, 0)
                   }
                 }
               }
@@ -237,5 +258,4 @@ NPanel {
       }
     }
   }
-  }
 }

Modules/Bar/Widgets/Tray.qml

@@ -14,7 +14,7 @@ Rectangle {
   id: root
 
   property ShellScreen screen
-  property real scaling: screen ? ScalingService.scale(screen) : 1.0
+  property real scaling: ScalingService.scale(screen)
   readonly property real itemSize: 24 * scaling
 
   visible: SystemTray.items.values.length > 0
@@ -80,42 +80,35 @@ Rectangle {
 
                        if (mouse.button === Qt.LeftButton) {
                          // Close any open menu first
-                         var trayMenuPanel = PanelService.getPanel("trayMenu")
+                         trayPanel.close()
-                         if (trayMenuPanel && trayMenuPanel.active) {
-                           trayMenuPanel.close()
-                         }
 
                          if (!modelData.onlyMenu) {
                            modelData.activate()
                          }
                        } else if (mouse.button === Qt.MiddleButton) {
                          // Close any open menu first
-                         var trayMenuPanel = PanelService.getPanel("trayMenu")
+                         trayPanel.close()
-                         if (trayMenuPanel && trayMenuPanel.active) {
-                           trayMenuPanel.close()
-                         }
 
                          modelData.secondaryActivate && modelData.secondaryActivate()
                        } else if (mouse.button === Qt.RightButton) {
                          trayTooltip.hide()
 
-                         // Don't open menu if screen is invalid
+                         // Close the menu if it was visible
-                         if (!screen || !screen.name) {
+                         if (trayPanel && trayPanel.visible) {
-                           Logger.warn("Tray", "Cannot open tray menu: invalid screen object")
+                           trayPanel.close()
                            return
                          }
 
-                         if (modelData.hasMenu && modelData.menu) {
+                         if (modelData.hasMenu && modelData.menu && trayMenu.item) {
-                           // Get the tray menu panel from PanelService
+                           trayPanel.open()
-                           var trayMenuPanel = PanelService.getPanel("trayMenu")
+
-                           if (trayMenuPanel) {
+                           // Anchor the menu to the tray icon item (parent) and position it below the icon
-                             trayMenuPanel.menu = modelData.menu
+                           const menuX = (width / 2) - (trayMenu.item.width / 2)
-                             trayMenuPanel.toggle(screen, this)
+                           const menuY = (Style.barHeight * scaling)
+                           trayMenu.item.menu = modelData.menu
+                           trayMenu.item.showAt(parent, menuX, menuY)
                          } else {
-                             Logger.warn("Tray", "Tray menu panel not found")
+                           Logger.log("Tray", "No menu available for", modelData.id, "or trayMenu not set")
-                           }
-                         } else {
-                           Logger.log("Tray", "No menu available for", modelData.id)
                          }
                        }
                      }
@@ -132,4 +125,43 @@ Rectangle {
       }
     }
   }
+
+  PanelWindow {
+    id: trayPanel
+    anchors.top: true
+    anchors.left: true
+    anchors.right: true
+    anchors.bottom: true
+    visible: false
+    color: Color.transparent
+    screen: screen
+
+    function open() {
+      visible = true
+
+      PanelService.willOpenPanel(trayPanel)
+    }
+
+    function close() {
+      visible = false
+      trayMenu.item.hideMenu()
+    }
+
+    // Clicking outside of the rectangle to close
+    MouseArea {
+      anchors.fill: parent
+      onClicked: trayPanel.close()
+    }
+
+    Loader {
+      id: trayMenu
+      source: "../Extras/TrayMenu.qml"
+
+      onLoaded: {
+        if (item) {
+          item.screen = screen
+        }
+      }
+    }
+  }
 }

Services/ArchUpdaterService.qml

@@ -23,6 +23,8 @@ Singleton {
   property bool updateInProgress: false
   property bool updateFailed: false
   property string lastUpdateError: ""
+  property bool checkFailed: false
+  property string lastCheckError: ""
 
   // Computed properties
   readonly property bool aurBusy: checkAurUpdatesProcess.running || checkAurOnlyProcess.running
@@ -87,6 +89,8 @@ Singleton {
         Logger.log("ArchUpdater", "No update processes detected, marking update as complete")
         updateInProgress = false
         updateMonitorTimer.stop()
+        errorCheckTimer.stop()
+        successCheckTimer.stop()
 
         // Don't stop the complete timer - let it handle failures
         // If the update actually failed, the timer will trigger and set updateFailed = true
@@ -111,6 +115,8 @@ Singleton {
         updateFailed = true
         updateCompleteTimer.stop()
         updateMonitorTimer.stop()
+        errorCheckTimer.stop()
+        successCheckTimer.stop()
         lastUpdateError = "Build or update error detected"
 
         // Refresh to check actual state
@@ -140,6 +146,8 @@ Singleton {
         updateFailed = false
         updateCompleteTimer.stop()
         updateMonitorTimer.stop()
+        errorCheckTimer.stop()
+        successCheckTimer.stop()
         lastUpdateError = ""
 
         // Refresh to check actual state
@@ -152,7 +160,7 @@ Singleton {
 
   // Timer to check for success more frequently when update is in progress
   Timer {
-    id: errorCheckTimer
+    id: successCheckTimer
     interval: 5000 // Check every 5 seconds
     repeat: true
     running: updateInProgress
@@ -163,6 +171,19 @@ Singleton {
     }
   }
 
+  // Timer to check for errors more frequently when update is in progress
+  Timer {
+    id: errorCheckTimer
+    interval: 5000 // Check every 5 seconds
+    repeat: true
+    running: updateInProgress
+    onTriggered: {
+      if (updateInProgress && !errorCheckProcess.running) {
+        errorCheckProcess.running = true
+      }
+    }
+  }
+
   // ============================================================================
   // MONITORING FUNCTIONS
   // ============================================================================
@@ -187,14 +208,23 @@ Singleton {
 
   // Initial check
   Component.onCompleted: {
-    // Initial poll without cooldown restriction
+    // Start AUR helper detection
-    const aurHelper = getAurHelper()
+    getAurHelper()
-    if (aurHelper) {
+
-      checkAurUpdatesProcess.command = [aurHelper, "-Qu"]
+    // Use a timer to check for AUR helper after detection completes
-      checkAurOnlyProcess.command = [aurHelper, "-Qua"]
+    Qt.callLater(() => {
+                   if (cachedAurHelper !== "") {
+                     checkAurUpdatesProcess.command = [cachedAurHelper, "-Qu"]
+                     checkAurOnlyProcess.command = [cachedAurHelper, getAurOnlyFlag()]
                      checkAurUpdatesProcess.running = true
                      lastPollTime = Date.now()
+                   } else {
+                     // No AUR helper found
+                     checkFailed = true
+                     lastCheckError = "No AUR helper found (yay or paru not installed)"
+                     Logger.warn("ArchUpdater", "No AUR helper found (yay or paru)")
                    }
+                 }, 1000)
   }
 
   // ============================================================================
@@ -208,9 +238,12 @@ Singleton {
     onExited: function (exitCode) {
       if (exitCode !== 0) {
         Logger.warn("ArchUpdater", "AUR helper check failed (code:", exitCode, ")")
+        checkFailed = true
+        lastCheckError = "Failed to check for updates (exit code: " + exitCode + ")"
         aurPackages = []
         repoPackages = []
       }
+      // Don't clear checkFailed here - wait for the second process to complete
     }
     stdout: StdioCollector {
       onStreamFinished: {
@@ -226,10 +259,21 @@ Singleton {
     id: checkAurOnlyProcess
     command: []
     onExited: function (exitCode) {
-      if (exitCode !== 0) {
+      // For paru -Qua, exit code 1 means "no AUR updates available", which is valid
+      // For yay -Qua, exit code 0 means success
+      if (exitCode !== 0 && exitCode !== 1) {
         Logger.warn("ArchUpdater", "AUR helper AUR-only check failed (code:", exitCode, ")")
+        checkFailed = true
+        lastCheckError = "Failed to check AUR updates (exit code: " + exitCode + ")"
         aurPackages = []
         repoPackages = []
+      } else {
+        // Only clear checkFailed if both processes succeeded
+        // Check if the first process also succeeded (no error was set)
+        if (!checkFailed) {
+          checkFailed = false
+          lastCheckError = ""
+        }
       }
     }
     stdout: StdioCollector {
@@ -324,17 +368,21 @@ Singleton {
       return
     }
 
-    // Get the AUR helper and set commands
+    // Check if we have a cached AUR helper
-    const aurHelper = getAurHelper()
+    if (cachedAurHelper !== "") {
-    if (aurHelper) {
+      checkAurUpdatesProcess.command = [cachedAurHelper, "-Qu"]
-      checkAurUpdatesProcess.command = [aurHelper, "-Qu"]
+      checkAurOnlyProcess.command = [cachedAurHelper, getAurOnlyFlag()]
-      checkAurOnlyProcess.command = [aurHelper, "-Qua"]
 
       // Start AUR updates check (includes both repo and AUR packages)
       checkAurUpdatesProcess.running = true
       lastPollTime = Date.now()
     } else {
-      Logger.warn("ArchUpdater", "No AUR helper found (yay or paru)")
+      // AUR helper detection is still in progress or failed
+      // Try to detect again if not already in progress
+      if (!yayCheckProcess.running && !paruCheckProcess.running) {
+        getAurHelper()
+      }
+      Logger.warn("ArchUpdater", "AUR helper detection in progress or failed")
     }
   }
 
@@ -363,11 +411,16 @@ Singleton {
     const terminal = Quickshell.env("TERMINAL") || "xterm"
 
     // Check if we have an AUR helper for full system update
-    const aurHelper = getAurHelper()
+    if (cachedAurHelper !== "" && (aurUpdates > 0 || updates > 0)) {
-    if (aurHelper && (aurUpdates > 0 || updates > 0)) {
       // Use AUR helper for full system update (handles both repo and AUR)
-      const command = generateUpdateCommand(aurHelper + " -Syu")
+      const command = generateUpdateCommand(cachedAurHelper + " -Syu")
       Quickshell.execDetached([terminal, "-e", "bash", "-c", command])
+    } else if (cachedAurHelper === "") {
+      // No AUR helper found
+      updateInProgress = false
+      updateFailed = true
+      lastUpdateError = "No AUR helper found (yay or paru not installed)"
+      Logger.warn("ArchUpdater", "No AUR helper found for update")
     }
 
     // Start monitoring and timeout timers
@@ -407,12 +460,14 @@ Singleton {
 
     // Update all packages with AUR helper (handles both repo and AUR)
     if (selectedPackages.length > 0) {
-      const aurHelper = getAurHelper()
+      if (cachedAurHelper !== "") {
-      if (aurHelper) {
         const packageList = selectedPackages.join(" ")
-        const command = generateUpdateCommand(aurHelper + " -S " + packageList)
+        const command = generateUpdateCommand(cachedAurHelper + " -S " + packageList)
         Quickshell.execDetached([terminal, "-e", "bash", "-c", command])
       } else {
+        updateInProgress = false
+        updateFailed = true
+        lastUpdateError = "No AUR helper found (yay or paru not installed)"
         Logger.warn("ArchUpdater", "No AUR helper found for packages:", selectedPackages.join(", "))
       }
     }
@@ -432,9 +487,13 @@ Singleton {
 
     updateInProgress = false
     lastUpdateError = ""
+    checkFailed = false
+    lastCheckError = ""
     updateCompleteTimer.stop()
     updateMonitorTimer.stop()
     refreshTimer.stop()
+    errorCheckTimer.stop()
+    successCheckTimer.stop()
 
     // Refresh to get current state
     doPoll()
@@ -450,18 +509,24 @@ Singleton {
     // Clear error states when refreshing
     updateFailed = false
     lastUpdateError = ""
+    checkFailed = false
+    lastCheckError = ""
 
-    // Get the AUR helper and set commands
+    // Check if we have a cached AUR helper
-    const aurHelper = getAurHelper()
+    if (cachedAurHelper !== "") {
-    if (aurHelper) {
+      checkAurUpdatesProcess.command = [cachedAurHelper, "-Qu"]
-      checkAurUpdatesProcess.command = [aurHelper, "-Qu"]
+      checkAurOnlyProcess.command = [cachedAurHelper, getAurOnlyFlag()]
-      checkAurOnlyProcess.command = [aurHelper, "-Qua"]
 
       // Force refresh by bypassing cooldown
       checkAurUpdatesProcess.running = true
       lastPollTime = Date.now()
     } else {
-      Logger.warn("ArchUpdater", "No AUR helper found (yay or paru)")
+      // AUR helper detection is still in progress or failed
+      // Try to detect again if not already in progress
+      if (!yayCheckProcess.running && !paruCheckProcess.running) {
+        getAurHelper()
+      }
+      Logger.warn("ArchUpdater", "AUR helper detection in progress or failed")
     }
   }
 
@@ -512,9 +577,19 @@ Singleton {
     yayCheckProcess.running = true
     paruCheckProcess.running = true
 
-    // For now, return a default (will be updated by the processes)
+    // Return empty string to indicate no helper found yet
-    // In a real implementation, you'd want to wait for the processes to complete
+    // The processes will update cachedAurHelper when they complete
-    return "paru" // Default fallback
+    return ""
+  }
+
+  // Helper function to get the correct AUR-only flag for the detected helper
+  function getAurOnlyFlag() {
+    if (cachedAurHelper === "yay") {
+      return "-Qua"
+    } else if (cachedAurHelper === "paru") {
+      return "-Qua" // paru uses the same flag but different exit code behavior
+    }
+    return "-Qua" // fallback
   }
 
   // ============================================================================

shell.qml

@@ -100,11 +100,6 @@ ShellRoot {
     objectName: "archUpdaterPanel"
   }
 
-  TrayMenu {
-    id: trayMenuPanel
-    objectName: "trayMenu"
-  }
-
   Component.onCompleted: {
     // Save a ref. to our lockScreen so we can access it  easily
     PanelService.lockScreen = lockScreen