solstone-linux 0.1.0__py3-none-any.whl

solstone_linux/dbus_service.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+# ruff: noqa: F722, F821
+
+import logging
+import time
+from datetime import datetime
+
+from dbus_next import PropertyAccess, Variant
+from dbus_next.service import (
+    ServiceInterface,
+    dbus_property,
+    method,
+    signal as dbus_signal,
+)
+
+logger = logging.getLogger(__name__)
+
+BUS_NAME = "org.solpbc.solstone.Observer1"
+OBJECT_PATH = "/org/solpbc/solstone/Observer1"
+
+
+class ObserverService(ServiceInterface):
+    """D-Bus service interface for the observer."""
+
+    def __init__(self, observer):
+        super().__init__("org.solpbc.solstone.Observer1")
+        self._observer = observer
+
+    @dbus_property(access=PropertyAccess.READ)
+    def Status(self) -> "s":
+        if self._observer._paused:
+            return "paused"
+        if self._observer.current_mode == "screencast":
+            return "recording"
+        return "idle"
+
+    @dbus_property(access=PropertyAccess.READ)
+    def SyncStatus(self) -> "s":
+        if self._observer._sync:
+            return self._observer._sync.sync_status
+        return "synced"
+
+    @dbus_property(access=PropertyAccess.READ)
+    def SyncProgress(self) -> "s":
+        if self._observer._sync:
+            return self._observer._sync.sync_progress
+        return ""
+
+    @dbus_property(access=PropertyAccess.READ)
+    def CaptureDir(self) -> "s":
+        return str(self._observer.config.captures_dir)
+
+    @dbus_property(access=PropertyAccess.READ)
+    def SegmentTimer(self) -> "i":
+        if self._observer._paused or self._observer.segment_dir is None:
+            return 0
+        remaining = self._observer.interval - (
+            time.monotonic() - self._observer.start_at_mono
+        )
+        return max(0, int(remaining))
+
+    @dbus_property(access=PropertyAccess.READ)
+    def PauseRemaining(self) -> "i":
+        if not self._observer._paused or self._observer._pause_until <= 0:
+            return 0
+        return max(0, int(self._observer._pause_until - time.monotonic()))
+
+    @dbus_property(access=PropertyAccess.READ)
+    def Error(self) -> "s":
+        return ""
+
+    @dbus_property(access=PropertyAccess.READ)
+    def ServerUrl(self) -> "s":
+        return self._observer.config.server_url or ""
+
+    @dbus_property(access=PropertyAccess.READ)
+    def Stream(self) -> "s":
+        return self._observer.stream
+
+    @dbus_property(access=PropertyAccess.READ)
+    def SegmentInterval(self) -> "i":
+        return self._observer.interval
+
+    @method()
+    def Pause(self, duration_seconds: "i") -> "s":
+        self._observer.pause(duration_seconds)
+        return "ok"
+
+    @method()
+    def Resume(self) -> "s":
+        self._observer.resume()
+        return "ok"
+
+    @method()
+    def GetStats(self) -> "a{sv}":
+        captures_today = 0
+        total_size = 0
+        today = datetime.now().strftime("%Y%m%d")
+        captures_dir = self._observer.config.captures_dir
+
+        try:
+            if captures_dir.exists():
+                for day_dir in captures_dir.iterdir():
+                    if not day_dir.is_dir():
+                        continue
+                    for stream_dir in day_dir.iterdir():
+                        if not stream_dir.is_dir():
+                            continue
+                        for seg_dir in stream_dir.iterdir():
+                            if not seg_dir.is_dir():
+                                continue
+                            if seg_dir.name.endswith(".incomplete"):
+                                continue
+                            if seg_dir.name.endswith(".failed"):
+                                continue
+                            if day_dir.name == today:
+                                captures_today += 1
+                            for file_path in seg_dir.iterdir():
+                                if file_path.is_file():
+                                    total_size += file_path.stat().st_size
+        except OSError:
+            pass
+
+        synced_days = 0
+        if self._observer._sync:
+            synced_days = len(self._observer._sync._synced_days)
+
+        total_size_mb = int(total_size / (1024 * 1024))
+        uptime_seconds = int(time.monotonic() - self._observer._start_mono)
+
+        return {
+            "captures_today": Variant("i", captures_today),
+            "total_size_mb": Variant("i", total_size_mb),
+            "synced_days": Variant("i", synced_days),
+            "uptime_seconds": Variant("i", uptime_seconds),
+        }
+
+    @dbus_signal()
+    def StatusChanged(self, status) -> "s":
+        return status
+
+    @dbus_signal()
+    def SyncProgressChanged(self, progress) -> "s":
+        return progress
+
+    @dbus_signal()
+    def ErrorOccurred(self, message) -> "s":
+        return message

solstone_linux/dbusmenu.py

@@ -0,0 +1,242 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+# ruff: noqa: F722, F821
+"""com.canonical.dbusmenu implementation over dbus-next.
+
+This implements the D-Bus menu protocol used by StatusNotifierItem
+to export application menus to the desktop environment's tray host.
+Both KDE Plasma and GNOME's AppIndicator extension consume this.
+
+Reference: https://github.com/AyatanaIndicators/libdbusmenu/blob/master/libdbusmenu-glib/dbus-menu.xml
+"""
+
+import logging
+
+from dbus_next import PropertyAccess, Variant
+from dbus_next.service import (
+    ServiceInterface,
+    dbus_property,
+    method,
+    signal as dbus_signal,
+)
+
+log = logging.getLogger(__name__)
+
+
+class MenuItem:
+    """A menu item in the dbusmenu tree."""
+
+    _next_id = 1
+
+    def __init__(
+        self,
+        label="",
+        icon_name="",
+        enabled=True,
+        visible=True,
+        toggle_type="",
+        toggle_state=-1,
+        item_type="",
+        children_display="",
+        shortcut=None,
+        callback=None,
+    ):
+        self.id = MenuItem._next_id
+        MenuItem._next_id += 1
+        self.label = label
+        self.icon_name = icon_name
+        self.enabled = enabled
+        self.visible = visible
+        self.toggle_type = toggle_type  # "", "checkmark", "radio"
+        self.toggle_state = toggle_state  # -1 = none, 0 = off, 1 = on
+        self.item_type = item_type  # "" = standard, "separator"
+        self.children_display = children_display  # "" or "submenu"
+        self.shortcut = shortcut
+        self.callback = callback
+        self.children: list["MenuItem"] = []
+
+    def get_properties(self) -> dict:
+        """Return non-default properties as a dict of Variants."""
+        props = {}
+        if self.label:
+            props["label"] = Variant("s", self.label)
+        if self.icon_name:
+            props["icon-name"] = Variant("s", self.icon_name)
+        # Some hosts cache booleans and won't default missing keys back to True.
+        props["enabled"] = Variant("b", self.enabled)
+        props["visible"] = Variant("b", self.visible)
+        if self.toggle_type:
+            props["toggle-type"] = Variant("s", self.toggle_type)
+            props["toggle-state"] = Variant("i", self.toggle_state)
+        if self.item_type:
+            props["type"] = Variant("s", self.item_type)
+        if self.children_display:
+            props["children-display"] = Variant("s", self.children_display)
+        return props
+
+
+def _separator():
+    """Create a separator menu item."""
+    item = MenuItem(item_type="separator")
+    return item
+
+
+class DBusMenu(ServiceInterface):
+    """com.canonical.dbusmenu service interface."""
+
+    def __init__(self):
+        super().__init__("com.canonical.dbusmenu")
+        self._revision = 1
+        self._root = MenuItem()  # id 0 is root
+        self._root.id = 0
+        self._root.children_display = "submenu"
+        self._items: dict[int, MenuItem] = {0: self._root}
+        MenuItem._next_id = 1
+
+    def set_menu(self, items: list[MenuItem]):
+        """Replace the entire menu tree."""
+        self._root.children = items
+        self._items = {0: self._root}
+        self._register_items(items)
+        self._revision += 1
+        self.LayoutUpdated(self._revision, 0)
+
+    def update_properties(self, item: MenuItem, *names: str):
+        if not names:
+            return
+
+        updated = {name: self._property_variant(item, name) for name in names}
+        self.ItemsPropertiesUpdated([[item.id, updated]], [])
+
+    def _register_items(self, items: list[MenuItem]):
+        for item in items:
+            self._items[item.id] = item
+            if item.children:
+                self._register_items(item.children)
+
+    def _property_variant(self, item: MenuItem, name: str) -> Variant:
+        if name == "label":
+            return Variant("s", item.label)
+        if name == "visible":
+            return Variant("b", item.visible)
+        if name == "enabled":
+            return Variant("b", item.enabled)
+        if name == "icon-name":
+            return Variant("s", item.icon_name)
+        if name == "toggle-state":
+            return Variant("i", item.toggle_state)
+
+        raise ValueError(f"unsupported menu property: {name}")
+
+    def _build_layout(self, item: MenuItem, depth: int, props: list[str]):
+        """Build the (ia{sv}av) layout tuple for GetLayout."""
+        item_props = item.get_properties()
+        if props:
+            item_props = {k: v for k, v in item_props.items() if k in props}
+
+        children_variants = []
+        if depth != 0 and item.children:
+            for child in item.children:
+                child_layout = self._build_layout(
+                    child,
+                    depth - 1 if depth > 0 else -1,
+                    props,
+                )
+                children_variants.append(Variant("(ia{sv}av)", child_layout))
+
+        return [item.id, item_props, children_variants]
+
+    # ── D-Bus Methods ──
+
+    @method()
+    def GetLayout(
+        self, parent_id: "i", recursion_depth: "i", property_names: "as"
+    ) -> "u(ia{sv}av)":
+        parent = self._items.get(parent_id, self._root)
+        layout = self._build_layout(parent, recursion_depth, property_names)
+        return [self._revision, layout]
+
+    @method()
+    def GetGroupProperties(self, ids: "ai", property_names: "as") -> "a(ia{sv})":
+        result = []
+        for item_id in ids:
+            item = self._items.get(item_id)
+            if item:
+                props = item.get_properties()
+                if property_names:
+                    props = {k: v for k, v in props.items() if k in property_names}
+                result.append([item_id, props])
+        return result
+
+    @method()
+    def GetProperty(self, item_id: "i", name: "s") -> "v":
+        item = self._items.get(item_id)
+        if item:
+            props = item.get_properties()
+            if name in props:
+                return props[name]
+        return Variant("s", "")
+
+    @method()
+    def Event(self, item_id: "i", event_id: "s", data: "v", timestamp: "u"):
+        item = self._items.get(item_id)
+        if item and event_id == "clicked" and item.callback:
+            log.info(f"Menu item clicked: {item.label!r} (id={item_id})")
+            item.callback()
+        elif item:
+            log.debug(f"Menu event: {event_id} on {item.label!r} (id={item_id})")
+
+    @method()
+    def EventGroup(self, events: "a(isvu)") -> "ai":
+        errors = []
+        for item_id, event_id, data, timestamp in events:
+            item = self._items.get(item_id)
+            if item and event_id == "clicked" and item.callback:
+                log.info(f"Menu item clicked: {item.label!r} (id={item_id})")
+                item.callback()
+        return errors
+
+    @method()
+    def AboutToShow(self, item_id: "i") -> "b":
+        return False  # GetLayout always returns fresh state; no pending unsignaled changes.
+
+    @method()
+    def AboutToShowGroup(self, ids: "ai") -> "aiai":
+        return [[], []]  # no updates, no errors
+
+    # ── D-Bus Properties ──
+
+    @dbus_property(access=PropertyAccess.READ)
+    def Version(self) -> "u":
+        return 3
+
+    @dbus_property(access=PropertyAccess.READ)
+    def TextDirection(self) -> "s":
+        return "ltr"
+
+    @dbus_property(access=PropertyAccess.READ)
+    def Status(self) -> "s":
+        return "normal"
+
+    @dbus_property(access=PropertyAccess.READ)
+    def IconThemePath(self) -> "as":
+        return []
+
+    # ── D-Bus Signals ──
+
+    @dbus_signal()
+    def ItemsPropertiesUpdated(self, updated_props, removed_props) -> "a(ia{sv})a(ias)":
+        return [updated_props, removed_props]
+
+    @dbus_signal()
+    def LayoutUpdated(self, revision, parent) -> "ui":
+        return [revision, parent]
+
+    @dbus_signal()
+    def ItemActivationRequested(self, item_id, timestamp) -> "iu":
+        return [item_id, timestamp]
+
+
+def separator():
+    """Create a separator menu item."""
+    return _separator()

solstone_linux/doctor.py

@@ -0,0 +1,277 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+"""Install prerequisite checks for solstone-linux.
+
+Exit code rule: fail anywhere -> 1; otherwise 0. Warn does not flip exit code.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import subprocess
+import sys
+from typing import Callable, NamedTuple
+
+CheckResult = NamedTuple(
+    "CheckResult",
+    [("name", str), ("severity", str), ("detail", str)],
+)
+
+_PORTAL_CHECK_TIMEOUT_SEC: float = 2.0
+
+
+def check_python_version() -> CheckResult:
+    version = tuple(sys.version_info[:2])
+    if version >= (3, 10):
+        return CheckResult("python version", "ok", f"{version[0]}.{version[1]}")
+    return CheckResult(
+        "python version",
+        "fail",
+        f"need >=3.10, got {version[0]}.{version[1]}",
+    )
+
+
+def check_gtk4_typelib() -> CheckResult:
+    try:
+        import gi
+
+        gi.require_version("Gtk", "4.0")
+        from gi.repository import Gtk  # noqa: F401
+    except (ImportError, ValueError):
+        return CheckResult(
+            "gtk4 typelib",
+            "fail",
+            "install gir1.2-gtk-4.0 (or distro equivalent)",
+        )
+    return CheckResult("gtk4 typelib", "ok", "Gtk 4.0 available")
+
+
+def check_gstreamer() -> CheckResult:
+    if shutil.which("gst-launch-1.0") is None:
+        return CheckResult(
+            "gstreamer",
+            "fail",
+            "gst-launch-1.0 not on PATH; install gstreamer1.0-tools or equivalent",
+        )
+    try:
+        import gi
+
+        gi.require_version("Gst", "1.0")
+        from gi.repository import Gst  # noqa: F401
+    except (ImportError, ValueError):
+        return CheckResult("gstreamer", "fail", "gir1.2-gstreamer-1.0 missing")
+    return CheckResult("gstreamer", "ok", "gst-launch-1.0 and Gst typelib available")
+
+
+def check_cairo() -> CheckResult:
+    try:
+        import cairo  # noqa: F401
+    except ImportError:
+        return CheckResult(
+            "cairo binding",
+            "fail",
+            "install python3-cairo (or distro equivalent)",
+        )
+    return CheckResult("cairo binding", "ok", "cairo import ok")
+
+
+def check_session_type() -> CheckResult:
+    session_type = os.environ.get("XDG_SESSION_TYPE", "").lower()
+    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)",
+        )
+    if not session_type:
+        return CheckResult(
+            "session type",
+            "warn",
+            "XDG_SESSION_TYPE not set; ScreenCast requires a Wayland session",
+        )
+    return CheckResult(
+        "session type",
+        "warn",
+        f"unrecognized session type '{session_type}'; Wayland required",
+    )
+
+
+def check_pipewire() -> CheckResult:
+    try:
+        result = subprocess.run(
+            ["pactl", "info"],
+            capture_output=True,
+            timeout=5,
+            text=True,
+        )
+    except FileNotFoundError:
+        return CheckResult(
+            "pipewire (pactl)",
+            "fail",
+            "pactl missing; install pipewire-pulse or pulseaudio-utils",
+        )
+    if result.returncode != 0:
+        detail = result.stderr.strip().splitlines()[0] if result.stderr.strip() else ""
+        return CheckResult("pipewire (pactl)", "fail", detail)
+    detail = result.stdout.strip().splitlines()[0] if result.stdout.strip() else ""
+    return CheckResult("pipewire (pactl)", "ok", detail)
+
+
+async def check_portal() -> CheckResult:
+    from dbus_next.aio import MessageBus
+    from dbus_next.constants import BusType
+    from dbus_next.errors import AuthError, DBusError, InvalidAddressError
+
+    async def _body() -> CheckResult:
+        bus = None
+        try:
+            try:
+                bus = await MessageBus(bus_type=BusType.SESSION).connect()
+            except (OSError, AuthError, InvalidAddressError, DBusError) as e:
+                return CheckResult(
+                    "xdg-desktop-portal",
+                    "fail",
+                    f"session bus unreachable: {e}",
+                )
+            try:
+                intro = await bus.introspect(
+                    "org.freedesktop.DBus", "/org/freedesktop/DBus"
+                )
+                obj = bus.get_proxy_object(
+                    "org.freedesktop.DBus", "/org/freedesktop/DBus", intro
+                )
+                iface = obj.get_interface("org.freedesktop.DBus")
+                owned = await iface.call_name_has_owner(
+                    "org.freedesktop.portal.Desktop"
+                )
+            except (DBusError, OSError) as e:
+                return CheckResult(
+                    "xdg-desktop-portal",
+                    "fail",
+                    f"session bus unreachable: {e}",
+                )
+            if owned:
+                return CheckResult(
+                    "xdg-desktop-portal",
+                    "ok",
+                    "org.freedesktop.portal.Desktop registered on session bus",
+                )
+            return CheckResult(
+                "xdg-desktop-portal",
+                "fail",
+                "org.freedesktop.portal.Desktop not registered on session bus",
+            )
+        finally:
+            if bus is not None:
+                bus.disconnect()
+
+    try:
+        return await asyncio.wait_for(_body(), timeout=_PORTAL_CHECK_TIMEOUT_SEC)
+    except asyncio.TimeoutError:
+        return CheckResult(
+            "xdg-desktop-portal",
+            "fail",
+            f"timed out after {_PORTAL_CHECK_TIMEOUT_SEC:g}s",
+        )
+
+
+def check_user_systemd() -> CheckResult:
+    try:
+        result = subprocess.run(
+            ["systemctl", "--user", "is-system-running"],
+            capture_output=True,
+            timeout=5,
+            text=True,
+        )
+    except FileNotFoundError:
+        return CheckResult(
+            "systemd --user",
+            "fail",
+            "systemctl --user not reachable",
+        )
+    detail = result.stdout.strip().splitlines()[0] if result.stdout.strip() else ""
+    if detail:
+        return CheckResult("systemd --user", "ok", detail)
+    return CheckResult("systemd --user", "fail", "systemctl --user not reachable")
+
+
+def check_pipx() -> CheckResult:
+    if shutil.which("pipx") is None:
+        return CheckResult(
+            "pipx",
+            "fail",
+            "pipx missing; install via 'python3 -m pip install --user pipx' or distro package",
+        )
+    return CheckResult("pipx", "ok", "pipx on PATH")
+
+
+def check_appindicator_ext() -> CheckResult:
+    desktop = os.environ.get("XDG_CURRENT_DESKTOP", "")
+    if "GNOME" not in desktop:
+        return CheckResult(
+            "appindicator ext (soft)",
+            "ok",
+            "not applicable (non-GNOME desktop)",
+        )
+    try:
+        result = subprocess.run(
+            ["gnome-extensions", "list"],
+            capture_output=True,
+            timeout=5,
+            text=True,
+        )
+    except FileNotFoundError:
+        return CheckResult(
+            "appindicator ext (soft)",
+            "warn",
+            "install gnome-shell-extension-appindicator",
+        )
+    if "appindicator" in result.stdout.lower():
+        return CheckResult(
+            "appindicator ext (soft)", "ok", "appindicator extension present"
+        )
+    return CheckResult(
+        "appindicator ext (soft)",
+        "warn",
+        "install gnome-shell-extension-appindicator",
+    )
+
+
+def run_doctor() -> int:
+    checks: list[tuple[str, Callable[[], CheckResult]]] = [
+        ("python version", check_python_version),
+        ("session type", check_session_type),
+        ("gtk4 typelib", check_gtk4_typelib),
+        ("gstreamer", check_gstreamer),
+        ("cairo binding", check_cairo),
+        ("pipewire (pactl)", check_pipewire),
+        ("xdg-desktop-portal", lambda: asyncio.run(check_portal())),
+        ("systemd --user", check_user_systemd),
+        ("pipx", check_pipx),
+        ("appindicator ext (soft)", check_appindicator_ext),
+    ]
+    fail_count = 0
+    warn_count = 0
+
+    for name, fn in checks:
+        try:
+            result = fn()
+        except Exception as e:
+            result = CheckResult(name, "fail", repr(e))
+        if not result.name or result.name != name:
+            result = CheckResult(name, result.severity, result.detail)
+        print(f"{result.severity:<4}  {result.name:<28}  {result.detail}")
+        if result.severity == "fail":
+            fail_count += 1
+        elif result.severity == "warn":
+            warn_count += 1
+
+    print()
+    print(f"doctor: {len(checks)} checks, {fail_count} failed, {warn_count} warnings")
+    return 1 if fail_count else 0

solstone_linux/icons/hicolor/index.theme

@@ -0,0 +1,12 @@
+[Icon Theme]
+Name=solstone
+Comment=solstone observer tray icons
+Inherits=hicolor
+Directories=scalable/status
+
+[scalable/status]
+Size=32
+Type=Scalable
+MinSize=16
+MaxSize=256
+Context=Status

solstone_linux/icons/hicolor/scalable/status/solstone-error.svg

@@ -0,0 +1,17 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="2.5 2.5 27 27"
+     role="img" aria-label="solstone icon error state">
+  <title>solstone — error</title>
+  <defs>
+    <mask id="ixko" maskUnits="userSpaceOnUse">
+      <rect x="2.5" y="2.5" width="27.0" height="27.0" fill="white"/>
+      <path d="M7 7 L25 25 M25 7 L7 25" fill="none" stroke="black"
+            stroke-width="5.5" stroke-linecap="round"/>
+    </mask>
+  </defs>
+  <g mask="url(#ixko)">
+    <path fill="#F5C740" d="M16.0 2.5 L18.6 7.3 A9.1 9.1 0 0 0 13.4 7.3 Z M23.9 5.1 L23.2 10.5 A9.1 9.1 0 0 0 19.0 7.4 Z M28.8 11.8 L25.1 15.8 A9.1 9.1 0 0 0 23.5 10.9 Z M28.8 20.2 L23.5 21.1 A9.1 9.1 0 0 0 25.1 16.2 Z M23.9 26.9 L19.0 24.6 A9.1 9.1 0 0 0 23.2 21.5 Z M16.0 29.5 L13.4 24.7 A9.1 9.1 0 0 0 18.6 24.7 Z M8.1 26.9 L8.8 21.5 A9.1 9.1 0 0 0 13.0 24.6 Z M3.2 20.2 L6.9 16.2 A9.1 9.1 0 0 0 8.5 21.1 Z M3.2 11.8 L8.5 10.9 A9.1 9.1 0 0 0 6.9 15.8 Z M8.1 5.1 L13.0 7.4 A9.1 9.1 0 0 0 8.8 10.5 Z"/>
+    <circle cx="16.0" cy="16.0" r="6.5" fill="none" stroke="#E8923A" stroke-width="1.7"/>
+  </g>
+  <path d="M7 7 L25 25 M25 7 L7 25" fill="none" stroke="#E8923A"
+        stroke-width="2.5" stroke-linecap="round"/>
+</svg>