flatpak: OCR via Screenshot portal + bundled tesseract; run-in-terminal/run-command on host via flatpak-spawn; open-path on host; drop home grant (fixes config writes); v0.9.3

Author: GaimsDevSoftware

actions.py

@@ -260,18 +260,46 @@ def search_web(text: str) -> None:
     get_backend().open_url(url)
 
 
+def _in_flatpak() -> bool:
+    return os.path.exists("/.flatpak-info")
+
+
+_TERMINALS = [
+    ("gnome-terminal", ["gnome-terminal", "--", "bash", "-c"]),
+    ("konsole", ["konsole", "-e", "bash", "-c"]),
+    ("xfce4-terminal", ["xfce4-terminal", "-e"]),
+    ("alacritty", ["alacritty", "-e", "bash", "-c"]),
+    ("kitty", ["kitty", "bash", "-c"]),
+    ("x-terminal-emulator", ["x-terminal-emulator", "-e", "bash", "-c"]),
+    ("xterm", ["xterm", "-hold", "-e", "bash", "-c"]),  # xterm has -hold
+]
+
+
+def _host_has(binary: str) -> bool:
+    """Is `binary` on the host's PATH? Checked through flatpak-spawn so it
+    works from inside the sandbox."""
+    try:
+        r = subprocess.run(
+            ["flatpak-spawn", "--host", "sh", "-c",
+             "command -v %s" % shlex.quote(binary)],
+            capture_output=True, timeout=5,
+        )
+        return r.returncode == 0
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
 def _find_terminal() -> Optional[tuple[str, list[str]]]:
-    """Return (binary, argv-prefix) for the first installed terminal emulator."""
-    candidates = [
-        ("gnome-terminal", ["gnome-terminal", "--", "bash", "-c"]),
-        ("konsole", ["konsole", "-e", "bash", "-c"]),
-        ("xfce4-terminal", ["xfce4-terminal", "-e"]),
-        ("alacritty", ["alacritty", "-e", "bash", "-c"]),
-        ("kitty", ["kitty", "bash", "-c"]),
-        ("x-terminal-emulator", ["x-terminal-emulator", "-e", "bash", "-c"]),
-        ("xterm", ["xterm", "-hold", "-e", "bash", "-c"]),  # xterm has -hold
-    ]
-    for binary, argv in candidates:
+    """Return (binary, argv-prefix) for the first available terminal emulator.
+    Inside Flatpak the command has to run on the host (running it in the
+    sandbox would hit the wrong filesystem and tools), so we look for the
+    terminal on the host's PATH and prefix the argv with flatpak-spawn --host."""
+    if _in_flatpak():
+        for binary, argv in _TERMINALS:
+            if _host_has(binary):
+                return binary, ["flatpak-spawn", "--host", *argv]
+        return None
+    for binary, argv in _TERMINALS:
         if shutil.which(binary):
             return binary, argv
     return None
@@ -512,7 +540,21 @@ def run_in_terminal(text: str) -> None:
 
 
 def open_path(text: str) -> None:
-    path = os.path.expanduser(_strip_invisible(text))
+    raw = _strip_invisible(text)
+    if _in_flatpak():
+        # Open on the host: the sandbox can't open an arbitrary host path
+        # (the OpenURI portal needs a readable fd we don't have). Expand a
+        # leading ~ against the HOST's $HOME, then run the host's xdg-open.
+        argv = ["flatpak-spawn", "--host", "sh", "-c",
+                'p="$1"; case "$p" in "~"*) p="$HOME${p#\\~}";; esac; '
+                'exec xdg-open "$p"', "sh", raw]
+        try:
+            subprocess.Popen(argv, start_new_session=True)
+            print(f"[actions] opened path on host: {raw}")
+        except OSError:
+            print("[actions] flatpak-spawn not available")
+        return
+    path = os.path.expanduser(raw)
     try:
         subprocess.Popen(
             ["xdg-open", path],

icon_picker.py

@@ -259,10 +259,11 @@ def _on_link_clicked(self, _label, uri: str) -> bool:
         """Handle the custom linuxpop:// link in the empty-state message."""
         if uri == "linuxpop://open-user-icons":
             USER_ICONS_DIR.mkdir(parents=True, exist_ok=True)
+            argv = (["flatpak-spawn", "--host", "xdg-open", str(USER_ICONS_DIR)]
+                    if os.path.exists("/.flatpak-info")
+                    else ["xdg-open", str(USER_ICONS_DIR)])
             try:
-                subprocess.Popen(
-                    ["xdg-open", str(USER_ICONS_DIR)], start_new_session=True,
-                )
+                subprocess.Popen(argv, start_new_session=True)
             except FileNotFoundError:
                 pass
             return True  # consumed

main.py

@@ -40,7 +40,7 @@
 from popup import PopupWindow
 from settings import get_settings
 
-__version__ = "0.9.2"
+__version__ = "0.9.3"
 
 CACHE_DIR = Path(os.path.expanduser("~/.cache/linuxpop"))
 LOG_FILE = CACHE_DIR / "linuxpop.log"

mcp_server.py

@@ -44,7 +44,7 @@
 
 PROTOCOL_VERSION = "2024-11-05"
 SERVER_NAME = "linuxpop"
-SERVER_VERSION = "0.9.2"
+SERVER_VERSION = "0.9.3"
 
 # 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

@@ -74,11 +74,17 @@ finish-args:
   # same host path KWin can open, so no broad /tmp grant is needed and the
   # host-tmp linter error is gone.
   - --filesystem=xdg-run/linuxpop:create
-  # Read-only home so the "open file/folder" action can hand the selected
-  # path to the OpenURI portal (xdg-open needs to open the file to pass its
-  # fd; with no filesystem access the portal call silently no-ops). Read-only
-  # is sufficient - the launched handler runs host-side with its own access.
-  - --filesystem=home:ro
+  # NOTE: no broad home/host filesystem grant. "Open file/folder" runs the
+  # host's xdg-open via flatpak-spawn --host (see actions.open_path), so it
+  # opens any selected path without home access - and the app keeps its own
+  # writable per-app config dir (a home grant would flip $HOME to the real,
+  # here read-only, home and break settings writes).
+  - --env=TESSDATA_PREFIX=/app/share/tessdata   # bundled OCR language data (eng+nor)
+  # "Run in terminal" / run-command actions execute the user's command on the
+  # HOST through flatpak-spawn --host. Running it inside the sandbox would hit
+  # the wrong tools and filesystem. This is a broad permission, but it is
+  # exactly what the feature does, and LinuxPop is self-distributed (not Flathub).
+  - --talk-name=org.freedesktop.Flatpak
   - --device=dri                  # GTK rendering
 
 cleanup:
@@ -298,6 +304,47 @@ modules:
       - /lib/pkgconfig
       - '*.la'
 
+  # ----- Screen OCR: leptonica + tesseract + language data (eng, nor) -----
+  # Capture happens through the XDG Screenshot portal (no screenshot binary
+  # needed in the sandbox); these provide the recognition engine.
+  - name: leptonica
+    buildsystem: autotools
+    sources:
+      - type: archive
+        url: https://github.com/DanBloomberg/leptonica/releases/download/1.85.0/leptonica-1.85.0.tar.gz
+        sha256: 3745ae3bf271a6801a2292eead83ac926e3a9bc1bf622e9cd4dd0f3786e17205
+    cleanup:
+      - /include
+      - /lib/pkgconfig
+      - '*.la'
+
+  - name: tesseract
+    buildsystem: autotools
+    config-opts:
+      - --disable-openmp
+      - --disable-legacy
+    sources:
+      - type: archive
+        url: https://github.com/tesseract-ocr/tesseract/archive/refs/tags/5.5.0.tar.gz
+        sha256: f2fb34ca035b6d087a42875a35a7a5c4155fa9979c6132365b1e5a28ebc3fc11
+    cleanup:
+      - /include
+      - /lib/pkgconfig
+      - '*.la'
+
+  - name: tessdata
+    buildsystem: simple
+    build-commands:
+      - install -Dm644 eng.traineddata /app/share/tessdata/eng.traineddata
+      - install -Dm644 nor.traineddata /app/share/tessdata/nor.traineddata
+    sources:
+      - type: file
+        url: https://github.com/tesseract-ocr/tessdata_fast/raw/main/eng.traineddata
+        sha256: 7d4322bd2a7749724879683fc3912cb542f19906c83bcc1a52132556427170b2
+      - type: file
+        url: https://github.com/tesseract-ocr/tessdata_fast/raw/main/nor.traineddata
+        sha256: 0451eb4f8049ae78196806bf878a389a2f40f1386fe038568cf4441226ba6ef2
+
   - name: linuxpop
     buildsystem: simple
     build-commands:

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

@@ -96,6 +96,14 @@
   <content_rating type="oars-1.1" />
 
   <releases>
+    <release version="0.9.3" date="2026-06-15">
+      <description>
+        <p>Flatpak: screen OCR is back (bundled tesseract + Screenshot portal);
+        run-in-terminal and run-command now run on the host via flatpak-spawn;
+        open file/folder works for any path; dropped the home filesystem grant
+        that was blocking the app from saving its own settings.</p>
+      </description>
+    </release>
     <release version="0.9.2" date="2026-06-15">
       <description>
         <p>Flatpak fixes: "open file/folder" now works (read-only home access);

recipe_loader.py

@@ -207,8 +207,13 @@ def disabled_handler(_text: str) -> None:
 
         def handler(text: str) -> None:
             cmd = _render(template, text)
+            # In Flatpak, run on the host (the sandbox has the wrong tools and
+            # filesystem); flatpak-spawn --host needs --talk-name=org.freedesktop.Flatpak.
+            argv = (["flatpak-spawn", "--host", "bash", "-c", cmd]
+                    if os.path.exists("/.flatpak-info")
+                    else ["bash", "-c", cmd])
             try:
-                subprocess.Popen(["bash", "-c", cmd], start_new_session=True)
+                subprocess.Popen(argv, start_new_session=True)
             except OSError as exc:
                 subprocess.run(
                     ["notify-send", "--hint=byte:transient:1", "-t", "3000",  "-i", "dialog-error",

screen_ocr.py

@@ -89,9 +89,68 @@ def has(needles: tuple[str, ...]) -> bool:
             "tesseract-ocr-nor maim")
 
 
+def _in_flatpak() -> bool:
+    return os.path.exists("/.flatpak-info")
+
+
+def _portal_screenshot(out_path: Path) -> bool:
+    """Capture a region via the XDG Screenshot portal (interactive). On KDE
+    this opens Spectacle's region selector; the portal hands back the saved
+    image URI, which we copy to out_path. This is how OCR captures inside the
+    Flatpak sandbox, where no screenshot binary is on PATH."""
+    try:
+        import urllib.parse
+        import dbus
+        from dbus.mainloop.glib import DBusGMainLoop
+        from gi.repository import GLib
+    except Exception as exc:  # noqa: BLE001
+        log.warning("[ocr] screenshot portal unavailable: %s", exc)
+        return False
+    got: dict[str, str] = {}
+    try:
+        DBusGMainLoop(set_as_default=True)
+        bus = dbus.SessionBus()
+        portal = bus.get_object("org.freedesktop.portal.Desktop",
+                                "/org/freedesktop/portal/desktop")
+        iface = dbus.Interface(portal, "org.freedesktop.portal.Screenshot")
+        loop = GLib.MainLoop()
+
+        def _on_response(response, results):
+            if int(response) == 0 and "uri" in results:
+                got["uri"] = str(results["uri"])
+            loop.quit()
+
+        req_path = iface.Screenshot(
+            "", {"interactive": dbus.Boolean(True),
+                 "handle_token": "linuxpop_ocr_%d" % os.getpid()})
+        bus.add_signal_receiver(
+            _on_response, signal_name="Response",
+            dbus_interface="org.freedesktop.portal.Request", path=str(req_path))
+        # Generous timeout: the user is drawing a box by hand.
+        GLib.timeout_add(180000, lambda: (loop.quit(), False)[1])
+        loop.run()
+    except Exception as exc:  # noqa: BLE001
+        log.warning("[ocr] screenshot portal call failed: %s", exc)
+        return False
+    uri = got.get("uri")
+    if not uri:
+        return False  # user cancelled, or no result
+    src = uri[7:] if uri.startswith("file://") else uri
+    src = urllib.parse.unquote(src)
+    try:
+        shutil.copyfile(src, str(out_path))
+    except OSError as exc:
+        log.warning("[ocr] could not read portal screenshot %s: %s", src, exc)
+        return False
+    return out_path.is_file() and out_path.stat().st_size > 0
+
+
 def _has_capture_tool() -> bool:
-    """True if any supported region-capture tool is on PATH. spectacle and
-    grim work natively on Wayland; maim/gnome-screenshot are the X11 path."""
+    """True if we can capture a region. Inside Flatpak we go through the XDG
+    Screenshot portal (no binary needed). Otherwise we need spectacle/grim
+    (Wayland) or maim/gnome-screenshot (X11) on PATH."""
+    if _in_flatpak():
+        return True
     return bool(shutil.which("spectacle") or shutil.which("grim")
                 or shutil.which("maim") or shutil.which("gnome-screenshot"))
 
@@ -114,6 +173,8 @@ def install_argv() -> "list[str] | None":
     we don't recognise the package manager. A capture tool is only added
     when none is present - KDE already ships spectacle, so on most Wayland
     desktops only tesseract is missing."""
+    if _in_flatpak():
+        return None  # can't install host packages from the sandbox; OCR is bundled
     ids = _distro_id()
 
     def has(needles: tuple) -> bool:
@@ -148,6 +209,8 @@ def _capture_region(out_path: Path) -> bool:
     """Use whichever region-capture tool is installed to grab a user-
     drawn rectangle and write it as a PNG. Returns False if the user
     cancelled or the tool errored out."""
+    if _in_flatpak():
+        return _portal_screenshot(out_path)
     if shutil.which("spectacle"):
         # KDE's capture tool. Its rectangular-region selector works
         # natively on Wayland (maim is X11-only and grim needs wlroots),
@@ -290,16 +353,6 @@ def run_ocr_to_clipboard() -> None:
     tray menu. Captures a region, OCRs it, puts the result on the
     clipboard, and shows the result text in the popup (so it lands as
     a selection the rest of LinuxPop's actions can pick up)."""
-    if os.path.exists("/.flatpak-info"):
-        # Screen OCR needs a screenshot tool + tesseract; neither is in the
-        # Flatpak (and Wayland capture would need the Screenshot portal). Don't
-        # show the distro "install ..." hint to a Flatpak user - just say so.
-        subprocess.run(
-            ["notify-send", "--hint=byte:transient:1", "-t", "4000",
-             "-i", "dialog-information", "LinuxPop OCR",
-             "Screen OCR isn't available in the Flatpak build of LinuxPop."],
-            check=False)
-        return
     ok_sup, reason = is_supported()
     if not ok_sup:
         subprocess.run(