chore: bump version to 4.11.133 [skip ci]

upload-artifact times out against git.ruv.wtf from the runner; publish the APK via the reachable synbox Gitea API in the build job instead.

.gitea/workflows/build.yml

@@ -103,28 +103,6 @@ jobs:
       - name: Build Android APK
         run: npm run android:apk:linux
 
-      - name: Upload APK
-        uses: actions/upload-artifact@v3
-        with:
-          name: Paarrot-Android.apk
-          path: android/app/build/outputs/apk/debug/Paarrot-*.apk
-
-  create-release:
-    runs-on: ubuntu-latest
-    needs: [increment-version, build-android]
-    if: always() && needs.build-android.result == 'success'
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          ref: ${{ github.ref_name }}
-      
-      - name: Pull latest (after version bump)
-        if: github.ref == 'refs/heads/master'
-        run: git pull origin master
-      
       - name: Get version
         id: version
         run: |
@@ -136,6 +114,13 @@ jobs:
           echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
           echo "Version: $VERSION"
 
+      - name: Prepare release files
+        run: |
+          mkdir -p release-files
+          find android/app/build/outputs/apk/debug -type f -name "Paarrot-*.apk" -exec cp {} release-files/ \;
+          ls -la release-files/
+          test -n "$(ls -A release-files/*.apk 2>/dev/null)"
+
       - name: Check if tag exists
         id: tag_check
         run: |
@@ -156,17 +141,8 @@ jobs:
           git tag -a "v${{ steps.version.outputs.VERSION }}" -m "Release v${{ steps.version.outputs.VERSION }}"
           git push origin "v${{ steps.version.outputs.VERSION }}"
 
-      - name: Download all artifacts
+      # Upload via the internal Gitea API. actions/upload-artifact times out against
-        uses: actions/download-artifact@v3
+      # git.ruv.wtf:443 from this runner; synbox:8418 is reachable on the LAN.
-        with:
-          path: artifacts
-      
-      - name: Prepare release files
-        run: |
-          mkdir -p release-files
-          find artifacts -type f -name "*.apk" -exec cp {} release-files/ \;
-          ls -la release-files/
-      
       - name: Create or Update Gitea Release
         env:
           GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "cinny"]
 	path = cinny
-	url = http://synbox.ruv.wtf:8418/litruv/cinny.git
+	url = ../cinny.git

android/app/src/main/java/com/paarrot/app/MatrixSyncService.kt

@@ -151,6 +151,21 @@ class MatrixSyncService : Service() {
             }
         }
 
+    private enum class RoomNotifyMode {
+        MUTE,
+        ALL_MESSAGES,
+        MENTIONS_AND_KEYWORDS,
+    }
+
+    private data class NotifyContext(
+        val myUserId: String,
+        val myDisplayName: String?,
+        val myLocalpart: String?,
+        val keywords: List<String>,
+        val directRoomIds: Set<String>,
+        val pushRules: JSONObject?,
+    )
+
     private fun processRoomEvents(sync: JSONObject, myUserId: String) {
         val prefs = applicationContext.getSharedPreferences(SyncServicePlugin.PREFS, Context.MODE_PRIVATE)
         val homeserver = prefs.getString(EXTRA_HOMESERVER, null)?.trimEnd('/') ?: return
@@ -159,10 +174,20 @@ class MatrixSyncService : Service() {
         val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         ensureMessageChannel(nm)
 
+        val notifyCtx = loadNotifyContext(homeserver, token, myUserId)
+
         val roomIds = joinedRooms.keys().asSequence().toList()
         for (roomId in roomIds) {
-            val timeline = joinedRooms.optJSONObject(roomId)
+            val roomData = joinedRooms.optJSONObject(roomId) ?: continue
-                ?.optJSONObject("timeline") ?: continue
+            val mode = resolveRoomNotifyMode(roomId, notifyCtx)
+
+            // Homeserver unread counts already apply push rules — skip rooms with nothing to notify.
+            val unread = roomData.optJSONObject("unread_notifications")
+            val notificationCount = unread?.optInt("notification_count", 0) ?: 0
+            if (mode == RoomNotifyMode.MUTE || notificationCount <= 0) continue
+
+            val mentionsOnly = mode == RoomNotifyMode.MENTIONS_AND_KEYWORDS
+            val timeline = roomData.optJSONObject("timeline") ?: continue
             val events = timeline.optJSONArray("events") ?: continue
 
             for (i in 0 until events.length()) {
@@ -174,6 +199,8 @@ class MatrixSyncService : Service() {
                 if (eventId.isNotBlank() && !shownEventIds.add(eventId)) continue
 
                 val content = event.optJSONObject("content") ?: continue
+                if (mentionsOnly && !isSpecialMessage(content, notifyCtx)) continue
+
                 val msgtype = content.optString("msgtype")
                 val rawBody = content.optString("body")
                 val body = when (msgtype) {
@@ -203,6 +230,144 @@ class MatrixSyncService : Service() {
         }
     }
 
+    /** Load push rules, DM list, keywords, and own display name for notification filtering. */
+    private fun loadNotifyContext(homeserver: String, token: String, myUserId: String): NotifyContext {
+        val pushRules = fetchJson("$homeserver/_matrix/client/v3/pushrules/", token)
+        val accountDataDirect = fetchJson("$homeserver/_matrix/client/v3/user/${urlEncode(myUserId)}/account_data/m.direct", token)
+        val profile = fetchJson("$homeserver/_matrix/client/v3/profile/${urlEncode(myUserId)}", token)
+
+        val directRoomIds = mutableSetOf<String>()
+        accountDataDirect?.keys()?.forEach { key ->
+            val rooms = accountDataDirect.optJSONArray(key) ?: return@forEach
+            for (i in 0 until rooms.length()) {
+                rooms.optString(i).takeIf { it.isNotBlank() }?.let { directRoomIds.add(it) }
+            }
+        }
+
+        val keywords = mutableListOf<String>()
+        val contentRules = pushRules?.optJSONObject("global")?.optJSONArray("content")
+        if (contentRules != null) {
+            for (i in 0 until contentRules.length()) {
+                val rule = contentRules.optJSONObject(i) ?: continue
+                if (rule.optBoolean("enabled", true).not()) continue
+                if (!actionsIncludeNotify(rule.optJSONArray("actions"))) continue
+                rule.optString("pattern").takeIf { it.isNotBlank() }?.let { keywords.add(it) }
+            }
+        }
+
+        return NotifyContext(
+            myUserId = myUserId,
+            myDisplayName = profile?.optString("displayname")?.takeIf { it.isNotBlank() },
+            myLocalpart = myUserId.substringAfter("@").substringBefore(":").takeIf { it.isNotBlank() },
+            keywords = keywords,
+            directRoomIds = directRoomIds,
+            pushRules = pushRules,
+        )
+    }
+
+    /**
+     * Mirrors Cinny/Paarrot room notification modes:
+     * Mute override → mute; room notify → all; room dont_notify → mentions;
+     * unset DM → all; unset room → mentions (app Default).
+     */
+    private fun resolveRoomNotifyMode(roomId: String, ctx: NotifyContext): RoomNotifyMode {
+        val global = ctx.pushRules?.optJSONObject("global")
+            // If push rules are unavailable, rely on homeserver unread_notifications only.
+            ?: return RoomNotifyMode.ALL_MESSAGES
+
+        val overrides = global.optJSONArray("override")
+        if (overrides != null) {
+            for (i in 0 until overrides.length()) {
+                val rule = overrides.optJSONObject(i) ?: continue
+                if (rule.optString("rule_id") != roomId) continue
+                if (rule.optBoolean("enabled", true).not()) continue
+                if (!actionsIncludeNotify(rule.optJSONArray("actions"))) {
+                    return RoomNotifyMode.MUTE
+                }
+            }
+        }
+
+        val roomRules = global.optJSONArray("room")
+        if (roomRules != null) {
+            for (i in 0 until roomRules.length()) {
+                val rule = roomRules.optJSONObject(i) ?: continue
+                if (rule.optString("rule_id") != roomId) continue
+                if (rule.optBoolean("enabled", true).not()) continue
+                return if (actionsIncludeNotify(rule.optJSONArray("actions"))) {
+                    RoomNotifyMode.ALL_MESSAGES
+                } else {
+                    RoomNotifyMode.MENTIONS_AND_KEYWORDS
+                }
+            }
+        }
+
+        return if (ctx.directRoomIds.contains(roomId)) {
+            RoomNotifyMode.ALL_MESSAGES
+        } else {
+            RoomNotifyMode.MENTIONS_AND_KEYWORDS
+        }
+    }
+
+    private fun actionsIncludeNotify(actions: org.json.JSONArray?): Boolean {
+        if (actions == null) return false
+        for (i in 0 until actions.length()) {
+            when (val action = actions.opt(i)) {
+                is String -> if (action == "notify") return true
+                is JSONObject -> if (action.has("set_tweak")) { /* tweaks only */ }
+            }
+        }
+        return false
+    }
+
+    private fun isSpecialMessage(content: JSONObject, ctx: NotifyContext): Boolean {
+        val mentions = content.optJSONObject("m.mentions")
+        if (mentions != null) {
+            val userIds = mentions.optJSONArray("user_ids")
+            if (userIds != null) {
+                for (i in 0 until userIds.length()) {
+                    if (userIds.optString(i) == ctx.myUserId) return true
+                }
+            }
+            if (mentions.optBoolean("room", false)) return true
+        }
+
+        val body = content.optString("body").lowercase()
+        if (body.isBlank()) return false
+        if (body.contains("@room")) return true
+        ctx.myDisplayName?.lowercase()?.takeIf { it.isNotBlank() }?.let {
+            if (body.contains(it)) return true
+        }
+        ctx.myLocalpart?.lowercase()?.let {
+            if (body.contains(it)) return true
+        }
+        for (keyword in ctx.keywords) {
+            if (body.contains(keyword.lowercase())) return true
+        }
+        return false
+    }
+
+    private fun urlEncode(value: String): String = URLEncoder.encode(value, "UTF-8")
+
+    private fun fetchJson(urlString: String, token: String): JSONObject? {
+        return try {
+            val conn = URL(urlString).openConnection() as HttpURLConnection
+            try {
+                conn.requestMethod = "GET"
+                conn.setRequestProperty("Authorization", "Bearer $token")
+                conn.setRequestProperty("Accept", "application/json")
+                conn.connectTimeout = 4_000
+                conn.readTimeout = 6_000
+                if (conn.responseCode != 200) return null
+                JSONObject(conn.inputStream.bufferedReader().readText())
+            } finally {
+                conn.disconnect()
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to fetch $urlString: ${e.message}")
+            null
+        }
+    }
+
     private fun resolveProfile(mxid: String, homeserver: String, token: String): UserProfile {
         val cachedName = displayNameCache[mxid]
         if (cachedName != null) return UserProfile(cachedName, avatarCache[mxid])

overlay/src/app/pages/client/ClientNonUIFeatures.tsx

@@ -376,6 +376,14 @@ function MessageNotifications() {
         return;
       }
 
+      // Match TitleBar / room bell settings: Default and Mentions rooms only notify on highlights.
+      const notificationType = getNotificationType(mx, room.roomId);
+      const isDm = mDirects.has(room.roomId);
+      const mentionsOnly =
+        notificationType === NotificationType.MentionsAndKeywords ||
+        (notificationType === NotificationType.Default && !isDm);
+      if (mentionsOnly && unreadInfo.highlight === 0) return;
+
       if (
         showNotifications &&
         ((isTauri() && !isElectron()) || isCapacitorNative() || notificationPermission('granted'))
@@ -397,7 +405,6 @@ function MessageNotifications() {
           messageBody = typeof content.body === 'string' ? content.body : undefined;
         }
         
-        const isDm = room.getJoinedMemberCount() === 2 && !room.isSpaceRoom();
         notify({
           roomName: room.name ?? 'Unknown',
           roomAvatar: avatarMxc
@@ -428,6 +435,7 @@ function MessageNotifications() {
     notify,
     selectedRoomId,
     useAuthentication,
+    mDirects,
   ]);
 
   return null;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "paarrot",
-  "version": "4.11.130",
+  "version": "4.11.133",
   "description": "Paarrot - A Matrix client based on Cinny",
   "engines": {
     "node": ">=18.0.0"