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

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

@@ -4,6 +4,28 @@ 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
+to your journal automatically, with no separate key step.
+
+### Changed
+
+- **first run sets itself up.** earlier versions asked you to create and paste
+  a key to connect the observer to your journal. now the observer introduces
+  itself to your journal on first run and remembers the connection on its own.
+  you go straight from install to observing, with no manual key step.
+
 ## [0.1.1] - 2026-06-02
 
 A focused maintenance release: two reliability fixes and a round of

{solstone_linux-0.1.1 → solstone_linux-0.3.0}/INSTALL.md

@@ -79,7 +79,7 @@ this is the developer/from-source path; most installs should use the `pipx insta
    ```
    solstone-linux setup
    ```
-   this prompts for the journal URL and auto-registers via `sol` when available.
+   this prompts for the journal URL and registers the observer with your journal.
 
 4. verify the service is running:
    ```

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solstone-linux
-Version: 0.1.1
+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.1.1 → 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.1.1 → solstone_linux-0.3.0}/pyproject.toml

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

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

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

{solstone_linux-0.1.1 → 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
@@ -24,6 +27,7 @@ from dbus_next.errors import (
 logger = logging.getLogger(__name__)
 
 _DBUS_PROBE_TIMEOUT_SEC = 2.0
+_POWER_SAVE_WARNED_BACKENDS: set[str] = set()
 
 _SERVICE_MISSING_ERRORS = (
     "org.freedesktop.DBus.Error.ServiceUnknown",
@@ -112,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 = {
@@ -125,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),
@@ -212,6 +300,22 @@ async def is_power_save_active(bus: MessageBus) -> bool:
 
     Returns True if power save is active, False otherwise.
     """
+
+    def log_backend_failure_once(backend: str, bus_name: str, path: str, exc) -> None:
+        level = logger.warning
+        if backend in _POWER_SAVE_WARNED_BACKENDS:
+            level = logger.debug
+        else:
+            _POWER_SAVE_WARNED_BACKENDS.add(backend)
+        level(
+            "is_power_save_active %s backend failed: service=%s path=%s: %s: %s",
+            backend,
+            bus_name,
+            path,
+            type(exc).__name__,
+            exc,
+        )
+
     # Try GNOME Mutter DisplayConfig first
     try:
         intro = await bus.introspect(DISPLAY_CONFIG_BUS, DISPLAY_CONFIG_PATH)
@@ -227,11 +331,10 @@ async def is_power_save_active(bus: MessageBus) -> bool:
         OSError,
     ) as exc:
         if not _is_service_missing(exc):
-            logger.warning(
-                "is_power_save_active Mutter backend failed: service=%s path=%s: %s: %s",
+            log_backend_failure_once(
+                "Mutter",
                 DISPLAY_CONFIG_BUS,
                 DISPLAY_CONFIG_PATH,
-                type(exc).__name__,
                 exc,
             )
 
@@ -248,14 +351,13 @@ async def is_power_save_active(bus: MessageBus) -> bool:
         OSError,
     ) as exc:
         if not _is_service_missing(exc):
-            logger.warning(
-                "is_power_save_active KDE backend failed: service=%s path=%s: %s: %s",
-                KDE_POWER_BUS,
-                KDE_POWER_PATH,
-                type(exc).__name__,
-                exc,
-            )
-        return False
+            log_backend_failure_once("KDE", KDE_POWER_BUS, KDE_POWER_PATH, exc)
+
+    # 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.1.1 → 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)
@@ -134,44 +125,23 @@ def cmd_setup(args: argparse.Namespace) -> int:
         )
         return 0
 
-    print(f"Stream: {config.stream}")
     save_config(config)
 
     if not config.key:
-        sol = shutil.which("sol")
-        if sol:
-            print("Registering via sol CLI...")
-            try:
-                result = subprocess.run(
-                    [sol, "observer", "--json", "create", config.stream],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout)
-                    config.key = data["key"]
-                    save_config(config)
-                    print(f"Registered (key: {config.key[:8]}...)")
-                else:
-                    print("CLI registration failed, trying HTTP...")
-            except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, OSError):
-                print("CLI registration failed, trying HTTP...")
-
-        if not config.key:
-            print("Registering with your journal...")
-            client = UploadClient(config)
-            if client.ensure_registered(config):
-                config = load_config()
-                print(f"Registered (key: {config.key[:8]}...)")
-            else:
-                print(
-                    "Warning: registration failed. Run setup again when your journal is available."
-                )
-                if non_interactive:
-                    return 1
+        print("Registering with your journal...")
+        client = UploadClient(config)
+        if client.ensure_registered(config):
+            print(f"Registered (key: {config.key[:8]}...)")
+            print(f"Stream: {config.stream}")
+        else:
+            print(
+                "Warning: registration failed. Run setup again when your journal is available."
+            )
+            if non_interactive:
+                return 1
     else:
         print(f"Already registered (key: {config.key[:8]}...)")
+        print(f"Stream: {config.stream}")
 
     print(f"\nConfig saved to {config.config_path}")
     print(f"Captures will go to {config.captures_dir}")
@@ -182,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:
@@ -203,46 +169,24 @@ def _cmd_setup_interactive() -> int:
         except ValueError as e:
             print(f"Error deriving stream name: {e}", file=sys.stderr)
             return 1
-    print(f"Stream: {config.stream}")
 
     # Save config before registration (so URL is persisted)
     config.ensure_dirs()
     save_config(config)
 
-    # Auto-register — try sol CLI first (no server needed), fall back to HTTP
     if not config.key:
-        sol = shutil.which("sol")
-        if sol:
-            print("Registering via sol CLI...")
-            try:
-                result = subprocess.run(
-                    [sol, "observer", "--json", "create", config.stream],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout)
-                    config.key = data["key"]
-                    save_config(config)
-                    print(f"Registered (key: {config.key[:8]}...)")
-                else:
-                    print("CLI registration failed, trying HTTP...")
-            except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, OSError):
-                print("CLI registration failed, trying HTTP...")
-
-        if not config.key:
-            print("Registering with your journal...")
-            client = UploadClient(config)
-            if client.ensure_registered(config):
-                config = load_config()
-                print(f"Registered (key: {config.key[:8]}...)")
-            else:
-                print(
-                    "Warning: registration failed. Run setup again when your journal is available."
-                )
+        print("Registering with your journal...")
+        client = UploadClient(config)
+        if client.ensure_registered(config):
+            print(f"Registered (key: {config.key[:8]}...)")
+            print(f"Stream: {config.stream}")
+        else:
+            print(
+                "Warning: registration failed. Run setup again when your journal is available."
+            )
     else:
         print(f"Already registered (key: {config.key[:8]}...)")
+        print(f"Stream: {config.stream}")
 
     print(f"\nConfig saved to {config.config_path}")
     print(f"Captures will go to {config.captures_dir}")
@@ -284,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.1.1 → 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.1.1 → 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),