dev-recall 0.2.0__py3-none-any.whl

recall/collectors/linux_process.py

@@ -0,0 +1,230 @@
+"""Process and port tracker using psutil.
+
+Polls every 30 s to detect:
+  - Dev server processes starting/stopping (by process name allowlist)
+  - Listening TCP ports opening/closing in the dev-server range
+
+Emits PORT_OPEN / PORT_CLOSE events when a listening port appears or
+disappears for a tracked process.
+
+Gracefully becomes a no-op when psutil is not installed.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+from recall.models import Event, EventType, Source
+
+logger = logging.getLogger(__name__)
+
+try:
+    import psutil  # type: ignore
+
+    _PSUTIL_AVAILABLE = True
+except ImportError:
+    _PSUTIL_AVAILABLE = False
+
+# Process names that indicate a dev server or interesting background service.
+# Matched as a substring of the process name or first cmdline argument.
+_DEV_PROCESS_NAMES = {
+    "node",
+    "npm",
+    "npx",
+    "yarn",
+    "pnpm",
+    "bun",
+    "deno",
+    "next",
+    "vite",
+    "webpack",
+    "parcel",
+    "rollup",
+    "esbuild",
+    "turbopack",
+    "python",
+    "python3",
+    "uvicorn",
+    "gunicorn",
+    "hypercorn",
+    "fastapi",
+    "flask",
+    "django",
+    "starlette",
+    "tornado",
+    "aiohttp",
+    "ruby",
+    "rails",
+    "puma",
+    "unicorn",
+    "thin",
+    "java",
+    "mvn",
+    "gradle",
+    "go",
+    "air",
+    "gin",
+    "fiber",
+    "php",
+    "artisan",
+    "symfony",
+    "cargo",
+    "rust-analyzer",
+    "dotnet",
+}
+
+# Only track ports in this range (typical dev / ephemeral service ports).
+_PORT_MIN = 1024
+_PORT_MAX = 65535
+
+# Ports to ignore (databases, system services, etc.)
+_PORT_IGNORE = {
+    3306,   # MySQL
+    5432,   # PostgreSQL
+    6379,   # Redis
+    27017,  # MongoDB
+    11211,  # Memcached
+    2181,   # ZooKeeper
+    2375,   # Docker daemon (unencrypted)
+    2376,   # Docker daemon (TLS)
+    22,     # SSH
+    25,     # SMTP
+    53,     # DNS
+    80,     # HTTP (production)
+    443,    # HTTPS (production)
+}
+
+_POLL_INTERVAL = 30  # seconds
+
+
+def _now_ts() -> tuple[str, str]:
+    now = datetime.now(timezone.utc)
+    return now.strftime("%Y-%m-%dT%H:%M:%SZ"), now.strftime("%Y-%m-%d")
+
+
+def _is_dev_process(proc: "psutil.Process") -> bool:  # type: ignore[name-defined]
+    """Return True if the process looks like a dev server."""
+    try:
+        name = proc.name().lower()
+        if name in _DEV_PROCESS_NAMES:
+            return True
+        # Also check the first cmdline argument (e.g. "python manage.py runserver")
+        cmdline = proc.cmdline()
+        if cmdline:
+            exe_base = cmdline[0].rsplit("/", 1)[-1].lower()
+            if exe_base in _DEV_PROCESS_NAMES:
+                return True
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        pass
+    return False
+
+
+def _snapshot_ports() -> dict[int, str]:
+    """Return {port: process_name} for all listening TCP sockets owned by dev processes."""
+    result: dict[int, str] = {}
+    try:
+        connections = psutil.net_connections(kind="tcp")
+    except psutil.AccessDenied:
+        return result
+
+    for conn in connections:
+        if conn.status != psutil.CONN_LISTEN:
+            continue
+        port = conn.laddr.port
+        if port < _PORT_MIN or port > _PORT_MAX or port in _PORT_IGNORE:
+            continue
+        pid = conn.pid
+        if pid is None:
+            continue
+        try:
+            proc = psutil.Process(pid)
+            if _is_dev_process(proc):
+                result[port] = proc.name()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return result
+
+
+class ProcessCollector:
+    """Poll psutil every 30 s and emit PORT_OPEN / PORT_CLOSE events."""
+
+    def __init__(self, event_callback: Callable[[Event], None]) -> None:
+        self._cb = event_callback
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+    def start(self) -> None:
+        if not _PSUTIL_AVAILABLE:
+            logger.debug("psutil unavailable — process/port tracking disabled")
+            return
+
+        self._thread = threading.Thread(
+            target=self._run,
+            daemon=True,
+            name="dev-recall-process",
+        )
+        self._thread.start()
+        logger.info("ProcessCollector started (poll interval %ds)", _POLL_INTERVAL)
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _run(self) -> None:
+        prev: dict[int, str] = {}
+        try:
+            prev = _snapshot_ports()
+        except Exception:
+            logger.exception("ProcessCollector initial snapshot failed")
+
+        while not self._stop_event.wait(_POLL_INTERVAL):
+            try:
+                curr = _snapshot_ports()
+                self._diff(prev, curr)
+                prev = curr
+            except Exception:
+                logger.exception("ProcessCollector poll failed")
+
+    def _diff(self, prev: dict[int, str], curr: dict[int, str]) -> None:
+        ts, date = _now_ts()
+
+        # Newly opened ports
+        for port, proc_name in curr.items():
+            if port not in prev:
+                raw = {"port": port, "process_name": proc_name}
+                event = Event(
+                    timestamp=ts,
+                    date=date,
+                    event_type=EventType.PORT_OPEN,
+                    source=Source.PROCESS_TRACKER,
+                    content="",
+                    raw_data=raw,
+                )
+                from recall.models import build_content
+
+                event.content = build_content(EventType.PORT_OPEN, raw)
+                self._cb(event)
+
+        # Closed ports
+        for port, proc_name in prev.items():
+            if port not in curr:
+                raw = {"port": port, "process_name": proc_name}
+                event = Event(
+                    timestamp=ts,
+                    date=date,
+                    event_type=EventType.PORT_CLOSE,
+                    source=Source.PROCESS_TRACKER,
+                    content="",
+                    raw_data=raw,
+                )
+                from recall.models import build_content
+
+                event.content = build_content(EventType.PORT_CLOSE, raw)
+                self._cb(event)

recall/collectors/linux_session.py

@@ -0,0 +1,229 @@
+"""Linux session event collector via D-Bus logind.
+
+Subscribes to org.freedesktop.login1.Manager signals:
+  - PrepareForSleep(before: bool)  → SYSTEM_SUSPEND / SYSTEM_RESUME
+  - org.freedesktop.login1.Session Lock / Unlock → SESSION_LOCK / SESSION_UNLOCK
+
+Uses dbus-next with an asyncio event loop running in a daemon thread.
+
+Gracefully becomes a no-op when dbus-next is not installed or the D-Bus
+session bus is not available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+import threading
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+from recall.models import Event, EventType, Source
+
+logger = logging.getLogger(__name__)
+
+try:
+    from dbus_next.aio import MessageBus  # type: ignore
+    from dbus_next import BusType, Message, MessageType  # type: ignore
+
+    _DBUS_AVAILABLE = True
+except ImportError:
+    _DBUS_AVAILABLE = False
+
+
+def _now_ts() -> tuple[str, str]:
+    now = datetime.now(timezone.utc)
+    return now.strftime("%Y-%m-%dT%H:%M:%SZ"), now.strftime("%Y-%m-%d")
+
+
+class LinuxSessionCollector:
+    """Collect screen lock/unlock and system sleep/resume events from D-Bus."""
+
+    def __init__(self, event_callback: Callable[[Event], None]) -> None:
+        self._cb = event_callback
+        self._thread: Optional[threading.Thread] = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._lock_time: Optional[float] = None
+        self._suspend_time: Optional[float] = None
+
+    def start(self) -> None:
+        if not _DBUS_AVAILABLE:
+            logger.debug("dbus-next unavailable — session event tracking disabled")
+            return
+
+        # Only works with a session D-Bus socket
+        if not os.environ.get("DBUS_SESSION_BUS_ADDRESS") and not os.path.exists(
+            "/run/user/%d/bus" % os.getuid()
+        ):
+            logger.debug("No D-Bus session bus — session event tracking disabled")
+            return
+
+        self._thread = threading.Thread(
+            target=self._run,
+            daemon=True,
+            name="devmem-session",
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._loop is not None:
+            self._loop.call_soon_threadsafe(self._loop.stop)
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _run(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        try:
+            self._loop.run_until_complete(self._subscribe())
+        except Exception:
+            logger.exception("LinuxSessionCollector crashed")
+
+    async def _subscribe(self) -> None:
+        try:
+            bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
+        except Exception:
+            logger.debug("Could not connect to system D-Bus — session tracking disabled")
+            return
+
+        # ----------------------------------------------------------------
+        # Subscribe to PrepareForSleep (system suspend/resume)
+        # ----------------------------------------------------------------
+        await bus.call(
+            Message(
+                destination="org.freedesktop.DBus",
+                path="/org/freedesktop/DBus",
+                interface="org.freedesktop.DBus",
+                member="AddMatch",
+                signature="s",
+                body=[
+                    "type='signal',"
+                    "sender='org.freedesktop.login1',"
+                    "interface='org.freedesktop.login1.Manager',"
+                    "member='PrepareForSleep'"
+                ],
+            )
+        )
+
+        # ----------------------------------------------------------------
+        # Subscribe to session Lock/Unlock
+        # ----------------------------------------------------------------
+        await bus.call(
+            Message(
+                destination="org.freedesktop.DBus",
+                path="/org/freedesktop/DBus",
+                interface="org.freedesktop.DBus",
+                member="AddMatch",
+                signature="s",
+                body=[
+                    "type='signal',"
+                    "sender='org.freedesktop.login1',"
+                    "interface='org.freedesktop.login1.Session',"
+                    "member='Lock'"
+                ],
+            )
+        )
+        await bus.call(
+            Message(
+                destination="org.freedesktop.DBus",
+                path="/org/freedesktop/DBus",
+                interface="org.freedesktop.DBus",
+                member="AddMatch",
+                signature="s",
+                body=[
+                    "type='signal',"
+                    "sender='org.freedesktop.login1',"
+                    "interface='org.freedesktop.login1.Session',"
+                    "member='Unlock'"
+                ],
+            )
+        )
+
+        logger.info("LinuxSessionCollector subscribed to D-Bus logind signals")
+
+        bus.add_message_handler(self._handle_message)
+
+        # Keep running until stop() is called
+        await asyncio.get_event_loop().run_in_executor(None, self._thread.join if self._thread else lambda: None)
+
+    def _handle_message(self, message: "Message") -> None:  # type: ignore[name-defined]
+        if message.message_type != MessageType.SIGNAL:
+            return
+        member = message.member
+        if member == "PrepareForSleep":
+            before = message.body[0] if message.body else True
+            self._on_prepare_for_sleep(before)
+        elif member == "Lock":
+            self._on_session_lock()
+        elif member == "Unlock":
+            self._on_session_unlock()
+
+    def _on_prepare_for_sleep(self, before: bool) -> None:
+        ts, date = _now_ts()
+        if before:
+            # Going to sleep
+            self._suspend_time = time.monotonic()
+            event = Event(
+                timestamp=ts,
+                date=date,
+                event_type=EventType.SYSTEM_SUSPEND,
+                source=Source.LINUX_SESSION,
+                content="",
+                raw_data={},
+            )
+        else:
+            # Waking up
+            raw: dict = {}
+            if self._suspend_time is not None:
+                raw["suspended_seconds"] = round(time.monotonic() - self._suspend_time)
+                self._suspend_time = None
+            event = Event(
+                timestamp=ts,
+                date=date,
+                event_type=EventType.SYSTEM_RESUME,
+                source=Source.LINUX_SESSION,
+                content="",
+                raw_data=raw,
+            )
+        from recall.models import build_content
+
+        event.content = build_content(event.event_type, event.raw_data)
+        self._cb(event)
+
+    def _on_session_lock(self) -> None:
+        self._lock_time = time.monotonic()
+        ts, date = _now_ts()
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.SESSION_LOCK,
+            source=Source.LINUX_SESSION,
+            content="",
+            raw_data={},
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.SESSION_LOCK, event.raw_data)
+        self._cb(event)
+
+    def _on_session_unlock(self) -> None:
+        ts, date = _now_ts()
+        raw: dict = {}
+        if self._lock_time is not None:
+            raw["locked_seconds"] = round(time.monotonic() - self._lock_time)
+            self._lock_time = None
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.SESSION_UNLOCK,
+            source=Source.LINUX_SESSION,
+            content="",
+            raw_data=raw,
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.SESSION_UNLOCK, event.raw_data)
+        self._cb(event)

recall/collectors/linux_window.py

@@ -0,0 +1,199 @@
+"""Linux window/app tracker using libwnck (X11/XWayland).
+
+Tracks application open/close, window focus changes, and virtual workspace
+switches via Wnck signals on a GLib main loop in a daemon thread.
+
+Gracefully becomes a no-op when:
+  - PyGObject / libwnck is not installed
+  - No X display is available (pure Wayland without XWayland)
+  - Wnck.Screen.get_default() returns None
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+from recall.models import Event, EventType, Source
+
+logger = logging.getLogger(__name__)
+
+try:
+    import gi
+
+    gi.require_version("Wnck", "3.0")
+    gi.require_version("GLib", "2.0")
+    from gi.repository import GLib, Wnck  # type: ignore
+
+    _WNCK_AVAILABLE = True
+except Exception:
+    _WNCK_AVAILABLE = False
+
+
+def _now_ts() -> tuple[str, str]:
+    """Return (ISO timestamp, YYYY-MM-DD)."""
+    now = datetime.now(timezone.utc)
+    return now.strftime("%Y-%m-%dT%H:%M:%SZ"), now.strftime("%Y-%m-%d")
+
+
+class LinuxWindowCollector:
+    """Collect application and window events from the X11/XWayland session."""
+
+    def __init__(self, event_callback: Callable[[Event], None]) -> None:
+        self._cb = event_callback
+        self._thread: Optional[threading.Thread] = None
+        self._loop: Optional["GLib.MainLoop"] = None  # type: ignore[name-defined]
+        # Track app open times for duration calculation
+        self._app_open_times: dict[int, float] = {}
+        # Track active workspace name for switch events
+        self._current_workspace: Optional[str] = None
+
+    def start(self) -> None:
+        if not _WNCK_AVAILABLE:
+            logger.debug("libwnck unavailable — window tracking disabled")
+            return
+
+        display = os.environ.get("DISPLAY", "")
+        if not display:
+            logger.debug("No DISPLAY — window tracking disabled")
+            return
+
+        self._thread = threading.Thread(
+            target=self._run,
+            daemon=True,
+            name="devmem-window",
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._loop is not None:
+            self._loop.quit()
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _run(self) -> None:
+        try:
+            self._loop = GLib.MainLoop()
+
+            # Wnck.Screen.get_default() must be called inside the GLib loop thread
+            GLib.idle_add(self._setup_wnck)
+            self._loop.run()
+        except Exception:
+            logger.exception("LinuxWindowCollector loop crashed")
+
+    def _setup_wnck(self) -> bool:
+        try:
+            screen = Wnck.Screen.get_default()
+            if screen is None:
+                logger.debug("Wnck.Screen.get_default() returned None — disabling window tracking")
+                if self._loop:
+                    self._loop.quit()
+                return False
+
+            screen.force_update()
+
+            # Seed current workspace
+            ws = screen.get_active_workspace()
+            self._current_workspace = ws.get_name() if ws else None
+
+            screen.connect("application-opened", self._on_app_opened)
+            screen.connect("application-closed", self._on_app_closed)
+            screen.connect("active-window-changed", self._on_window_focus)
+            screen.connect("active-workspace-changed", self._on_workspace_changed)
+            logger.info("Wnck window tracking active on DISPLAY=%s", os.environ.get("DISPLAY"))
+        except Exception:
+            logger.exception("Wnck setup failed")
+        return False  # remove idle callback
+
+    def _on_app_opened(self, screen: "Wnck.Screen", app: "Wnck.Application") -> None:  # type: ignore[name-defined]
+        xid = app.get_xid()
+        self._app_open_times[xid] = time.monotonic()
+        ts, date = _now_ts()
+        name = app.get_name() or ""
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.APP_OPEN,
+            source=Source.LINUX_WINDOW,
+            content="",
+            raw_data={"app_name": name, "xid": xid},
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.APP_OPEN, event.raw_data)
+        self._cb(event)
+
+    def _on_app_closed(self, screen: "Wnck.Screen", app: "Wnck.Application") -> None:  # type: ignore[name-defined]
+        xid = app.get_xid()
+        ts, date = _now_ts()
+        name = app.get_name() or ""
+        raw: dict = {"app_name": name, "xid": xid}
+        open_t = self._app_open_times.pop(xid, None)
+        if open_t is not None:
+            raw["duration_seconds"] = round(time.monotonic() - open_t)
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.APP_CLOSE,
+            source=Source.LINUX_WINDOW,
+            content="",
+            raw_data=raw,
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.APP_CLOSE, event.raw_data)
+        self._cb(event)
+
+    def _on_window_focus(
+        self,
+        screen: "Wnck.Screen",  # type: ignore[name-defined]
+        prev_window: Optional["Wnck.Window"],  # type: ignore[name-defined]
+    ) -> None:
+        window = screen.get_active_window()
+        if window is None:
+            return
+        ts, date = _now_ts()
+        title = window.get_name() or ""
+        app = window.get_application()
+        app_name = app.get_name() if app else ""
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.WINDOW_FOCUS,
+            source=Source.LINUX_WINDOW,
+            content="",
+            raw_data={"window_title": title, "app_name": app_name},
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.WINDOW_FOCUS, event.raw_data)
+        self._cb(event)
+
+    def _on_workspace_changed(
+        self,
+        screen: "Wnck.Screen",  # type: ignore[name-defined]
+        prev_ws: Optional["Wnck.Workspace"],  # type: ignore[name-defined]
+    ) -> None:
+        from_name = prev_ws.get_name() if prev_ws else (self._current_workspace or "")
+        ws = screen.get_active_workspace()
+        to_name = ws.get_name() if ws else ""
+        self._current_workspace = to_name
+        ts, date = _now_ts()
+        event = Event(
+            timestamp=ts,
+            date=date,
+            event_type=EventType.WORKSPACE_SWITCH,
+            source=Source.LINUX_WINDOW,
+            content="",
+            raw_data={"from_workspace": from_name, "to_workspace": to_name},
+        )
+        from recall.models import build_content
+
+        event.content = build_content(EventType.WORKSPACE_SWITCH, event.raw_data)
+        self._cb(event)