init

desktop/kadence_desktop/blocking/manager.py

@@ -0,0 +1,109 @@
+"""Turning the server's policy into what this machine actually does.
+
+Called on every poll with the policy the backend computed. It keeps the hosts
+file and the process list in step with it, reports every turned-away attempt
+back to the API (that is what makes the daily report fun), and — importantly —
+puts everything back the moment the policy says blocking is off, including when
+the app exits or crashes mid-interval.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+from kadence_desktop.blocking import processes
+from kadence_desktop.blocking.hosts import HostsBlocker
+
+log = logging.getLogger(__name__)
+
+
+class BlockerManager:
+    def __init__(
+        self,
+        *,
+        helper_path: str,
+        report: Callable[[str, str, str, str | None], None],
+        notify: Callable[[str, str], None] | None = None,
+    ) -> None:
+        self._hosts = HostsBlocker(helper_path)
+        self._report = report
+        self._notify = notify
+        self._active = False
+        self._applied: list[str] = []
+        self._announced: set[int] = set()
+        self.enforce_hosts = True
+        self.enforce_apps = True
+        self.last_error: str | None = None
+        self.killed_today = 0
+
+    # ---- state -------------------------------------------------------------
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @property
+    def helper_installed(self) -> bool:
+        return self._hosts.helper_installed
+
+    @property
+    def blocked_domains(self) -> list[str]:
+        return list(self._applied)
+
+    # ---- the one entry point ----------------------------------------------
+
+    def sync(self, policy: dict) -> None:
+        """Bring the machine in line with `policy` (from /api/blocker/policy)."""
+        should_block = bool(policy.get("active")) and bool(policy.get("enabled"))
+        domains = [str(item) for item in policy.get("domains", [])]
+        apps = [str(item) for item in policy.get("apps", [])]
+        redirect_ip = str(policy.get("redirect_ip") or "127.0.0.1")
+
+        if should_block:
+            if self.enforce_hosts and domains != self._applied:
+                if self._hosts.apply(domains, redirect_ip):
+                    self._applied = domains
+                    self.last_error = None
+                    log.info("blocking %s domain(s)", len(domains))
+                else:
+                    self.last_error = self._hosts.last_error
+            if self.enforce_apps and apps:
+                self._enforce_apps(apps, kill=bool(policy.get("kill_apps", True)))
+            self._active = True
+        else:
+            self.release()
+
+    def release(self) -> None:
+        """Unblock everything. Called when the interval ends, and on shutdown."""
+        if self._applied or self._hosts_dirty():
+            if self._hosts.clear():
+                self._applied = []
+                self.last_error = None
+            else:
+                self.last_error = self._hosts.last_error
+        self._active = False
+        self._announced.clear()
+
+    def _hosts_dirty(self) -> bool:
+        from kadence_desktop.blocking.hosts import current_block
+
+        return bool(current_block())
+
+    # ---- apps --------------------------------------------------------------
+
+    def _enforce_apps(self, patterns: list[str], *, kill: bool) -> None:
+        for app in processes.scan(patterns):
+            if app.pid in self._announced:
+                continue
+            self._announced.add(app.pid)
+
+            if kill and processes.terminate(app):
+                self.killed_today += 1
+                self._report("app", app.matched, "killed", f"{app.name} (pid {app.pid})")
+                if self._notify:
+                    self._notify("Closed a distraction", f"{app.name} is blocked during focus.")
+            else:
+                self._report("app", app.matched, "warned", f"{app.name} (pid {app.pid})")
+                if self._notify:
+                    self._notify("That app is blocked", f"{app.name} is on your block list.")