solstone-linux 0.2.0__tar.gz → 0.3.0__tar.gz

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to solstone-linux are documented here.
 The format is based on Keep a Changelog (https://keepachangelog.com/),
 and this project adheres to Semantic Versioning.
 
+## [0.3.0] - 2026-06-14
+
+setup is now zero-config: the observer connects to your journal automatically,
+with no url to type.
+
+### Changed
+- setup no longer asks for a journal url. if your journal runs on another
+  machine you reach directly, set its address with
+  `solstone-linux setup --server-url <url>`.
+
 ## [0.2.0] - 2026-06-13
 
 setup is now hands-off: the first time the observer runs, it connects itself

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solstone-linux
-Version: 0.2.0
+Version: 0.3.0
 Summary: Standalone Linux desktop observer for solstone
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -33,7 +33,7 @@ Standalone Linux desktop observer for [solstone](https://solpbc.org). Experience
 
    **Arch:**
    ```
-   sudo pacman -S python-gobject gtk4 gstreamer gst-plugin-pipewire libpulse alsa-lib xdg-desktop-portal pipx
+   sudo pacman -S python-gobject gtk4 gstreamer gst-plugin-pipewire gst-plugins-good libpulse alsa-lib xdg-desktop-portal python-pipx uv python-cairo
    ```
 
    **openSUSE:**

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/README.md

@@ -18,7 +18,7 @@ Standalone Linux desktop observer for [solstone](https://solpbc.org). Experience
 
    **Arch:**
    ```
-   sudo pacman -S python-gobject gtk4 gstreamer gst-plugin-pipewire libpulse alsa-lib xdg-desktop-portal pipx
+   sudo pacman -S python-gobject gtk4 gstreamer gst-plugin-pipewire gst-plugins-good libpulse alsa-lib xdg-desktop-portal python-pipx uv python-cairo
    ```
 
    **openSUSE:**

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solstone-linux"
-version = "0.2.0"
+version = "0.3.0"
 description = "Standalone Linux desktop observer for solstone"
 readme = "README.md"
 license = "AGPL-3.0-only"

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/__init__.py

@@ -3,4 +3,4 @@
 
 """Standalone Linux desktop observer for solstone."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/activity.py

@@ -12,6 +12,9 @@ running regardless of desktop environment.
 import asyncio
 import logging
 import os
+import re
+import shutil
+import subprocess
 
 from dbus_next import Variant
 from dbus_next.aio import MessageBus
@@ -113,6 +116,83 @@ async def _name_has_owner(bus: MessageBus, bus_name: str) -> bool:
         return False
 
 
+def get_monitor_geometries_x11() -> list[dict]:
+    """Get monitor geometry from xrandr (X11 only).
+
+    Returns:
+        List of dicts with format:
+        [{"id": "connector-id", "box": [x1, y1, x2, y2], "position": "..."}, ...]
+        Empty list if xrandr is unavailable or returns no connected monitors.
+    """
+    try:
+        result = subprocess.run(
+            ["xrandr"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return []
+
+    if result.returncode != 0:
+        return []
+
+    from .monitor_positions import assign_monitor_positions
+
+    monitors = []
+    for line in result.stdout.splitlines():
+        if " connected" not in line or "disconnected" in line:
+            continue
+        parts = line.split()
+        name = parts[0]
+        for part in parts:
+            m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", part)
+            if m:
+                w, h = int(m.group(1)), int(m.group(2))
+                x, y = int(m.group(3)), int(m.group(4))
+                if x < 0 or y < 0:
+                    logger.warning(
+                        "Skipping monitor %s with negative offset (%d, %d); "
+                        "ximagesrc requires non-negative coordinates",
+                        name,
+                        x,
+                        y,
+                    )
+                    break
+                monitors.append({"id": name, "box": [x, y, x + w, y + h]})
+                break
+
+    return assign_monitor_positions(monitors)
+
+
+async def is_dpms_active() -> bool:
+    """Check if DPMS has powered off the display (X11 only).
+
+    Runs xset q and parses the monitor state line.
+    Returns True if the display is in standby/suspend/off state, False otherwise.
+    Degrades gracefully to False when xset is unavailable or returns an error.
+    """
+    try:
+        result = await asyncio.to_thread(
+            subprocess.run,
+            ["xset", "q"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return False
+
+    if result.returncode != 0:
+        return False
+
+    for line in result.stdout.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("Monitor is"):
+            return stripped != "Monitor is On"
+    return False
+
+
 async def probe_activity_services(bus: MessageBus) -> dict[str, bool]:
     """Check which activity DBus services are reachable."""
     services = {
@@ -126,17 +206,24 @@ async def probe_activity_services(bus: MessageBus) -> dict[str, bool]:
     for name, bus_name in services.items():
         results[name] = await _name_has_owner(bus, bus_name)
 
+    # DPMS is X11-only, checked via xset availability
+    results["dpms"] = bool(shutil.which("xset"))
+    results["gtk4"] = _HAS_GTK
+
     # Log grouped by function
     lock_backends = ["fdo_screensaver", "gnome_screensaver"]
     power_backends = ["gnome_display_config", "kde_power"]
     monitor_backends = ["kscreen"]
-    results["gtk4"] = _HAS_GTK
 
     def _status(keys):
         return ", ".join(f"{k} [{'ok' if results[k] else 'missing'}]" for k in keys)
 
     logger.info("Screen lock backends: %s", _status(lock_backends))
-    logger.info("Power save backends: %s", _status(power_backends))
+    logger.info(
+        "Power save backends: %s, dpms [%s]",
+        _status(power_backends),
+        "ok" if results["dpms"] else "missing",
+    )
     logger.info(
         "Monitor backends: %s, gtk4 [%s]",
         _status(monitor_backends),
@@ -265,7 +352,12 @@ async def is_power_save_active(bus: MessageBus) -> bool:
     ) as exc:
         if not _is_service_missing(exc):
             log_backend_failure_once("KDE", KDE_POWER_BUS, KDE_POWER_PATH, exc)
-        return False
+
+    # X11-only fallback: DPMS via xset
+    if os.environ.get("XDG_SESSION_TYPE", "").lower() == "x11":
+        return await is_dpms_active()
+
+    return False
 
 
 def get_monitor_geometries() -> list[dict]:

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/cli.py

@@ -25,7 +25,7 @@ import sys
 from pathlib import Path
 
 from . import doctor, streams
-from .config import load_config, save_config
+from .config import DEFAULT_SERVER_URL, load_config, save_config
 from .streams import stream_name
 
 
@@ -94,19 +94,10 @@ def cmd_setup(args: argparse.Namespace) -> int:
     config = load_config()
 
     server_url = getattr(args, "server_url", None) or config.server_url
-    if not server_url:
-        if non_interactive:
-            print(
-                "error: --server-url required with --non-interactive", file=sys.stderr
-            )
-            return 2
-        default_url = config.server_url or ""
-        url = input(f"Solstone journal URL [{default_url}]: ").strip()
-        if url:
-            server_url = url
-        elif not config.server_url:
-            print("Error: journal URL is required", file=sys.stderr)
-            return 1
+    if not server_url and not non_interactive:
+        url = input(f"Solstone journal URL [{DEFAULT_SERVER_URL}]: ").strip()
+        server_url = url or DEFAULT_SERVER_URL
+    server_url = server_url or DEFAULT_SERVER_URL
     config.server_url = server_url
 
     stream_override = getattr(args, "stream_name", None)
@@ -161,19 +152,15 @@ def cmd_setup(args: argparse.Namespace) -> int:
 
 
 def _cmd_setup_interactive() -> int:
-    # Keep the legacy no-flags setup path separate so its prompt/output stays byte-identical.
+    # Keep the legacy no-flags setup path separate so its output stays stable.
     from .upload import UploadClient
 
     config = load_config()
 
     # Prompt for server URL
-    default_url = config.server_url or ""
+    default_url = config.server_url or DEFAULT_SERVER_URL
     url = input(f"Solstone journal URL [{default_url}]: ").strip()
-    if url:
-        config.server_url = url
-    elif not config.server_url:
-        print("Error: journal URL is required", file=sys.stderr)
-        return 1
+    config.server_url = url or default_url
 
     # Derive stream name
     if not config.stream:
@@ -241,6 +228,28 @@ def cmd_install_service(args: argparse.Namespace) -> int:
     unit_path.write_text(unit)
     print(f"Wrote {unit_path}")
 
+    # XDG autostart entry — X11 session managers that don't activate
+    # graphical-session.target (the systemd unit's WantedBy target) need this
+    # to autostart the service.  On Wayland, `start` is a no-op when the
+    # service is already running.
+    autostart_dir = Path.home() / ".config" / "autostart"
+    autostart_dir.mkdir(parents=True, exist_ok=True)
+    autostart_path = autostart_dir / "solstone-linux.desktop"
+    autostart_path.write_text(
+        "[Desktop Entry]\n"
+        "Version=1.2\n"
+        "Type=Application\n"
+        "Name=Solstone Observer\n"
+        "Comment=Experience screen and audio with your solstone journal\n"
+        "Exec=/bin/sh -c 'systemctl --user import-environment"
+        " DISPLAY XAUTHORITY XDG_SESSION_TYPE 2>/dev/null;"
+        " systemctl --user start solstone-linux.service'\n"
+        "StartupNotify=false\n"
+        "X-GNOME-Autostart-enabled=true\n"
+        "Hidden=false\n"
+    )
+    print(f"Wrote {autostart_path}")
+
     # Reload, enable, restart, and show status
     try:
         subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/config.py

@@ -20,6 +20,7 @@ from pathlib import Path
 logger = logging.getLogger(__name__)
 
 DEFAULT_BASE_DIR = Path.home() / ".local" / "share" / "solstone-linux"
+DEFAULT_SERVER_URL = "http://localhost:5015"
 DEFAULT_SEGMENT_INTERVAL = 300
 DEFAULT_SYNC_RETRY_DELAYS = [5, 30, 120, 300]
 DEFAULT_SYNC_MAX_RETRIES = 10
@@ -39,6 +40,9 @@ class Config:
     sync_max_retries: int = DEFAULT_SYNC_MAX_RETRIES
     cache_retention_days: int = 7
     chat_bridge_enabled: bool = True
+    capture_framerate: int = 1
+    draw_cursor: bool = True
+    start_paused: bool = False
     base_dir: Path = DEFAULT_BASE_DIR
 
     @property
@@ -98,6 +102,9 @@ def load_config(base_dir: Path | None = None) -> Config:
     except (TypeError, ValueError):
         config.cache_retention_days = 7
     config.chat_bridge_enabled = data.get("chat_bridge_enabled", True)
+    config.capture_framerate = max(1, min(int(data.get("capture_framerate", 1)), 10))
+    config.draw_cursor = bool(data.get("draw_cursor", True))
+    config.start_paused = bool(data.get("start_paused", False))
 
     return config
 
@@ -115,6 +122,9 @@ def save_config(config: Config) -> None:
         "sync_max_retries": config.sync_max_retries,
         "cache_retention_days": config.cache_retention_days,
         "chat_bridge_enabled": config.chat_bridge_enabled,
+        "capture_framerate": config.capture_framerate,
+        "draw_cursor": config.draw_cursor,
+        "start_paused": config.start_paused,
     }
 
     config_path = config.config_path

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/doctor.py

@@ -83,22 +83,17 @@ def check_session_type() -> CheckResult:
     if session_type == "wayland":
         return CheckResult("session type", "ok", "wayland")
     if session_type == "x11":
-        return CheckResult(
-            "session type",
-            "fail",
-            "x11 session; ScreenCast portal needs Wayland "
-            "(KDE's screencast protocol is Wayland-only)",
-        )
+        return CheckResult("session type", "ok", "x11 (using ximagesrc capture)")
     if not session_type:
         return CheckResult(
             "session type",
             "warn",
-            "XDG_SESSION_TYPE not set; ScreenCast requires a Wayland session",
+            "XDG_SESSION_TYPE not set; Wayland or X11 required",
         )
     return CheckResult(
         "session type",
         "warn",
-        f"unrecognized session type '{session_type}'; Wayland required",
+        f"unrecognized session type '{session_type}'; Wayland or X11 required",
     )
 
 
@@ -162,6 +157,13 @@ async def check_portal() -> CheckResult:
                     "ok",
                     "org.freedesktop.portal.Desktop registered on session bus",
                 )
+            session_type = os.environ.get("XDG_SESSION_TYPE", "").lower()
+            if session_type == "x11":
+                return CheckResult(
+                    "xdg-desktop-portal",
+                    "warn",
+                    "not registered — not needed on X11 (using ximagesrc)",
+                )
             return CheckResult(
                 "xdg-desktop-portal",
                 "fail",
@@ -181,6 +183,47 @@ async def check_portal() -> CheckResult:
         )
 
 
+def check_x11_capture() -> CheckResult:
+    session_type = os.environ.get("XDG_SESSION_TYPE", "").lower()
+    if session_type == "wayland":
+        return CheckResult("x11 capture", "ok", "not applicable (wayland session)")
+    if not os.environ.get("DISPLAY"):
+        if session_type != "x11":
+            return CheckResult("x11 capture", "ok", "not applicable (no X11 display)")
+        return CheckResult("x11 capture", "fail", "DISPLAY not set")
+    if shutil.which("xrandr") is None:
+        return CheckResult(
+            "x11 capture",
+            "fail",
+            "xrandr not on PATH; install x11-xserver-utils or equivalent",
+        )
+    try:
+        result = subprocess.run(
+            ["gst-inspect-1.0", "ximagesrc"],
+            capture_output=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return CheckResult(
+                "x11 capture",
+                "fail",
+                "ximagesrc plugin missing; install gstreamer1.0-plugins-good",
+            )
+    except FileNotFoundError:
+        return CheckResult(
+            "x11 capture",
+            "warn",
+            "could not verify ximagesrc (gst-inspect-1.0 not found)",
+        )
+    except subprocess.TimeoutExpired:
+        return CheckResult(
+            "x11 capture",
+            "warn",
+            "could not verify ximagesrc (gst-inspect-1.0 timed out)",
+        )
+    return CheckResult("x11 capture", "ok", "xrandr and ximagesrc available")
+
+
 def check_user_systemd() -> CheckResult:
     try:
         result = subprocess.run(
@@ -252,6 +295,7 @@ def run_doctor() -> int:
         ("cairo binding", check_cairo),
         ("pipewire (pactl)", check_pipewire),
         ("xdg-desktop-portal", lambda: asyncio.run(check_portal())),
+        ("x11 capture", check_x11_capture),
         ("systemd --user", check_user_systemd),
         ("pipx", check_pipx),
         ("appindicator ext (soft)", check_appindicator_ext),

{solstone_linux-0.2.0 → solstone_linux-0.3.0}/src/solstone_linux/observer.py

@@ -42,12 +42,36 @@ from .audio_recorder import AudioRecorder
 from .chat_bridge import run_chat_bridge
 from .config import Config
 from .recovery import write_segment_metadata
-from .screencast import Screencaster, SilentStream, StreamInfo
+from .screencast import Screencaster, SilentStream, StreamInfo, X11Screencaster
 from .sync import SyncService
 from .upload import UploadClient
 
 logger = logging.getLogger(__name__)
 
+
+def _create_screencaster(config) -> "Screencaster | X11Screencaster":
+    """Return the appropriate screencaster for the current desktop session.
+
+    Selection order:
+    1. XDG_SESSION_TYPE=x11  → X11Screencaster
+    2. WAYLAND_DISPLAY set   → Screencaster (portal/PipeWire)
+    3. Only DISPLAY set      → X11Screencaster (no Wayland available)
+    4. Fallback              → Screencaster (portal/PipeWire)
+    """
+    session_type = os.environ.get("XDG_SESSION_TYPE", "").lower()
+    if session_type == "x11":
+        logger.info("X11 session detected — using X11 screencaster")
+        return X11Screencaster()
+    if os.environ.get("WAYLAND_DISPLAY") or session_type == "wayland":
+        logger.info("Wayland session detected — using portal/PipeWire screencaster")
+        return Screencaster(config.restore_token_path)
+    if os.environ.get("DISPLAY") and not os.environ.get("WAYLAND_DISPLAY"):
+        logger.info("No Wayland display found — falling back to X11 screencaster")
+        return X11Screencaster()
+    logger.info("Using portal/PipeWire screencaster (default)")
+    return Screencaster(config.restore_token_path)
+
+
 # Host identification
 HOST = socket.gethostname()
 PLATFORM = platform.system().lower()
@@ -81,7 +105,7 @@ class Observer:
         self.config = config
         self.interval = config.segment_interval
         self.audio_recorder = AudioRecorder()
-        self.screencaster = Screencaster(config.restore_token_path)
+        self.screencaster = _create_screencaster(config)
         self.bus: MessageBus | None = None
         self.running = True
         self.stream = config.stream
@@ -152,11 +176,11 @@ class Observer:
         # Probe which activity signals are available (logging only)
         await probe_activity_services(self.bus)
 
-        # Verify portal is available (exit if not)
+        # Verify capture backend is available (exit if not)
         if not await self.screencaster.connect():
-            logger.error("Screencast portal not available")
+            logger.error("Screencast capture backend not available")
             return False
-        logger.info("Screencast portal connected")
+        logger.info("Screencast capture backend connected")
 
         # Initialize upload client and sync service
         self._client = UploadClient(self.config)
@@ -374,7 +398,9 @@ class Observer:
 
         try:
             streams = await self.screencaster.start(
-                str(segment_dir), framerate=1, draw_cursor=True
+                str(segment_dir),
+                framerate=self.config.capture_framerate,
+                draw_cursor=self.config.draw_cursor,
             )
         except RuntimeError as e:
             logger.error(f"Failed to start screencast: {e}")
@@ -519,30 +545,35 @@ class Observer:
         self.segment_is_muted = self.cached_is_muted
         self.current_mode = new_mode
 
-        # Start initial capture based on mode
-        if new_mode == MODE_SCREENCAST and not self.cached_screen_locked:
-            try:
-                await self.initialize_screencast()
-            except RuntimeError:
-                self.running = False
-                if sync_task:
-                    if self._sync:
-                        self._sync.stop()
-                    sync_task.cancel()
-                    try:
-                        await sync_task
-                    except asyncio.CancelledError:
-                        pass
-                bridge_stop_event.set()
-                if bridge_task:
-                    bridge_task.cancel()
-                    try:
-                        await bridge_task
-                    except (asyncio.CancelledError, Exception):
-                        pass
-                return
-        else:
-            self._start_segment()
+        if self.config.start_paused:
+            self.pause(0)
+            logger.info("Starting in paused mode (start_paused=true)")
+
+        # Start initial capture based on mode (skipped when starting paused)
+        if not self._paused:
+            if new_mode == MODE_SCREENCAST and not self.cached_screen_locked:
+                try:
+                    await self.initialize_screencast()
+                except RuntimeError:
+                    self.running = False
+                    if sync_task:
+                        if self._sync:
+                            self._sync.stop()
+                        sync_task.cancel()
+                        try:
+                            await sync_task
+                        except asyncio.CancelledError:
+                            pass
+                    bridge_stop_event.set()
+                    if bridge_task:
+                        bridge_task.cancel()
+                        try:
+                            await bridge_task
+                        except (asyncio.CancelledError, Exception):
+                            pass
+                    return
+            else:
+                self._start_segment()
 
         logger.info(f"Initial mode: {self.current_mode}")