elsewindow 0.2.0__tar.gz → 0.2.1__tar.gz

elsewindow-0.2.1/.version

@@ -0,0 +1 @@
+0.2.1

{elsewindow-0.2.0 → elsewindow-0.2.1}/CHANGELOG.md

@@ -6,6 +6,79 @@ All notable changes to Elsewindow are documented here.
 
 ## Unreleased
 
+### Fixed
+
+- Submit the two Xpra environment locks together with the other six to the
+  GitHub dependency graph. Since 0.2.0 the push-only submission job rejected the
+  generated snapshot; a unit test now keeps its accepted manifest list equal to
+  the generator's output.
+
+## [0.2.1] - 2026-09-08
+
+### Added
+
+- Include the standard desktop portal and GTK backend in explicit system-package
+  preparation and the release-backed disposable images. Startup never installs
+  system packages.
+- Own a private foreground desktop portal, GTK backend and transient permission
+  store for remote file dialogs and portal notifications. OpenURI and unrelated
+  desktop portal methods remain disabled.
+- Prevent repeated child-start requests from launching a second application or
+  competing portal helpers within the same owned session.
+- Add repeatable `--env NAME=VALUE` and `--env NAME` application overrides for
+  ordinary and persistent sessions. Preserve literal and empty values, isolate
+  overrides from session helpers, and require matching values on persistent
+  reconnects.
+- Document that Zed's default `notify_when_agent_waiting` opens no agent
+  notification window in any Wayland session, including Elsewindow's, and that
+  `all_screens` delivers them as forwarded windows.
+- Cover application-drawn agent notification windows in the live test with a
+  lightweight probe of Zed's Wayland flow, the operator's persistent H.264
+  `gigabit_lan` command line, and a real xfwm4 desktop across a persistent
+  reconnect.
+- Resume the ordered live matrix at a fixed failure with
+  `make live-test LIVE_FROM=CASE`, and run selected tests without the coverage
+  gate with `make test-focused TESTS=...`. Only a complete live run validates a
+  change.
+
+### Changed
+
+- Update the published SSH runtime dependency through its single requirements
+  input. Derive environment, lock, clean-install, standalone and live identity
+  checks from that input instead of maintaining duplicate version constants.
+- Missing journald no longer prevents ordinary or persistent application startup;
+  warn with setup guidance and retain terminal output and the remote log relay.
+- Check optional notification and GPU prerequisites on both hosts. Missing
+  support disables delivery or selects RGB for this connection with explicit
+  package guidance; absent portal services never prevent application startup.
+- Unavailable persistence or declined linger falls back to an ordinary session
+  only when no persistent state is recorded, with a warning about disconnect
+  cleanup. Never replace or duplicate an existing persistent application.
+- Synchronized the maintained fork's client wheel default and pointer diagnostics
+  without duplicating the mirrored wheel option in the session policy.
+
+### Fixed
+
+- Prevent an open but unread SSH output pipe from blocking ordinary remote
+  shutdown. Bound raw-output queues, retain native journal processing, and report
+  dropped bytes without postponing owned application cleanup.
+- Wait for the remote dialog's actual focus before sending its dismissal key
+  in the live GUI test. Repeat abrupt master loss and retain bounded process,
+  owned-path and shutdown-journal evidence on cleanup failure.
+- Allow local Xpra environment preparation, reuse, and startup on shared
+  filesystems with mapped ownership or broader Unix permissions.
+- Use the same resolved Xpra executable for preparation, diagnosis, and session
+  startup when PATH contains symbolic links. Allow longer installed-file checks
+  on shared storage and report timeouts without treating them as stale
+  environments or reinstalling dependencies.
+- Read installed file inventories directly with bounded concurrent reads during
+  Xpra validation to avoid repeated filesystem metadata scans and detect missing
+  package files.
+- Consume the canonical Xpra client modal-window default from the mirrored YAML
+  instead of duplicating it in Python.
+- Mask the current packaged Xpra socket and service in the disposable target so
+  its only TCP listener is SSH.
+
 ## [0.2.0] - 2026-09-05
 
 ### Added

{elsewindow-0.2.0 → elsewindow-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elsewindow
-Version: 0.2.0
+Version: 0.2.1
 Summary: Run one remote Linux GUI application through Xpra over one owned OpenSSH master
 Author: kogeler
 Maintainer: kogeler
@@ -25,7 +25,7 @@ Classifier: Typing :: Typed
 Requires-Python: <3.15,>=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ssh-wrapper==0.1.0
+Requires-Dist: ssh-wrapper==0.1.1
 Dynamic: license-file
 
 # Elsewindow
@@ -37,22 +37,26 @@ cleans only the server, application process group, sockets, and runtime state
 created by that invocation.
 
 The application renders through the remote Wayland compositor and remote GPU.
-Only Xpra picture, input, clipboard, and control traffic crosses SSH.
+Only Xpra picture, input, clipboard, notification, and control traffic crosses SSH.
 
 ## Install And Run
 
 The Python distribution requires Linux, CPython 3.13 or 3.14, OpenSSH,
-`false`, a local graphical session, and compatible Xpra packages and an
-accessible system journal on both systems. Install with pip or pipx after the
-first release:
+`false`, a local graphical session, and compatible Xpra packages on both
+systems. [Optional desktop features](doc/cli.md#optional-desktop-features)
+have separate system prerequisites: missing support produces a warning and
+disables only that feature for the session. Startup never installs packages.
+Install the latest published release with pip or pipx:
 
 ```bash
-python3.14 -m pip install "elsewindow==0.2.0"
-# or: pipx install "elsewindow==0.2.0"
+python3.14 -m pip install elsewindow
+# or: pipx install elsewindow
 elsewindow --prepare-xpra
 elsewindow --ssh-alias agents-a -- xterm
 ```
 
+The version prepared by this source tree is recorded only in [`.version`](.version).
+
 Check packaged versions, profile digests, Linux support, and local commands
 without opening a connection:
 
@@ -61,7 +65,8 @@ elsewindow --diagnose
 ```
 
 The published distribution resolves the exact reviewed
-[`ssh-wrapper==0.1.0`](https://pypi.org/project/ssh-wrapper/0.1.0/) dependency.
+[`ssh-wrapper`](https://pypi.org/project/ssh-wrapper/) release pinned only in
+[`requirements.in`](requirements.in).
 For a source checkout, prepare the hash-locked runtime and use the repository
 launcher from any working directory:
 
@@ -91,7 +96,9 @@ elsewindow \
 
 See the [CLI reference](doc/cli.md) for every option, default, and allowed
 value, including encoding/network profiles, clipboard policy, logging, and
-persistence. Reviewed profile arguments come from the packaged YAML mirrors.
+persistence. Repeat [`--env`](doc/cli.md#application-environment) to set remote
+application variables or copy explicitly named local values. Reviewed profile
+arguments come from the packaged YAML mirrors.
 The [Xpra guide](doc/xpra.md) covers hardware, application, and lifecycle
 behavior; the [security model](doc/security.md) explains clipboard and logging
 trust boundaries.

{elsewindow-0.2.0 → elsewindow-0.2.1}/README.md

@@ -7,22 +7,26 @@ cleans only the server, application process group, sockets, and runtime state
 created by that invocation.
 
 The application renders through the remote Wayland compositor and remote GPU.
-Only Xpra picture, input, clipboard, and control traffic crosses SSH.
+Only Xpra picture, input, clipboard, notification, and control traffic crosses SSH.
 
 ## Install And Run
 
 The Python distribution requires Linux, CPython 3.13 or 3.14, OpenSSH,
-`false`, a local graphical session, and compatible Xpra packages and an
-accessible system journal on both systems. Install with pip or pipx after the
-first release:
+`false`, a local graphical session, and compatible Xpra packages on both
+systems. [Optional desktop features](doc/cli.md#optional-desktop-features)
+have separate system prerequisites: missing support produces a warning and
+disables only that feature for the session. Startup never installs packages.
+Install the latest published release with pip or pipx:
 
 ```bash
-python3.14 -m pip install "elsewindow==0.2.0"
-# or: pipx install "elsewindow==0.2.0"
+python3.14 -m pip install elsewindow
+# or: pipx install elsewindow
 elsewindow --prepare-xpra
 elsewindow --ssh-alias agents-a -- xterm
 ```
 
+The version prepared by this source tree is recorded only in [`.version`](.version).
+
 Check packaged versions, profile digests, Linux support, and local commands
 without opening a connection:
 
@@ -31,7 +35,8 @@ elsewindow --diagnose
 ```
 
 The published distribution resolves the exact reviewed
-[`ssh-wrapper==0.1.0`](https://pypi.org/project/ssh-wrapper/0.1.0/) dependency.
+[`ssh-wrapper`](https://pypi.org/project/ssh-wrapper/) release pinned only in
+[`requirements.in`](requirements.in).
 For a source checkout, prepare the hash-locked runtime and use the repository
 launcher from any working directory:
 
@@ -61,7 +66,9 @@ elsewindow \
 
 See the [CLI reference](doc/cli.md) for every option, default, and allowed
 value, including encoding/network profiles, clipboard policy, logging, and
-persistence. Reviewed profile arguments come from the packaged YAML mirrors.
+persistence. Repeat [`--env`](doc/cli.md#application-environment) to set remote
+application variables or copy explicitly named local values. Reviewed profile
+arguments come from the packaged YAML mirrors.
 The [Xpra guide](doc/xpra.md) covers hardware, application, and lifecycle
 behavior; the [security model](doc/security.md) explains clipboard and logging
 trust boundaries.

{elsewindow-0.2.0 → elsewindow-0.2.1}/elsewindow/_persistent_agent.py

@@ -26,6 +26,11 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 
+from elsewindow.desktop import (
+    APPLICATION_LOADER,
+    application_argv,
+    validate_application_environment,
+)
 from elsewindow.journal import (
     DEFAULT_LOG_LEVEL,
     LOG_LEVELS,
@@ -44,7 +49,7 @@ SCHEMA = 1
 MAX_BYTES = 128 * 1024
 COMMAND_TIMEOUT = 15
 LOADER = REMOTE_LOADER
-APP_LOADER = "import base64,json,os,sys;a=json.loads(base64.b64decode(sys.argv[1]));os.execv(a[0],a)"
+APP_LOADER = APPLICATION_LOADER
 IDENTITY = re.compile(r"[a-f0-9]{64}")
 TOKEN = re.compile(r"[a-f0-9]{32}")
 DISPLAY = re.compile(r"wayland-[0-9]+")
@@ -135,18 +140,24 @@ def prerequisites() -> dict[str, Any]:
                 "persistent_systemd_unavailable",
                 "persistent sessions require systemd, loginctl and systemd-run on the remote host",
             )
-    linger = linger_enabled()
-    manager = False
-    if linger:
-        runtime_directory()
-        manager = (
-            run("/usr/bin/systemctl", "--user", "show-environment").returncode == 0
-        )
-        if not manager:
-            raise AgentError(
-                "persistent_systemd_unavailable",
-                "the remote systemd user manager is not available",
+    try:
+        linger = linger_enabled()
+        manager = False
+        if linger:
+            runtime_directory()
+            manager = (
+                run("/usr/bin/systemctl", "--user", "show-environment").returncode == 0
             )
+            if not manager:
+                raise AgentError(
+                    "persistent_systemd_unavailable",
+                    "the remote systemd user manager is not available",
+                )
+    except (OSError, subprocess.SubprocessError) as error:
+        raise AgentError(
+            "persistent_systemd_unavailable",
+            "the remote systemd user manager is unavailable",
+        ) from error
     return {"linger": linger, "manager": manager}
 
 
@@ -173,7 +184,20 @@ def enable_linger() -> dict[str, Any]:
     return {"linger": True}
 
 
-def canonical_application(value: Any) -> list[str]:
+def request_environment(request: dict[str, Any]) -> dict[str, str]:
+    try:
+        return validate_application_environment(
+            request.get("application_environment", {})
+        )
+    except ValueError as error:
+        raise AgentError(
+            "invalid_application_environment", "the application environment is invalid"
+        ) from error
+
+
+def canonical_application(
+    value: Any, environment: dict[str, str] | None = None
+) -> list[str]:
     if (
         not isinstance(value, list)
         or not value
@@ -186,7 +210,9 @@ def canonical_application(value: Any) -> list[str]:
         )
     executable = value[0]
     if "/" not in executable:
-        executable = shutil.which(executable) or ""
+        executable = (
+            shutil.which(executable, path=(environment or {}).get("PATH")) or ""
+        )
     if not executable:
         raise AgentError(
             "invalid_application", "the remote application executable was not found"
@@ -206,6 +232,21 @@ def state_root() -> Path:
     return secure_directory(runtime_directory() / "elsewindow-persistent", create=True)
 
 
+def ordinary_fallback(request: dict[str, Any]) -> dict[str, bool]:
+    """Never turn a failed resume into a second application instance."""
+    application = canonical_application(
+        request["application"], request_environment(request)
+    )
+    key = digest(application)
+    try:
+        runtime = secure_directory(Path("/run/user") / str(os.getuid()))
+        root = secure_directory(runtime / "elsewindow-persistent")
+    except FileNotFoundError:
+        return {"allowed": True}
+    with locked(root, key):
+        return {"allowed": read_record(root, key) is None}
+
+
 @contextmanager
 def locked(root: Path, key: str) -> Iterator[None]:
     if IDENTITY.fullmatch(key) is None:
@@ -353,15 +394,47 @@ def public_record(record: dict[str, Any], *, created: bool = False) -> dict[str,
             "xpra_pid",
             "xpra_start",
             "session_name",
+            "server_features",
         )
     } | {"created": created}
 
 
+def canonical_server(
+    server: Any,
+    application: list[str],
+    root: Path,
+    key: str,
+    application_environment: dict[str, str],
+) -> list[str]:
+    if not isinstance(server, list) or not all(isinstance(arg, str) for arg in server):
+        raise AgentError("invalid_configuration", "invalid persistent server command")
+    server = [arg.replace("$XDG_RUNTIME_DIR", str(root.parent)) for arg in server]
+    child = shlex.join(
+        application_argv(
+            tuple(application),
+            "--notifications=no" not in server,
+            application_environment=tuple(application_environment.items()),
+        )
+    )
+    indexes = [i for i, arg in enumerate(server) if arg.startswith("--start-child=")]
+    if len(indexes) != 1:
+        raise AgentError(
+            "invalid_configuration", "persistent server has no unique child command"
+        )
+    server[indexes[0]] = f"--start-child={child}"
+    session_name = f"elsewindow-{key[:16]}"
+    return [
+        f"--session-name={session_name}" if arg.startswith("--session-name=") else arg
+        for arg in server
+    ]
+
+
 def ensure(request: dict[str, Any], source: str) -> dict[str, Any]:
     """Serialize lookup and creation; never stop or replace an existing service."""
     # Complete an accepted launch even if the SSH command loses its terminal.
     signal.signal(signal.SIGHUP, signal.SIG_IGN)
-    application = canonical_application(request["application"])
+    application_environment = request_environment(request)
+    application = canonical_application(request["application"], application_environment)
     key = digest(application)
     session = log_session(key)
     if request.get("log_session", session) != session:
@@ -372,23 +445,29 @@ def ensure(request: dict[str, Any], source: str) -> dict[str, Any]:
     if level not in LOG_LEVELS:
         raise AgentError("invalid_configuration", "invalid logging policy")
     root = state_root()
-    server = request["server"]
-    if not isinstance(server, list) or not all(isinstance(arg, str) for arg in server):
-        raise AgentError("invalid_configuration", "invalid persistent server command")
-    server = [arg.replace("$XDG_RUNTIME_DIR", str(root.parent)) for arg in server]
-    child = shlex.join((sys.executable, "-c", APP_LOADER, encode(application)))
-    indexes = [i for i, arg in enumerate(server) if arg.startswith("--start-child=")]
-    if len(indexes) != 1:
-        raise AgentError(
-            "invalid_configuration", "persistent server has no unique child command"
-        )
-    server[indexes[0]] = f"--start-child={child}"
+    server = canonical_server(
+        request["server"], application, root, key, application_environment
+    )
+    requested = canonical_server(
+        request.get("requested_server", request["server"]),
+        application,
+        root,
+        key,
+        application_environment,
+    )
+    requested_sha256 = digest(["xpra", *requested[3:]])
     session_name = f"elsewindow-{key[:16]}"
-    server = [
-        f"--session-name={session_name}" if arg.startswith("--session-name=") else arg
-        for arg in server
-    ]
     argv_sha256 = digest(["xpra", *server[3:]])
+    features = request.get("server_features")
+    if features is not None and (
+        not isinstance(features, dict)
+        or set(features) != {"notifications", "encoding_profile"}
+        or type(features["notifications"]) is not bool
+        or not isinstance(features["encoding_profile"], str)
+        or len(features["encoding_profile"]) > 64
+        or features["notifications"] != ("--notifications=no" not in server)
+    ):
+        raise AgentError("invalid_configuration", "invalid persistent feature policy")
     with locked(root, key):
         record = read_record(root, key)
         state = unit_state(key)
@@ -396,9 +475,17 @@ def ensure(request: dict[str, Any], source: str) -> dict[str, Any]:
             verify_unit(record, state)
             if state.get("ActiveState") in {"active", "activating", "reloading"}:
                 assert record is not None
+                if record.get("application_environment", {}) != application_environment:
+                    raise AgentError(
+                        "persistent_environment_mismatch",
+                        "the existing session uses different application environment values; reconnect with its original --env values or exit the application first",
+                    )
                 if (
                     record.get("application") != application
-                    or record.get("argv_sha256") != argv_sha256
+                    or record.get("requested_argv_sha256", record.get("argv_sha256"))
+                    != requested_sha256
+                    or record.get("argv_sha256")
+                    != digest(["xpra", *record["server"][3:]])
                     or record.get("log_level") != level
                     or record.get("journal_protocol") != LOG_PROTOCOL
                     or record.get("log_session") != session
@@ -417,8 +504,11 @@ def ensure(request: dict[str, Any], source: str) -> dict[str, Any]:
             "key": key,
             "token": secrets.token_hex(16),
             "application": application,
+            "application_environment": application_environment,
             "server": server,
             "argv_sha256": argv_sha256,
+            "requested_argv_sha256": requested_sha256,
+            "server_features": features,
             "cwd": str(Path.cwd()),
             "environment": {
                 key: os.environ[key]
@@ -529,7 +619,7 @@ def serve(request: dict[str, Any]) -> None:
                 "server",
                 record["log_session"],
             )
-            journal.open()
+            journal.open_optional()
             record.update(
                 worker_pid=os.getpid(),
                 worker_start=process_start(os.getpid()),
@@ -540,7 +630,10 @@ def serve(request: dict[str, Any]) -> None:
                 stdin=subprocess.DEVNULL,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
-                env=bus.start(xpra_environment(journal.level)),
+                env=bus.start_optional(
+                    xpra_environment(journal.level),
+                    lambda message: journal.emit(PRIORITIES["warning"], message),
+                ),
             )
             record.update(xpra_pid=process.pid, xpra_start=process_start(process.pid))
             write_record(root, record)
@@ -621,9 +714,11 @@ def main(arguments: list[str]) -> int:
         request = json.loads(base64.b64decode(encoded, validate=True))
         if not isinstance(request, dict):
             raise TypeError("payload must be an object")
-        if action in {
+        result: dict[str, Any]
+        if not request.get("log_deferred", False) and action in {
             "identify",
             "probe",
+            "ordinary-fallback",
             "enable-linger",
             "ensure",
             "status",
@@ -634,9 +729,13 @@ def main(arguments: list[str]) -> int:
                 "server",
                 request.get("log_session", ""),
             )
-            journal.open()
+            journal.open_optional()
         if action == "identify":
-            key = digest(canonical_application(request["application"]))
+            key = digest(
+                canonical_application(
+                    request["application"], request_environment(request)
+                )
+            )
             # No successful record precedes identity negotiation. Errors still
             # use the shared invocation ID supplied by the client.
             result = {"key": key, "log_session": log_session(key)}
@@ -644,6 +743,8 @@ def main(arguments: list[str]) -> int:
             result = prerequisites()
             if journal is not None:
                 journal.emit(PRIORITIES["info"], "persistent prerequisites checked")
+        elif action == "ordinary-fallback":
+            result = ordinary_fallback(request)
         elif action == "enable-linger":
             result = enable_linger()
         elif action == "ensure":
@@ -661,7 +762,15 @@ def main(arguments: list[str]) -> int:
         return 0
     except AgentError as error:
         if journal is not None:
-            journal.emit(PRIORITIES["error"], f"{error.code}: {error}")
+            journal.emit(
+                PRIORITIES[
+                    "warning"
+                    if action == "probe"
+                    and error.code == "persistent_systemd_unavailable"
+                    else "error"
+                ],
+                f"{error.code}: {error}",
+            )
         if not serving:
             print(json.dumps({"error": error.code, "message": str(error)}), flush=True)
     except JournalError:

{elsewindow-0.2.0 → elsewindow-0.2.1}/elsewindow/cli.py

@@ -10,6 +10,7 @@ import asyncio
 import hashlib
 import shutil
 import signal
+import subprocess
 import sys
 from collections.abc import Sequence
 from contextlib import suppress
@@ -36,7 +37,15 @@ from .config import (
     SUPPORTED_NETWORK_PROFILES,
     XpraConfig,
 )
-from .journal import DEFAULT_LOG_LEVEL, LOG_LEVELS, PRIORITIES, Journal
+from .desktop import NOTIFICATION_PACKAGES, probe_argv, probe_result
+from .journal import (
+    DEFAULT_LOG_LEVEL,
+    LOG_LEVELS,
+    PRIORITIES,
+    Journal,
+    JournalError,
+    xpra_environment,
+)
 from .session import ReportedSSHError, XpraSession
 from .xpra_runtime import XpraRuntimeError, prepare, prepared_launcher
 
@@ -66,6 +75,12 @@ def build_parser() -> argparse.ArgumentParser:
     authority.add_argument("--host", help="direct SSH host or address")
     parser.add_argument("--user", help="remote user required with --host")
     parser.add_argument("--port", type=int, default=22, help="direct SSH port")
+    parser.add_argument(
+        "--env",
+        action="append",
+        metavar="NAME[=VALUE]",
+        help="set an application variable, or copy a named local variable; repeat for multiple variables",
+    )
     parser.add_argument(
         "--encoding-profile",
         choices=SUPPORTED_ENCODING_PROFILES,
@@ -90,7 +105,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--persistent",
         action="store_true",
-        help="keep the remote application after disconnect and resume by its argv",
+        help="request persistence and resume by argv; warn and use ordinary lifetime if unavailable",
     )
     parser.add_argument(
         "--log-level",
@@ -136,6 +151,7 @@ def _diagnose() -> int:
         ("_persistent_agent.py", files("elsewindow").joinpath("_persistent_agent.py")),
         ("journal.py", files("elsewindow").joinpath("journal.py")),
         ("session_bus.py", files("elsewindow").joinpath("session_bus.py")),
+        ("desktop.py", files("elsewindow").joinpath("desktop.py")),
         ("log_transport.py", files("elsewindow").joinpath("log_transport.py")),
         (
             "requirements-xpra.txt",
@@ -185,9 +201,58 @@ def _diagnose() -> int:
                     failed = True
                 else:
                     print("xpra-environment: verified")
+    if not failed:
+        _diagnose_optional()
     return int(failed)
 
 
+def _diagnose_optional() -> None:
+    try:
+        result = subprocess.run(
+            probe_argv("client"),
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            env=xpra_environment(DEFAULT_LOG_LEVEL),
+            timeout=15,
+            check=False,
+        )
+        capabilities = probe_result(result.returncode, result.stdout)
+    except (OSError, ValueError, subprocess.TimeoutExpired):
+        capabilities = {"notifications": False, "render": False}
+    for feature, available in capabilities.items():
+        print(
+            f"optional-local-{feature}: {'available' if available else 'unavailable'}"
+        )
+    if not capabilities["notifications"]:
+        print(
+            "elsewindow: warning: local notification delivery is unavailable. "
+            f"On Debian/Ubuntu, install {NOTIFICATION_PACKAGES} and run a desktop "
+            "notification service (for example dunst). Sessions continue without delivery.",
+            file=sys.stderr,
+        )
+    if not capabilities["render"]:
+        print(
+            "elsewindow: warning: no accessible local DRM render device; H.264 "
+            "connections fall back to RGB. Check GPU permissions and the system "
+            "VA-API driver. Ordinary RGB sessions remain available.",
+            file=sys.stderr,
+        )
+    journal = Journal(DEFAULT_LOG_LEVEL, "client")
+    try:
+        journal.open()
+    except (OSError, JournalError):
+        print(
+            "elsewindow: warning: local journald is unavailable. Install systemd "
+            "and enable systemd-journald; terminal logging remains available.",
+            file=sys.stderr,
+        )
+    finally:
+        journal.close()
+    print(
+        "optional-remote-features: checked after SSH authentication and display startup"
+    )
+
+
 async def _run_with_signals(config: XpraConfig) -> int:
     session = XpraSession(config)
     loop = asyncio.get_running_loop()
@@ -234,9 +299,10 @@ def main(argv: Sequence[str] | None = None) -> int:
             or args.user is not None
             or args.port != 22
             or args.application
+            or args.env
         ):
             parser.error(
-                "setup and diagnosis cannot be combined with a session authority"
+                "setup and diagnosis cannot be combined with session or application inputs"
             )
         if args.diagnose:
             return _diagnose()