Bundle ydotool in Flatpak so Cut/Paste/Backspace work out of the box on KDE Wayland

- Build ydotool v1.0.4 (pure C99, no external deps) in the Flatpak manifest.
- Add --device=all so ydotoold can write to /dev/uinput inside the sandbox.
- Start ydotoold from the Flatpak wrapper when running under Wayland.
- Prefer the bundled /app/bin/ydotool in the Wayland backend; keep the
  flatpak-spawn --host fallback for custom builds.
- Add one-time desktop notifications when key injection fails so the
  buttons no longer fail silently.
- Fix indentation bug in publish-flatpak-repo.sh.
- Bump version to 0.9.7.

Author: GaimsDevSoftware

main.py

@@ -41,7 +41,7 @@
 from settings import get_settings
 from xdg_paths import CACHE_DIR, CONFIG_DIR
 
-__version__ = "0.9.6"
+__version__ = "0.9.7"
 
 LOG_FILE = CACHE_DIR / "linuxpop.log"
 LOCK_FILE = CACHE_DIR / "linuxpop.lock"

mcp_server.py

@@ -47,7 +47,7 @@
 
 PROTOCOL_VERSION = "2024-11-05"
 SERVER_NAME = "linuxpop"
-SERVER_VERSION = "0.9.6"
+SERVER_VERSION = "0.9.7"
 
 # Log to a file so the user can debug without stdout-noise corrupting
 # the JSON-RPC stream the MCP client is reading.

packaging/flatpak/io.github.GaimsDevSoftware.LinuxPop.yml

@@ -22,17 +22,12 @@
 #     - gtk-layer-shell: positions the popup as a layer-shell surface
 #       (a plain GTK window can't be placed on Wayland). Built with
 #       introspection so the GtkLayerShell-0.1 typelib is loadable by gi.
+#     - ydotool + ydotoold: key injection on Wayland. ydotoold writes to
+#       /dev/uinput, which needs the --device=all finish-arg. Bundling it
+#       means users don't have to install a host tool for Cut/Paste/Backspace.
 #     Neither ships in GNOME Platform 46, so both are built from source
 #     below with real upstream URL + sha256.
 #
-#   NOT bundled - ydotool (key injection / paste chords):
-#     ydotool needs /dev/uinput + the ydotoold daemon, which a Flatpak
-#     sandbox cannot provide, so the binary would be inert here. wtype is
-#     also dead on KWin (no zwp_virtual_keyboard_v1). In-sandbox paste
-#     therefore needs the libei / XDG RemoteDesktop portal route (future
-#     work); until then the Wayland paste path degrades to "copy + press
-#     Ctrl+V yourself". Outside Flatpak the host's ydotool is used.
-#
 #   RUNTIME VERSION: org.gnome.Platform//49 (GNOME 46 is EOL). 49 was
 #     verified to ship GTK3, the Handy-1 typelib, and python3-gi on Python
 #     3.13 - the bundled Python wheels are cp313 to match. Re-check the
@@ -86,6 +81,7 @@ finish-args:
   # exactly what the feature does, and LinuxPop is self-distributed (not Flathub).
   - --talk-name=org.freedesktop.Flatpak
   - --device=dri                  # GTK rendering
+  - --device=all                  # ydotoold needs /dev/uinput for key injection
 
 cleanup:
   - /include
@@ -235,6 +231,23 @@ modules:
         url: https://github.com/bugaevc/wl-clipboard/archive/refs/tags/v2.3.0.tar.gz
         sha256: b4dc560973f0cd74e02f817ffa2fd44ba645a4f1ea94b7b9614dacc9f895f402
 
+  # ----- ydotool -----
+  # Key injection on Wayland. ydotool v1.x is pure C99 with no external
+  # dependencies and only needs CMake. The companion ydotoold daemon holds
+  # a persistent uinput device; the wrapper script starts it at launch.
+  # --device=all grants /dev/uinput access inside the sandbox.
+  # We patch out the manpage subdir so we don't need scdoc in the SDK.
+  - name: ydotool
+    buildsystem: cmake-ninja
+    config-opts:
+      - -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+    sources:
+      - type: archive
+        url: https://github.com/ReimuNotMoe/ydotool/archive/refs/tags/v1.0.4.tar.gz
+        sha256: ba075a43aa6ead51940e892ecffa4d0b8b40c241e4e2bc4bd9bd26b61fde23bd
+      - type: patch
+        path: ydotool-no-docs.patch
+
   # ----- python3-dbus (dbus-python) -----
   # The Wayland/KDE backend uses dbus-python for KGlobalAccel (global
   # hotkeys) and KWin scripting over D-Bus; it is NOT in the GNOME runtime,

packaging/flatpak/linuxpop.wrapper

@@ -1,4 +1,13 @@
 #!/bin/sh
 # Wrapper that launches LinuxPop from inside the Flatpak sandbox.
 # /app/share/linuxpop is where the build step deposits the Python sources.
+
+# Start the bundled ydotool daemon on Wayland if present. It needs
+# /dev/uinput (granted via --device=all) so key injection works out of
+# the box without a host-installed ydotool. If a daemon is already
+# running it will quietly fail and the existing socket is reused.
+if [ -n "$WAYLAND_DISPLAY" ] && [ -x /app/bin/ydotoold ]; then
+    nohup /app/bin/ydotoold >/dev/null 2>&1 &
+fi
+
 exec python3 /app/share/linuxpop/main.py "$@"

packaging/flatpak/publish-flatpak-repo.sh

@@ -36,8 +36,8 @@ touch "$PAGES/.nojekyll"
 
 echo "[4/5] commit + push Pages ..."
 git -C "$PAGES" config user.name  "$(git -C "$HOME/src/linuxpop" config user.name)"
-  git -C "$PAGES" config user.email "$(git -C "$HOME/src/linuxpop" config user.email)"
-  git -C "$PAGES" add -A
+git -C "$PAGES" config user.email "$(git -C "$HOME/src/linuxpop" config user.email)"
+git -C "$PAGES" add -A
 git -C "$PAGES" commit -m "Update Flatpak repo ($(git -C "$(dirname "$MANIFEST")/../.." describe --tags --always 2>/dev/null || echo update))" \
   && git -C "$PAGES" push || echo "  (nothing to push)"
 

packaging/flatpak/ydotool-no-docs.patch

@@ -0,0 +1,7 @@
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -37,4 +37,3 @@ add_executable(ydotool ${SOURCE_FILES_CLIENT})
+ install(TARGETS ydotool DESTINATION ${CMAKE_INSTALL_BINDIR})
+ 
+ add_subdirectory(Daemon)
+-add_subdirectory(manpage)

packaging/io.github.GaimsDevSoftware.LinuxPop.metainfo.xml

@@ -96,6 +96,15 @@
   <content_rating type="oars-1.1" />
 
   <releases>
+    <release version="0.9.7" date="2026-06-16">
+      <description>
+        <p>Cut, Paste, Backspace and the other editing buttons now work out
+        of the box in the Flatpak build on KDE Plasma Wayland. ydotool and
+        its ydotoold daemon are bundled and started automatically, so users
+        no longer need to install a host key-injection tool. If injection
+        ever fails, the app now shows a warning instead of failing silently.</p>
+      </description>
+    </release>
     <release version="0.9.6" date="2026-06-15">
       <description>
         <p>The editing buttons work in the Flatpak again. Select all, Cut,

platform_backend/base.py

@@ -21,8 +21,28 @@
 from __future__ import annotations
 
 import abc
+import subprocess
 from typing import Callable, Optional, Protocol
 
+# One-time notification per session when a key-injection backend is missing.
+# Keeps Cut/Paste/Backspace from failing completely silently.
+_missing_injector_warned: set[str] = set()
+
+
+def _warn_missing_injector(backend_name: str, message: str) -> None:
+    """Show a desktop notification once per session if key injection fails."""
+    if backend_name in _missing_injector_warned:
+        return
+    _missing_injector_warned.add(backend_name)
+    try:
+        subprocess.run(
+            ["notify-send", "--hint=byte:transient:1", "-t", "6000",
+             "-i", "dialog-warning", "LinuxPop", message],
+            check=False,
+        )
+    except Exception:
+        pass
+
 
 class SelectionWatcher(Protocol):
     """Fires on_selection(text, x, y) when the primary selection changes."""

platform_backend/wayland_kde.py

@@ -836,15 +836,23 @@ def _wtype_args(self, combo: str) -> Optional[list[str]]:
         return args
 
     def _has_ydotool(self) -> bool:
-        return _host_has("ydotool") if _in_flatpak() else bool(
-            shutil.which("ydotool"))
+        if _in_flatpak():
+            # Prefer the bundled ydotool (needs --device=all for /dev/uinput);
+            # fall back to a host install for custom Flatpak builds without it.
+            return os.path.isfile("/app/bin/ydotool") or _host_has("ydotool")
+        return bool(shutil.which("ydotool"))
 
     def _ydotool_run(self, sub_argv: list) -> bool:
-        """Dispatch `ydotool <sub_argv>` to the daemon. In the Flatpak the
-        sandbox has no /dev/uinput, so we run ydotool on the HOST via
-        flatpak-spawn (same daemon + socket the native app uses); otherwise
-        we run it in-process. Returns True if it was dispatched."""
-        if _in_flatpak():
+        """Dispatch `ydotool <sub_argv>` to the daemon.
+
+        In the Flatpak we prefer the bundled ydotool binary and run it inside
+        the sandbox (ydotoold is started by the wrapper). We keep the
+        flatpak-spawn --host fallback so custom builds without the bundled
+        binary can still use a host-installed ydotool."""
+        bundled = "/app/bin/ydotool"
+        if _in_flatpak() and os.path.isfile(bundled):
+            argv = [bundled, *sub_argv]
+        elif _in_flatpak():
             runtime = os.environ.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
             sock = os.path.join(runtime, ".ydotool_socket")
             argv = ["flatpak-spawn", "--host",
@@ -871,6 +879,20 @@ def send_key(self, combo: str) -> None:
                 return
         print(f"[wayland] no working key-injection tool for {combo!r} "
               "(install ydotool + ydotoold on KWin)")
+        from .base import _warn_missing_injector
+        if _in_flatpak():
+            _warn_missing_injector(
+                "wayland_kde_flatpak",
+                "Cut/Paste/Backspace could not use ydotool. If this is a custom "
+                "Flatpak build, install ydotool on the host; otherwise the "
+                "bundled daemon may not have started.",
+            )
+        else:
+            _warn_missing_injector(
+                "wayland_kde_native",
+                "Cut/Paste/Backspace needs ydotool + ydotoold. Install and "
+                "start ydotoold to enable keystroke actions.",
+            )
 
     def type_text(self, text: str) -> None:
         # `--` terminates ydotool's own option parsing so text that starts

platform_backend/x11.py

@@ -101,6 +101,12 @@ def send_key(self, combo: str) -> None:
         import shutil
         if not shutil.which("xdotool"):
             print("[x11] xdotool missing - cannot send key")
+            from .base import _warn_missing_injector
+            _warn_missing_injector(
+                "x11",
+                "Cut/Paste/Backspace needs xdotool. Install it to enable "
+                "keystroke actions.",
+            )
             return
         subprocess.run(
             ["xdotool", "key", "--clearmodifiers", combo], check=False,
@@ -114,6 +120,12 @@ def type_text(self, text: str) -> None:
         import shutil
         if not shutil.which("xdotool"):
             print("[x11] xdotool missing - cannot type text")
+            from .base import _warn_missing_injector
+            _warn_missing_injector(
+                "x11",
+                "Cut/Paste/Backspace needs xdotool. Install it to enable "
+                "keystroke actions.",
+            )
             return
         subprocess.run(
             ["xdotool", "type", "--clearmodifiers", "--", text], check=False,