Reading desktop notifications from the command line. Debian/Ubuntu

Running Ubuntu 24.04lts.

NOTE: I am trying to read the notification sent by he Discord app to my personal desktop notifications. When I notification from a specific sender, with a specific message, I want to run a command. For now just being able to print MY desktop notifications to terminal output will suffice.

I am trying to create a script that listens to the desktop notifications dbus and print the sender and message to the command line.... the final goal is to run a specific function when I get a specific notification.

I want to see these notifications on the command line. They are intended for me.... why I can't I easily access this info???

I tried using dbus-monitor --session which prints stuff out when I get a notification, but I don't see the actual notification. I had Gemini AI help me write some python code, this code runs, but nothing happens when I get a notification.

import asyncio
from dbus_next.aio import MessageBus
from dbus_next.constants import BusType, MessageType
from dbus_next import Message, Variant
import logging

# Set up basic logging
# Note: We are only using INFO level for connection status, 
# message processing is handled via print() for clarity.
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')

# --- DBus Interface Constants ---
# The D-Bus service name for notifications
NOTIF_SERVICE = 'org.freedesktop.Notifications'
# The D-Bus object path for notifications
NOTIF_PATH = '/org/freedesktop/Notifications'
# The D-Bus interface for notifications
NOTIF_INTERFACE = NOTIF_SERVICE

# ANSI escape codes for bold text
BOLD_START = '\033[1m'
BOLD_END = '\033[0m'

def message_handler(message):
    """
    Generic handler for D-Bus messages, focusing only on new notifications 
    (Notify method calls) and printing the sender, summary, and message body.
    """
    if message.interface == NOTIF_INTERFACE:
        
        # --- Handle New Notification (Method Call) ---
        if message.message_type == MessageType.METHOD_CALL and message.member == 'Notify':
            # Notify arguments: (app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout)
            
            # Ensure we have enough arguments (at least app_name and body)
            if len(message.body) >= 8:
                app_name = message.body[0] # App Name (Sender)
                summary = message.body[3] # Notification Summary (Title)
                body_text = message.body[4] # Notification Body (Main message)
                
                # Combine summary and body for the message
                # If both exist, use "Summary: Body". If only one exists, use that.
                if summary and body_text:
                    message_content = f"{summary}: {body_text}"
                elif summary:
                    message_content = summary
                else:
                    message_content = body_text

                output = f"[{app_name}] {message_content}"
                
                # Apply bold formatting if the sender is Discord (case-insensitive check)
                if app_name.lower() == 'discord':
                    output = f"{BOLD_START}{output}{BOLD_END}"
                
                print(output)
            
        # Log other relevant messages (like replies to GetCapabilities)
        else:
            logging.debug(f"[D-Bus Message] Type: {message.message_type.name}, Member: {message.member}, Body: {message.body}")


async def notification_listener(bus):
    """
    Configures the bus to listen for all messages related to the 
    org.freedesktop.Notifications interface.
    """
    # 1. Add the generic message handler
    bus.add_message_handler(message_handler)

    # 2. Use AddMatch to filter messages directed to this interface
    # This is crucial for catching the 'Notify' method call.
    # The rule is updated to match on the specific method call ('Notify') rather than 
    # relying solely on the destination service, which is a more robust way to capture 
    # new notification requests.
    match_rule = f"type='method_call', interface='{NOTIF_INTERFACE}', member='Notify'"
    
    await bus.call(
        Message(
            destination='org.freedesktop.DBus',
            path='/org/freedesktop/DBus',
            interface='org.freedesktop.DBus',
            member='AddMatch',
            signature='s',
            body=[match_rule]
        )
    )

    logging.info("Listening for ALL D-Bus Messages on org.freedesktop.Notifications interface.")
    logging.info("To test, send a notification, e.g., 'notify-send Hello World'")
    
    # Keep the asyncio loop running indefinitely
    await asyncio.get_running_loop().create_future()


async def main():
    """
    The main entry point for the script.
    """
    try:
        logging.info(f"Attempting to connect to the D-Bus session bus...")
        bus = await MessageBus(bus_type=BusType.SESSION).connect()
        logging.info("Successfully connected to the D-Bus session bus.")
        
        # Attempt to call the GetCapabilities method to ensure the service is running
        reply = await bus.call(
            Message(
                destination=NOTIF_SERVICE,
                path=NOTIF_PATH,
                interface=NOTIF_INTERFACE,
                member='GetCapabilities',
                signature='',
                body=[]
            )
        )
        
        if reply.message_type == MessageType.METHOD_RETURN:
            caps = reply.body[0]
            logging.info(f"Notification service capabilities retrieved: {caps}")
            await notification_listener(bus)
        else:
            # This often means no notification daemon (like dunst or a desktop environment's service) is running.
            logging.error("Could not retrieve notification service capabilities. Is a notification daemon running?")
    except Exception as e:
        logging.error(f"Error during D-Bus setup or initial capability check:   {e}")

if __name__ == "__main__":
    try:
        # Run the main coroutine
        asyncio.run(main())
    except KeyboardInterrupt:
        logging.info("Notification listener stopped by user.")
    except Exception as e:
        logging.error(f"An unexpected error occurred: {e}")

It seems like this should be a simple task.... I would rather use a bash script if I could, but python would be fine too.

I did find [this post][1] which had a python script that I had to be update to work with py3. This script runs but nothing happens when I get a notification or send one via `notify-send`

import gi
gi.require_version("Gtk", "3.0") # or "4.0" depending on your target GTK version
from gi.repository import Gtk
import dbus
from dbus.mainloop.glib import DBusGMainLoop

def filter_cb(bus, message):
    # the NameAcquired message comes through before match string gets applied
    if message.get_member() != "Notify":
        return
    args = message.get_args_list()
    # args are
    # (app_name, notification_id, icon, summary, body, actions, hints, timeout)
    print("Notification from app '%s'" % args[0])
    print("Summary: %s" % args[3])
    print("Body: %s", args[4])


DBusGMainLoop(set_as_default=True)
bus = dbus.SessionBus()
bus.add_match_string(
    "type='method_call',interface='org.freedesktop.Notifications',member='Notify'")
bus.add_message_filter(filter_cb)
Gtk.main()

Thanks.