From 0539d183b184e78ccee7e023fcfa1cd7ec45892a Mon Sep 17 00:00:00 2001
From: Juergen Kunz <juergen@foss.global>
Date: Fri, 9 Jan 2026 23:28:33 +0000
Subject: [PATCH] update

---
 ecoos_daemon/ts/version.ts                    |   2 +-
 ecoos_daemon/vdagent/eco-vdagent.py           | 448 ++++++++++++++++++
 .../normal/0100-enable-services.hook.chroot   |   3 +
 .../etc/systemd/system/eco-vdagent.service    |  16 +
 .../eco-vdagent.service                       |   1 +
 .../includes.chroot/opt/eco/bin/eco-daemon    | Bin 87003557 -> 87002825 bytes
 .../includes.chroot/opt/eco/bin/eco-vdagent   | 448 ++++++++++++++++++
 .../live-build/package-lists/base.list.chroot |   1 +
 .../package-lists/drivers.list.chroot         |   1 +
 isotest/enable-displays.py                    | 128 +++++
 isotest/run-test.sh                           |  12 +-
 isotest/virt-viewer-settings                  |   5 +
 package.json                                  |   2 +-
 13 files changed, 1061 insertions(+), 6 deletions(-)
 create mode 100644 ecoos_daemon/vdagent/eco-vdagent.py
 create mode 100644 isobuild/config/includes.chroot/etc/systemd/system/eco-vdagent.service
 create mode 120000 isobuild/config/includes.chroot/etc/systemd/system/multi-user.target.wants/eco-vdagent.service
 create mode 100755 isobuild/config/includes.chroot/opt/eco/bin/eco-vdagent
 create mode 100755 isotest/enable-displays.py
 create mode 100644 isotest/virt-viewer-settings

diff --git a/ecoos_daemon/ts/version.ts b/ecoos_daemon/ts/version.ts
index 86305df..0fdd7d6 100644
--- a/ecoos_daemon/ts/version.ts
+++ b/ecoos_daemon/ts/version.ts
@@ -1 +1 @@
-export const VERSION = "0.4.4";
+export const VERSION = "0.4.11";
diff --git a/ecoos_daemon/vdagent/eco-vdagent.py b/ecoos_daemon/vdagent/eco-vdagent.py
new file mode 100644
index 0000000..f1ddda3
--- /dev/null
+++ b/ecoos_daemon/vdagent/eco-vdagent.py
@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+"""
+EcoOS Wayland Display Agent (eco-vdagent)
+
+A Wayland-native replacement for spice-vdagent that uses swaymsg/wlr-output-management
+instead of xrandr to configure displays.
+
+Listens on the SPICE virtio-serial port for VD_AGENT_MONITORS_CONFIG messages
+and applies the configuration to Sway outputs.
+"""
+
+import os
+import sys
+import struct
+import subprocess
+import json
+import time
+import signal
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - eco-vdagent - %(levelname)s - %(message)s'
+)
+log = logging.getLogger('eco-vdagent')
+
+# SPICE VDAgent Protocol Constants
+VD_AGENT_PROTOCOL = 1
+
+# Message types
+VD_AGENT_MOUSE_STATE = 1
+VD_AGENT_MONITORS_CONFIG = 2
+VD_AGENT_REPLY = 3
+VD_AGENT_CLIPBOARD = 4
+VD_AGENT_DISPLAY_CONFIG = 5
+VD_AGENT_ANNOUNCE_CAPABILITIES = 6
+VD_AGENT_CLIPBOARD_GRAB = 7
+VD_AGENT_CLIPBOARD_REQUEST = 8
+VD_AGENT_CLIPBOARD_RELEASE = 9
+VD_AGENT_FILE_XFER_START = 10
+VD_AGENT_FILE_XFER_STATUS = 11
+VD_AGENT_FILE_XFER_DATA = 12
+VD_AGENT_CLIENT_DISCONNECTED = 13
+VD_AGENT_MAX_CLIPBOARD = 14
+VD_AGENT_AUDIO_VOLUME_SYNC = 15
+VD_AGENT_GRAPHICS_DEVICE_INFO = 16
+
+# Reply error codes
+VD_AGENT_SUCCESS = 1
+VD_AGENT_ERROR = 2
+
+# Capability bits
+VD_AGENT_CAP_MOUSE_STATE = 0
+VD_AGENT_CAP_MONITORS_CONFIG = 1
+VD_AGENT_CAP_REPLY = 2
+VD_AGENT_CAP_CLIPBOARD = 3
+VD_AGENT_CAP_DISPLAY_CONFIG = 4
+VD_AGENT_CAP_CLIPBOARD_BY_DEMAND = 5
+VD_AGENT_CAP_CLIPBOARD_SELECTION = 6
+VD_AGENT_CAP_SPARSE_MONITORS_CONFIG = 7
+VD_AGENT_CAP_GUEST_LINEEND_LF = 8
+VD_AGENT_CAP_GUEST_LINEEND_CRLF = 9
+VD_AGENT_CAP_MAX_CLIPBOARD = 10
+VD_AGENT_CAP_AUDIO_VOLUME_SYNC = 11
+VD_AGENT_CAP_MONITORS_CONFIG_POSITION = 12
+VD_AGENT_CAP_FILE_XFER_DISABLED = 13
+VD_AGENT_CAP_FILE_XFER_DETAILED_ERRORS = 14
+VD_AGENT_CAP_GRAPHICS_DEVICE_INFO = 15
+VD_AGENT_CAP_CLIPBOARD_NO_RELEASE_ON_REGRAB = 16
+VD_AGENT_CAP_CLIPBOARD_GRAB_SERIAL = 17
+
+# Virtio serial port path
+VIRTIO_PORT = '/dev/virtio-ports/com.redhat.spice.0'
+
+# VDI Chunk header: port(4) + size(4) = 8 bytes
+VDI_CHUNK_HEADER_SIZE = 8
+VDI_CHUNK_HEADER_FMT = '<II'  # port, size
+
+# VDI Port constants
+VDP_CLIENT_PORT = 1
+VDP_SERVER_PORT = 2
+
+# VDAgentMessage header: protocol(4) + type(4) + opaque(8) + size(4) = 20 bytes
+VDAGENT_MSG_HEADER_SIZE = 20
+VDAGENT_MSG_HEADER_FMT = '<IIQI'  # little-endian: uint32, uint32, uint64, uint32
+
+# VDAgentMonitorsConfig header: num_of_monitors(4) + flags(4) = 8 bytes
+MONITORS_CONFIG_HEADER_SIZE = 8
+MONITORS_CONFIG_HEADER_FMT = '<II'
+
+# VDAgentMonConfig: height(4) + width(4) + depth(4) + x(4) + y(4) = 20 bytes
+MON_CONFIG_SIZE = 20
+MON_CONFIG_FMT = '<IIIii'  # height, width, depth, x, y (x,y are signed)
+
+
+class EcoVDAgent:
+    def __init__(self):
+        self.port_fd = None
+        self.running = True
+        self.sway_socket = None
+
+    def find_sway_socket(self):
+        """Find the Sway IPC socket"""
+        # Check environment first
+        if 'SWAYSOCK' in os.environ:
+            return os.environ['SWAYSOCK']
+
+        # Search common locations
+        runtime_dir = os.environ.get('XDG_RUNTIME_DIR', '/run/user/1000')
+
+        # Try to find sway socket
+        for pattern in [f'{runtime_dir}/sway-ipc.*.sock', '/run/user/*/sway-ipc.*.sock']:
+            import glob
+            sockets = glob.glob(pattern)
+            if sockets:
+                return sockets[0]
+
+        return None
+
+    def run_swaymsg(self, *args):
+        """Run swaymsg command"""
+        cmd = ['swaymsg']
+        if self.sway_socket:
+            cmd.extend(['-s', self.sway_socket])
+        cmd.extend(args)
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+            if result.returncode != 0:
+                log.warning(f"swaymsg failed: {result.stderr}")
+            return result.returncode == 0, result.stdout
+        except Exception as e:
+            log.error(f"Failed to run swaymsg: {e}")
+            return False, ""
+
+    def get_outputs(self):
+        """Get current Sway outputs"""
+        success, output = self.run_swaymsg('-t', 'get_outputs', '-r')
+        if success:
+            try:
+                return json.loads(output)
+            except json.JSONDecodeError:
+                pass
+        return []
+
+    def configure_output(self, name, width, height, x, y, enable=True):
+        """Configure a Sway output"""
+        if enable:
+            # Try to enable and position the output
+            # First, try setting mode
+            mode_cmd = f'output {name} mode {width}x{height} position {x} {y} enable'
+            success, _ = self.run_swaymsg(mode_cmd)
+            if not success:
+                # Try without explicit mode (use preferred)
+                pos_cmd = f'output {name} position {x} {y} enable'
+                success, _ = self.run_swaymsg(pos_cmd)
+            return success
+        else:
+            return self.run_swaymsg(f'output {name} disable')[0]
+
+    def apply_monitors_config(self, monitors):
+        """Apply monitor configuration to Sway outputs"""
+        log.info(f"Applying configuration for {len(monitors)} monitors")
+
+        # Get current outputs
+        outputs = self.get_outputs()
+        output_names = [o.get('name') for o in outputs]
+        log.info(f"Available outputs: {output_names}")
+
+        # Sort monitors by x position to match with outputs
+        monitors_sorted = sorted(enumerate(monitors), key=lambda m: m[1]['x'])
+
+        # Match monitors to outputs
+        for i, (mon_idx, mon) in enumerate(monitors_sorted):
+            if i < len(output_names):
+                name = output_names[i]
+                log.info(f"Configuring {name}: {mon['width']}x{mon['height']} at ({mon['x']}, {mon['y']})")
+                self.configure_output(
+                    name,
+                    mon['width'],
+                    mon['height'],
+                    mon['x'],
+                    mon['y'],
+                    enable=True
+                )
+            else:
+                log.warning(f"No output available for monitor {mon_idx}")
+
+        # Disable extra outputs
+        for i in range(len(monitors), len(output_names)):
+            name = output_names[i]
+            log.info(f"Disabling unused output: {name}")
+            self.configure_output(name, 0, 0, 0, 0, enable=False)
+
+    def parse_monitors_config(self, data):
+        """Parse VD_AGENT_MONITORS_CONFIG message"""
+        if len(data) < MONITORS_CONFIG_HEADER_SIZE:
+            log.error("Monitors config data too short")
+            return None
+
+        num_monitors, flags = struct.unpack(MONITORS_CONFIG_HEADER_FMT, data[:MONITORS_CONFIG_HEADER_SIZE])
+        log.info(f"Monitors config: {num_monitors} monitors, flags={flags}")
+
+        monitors = []
+        offset = MONITORS_CONFIG_HEADER_SIZE
+
+        for i in range(num_monitors):
+            if offset + MON_CONFIG_SIZE > len(data):
+                log.error(f"Truncated monitor config at index {i}")
+                break
+
+            height, width, depth, x, y = struct.unpack(
+                MON_CONFIG_FMT,
+                data[offset:offset + MON_CONFIG_SIZE]
+            )
+
+            monitors.append({
+                'width': width,
+                'height': height,
+                'depth': depth,
+                'x': x,
+                'y': y
+            })
+            log.info(f"  Monitor {i}: {width}x{height}+{x}+{y} depth={depth}")
+            offset += MON_CONFIG_SIZE
+
+        return monitors
+
+    def send_reply(self, msg_type, error_code):
+        """Send VD_AGENT_REPLY message"""
+        # Reply data: type(4) + error(4) = 8 bytes
+        reply_data = struct.pack('<II', msg_type, error_code)
+
+        if self.send_message(VD_AGENT_REPLY, reply_data):
+            log.debug(f"Sent reply for type {msg_type}: {'success' if error_code == VD_AGENT_SUCCESS else 'error'}")
+        else:
+            log.error(f"Failed to send reply for type {msg_type}")
+
+    def send_message(self, msg_type, data):
+        """Send a VDAgent message with proper chunk header"""
+        if not self.port_fd:
+            return False
+
+        # Build VDAgentMessage header
+        msg_header = struct.pack(
+            VDAGENT_MSG_HEADER_FMT,
+            VD_AGENT_PROTOCOL,
+            msg_type,
+            0,  # opaque
+            len(data)
+        )
+
+        # Full message = header + data
+        full_msg = msg_header + data
+
+        # Build VDI chunk header (port=SERVER, size=message size)
+        chunk_header = struct.pack(
+            VDI_CHUNK_HEADER_FMT,
+            VDP_SERVER_PORT,
+            len(full_msg)
+        )
+
+        # Retry writes with EAGAIN handling (non-blocking fd)
+        message = chunk_header + full_msg
+        retries = 10
+        while retries > 0:
+            try:
+                os.write(self.port_fd, message)
+                return True
+            except OSError as e:
+                if e.errno == 11:  # EAGAIN - resource temporarily unavailable
+                    retries -= 1
+                    time.sleep(0.1)
+                    continue
+                log.error(f"Failed to send message type {msg_type}: {e}")
+                return False
+        log.error(f"Failed to send message type {msg_type}: EAGAIN after retries")
+        return False
+
+    def announce_capabilities(self):
+        """Send VD_AGENT_ANNOUNCE_CAPABILITIES to register with SPICE server"""
+        # Build capability bits - we support monitors config
+        caps = 0
+        caps |= (1 << VD_AGENT_CAP_MONITORS_CONFIG)
+        caps |= (1 << VD_AGENT_CAP_REPLY)
+        caps |= (1 << VD_AGENT_CAP_SPARSE_MONITORS_CONFIG)
+        caps |= (1 << VD_AGENT_CAP_MONITORS_CONFIG_POSITION)
+
+        # VDAgentAnnounceCapabilities: request(4) + caps(4) = 8 bytes
+        # request=1 means we want the server to send us its capabilities
+        announce_data = struct.pack('<II', 1, caps)
+
+        if self.send_message(VD_AGENT_ANNOUNCE_CAPABILITIES, announce_data):
+            log.info("Announced capabilities to SPICE server")
+        else:
+            log.error("Failed to announce capabilities")
+
+    def handle_message(self, msg_type, data):
+        """Handle a VDAgent message"""
+        if msg_type == VD_AGENT_MONITORS_CONFIG:
+            log.info("Received VD_AGENT_MONITORS_CONFIG")
+            monitors = self.parse_monitors_config(data)
+            if monitors:
+                self.apply_monitors_config(monitors)
+                self.send_reply(VD_AGENT_MONITORS_CONFIG, VD_AGENT_SUCCESS)
+            else:
+                self.send_reply(VD_AGENT_MONITORS_CONFIG, VD_AGENT_ERROR)
+
+        elif msg_type == VD_AGENT_ANNOUNCE_CAPABILITIES:
+            log.info("Received VD_AGENT_ANNOUNCE_CAPABILITIES")
+            # We could respond with our capabilities here
+            # For now, just acknowledge
+
+        elif msg_type == VD_AGENT_DISPLAY_CONFIG:
+            log.info("Received VD_AGENT_DISPLAY_CONFIG")
+            # Display config for disabling client display changes
+
+        elif msg_type == VD_AGENT_CLIENT_DISCONNECTED:
+            log.info("Client disconnected")
+
+        else:
+            log.debug(f"Unhandled message type: {msg_type}")
+
+    def read_message(self):
+        """Read a single VDAgent message from the port (with chunk header)"""
+        # Read VDI chunk header first
+        try:
+            chunk_header_data = os.read(self.port_fd, VDI_CHUNK_HEADER_SIZE)
+        except OSError as e:
+            if e.errno == 11:  # EAGAIN
+                return None
+            raise
+
+        if len(chunk_header_data) < VDI_CHUNK_HEADER_SIZE:
+            if len(chunk_header_data) == 0:
+                return None
+            log.warning(f"Short chunk header read: {len(chunk_header_data)} bytes")
+            return None
+
+        port, chunk_size = struct.unpack(VDI_CHUNK_HEADER_FMT, chunk_header_data)
+        log.debug(f"Chunk header: port={port}, size={chunk_size}")
+
+        if chunk_size < VDAGENT_MSG_HEADER_SIZE:
+            log.warning(f"Chunk size too small: {chunk_size}")
+            return None
+
+        # Read VDAgent message header
+        try:
+            header_data = os.read(self.port_fd, VDAGENT_MSG_HEADER_SIZE)
+        except OSError as e:
+            if e.errno == 11:  # EAGAIN
+                return None
+            raise
+
+        if len(header_data) < VDAGENT_MSG_HEADER_SIZE:
+            log.warning(f"Short message header read: {len(header_data)} bytes")
+            return None
+
+        protocol, msg_type, opaque, size = struct.unpack(VDAGENT_MSG_HEADER_FMT, header_data)
+
+        if protocol != VD_AGENT_PROTOCOL:
+            log.warning(f"Unknown protocol: {protocol}")
+            return None
+
+        # Read message data
+        data = b''
+        while len(data) < size:
+            try:
+                chunk = os.read(self.port_fd, size - len(data))
+                if not chunk:
+                    break
+                data += chunk
+            except OSError as e:
+                if e.errno == 11:  # EAGAIN
+                    time.sleep(0.01)
+                    continue
+                raise
+
+        return msg_type, data
+
+    def signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        log.info(f"Received signal {signum}, shutting down...")
+        self.running = False
+
+    def run(self):
+        """Main loop"""
+        # Set up signal handlers
+        signal.signal(signal.SIGTERM, self.signal_handler)
+        signal.signal(signal.SIGINT, self.signal_handler)
+
+        # Find Sway socket
+        self.sway_socket = self.find_sway_socket()
+        if self.sway_socket:
+            log.info(f"Using Sway socket: {self.sway_socket}")
+        else:
+            log.warning("No Sway socket found, will retry...")
+
+        # Wait for virtio port
+        log.info(f"Waiting for virtio port: {VIRTIO_PORT}")
+        while self.running and not Path(VIRTIO_PORT).exists():
+            time.sleep(1)
+
+        if not self.running:
+            return
+
+        log.info("Opening virtio port...")
+        try:
+            self.port_fd = os.open(VIRTIO_PORT, os.O_RDWR | os.O_NONBLOCK)
+        except OSError as e:
+            log.error(f"Failed to open virtio port: {e}")
+            return
+
+        log.info("eco-vdagent started, announcing capabilities...")
+
+        # Announce our capabilities to the SPICE server
+        self.announce_capabilities()
+
+        log.info("Listening for SPICE agent messages...")
+
+        # Main loop
+        while self.running:
+            try:
+                # Try to find Sway socket if not found yet
+                if not self.sway_socket:
+                    self.sway_socket = self.find_sway_socket()
+
+                result = self.read_message()
+                if result:
+                    msg_type, data = result
+                    self.handle_message(msg_type, data)
+                else:
+                    time.sleep(0.1)
+            except Exception as e:
+                log.error(f"Error in main loop: {e}")
+                time.sleep(1)
+
+        if self.port_fd:
+            os.close(self.port_fd)
+
+        log.info("eco-vdagent stopped")
+
+
+if __name__ == '__main__':
+    agent = EcoVDAgent()
+    agent.run()
diff --git a/isobuild/config/hooks/normal/0100-enable-services.hook.chroot b/isobuild/config/hooks/normal/0100-enable-services.hook.chroot
index f94dbc4..9ee19d6 100755
--- a/isobuild/config/hooks/normal/0100-enable-services.hook.chroot
+++ b/isobuild/config/hooks/normal/0100-enable-services.hook.chroot
@@ -26,4 +26,7 @@ systemctl enable ssh.service || true
 echo "Enabling debug service..."
 systemctl enable debug-network.service || true
 
+echo "Enabling eco-vdagent service (Wayland display agent for VMs)..."
+systemctl enable eco-vdagent.service || true
+
 echo "Services enabled."
diff --git a/isobuild/config/includes.chroot/etc/systemd/system/eco-vdagent.service b/isobuild/config/includes.chroot/etc/systemd/system/eco-vdagent.service
new file mode 100644
index 0000000..fab9166
--- /dev/null
+++ b/isobuild/config/includes.chroot/etc/systemd/system/eco-vdagent.service
@@ -0,0 +1,16 @@
+[Unit]
+Description=EcoOS Wayland Display Agent
+Documentation=https://ecobridge.xyz
+After=seatd.service
+Wants=seatd.service
+ConditionVirtualization=vm
+
+[Service]
+Type=simple
+ExecStart=/opt/eco/bin/eco-vdagent
+Restart=always
+RestartSec=5
+Environment=XDG_RUNTIME_DIR=/run/user/1000
+
+[Install]
+WantedBy=multi-user.target
diff --git a/isobuild/config/includes.chroot/etc/systemd/system/multi-user.target.wants/eco-vdagent.service b/isobuild/config/includes.chroot/etc/systemd/system/multi-user.target.wants/eco-vdagent.service
new file mode 120000
index 0000000..f378f91
--- /dev/null
+++ b/isobuild/config/includes.chroot/etc/systemd/system/multi-user.target.wants/eco-vdagent.service
@@ -0,0 +1 @@
+/etc/systemd/system/eco-vdagent.service
\ No newline at end of file
diff --git a/isobuild/config/includes.chroot/opt/eco/bin/eco-daemon b/isobuild/config/includes.chroot/opt/eco/bin/eco-daemon
index 2bf08b83d84bbf5e4aa12b8307774cfaa6d825bd..1412263cb37bba12b1146e4d2169d26b6e039c3c 100755
GIT binary patch
delta 4498
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

delta 5059
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
VGbeT&wcU2hb-V4xZpdx9^$+i0{=@(P

diff --git a/isobuild/config/includes.chroot/opt/eco/bin/eco-vdagent b/isobuild/config/includes.chroot/opt/eco/bin/eco-vdagent
new file mode 100755
index 0000000..f1ddda3
--- /dev/null
+++ b/isobuild/config/includes.chroot/opt/eco/bin/eco-vdagent
@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+"""
+EcoOS Wayland Display Agent (eco-vdagent)
+
+A Wayland-native replacement for spice-vdagent that uses swaymsg/wlr-output-management
+instead of xrandr to configure displays.
+
+Listens on the SPICE virtio-serial port for VD_AGENT_MONITORS_CONFIG messages
+and applies the configuration to Sway outputs.
+"""
+
+import os
+import sys
+import struct
+import subprocess
+import json
+import time
+import signal
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - eco-vdagent - %(levelname)s - %(message)s'
+)
+log = logging.getLogger('eco-vdagent')
+
+# SPICE VDAgent Protocol Constants
+VD_AGENT_PROTOCOL = 1
+
+# Message types
+VD_AGENT_MOUSE_STATE = 1
+VD_AGENT_MONITORS_CONFIG = 2
+VD_AGENT_REPLY = 3
+VD_AGENT_CLIPBOARD = 4
+VD_AGENT_DISPLAY_CONFIG = 5
+VD_AGENT_ANNOUNCE_CAPABILITIES = 6
+VD_AGENT_CLIPBOARD_GRAB = 7
+VD_AGENT_CLIPBOARD_REQUEST = 8
+VD_AGENT_CLIPBOARD_RELEASE = 9
+VD_AGENT_FILE_XFER_START = 10
+VD_AGENT_FILE_XFER_STATUS = 11
+VD_AGENT_FILE_XFER_DATA = 12
+VD_AGENT_CLIENT_DISCONNECTED = 13
+VD_AGENT_MAX_CLIPBOARD = 14
+VD_AGENT_AUDIO_VOLUME_SYNC = 15
+VD_AGENT_GRAPHICS_DEVICE_INFO = 16
+
+# Reply error codes
+VD_AGENT_SUCCESS = 1
+VD_AGENT_ERROR = 2
+
+# Capability bits
+VD_AGENT_CAP_MOUSE_STATE = 0
+VD_AGENT_CAP_MONITORS_CONFIG = 1
+VD_AGENT_CAP_REPLY = 2
+VD_AGENT_CAP_CLIPBOARD = 3
+VD_AGENT_CAP_DISPLAY_CONFIG = 4
+VD_AGENT_CAP_CLIPBOARD_BY_DEMAND = 5
+VD_AGENT_CAP_CLIPBOARD_SELECTION = 6
+VD_AGENT_CAP_SPARSE_MONITORS_CONFIG = 7
+VD_AGENT_CAP_GUEST_LINEEND_LF = 8
+VD_AGENT_CAP_GUEST_LINEEND_CRLF = 9
+VD_AGENT_CAP_MAX_CLIPBOARD = 10
+VD_AGENT_CAP_AUDIO_VOLUME_SYNC = 11
+VD_AGENT_CAP_MONITORS_CONFIG_POSITION = 12
+VD_AGENT_CAP_FILE_XFER_DISABLED = 13
+VD_AGENT_CAP_FILE_XFER_DETAILED_ERRORS = 14
+VD_AGENT_CAP_GRAPHICS_DEVICE_INFO = 15
+VD_AGENT_CAP_CLIPBOARD_NO_RELEASE_ON_REGRAB = 16
+VD_AGENT_CAP_CLIPBOARD_GRAB_SERIAL = 17
+
+# Virtio serial port path
+VIRTIO_PORT = '/dev/virtio-ports/com.redhat.spice.0'
+
+# VDI Chunk header: port(4) + size(4) = 8 bytes
+VDI_CHUNK_HEADER_SIZE = 8
+VDI_CHUNK_HEADER_FMT = '<II'  # port, size
+
+# VDI Port constants
+VDP_CLIENT_PORT = 1
+VDP_SERVER_PORT = 2
+
+# VDAgentMessage header: protocol(4) + type(4) + opaque(8) + size(4) = 20 bytes
+VDAGENT_MSG_HEADER_SIZE = 20
+VDAGENT_MSG_HEADER_FMT = '<IIQI'  # little-endian: uint32, uint32, uint64, uint32
+
+# VDAgentMonitorsConfig header: num_of_monitors(4) + flags(4) = 8 bytes
+MONITORS_CONFIG_HEADER_SIZE = 8
+MONITORS_CONFIG_HEADER_FMT = '<II'
+
+# VDAgentMonConfig: height(4) + width(4) + depth(4) + x(4) + y(4) = 20 bytes
+MON_CONFIG_SIZE = 20
+MON_CONFIG_FMT = '<IIIii'  # height, width, depth, x, y (x,y are signed)
+
+
+class EcoVDAgent:
+    def __init__(self):
+        self.port_fd = None
+        self.running = True
+        self.sway_socket = None
+
+    def find_sway_socket(self):
+        """Find the Sway IPC socket"""
+        # Check environment first
+        if 'SWAYSOCK' in os.environ:
+            return os.environ['SWAYSOCK']
+
+        # Search common locations
+        runtime_dir = os.environ.get('XDG_RUNTIME_DIR', '/run/user/1000')
+
+        # Try to find sway socket
+        for pattern in [f'{runtime_dir}/sway-ipc.*.sock', '/run/user/*/sway-ipc.*.sock']:
+            import glob
+            sockets = glob.glob(pattern)
+            if sockets:
+                return sockets[0]
+
+        return None
+
+    def run_swaymsg(self, *args):
+        """Run swaymsg command"""
+        cmd = ['swaymsg']
+        if self.sway_socket:
+            cmd.extend(['-s', self.sway_socket])
+        cmd.extend(args)
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+            if result.returncode != 0:
+                log.warning(f"swaymsg failed: {result.stderr}")
+            return result.returncode == 0, result.stdout
+        except Exception as e:
+            log.error(f"Failed to run swaymsg: {e}")
+            return False, ""
+
+    def get_outputs(self):
+        """Get current Sway outputs"""
+        success, output = self.run_swaymsg('-t', 'get_outputs', '-r')
+        if success:
+            try:
+                return json.loads(output)
+            except json.JSONDecodeError:
+                pass
+        return []
+
+    def configure_output(self, name, width, height, x, y, enable=True):
+        """Configure a Sway output"""
+        if enable:
+            # Try to enable and position the output
+            # First, try setting mode
+            mode_cmd = f'output {name} mode {width}x{height} position {x} {y} enable'
+            success, _ = self.run_swaymsg(mode_cmd)
+            if not success:
+                # Try without explicit mode (use preferred)
+                pos_cmd = f'output {name} position {x} {y} enable'
+                success, _ = self.run_swaymsg(pos_cmd)
+            return success
+        else:
+            return self.run_swaymsg(f'output {name} disable')[0]
+
+    def apply_monitors_config(self, monitors):
+        """Apply monitor configuration to Sway outputs"""
+        log.info(f"Applying configuration for {len(monitors)} monitors")
+
+        # Get current outputs
+        outputs = self.get_outputs()
+        output_names = [o.get('name') for o in outputs]
+        log.info(f"Available outputs: {output_names}")
+
+        # Sort monitors by x position to match with outputs
+        monitors_sorted = sorted(enumerate(monitors), key=lambda m: m[1]['x'])
+
+        # Match monitors to outputs
+        for i, (mon_idx, mon) in enumerate(monitors_sorted):
+            if i < len(output_names):
+                name = output_names[i]
+                log.info(f"Configuring {name}: {mon['width']}x{mon['height']} at ({mon['x']}, {mon['y']})")
+                self.configure_output(
+                    name,
+                    mon['width'],
+                    mon['height'],
+                    mon['x'],
+                    mon['y'],
+                    enable=True
+                )
+            else:
+                log.warning(f"No output available for monitor {mon_idx}")
+
+        # Disable extra outputs
+        for i in range(len(monitors), len(output_names)):
+            name = output_names[i]
+            log.info(f"Disabling unused output: {name}")
+            self.configure_output(name, 0, 0, 0, 0, enable=False)
+
+    def parse_monitors_config(self, data):
+        """Parse VD_AGENT_MONITORS_CONFIG message"""
+        if len(data) < MONITORS_CONFIG_HEADER_SIZE:
+            log.error("Monitors config data too short")
+            return None
+
+        num_monitors, flags = struct.unpack(MONITORS_CONFIG_HEADER_FMT, data[:MONITORS_CONFIG_HEADER_SIZE])
+        log.info(f"Monitors config: {num_monitors} monitors, flags={flags}")
+
+        monitors = []
+        offset = MONITORS_CONFIG_HEADER_SIZE
+
+        for i in range(num_monitors):
+            if offset + MON_CONFIG_SIZE > len(data):
+                log.error(f"Truncated monitor config at index {i}")
+                break
+
+            height, width, depth, x, y = struct.unpack(
+                MON_CONFIG_FMT,
+                data[offset:offset + MON_CONFIG_SIZE]
+            )
+
+            monitors.append({
+                'width': width,
+                'height': height,
+                'depth': depth,
+                'x': x,
+                'y': y
+            })
+            log.info(f"  Monitor {i}: {width}x{height}+{x}+{y} depth={depth}")
+            offset += MON_CONFIG_SIZE
+
+        return monitors
+
+    def send_reply(self, msg_type, error_code):
+        """Send VD_AGENT_REPLY message"""
+        # Reply data: type(4) + error(4) = 8 bytes
+        reply_data = struct.pack('<II', msg_type, error_code)
+
+        if self.send_message(VD_AGENT_REPLY, reply_data):
+            log.debug(f"Sent reply for type {msg_type}: {'success' if error_code == VD_AGENT_SUCCESS else 'error'}")
+        else:
+            log.error(f"Failed to send reply for type {msg_type}")
+
+    def send_message(self, msg_type, data):
+        """Send a VDAgent message with proper chunk header"""
+        if not self.port_fd:
+            return False
+
+        # Build VDAgentMessage header
+        msg_header = struct.pack(
+            VDAGENT_MSG_HEADER_FMT,
+            VD_AGENT_PROTOCOL,
+            msg_type,
+            0,  # opaque
+            len(data)
+        )
+
+        # Full message = header + data
+        full_msg = msg_header + data
+
+        # Build VDI chunk header (port=SERVER, size=message size)
+        chunk_header = struct.pack(
+            VDI_CHUNK_HEADER_FMT,
+            VDP_SERVER_PORT,
+            len(full_msg)
+        )
+
+        # Retry writes with EAGAIN handling (non-blocking fd)
+        message = chunk_header + full_msg
+        retries = 10
+        while retries > 0:
+            try:
+                os.write(self.port_fd, message)
+                return True
+            except OSError as e:
+                if e.errno == 11:  # EAGAIN - resource temporarily unavailable
+                    retries -= 1
+                    time.sleep(0.1)
+                    continue
+                log.error(f"Failed to send message type {msg_type}: {e}")
+                return False
+        log.error(f"Failed to send message type {msg_type}: EAGAIN after retries")
+        return False
+
+    def announce_capabilities(self):
+        """Send VD_AGENT_ANNOUNCE_CAPABILITIES to register with SPICE server"""
+        # Build capability bits - we support monitors config
+        caps = 0
+        caps |= (1 << VD_AGENT_CAP_MONITORS_CONFIG)
+        caps |= (1 << VD_AGENT_CAP_REPLY)
+        caps |= (1 << VD_AGENT_CAP_SPARSE_MONITORS_CONFIG)
+        caps |= (1 << VD_AGENT_CAP_MONITORS_CONFIG_POSITION)
+
+        # VDAgentAnnounceCapabilities: request(4) + caps(4) = 8 bytes
+        # request=1 means we want the server to send us its capabilities
+        announce_data = struct.pack('<II', 1, caps)
+
+        if self.send_message(VD_AGENT_ANNOUNCE_CAPABILITIES, announce_data):
+            log.info("Announced capabilities to SPICE server")
+        else:
+            log.error("Failed to announce capabilities")
+
+    def handle_message(self, msg_type, data):
+        """Handle a VDAgent message"""
+        if msg_type == VD_AGENT_MONITORS_CONFIG:
+            log.info("Received VD_AGENT_MONITORS_CONFIG")
+            monitors = self.parse_monitors_config(data)
+            if monitors:
+                self.apply_monitors_config(monitors)
+                self.send_reply(VD_AGENT_MONITORS_CONFIG, VD_AGENT_SUCCESS)
+            else:
+                self.send_reply(VD_AGENT_MONITORS_CONFIG, VD_AGENT_ERROR)
+
+        elif msg_type == VD_AGENT_ANNOUNCE_CAPABILITIES:
+            log.info("Received VD_AGENT_ANNOUNCE_CAPABILITIES")
+            # We could respond with our capabilities here
+            # For now, just acknowledge
+
+        elif msg_type == VD_AGENT_DISPLAY_CONFIG:
+            log.info("Received VD_AGENT_DISPLAY_CONFIG")
+            # Display config for disabling client display changes
+
+        elif msg_type == VD_AGENT_CLIENT_DISCONNECTED:
+            log.info("Client disconnected")
+
+        else:
+            log.debug(f"Unhandled message type: {msg_type}")
+
+    def read_message(self):
+        """Read a single VDAgent message from the port (with chunk header)"""
+        # Read VDI chunk header first
+        try:
+            chunk_header_data = os.read(self.port_fd, VDI_CHUNK_HEADER_SIZE)
+        except OSError as e:
+            if e.errno == 11:  # EAGAIN
+                return None
+            raise
+
+        if len(chunk_header_data) < VDI_CHUNK_HEADER_SIZE:
+            if len(chunk_header_data) == 0:
+                return None
+            log.warning(f"Short chunk header read: {len(chunk_header_data)} bytes")
+            return None
+
+        port, chunk_size = struct.unpack(VDI_CHUNK_HEADER_FMT, chunk_header_data)
+        log.debug(f"Chunk header: port={port}, size={chunk_size}")
+
+        if chunk_size < VDAGENT_MSG_HEADER_SIZE:
+            log.warning(f"Chunk size too small: {chunk_size}")
+            return None
+
+        # Read VDAgent message header
+        try:
+            header_data = os.read(self.port_fd, VDAGENT_MSG_HEADER_SIZE)
+        except OSError as e:
+            if e.errno == 11:  # EAGAIN
+                return None
+            raise
+
+        if len(header_data) < VDAGENT_MSG_HEADER_SIZE:
+            log.warning(f"Short message header read: {len(header_data)} bytes")
+            return None
+
+        protocol, msg_type, opaque, size = struct.unpack(VDAGENT_MSG_HEADER_FMT, header_data)
+
+        if protocol != VD_AGENT_PROTOCOL:
+            log.warning(f"Unknown protocol: {protocol}")
+            return None
+
+        # Read message data
+        data = b''
+        while len(data) < size:
+            try:
+                chunk = os.read(self.port_fd, size - len(data))
+                if not chunk:
+                    break
+                data += chunk
+            except OSError as e:
+                if e.errno == 11:  # EAGAIN
+                    time.sleep(0.01)
+                    continue
+                raise
+
+        return msg_type, data
+
+    def signal_handler(self, signum, frame):
+        """Handle shutdown signals"""
+        log.info(f"Received signal {signum}, shutting down...")
+        self.running = False
+
+    def run(self):
+        """Main loop"""
+        # Set up signal handlers
+        signal.signal(signal.SIGTERM, self.signal_handler)
+        signal.signal(signal.SIGINT, self.signal_handler)
+
+        # Find Sway socket
+        self.sway_socket = self.find_sway_socket()
+        if self.sway_socket:
+            log.info(f"Using Sway socket: {self.sway_socket}")
+        else:
+            log.warning("No Sway socket found, will retry...")
+
+        # Wait for virtio port
+        log.info(f"Waiting for virtio port: {VIRTIO_PORT}")
+        while self.running and not Path(VIRTIO_PORT).exists():
+            time.sleep(1)
+
+        if not self.running:
+            return
+
+        log.info("Opening virtio port...")
+        try:
+            self.port_fd = os.open(VIRTIO_PORT, os.O_RDWR | os.O_NONBLOCK)
+        except OSError as e:
+            log.error(f"Failed to open virtio port: {e}")
+            return
+
+        log.info("eco-vdagent started, announcing capabilities...")
+
+        # Announce our capabilities to the SPICE server
+        self.announce_capabilities()
+
+        log.info("Listening for SPICE agent messages...")
+
+        # Main loop
+        while self.running:
+            try:
+                # Try to find Sway socket if not found yet
+                if not self.sway_socket:
+                    self.sway_socket = self.find_sway_socket()
+
+                result = self.read_message()
+                if result:
+                    msg_type, data = result
+                    self.handle_message(msg_type, data)
+                else:
+                    time.sleep(0.1)
+            except Exception as e:
+                log.error(f"Error in main loop: {e}")
+                time.sleep(1)
+
+        if self.port_fd:
+            os.close(self.port_fd)
+
+        log.info("eco-vdagent stopped")
+
+
+if __name__ == '__main__':
+    agent = EcoVDAgent()
+    agent.run()
diff --git a/isobuild/config/live-build/package-lists/base.list.chroot b/isobuild/config/live-build/package-lists/base.list.chroot
index 939a648..f0d5ce4 100644
--- a/isobuild/config/live-build/package-lists/base.list.chroot
+++ b/isobuild/config/live-build/package-lists/base.list.chroot
@@ -36,6 +36,7 @@ vim
 nano
 tmux
 jq
+python3
 
 # System utilities
 pciutils
diff --git a/isobuild/config/live-build/package-lists/drivers.list.chroot b/isobuild/config/live-build/package-lists/drivers.list.chroot
index 2c46e01..4cec5dd 100644
--- a/isobuild/config/live-build/package-lists/drivers.list.chroot
+++ b/isobuild/config/live-build/package-lists/drivers.list.chroot
@@ -37,3 +37,4 @@ bluez-tools
 # Virtualization support
 qemu-guest-agent
 open-vm-tools
+# Note: Using eco-vdagent (Wayland-native) instead of spice-vdagent (X11-only)
diff --git a/isotest/enable-displays.py b/isotest/enable-displays.py
new file mode 100755
index 0000000..262e05d
--- /dev/null
+++ b/isotest/enable-displays.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Enable multiple displays on a SPICE VM by sending monitor configuration.
+Uses SpiceMainChannel.set_display() to configure displays directly.
+"""
+
+import gi
+import sys
+
+gi.require_version('SpiceClientGLib', '2.0')
+from gi.repository import SpiceClientGLib, GLib
+
+# Channel types (from spice-protocol)
+CHANNEL_MAIN = 1
+CHANNEL_DISPLAY = 2
+
+class SpiceDisplayEnabler:
+    def __init__(self, uri, num_displays=3, width=1920, height=1080):
+        self.uri = uri
+        self.num_displays = num_displays
+        self.width = width
+        self.height = height
+        self.session = None
+        self.main_channel = None
+        self.display_channels = []
+        self.loop = GLib.MainLoop()
+        self.configured = False
+
+    def on_channel_new(self, session, channel):
+        """Handle new channel creation"""
+        channel_type = channel.get_property('channel-type')
+        channel_id = channel.get_property('channel-id')
+        print(f"New channel: type={channel_type}, id={channel_id}")
+
+        if channel_type == CHANNEL_MAIN:
+            self.main_channel = channel
+            channel.connect_after('channel-event', self.on_channel_event)
+        elif channel_type == CHANNEL_DISPLAY:
+            self.display_channels.append((channel_id, channel))
+            print(f"  Display channel {channel_id} added")
+
+    def on_channel_event(self, channel, event):
+        """Handle channel events"""
+        print(f"Channel event: {event}")
+        if event == SpiceClientGLib.ChannelEvent.OPENED:
+            print("Main channel opened, configuring displays...")
+            GLib.timeout_add(2000, self.configure_monitors)
+
+    def configure_monitors(self):
+        """Configure multiple monitors via SPICE protocol"""
+        print(f"\n=== Configuring {self.num_displays} displays ===")
+        print(f"Display channels available: {len(self.display_channels)}")
+
+        if not self.main_channel:
+            print("No main channel!")
+            GLib.timeout_add(1000, self.quit)
+            return False
+
+        # Enable and configure each display
+        for i in range(self.num_displays):
+            x = i * self.width  # Position displays side by side
+            y = 0
+
+            print(f"Setting display {i}: {self.width}x{self.height} at ({x}, {y})")
+
+            try:
+                # Enable the display
+                self.main_channel.set_display_enabled(i, True)
+
+                # Set display geometry (id, x, y, width, height)
+                self.main_channel.set_display(i, x, y, self.width, self.height)
+            except Exception as e:
+                print(f"  Error setting display {i}: {e}")
+
+        # Send the configuration immediately
+        print("\nSending monitor config to guest...")
+        try:
+            self.main_channel.send_monitor_config()
+            self.configured = True
+            print("Monitor config sent!")
+        except Exception as e:
+            print(f"Error sending config: {e}")
+
+        # Wait a bit then check agent status and quit
+        GLib.timeout_add(3000, self.check_and_quit)
+        return False
+
+    def check_and_quit(self):
+        """Check final status and quit"""
+        if self.main_channel:
+            agent_connected = self.main_channel.get_property('agent-connected')
+            print(f"\nAgent connected: {agent_connected}")
+        self.quit()
+        return False
+
+    def quit(self):
+        self.loop.quit()
+        return False
+
+    def run(self):
+        print(f"Connecting to {self.uri}...")
+        print(f"Target: {self.num_displays} displays at {self.width}x{self.height}")
+
+        self.session = SpiceClientGLib.Session()
+        self.session.set_property('uri', self.uri)
+        self.session.connect_after('channel-new', self.on_channel_new)
+
+        if not self.session.connect():
+            print("Failed to connect")
+            return False
+
+        # Fallback timeout to configure monitors
+        GLib.timeout_add(5000, self.configure_monitors)
+        GLib.timeout_add(15000, self.quit)
+        self.loop.run()
+
+        print(f"\n=== Result ===")
+        print(f"Configured: {self.configured}")
+        print(f"Display channels: {len(self.display_channels)}")
+        return self.configured
+
+if __name__ == '__main__':
+    uri = sys.argv[1] if len(sys.argv) > 1 else 'spice://localhost:5930'
+    num_displays = int(sys.argv[2]) if len(sys.argv) > 2 else 3
+
+    enabler = SpiceDisplayEnabler(uri, num_displays)
+    success = enabler.run()
+    sys.exit(0 if success else 1)
diff --git a/isotest/run-test.sh b/isotest/run-test.sh
index 3098bb8..7cbfb61 100755
--- a/isotest/run-test.sh
+++ b/isotest/run-test.sh
@@ -55,6 +55,9 @@ cleanup() {
     if [ -n "$VIEWER_PID" ] && kill -0 "$VIEWER_PID" 2>/dev/null; then
         kill "$VIEWER_PID" 2>/dev/null || true
     fi
+    if [ -n "$TWM_PID" ] && kill -0 "$TWM_PID" 2>/dev/null; then
+        kill "$TWM_PID" 2>/dev/null || true
+    fi
     if [ -n "$XORG_PID" ] && kill -0 "$XORG_PID" 2>/dev/null; then
         kill "$XORG_PID" 2>/dev/null || true
     fi
@@ -78,7 +81,9 @@ qemu-system-x86_64 \
   -bios /usr/share/qemu/OVMF.fd \
   -drive file="$ISO_PATH",media=cdrom \
   -drive file="$DISK_PATH",format=qcow2,if=virtio \
-  -device virtio-vga,max_outputs=3 \
+  -device qxl-vga,id=video0,ram_size=67108864,vram_size=67108864,vgamem_mb=64 \
+  -device qxl,id=video1,ram_size=67108864,vram_size=67108864,vgamem_mb=64 \
+  -device qxl,id=video2,ram_size=67108864,vram_size=67108864,vgamem_mb=64 \
   -display none \
   -spice port=5930,disable-ticketing=on \
   -device virtio-serial-pci \
@@ -163,10 +168,9 @@ if [ -z "$DISPLAY" ] && [ -z "$WAYLAND_DISPLAY" ]; then
     xrandr --output DUMMY1 --mode 1920x1080 --pos 1920x0 2>/dev/null || true
     xrandr --output DUMMY2 --mode 1920x1080 --pos 3840x0 2>/dev/null || true
 
-    echo "Headless X server started on :$XDISPLAY with 3 RandR monitors"
-    xrandr --listmonitors
+    echo "Headless X server started on :$XDISPLAY"
 
-    # Launch remote-viewer in fullscreen to use all monitors
+    # Launch remote-viewer in fullscreen to request all monitors
     remote-viewer --full-screen spice://localhost:5930 &
     VIEWER_PID=$!
     echo "remote-viewer running headlessly (PID: $VIEWER_PID)"
diff --git a/isotest/virt-viewer-settings b/isotest/virt-viewer-settings
new file mode 100644
index 0000000..6790846
--- /dev/null
+++ b/isotest/virt-viewer-settings
@@ -0,0 +1,5 @@
+[virt-viewer]
+share-clipboard=true
+
+[fallback]
+monitor-mapping=1:0;2:1;3:2
diff --git a/package.json b/package.json
index e61a8bb..96aa707 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ecobridge/eco-os",
-  "version": "0.4.4",
+  "version": "0.4.11",
   "private": true,
   "scripts": {
     "build": "[ -z \"$CI\" ] && npm version patch --no-git-tag-version || true && node -e \"const v=require('./package.json').version; require('fs').writeFileSync('ecoos_daemon/ts/version.ts', 'export const VERSION = \\\"'+v+'\\\";\\n');\" && pnpm run daemon:bundle && cp ecoos_daemon/bundle/eco-daemon isobuild/config/includes.chroot/opt/eco/bin/ && mkdir -p .nogit/iso && docker build --no-cache -t ecoos-builder -f isobuild/Dockerfile . && docker run --privileged --name ecoos-build ecoos-builder && docker cp ecoos-build:/output/ecoos.iso .nogit/iso/ecoos.iso && docker rm ecoos-build",