Restore native OCR capture in Flatpak (drop portal)

The sandbox build captured through the XDG Screenshot portal, which on
KDE opens Spectacle's full window plus an Accept step and a one-time
permission dialog. Route capture through the host's own tools via
flatpak-spawn instead, writing to the shared $XDG_RUNTIME_DIR/linuxpop
dir: the frictionless freeze-and-drag overlay (host spectacle -f for the
full grab) and the spectacle -r region fallback both work again, exactly
like a native install. Portal stays as a last resort. Bump to 0.9.5.

Author: GaimsDevSoftware

main.py

@@ -41,7 +41,7 @@
 from settings import get_settings
 from xdg_paths import CACHE_DIR, CONFIG_DIR
 
-__version__ = "0.9.4"
+__version__ = "0.9.5"
 
 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.4"
+SERVER_VERSION = "0.9.5"
 
 # Log to a file so the user can debug without stdout-noise corrupting
 # the JSON-RPC stream the MCP client is reading.

ocr_selector.py

@@ -27,19 +27,63 @@
 from gi.repository import Gtk, Gdk, GdkPixbuf, GLib  # noqa: E402
 
 
+def _in_flatpak() -> bool:
+    return os.path.exists("/.flatpak-info")
+
+
+def _host_has(binary: str) -> bool:
+    """Is `binary` on the host's PATH? (Used in Flatpak, where the screen
+    grabbers live on the host, not in the sandbox.)"""
+    try:
+        r = subprocess.run(
+            ["flatpak-spawn", "--host", "sh", "-c", f"command -v {binary}"],
+            capture_output=True, text=True, timeout=5)
+        return r.returncode == 0 and bool(r.stdout.strip())
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def _grabber() -> "str | None":
+    """Name of the first available full-screen grabber, or None. Checks the
+    host's PATH inside Flatpak, the sandbox's PATH otherwise."""
+    probe = _host_has if _in_flatpak() else shutil.which
+    for tool in ("spectacle", "grim", "maim"):
+        if probe(tool):
+            return tool
+    return None
+
+
 def _capture_fullscreen() -> "str | None":
     """Grab the whole screen to a temp PNG with no UI. spectacle -f -b is the
-    KWin-native path; grim covers wlroots; maim covers X11."""
-    fd, path = tempfile.mkstemp(suffix=".png", prefix="lp-ocr-full-")
-    os.close(fd)
+    KWin-native path; grim covers wlroots; maim covers X11.
+
+    Inside Flatpak the grabbers run on the HOST (flatpak-spawn), and the PNG
+    must land in a dir the host can write and the sandbox can read: the app's
+    $XDG_RUNTIME_DIR/linuxpop is bind-mounted to the identical host path."""
+    tool = _grabber()
+    if not tool:
+        return None
+    in_fp = _in_flatpak()
+    if in_fp:
+        runtime = os.environ.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
+        shared = os.path.join(runtime, "linuxpop")
+        try:
+            os.makedirs(shared, exist_ok=True)
+        except OSError:
+            return None
+        path = os.path.join(shared, f"lp-ocr-full-{os.getpid()}.png")
+        prefix = ["flatpak-spawn", "--host"]
+    else:
+        fd, path = tempfile.mkstemp(suffix=".png", prefix="lp-ocr-full-")
+        os.close(fd)
+        prefix = []
+    argv = {
+        "spectacle": [*prefix, "spectacle", "-f", "-b", "-n", "-o", path],
+        "grim":      [*prefix, "grim", path],
+        "maim":      [*prefix, "maim", path],
+    }[tool]
     try:
-        if shutil.which("spectacle"):
-            subprocess.run(["spectacle", "-f", "-b", "-n", "-o", path],
-                           capture_output=True, timeout=15)
-        elif shutil.which("grim"):
-            subprocess.run(["grim", path], capture_output=True, timeout=15)
-        elif shutil.which("maim"):
-            subprocess.run(["maim", path], capture_output=True, timeout=15)
+        subprocess.run(argv, capture_output=True, timeout=15)
         if os.path.exists(path) and os.path.getsize(path) > 0:
             return path
     except (OSError, subprocess.SubprocessError):
@@ -212,9 +256,9 @@ def select_and_capture(callback) -> bool:
 
 
 def available() -> bool:
-    """True if we have a full-screen grabber and layer-shell/X11 to overlay."""
-    if not (shutil.which("spectacle") or shutil.which("grim")
-            or shutil.which("maim")):
+    """True if we have a full-screen grabber and layer-shell/X11 to overlay.
+    In Flatpak the grabber is checked on the host (flatpak-spawn)."""
+    if not _grabber():
         return False
     try:
         gi.require_version("GtkLayerShell", "0.1")

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

@@ -96,6 +96,16 @@
   <content_rating type="oars-1.1" />
 
   <releases>
+    <release version="0.9.5" date="2026-06-15">
+      <description>
+        <p>Screen OCR feels like it used to again. The Flatpak build had been
+        routing capture through the desktop's screenshot portal, which on KDE
+        popped Spectacle's full window and an extra confirm step. It now freezes
+        the screen and lets you drag one rectangle, the same quick flow as a
+        normal install, by driving the host's own capture tool. Recognition
+        still runs on the bundled engine, no setup needed.</p>
+      </description>
+    </release>
     <release version="0.9.4" date="2026-06-15">
       <description>
         <p>Your settings finally stick. In the Flatpak build the app was saving

screen_ocr.py

@@ -145,6 +145,81 @@ def _on_response(response, results):
     return out_path.is_file() and out_path.stat().st_size > 0
 
 
+def _host_has(binary: str) -> bool:
+    """Is `binary` on the host's PATH? (In Flatpak the capture tools live on
+    the host, not in the sandbox.)"""
+    try:
+        r = subprocess.run(
+            ["flatpak-spawn", "--host", "sh", "-c", f"command -v {binary}"],
+            capture_output=True, text=True, timeout=5)
+        return r.returncode == 0 and bool(r.stdout.strip())
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def _host_capture_region(out_path: Path) -> bool:
+    """Flatpak: drive the HOST's region-capture tool (the same spectacle / grim
+    / maim flow a native install uses) through flatpak-spawn, instead of the
+    clunkier Screenshot portal. The capture lands in $XDG_RUNTIME_DIR/linuxpop,
+    which is bind-mounted to the identical host path, then we move it to
+    out_path. Returns False (so the caller can fall back to the portal) when no
+    host tool is present or the user cancelled."""
+    runtime = os.environ.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
+    shared_dir = Path(runtime) / "linuxpop"
+    try:
+        shared_dir.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return False
+    shared = shared_dir / f"ocr-region-{os.getpid()}.png"
+    try:
+        shared.unlink()
+    except OSError:
+        pass
+    sp = str(shared)
+
+    def host(*argv, timeout):
+        try:
+            return subprocess.run(["flatpak-spawn", "--host", *argv],
+                                  capture_output=True, text=True, timeout=timeout)
+        except (OSError, subprocess.SubprocessError):
+            return None
+
+    ok = False
+    if _host_has("spectacle"):
+        # -r region, -b background (no GUI window), -n no notification: a
+        # direct rectangular drag, exactly like a native KDE install.
+        host("spectacle", "-r", "-b", "-n", "-o", sp, timeout=120)
+        ok = shared.is_file() and shared.stat().st_size > 0
+    elif _host_has("grim") and _host_has("slurp"):
+        geom = host("slurp", timeout=60)
+        if geom and geom.returncode == 0 and geom.stdout.strip():
+            host("grim", "-g", geom.stdout.strip(), sp, timeout=30)
+            ok = shared.is_file() and shared.stat().st_size > 0
+    elif _host_has("maim"):
+        host("maim", "-s", sp, timeout=60)
+        ok = shared.is_file() and shared.stat().st_size > 0
+    elif _host_has("gnome-screenshot"):
+        host("gnome-screenshot", "--area", "--file", sp, timeout=60)
+        ok = shared.is_file() and shared.stat().st_size > 0
+    else:
+        return False  # no host capture tool; caller tries the portal
+    if not ok:
+        try:
+            shared.unlink()
+        except OSError:
+            pass
+        return False
+    try:
+        shutil.move(sp, str(out_path))
+    except OSError:
+        try:
+            shutil.copyfile(sp, str(out_path))
+            shared.unlink()
+        except OSError:
+            return False
+    return out_path.is_file() and out_path.stat().st_size > 0
+
+
 def _has_capture_tool() -> bool:
     """True if we can capture a region. Inside Flatpak we go through the XDG
     Screenshot portal (no binary needed). Otherwise we need spectacle/grim
@@ -210,6 +285,11 @@ def _capture_region(out_path: Path) -> bool:
     drawn rectangle and write it as a PNG. Returns False if the user
     cancelled or the tool errored out."""
     if _in_flatpak():
+        # Prefer the native host tools (spectacle region drag, etc.) via
+        # flatpak-spawn; only fall back to the Screenshot portal if the host
+        # has no capture tool at all.
+        if _host_capture_region(out_path):
+            return True
         return _portal_screenshot(out_path)
     if shutil.which("spectacle"):
         # KDE's capture tool. Its rectangular-region selector works