Would it be as simple as allowing Virtual-virtual-xdp-kde?

[TrinitySlayy]

Select Topic Area

Question

Body

So basically kde supports virtual displays for remote desktop etc.
This script allows me to call the popup to select screen or create virtual display: (beware - ai slop)

#!/usr/bin/env python3
import dbus
import time
import os
import random
import string
from dbus.mainloop.glib import DBusGMainLoop
from gi.repository import GLib

os.environ["XDG_CURRENT_DESKTOP"] = "KDE"
os.environ["QT_QPA_PLATFORM"] = "wayland"


class VirtualDisplay:
    def __init__(self):
        DBusGMainLoop(set_as_default=True)
        self.bus = dbus.SessionBus()
        self.loop = GLib.MainLoop()
        self.session_path = None
        self.active = False

    def _generate_token(self):
        return ''.join(random.choices(string.ascii_letters + string.digits, k=16))

    def _await_response(self, request_path):
        response_received = False
        response_success = False
        response_data = None

        def handler(response, results):
            nonlocal response_received, response_success, response_data
            response_received = True
            response_success = response == 0
            response_data = results
            self.loop.quit()

        self.bus.add_signal_receiver(
            handler,
            signal_name='Response',
            dbus_interface='org.freedesktop.portal.Request',
            path=request_path
        )

        GLib.timeout_add_seconds(30, self.loop.quit)
        self.loop.run()

        if not response_received:
            raise TimeoutError("Portal response timeout")
        return response_success, response_data

    def create_display(self):
        try:
            portal = self.bus.get_object(
                'org.freedesktop.portal.Desktop',
                '/org/freedesktop/portal/desktop'
            )
            screencast = dbus.Interface(portal, 'org.freedesktop.portal.ScreenCast')

            # Step 1: Create session
            session_token = self._generate_token()
            request_path = screencast.CreateSession({
                'session_handle_token': dbus.String(session_token),
                'handle_token': dbus.String(self._generate_token())
            })
            print(f"Session request: {request_path}")

            success, results = self._await_response(request_path)
            if not success:
                raise RuntimeError("Session creation denied")

            self.session_path = results.get('session_handle',
                                            f"/org/freedesktop/portal/desktop/session/{os.getuid()}_{session_token}")
            print(f"Session established: {self.session_path}")

            # Step 2: Select sources - CRITICAL CHANGE HERE
            request_path = screencast.SelectSources(self.session_path, {
                'types': dbus.UInt32(1),  # 1 = MONITOR (not window)
                'cursor_mode': dbus.UInt32(1),  # Hidden cursor
                'virtual': dbus.Boolean(True),  # Request virtual monitor
                'multiple': dbus.Boolean(False),  # Single monitor
                'persist_mode': dbus.UInt32(0)  # Don't persist
            })
            print(f"Source selection: {request_path}")

            success, _ = self._await_response(request_path)
            if not success:
                raise RuntimeError("Source selection denied")

            # Step 3: Start session
            request_path = screencast.Start(
                self.session_path,
                '',  # Parent window
                {
                    'handle_token': dbus.String(self._generate_token()),
                    'output_name': dbus.String("Virtual-1")
                }
            )
            print(f"Start request: {request_path}")

            success, results = self._await_response(request_path)
            if not success:
                raise RuntimeError("Session start denied")

            # Get the PipeWire stream metadata
            streams = results.get('streams', [])
            print(f"Created streams: {streams}")

            self.active = True
            print("Virtual display created successfully!")
            print("Press Ctrl+C to terminate")

            while self.active:
                time.sleep(1)

        except dbus.exceptions.DBusException as e:
            print(f"DBus error: {e.get_dbus_message()}")
        except Exception as e:
            print(f"Error: {e}")
        finally:
            self.active = False


if __name__ == "__main__":
    display = VirtualDisplay()
    try:
        display.create_display()
    except KeyboardInterrupt:
        print("\nVirtual display terminated")

Sunshine sees the virtual display, but rejects it.

Offset: 2652x0
[2025-12-05 17:27:52.709]: Info: Logical size: 1920x1080
[2025-12-05 17:27:52.709]: Info: Name: Virtual-virtual-xdp-kde-pycharm
[2025-12-05 17:27:52.709]: Info: Found monitor: Virtual Output (shared with PyCharm Community Edition)
[2025-12-05 17:27:52.709]: Info: -------- Start of KMS monitor list --------
[2025-12-05 17:27:52.709]: Info: Monitor 1 is DVI-D-1: Rogen Tech Distribution Inc B102005
[2025-12-05 17:27:52.709]: Info: Monitor 0 is DVI-I-1: Dell Inc. DELL 1905FP
[2025-12-05 17:27:52.709]: Error: Unknown Monitor connector type [Virtual-virtual-xdp-kde]: Please report this to the GitHub issue tracker

Now my question is: Would it be as simple as adding the connector type "Virtual-virtual-xdp-kde" to the whitelist to make the virtual display streamable?