arthexis 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

nodes/models.py

@@ -1,27 +1,34 @@
+from collections.abc import Iterable
 from django.db import models
+from django.db.models.signals import post_delete
+from django.dispatch import Signal, receiver
 from core.entity import Entity
-from core.fields import (
-    SigilShortAutoField,
-    SigilLongCheckField,
-    SigilLongAutoField,
-)
+from core.models import Profile
+from core.fields import SigilShortAutoField
 import re
 import json
 import base64
+from django.utils import timezone
 from django.utils.text import slugify
 from django.conf import settings
 from django.contrib.sites.models import Site
+from datetime import timedelta
 import uuid
 import os
+import shutil
 import socket
+import stat
+import subprocess
 from pathlib import Path
 from utils import revision
+from core.notifications import notify_async
 from django.core.exceptions import ValidationError
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 from django.contrib.auth import get_user_model
-from django.core.mail import get_connection, send_mail
+from django.core.mail import get_connection
+from core import mailer
 import logging
 
 
@@ -53,6 +60,60 @@ class NodeRole(Entity):
         return self.name
 
 
+class NodeFeatureManager(models.Manager):
+    def get_by_natural_key(self, slug: str):
+        return self.get(slug=slug)
+
+
+class NodeFeature(Entity):
+    """Feature that may be enabled on nodes and roles."""
+
+    slug = models.SlugField(max_length=50, unique=True)
+    display = models.CharField(max_length=50)
+    roles = models.ManyToManyField(NodeRole, blank=True, related_name="features")
+
+    objects = NodeFeatureManager()
+
+    class Meta:
+        ordering = ["display"]
+        verbose_name = "Node Feature"
+        verbose_name_plural = "Node Features"
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (self.slug,)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.display
+
+    @property
+    def is_enabled(self) -> bool:
+        from django.conf import settings
+        from pathlib import Path
+
+        node = Node.get_local()
+        if not node:
+            return False
+        if node.features.filter(pk=self.pk).exists():
+            return True
+        if self.slug == "gui-toast":
+            from core.notifications import supports_gui_toast
+
+            return supports_gui_toast()
+        if self.slug == "rpi-camera":
+            return Node._has_rpi_camera()
+        lock_map = {
+            "lcd-screen": "lcd_screen.lck",
+            "rfid-scanner": "rfid.lck",
+            "celery-queue": "celery.lck",
+            "nginx-server": "nginx_mode.lck",
+        }
+        lock = lock_map.get(self.slug)
+        if lock:
+            base_path = Path(node.base_path or settings.BASE_DIR)
+            return (base_path / "locks" / lock).exists()
+        return False
+
+
 def get_terminal_role():
     """Return the NodeRole representing a Terminal if it exists."""
     return NodeRole.objects.filter(name="Terminal").first()
@@ -63,9 +124,7 @@ class Node(Entity):
 
     hostname = models.CharField(max_length=100)
     address = models.GenericIPAddressField()
-    mac_address = models.CharField(
-        max_length=17, unique=True, null=True, blank=True
-    )
+    mac_address = models.CharField(max_length=17, unique=True, null=True, blank=True)
     port = models.PositiveIntegerField(default=8000)
     badge_color = models.CharField(max_length=7, default="#28a745")
     role = models.ForeignKey(NodeRole, on_delete=models.SET_NULL, null=True, blank=True)
@@ -75,8 +134,6 @@ class Node(Entity):
         verbose_name="enable public API",
     )
     public_endpoint = models.SlugField(blank=True, unique=True)
-    clipboard_polling = models.BooleanField(default=False)
-    screenshot_polling = models.BooleanField(default=False)
     uuid = models.UUIDField(
         default=uuid.uuid4,
         unique=True,
@@ -87,7 +144,31 @@ class Node(Entity):
     base_path = models.CharField(max_length=255, blank=True)
     installed_version = models.CharField(max_length=20, blank=True)
     installed_revision = models.CharField(max_length=40, blank=True)
-    has_lcd_screen = models.BooleanField(default=False)
+    features = models.ManyToManyField(
+        NodeFeature,
+        through="NodeFeatureAssignment",
+        related_name="nodes",
+        blank=True,
+    )
+
+    FEATURE_LOCK_MAP = {
+        "lcd-screen": "lcd_screen.lck",
+        "rfid-scanner": "rfid.lck",
+        "celery-queue": "celery.lck",
+        "nginx-server": "nginx_mode.lck",
+    }
+    RPI_CAMERA_DEVICE = Path("/dev/video0")
+    RPI_CAMERA_BINARIES = ("rpicam-hello", "rpicam-still", "rpicam-vid")
+    AP_ROUTER_SSID = "gelectriic-ap"
+    NMCLI_TIMEOUT = 5
+    AUTO_MANAGED_FEATURES = set(FEATURE_LOCK_MAP.keys()) | {
+        "gui-toast",
+        "rpi-camera",
+        "ap-router",
+        "ap-public-wifi",
+        "postgres-db",
+    }
+    MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll"}
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.hostname}:{self.port}"
@@ -122,7 +203,6 @@ class Node(Entity):
         node = cls.objects.filter(mac_address=mac).first()
         if not node:
             node = cls.objects.filter(public_endpoint=slug).first()
-        lcd_lock = Path(settings.BASE_DIR) / "locks" / "lcd_screen.lck"
         defaults = {
             "hostname": hostname,
             "address": address,
@@ -132,14 +212,11 @@ class Node(Entity):
             "installed_revision": installed_revision,
             "public_endpoint": slug,
             "mac_address": mac,
-            "has_lcd_screen": lcd_lock.exists(),
         }
         if node:
             for field, value in defaults.items():
-                if field == "has_lcd_screen":
-                    continue
                 setattr(node, field, value)
-            update_fields = [k for k in defaults.keys() if k != "has_lcd_screen"]
+            update_fields = list(defaults.keys())
             node.save(update_fields=update_fields)
             created = False
         else:
@@ -161,17 +238,119 @@ class Node(Entity):
                 node.save(update_fields=["role"])
         Site.objects.get_or_create(domain=hostname, defaults={"name": "host"})
         node.ensure_keys()
+        node.notify_peers_of_update()
         return node, created
 
+    def notify_peers_of_update(self):
+        """Attempt to update this node's registration with known peers."""
+
+        from secrets import token_hex
+
+        try:
+            import requests
+        except Exception:  # pragma: no cover - requests should be available
+            return
+
+        security_dir = Path(self.base_path or settings.BASE_DIR) / "security"
+        priv_path = security_dir / f"{self.public_endpoint}"
+        if not priv_path.exists():
+            logger.debug("Private key for %s not found; skipping peer update", self)
+            return
+        try:
+            private_key = serialization.load_pem_private_key(
+                priv_path.read_bytes(), password=None
+            )
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Failed to load private key for %s: %s", self, exc)
+            return
+        token = token_hex(16)
+        try:
+            signature = private_key.sign(
+                token.encode(),
+                padding.PKCS1v15(),
+                hashes.SHA256(),
+            )
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Failed to sign peer update for %s: %s", self, exc)
+            return
+
+        payload = {
+            "hostname": self.hostname,
+            "address": self.address,
+            "port": self.port,
+            "mac_address": self.mac_address,
+            "public_key": self.public_key,
+            "token": token,
+            "signature": base64.b64encode(signature).decode(),
+        }
+        if self.installed_version:
+            payload["installed_version"] = self.installed_version
+        if self.installed_revision:
+            payload["installed_revision"] = self.installed_revision
+
+        payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
+        headers = {"Content-Type": "application/json"}
+
+        peers = Node.objects.exclude(pk=self.pk)
+        for peer in peers:
+            host_candidates: list[str] = []
+            if peer.address:
+                host_candidates.append(peer.address)
+            if peer.hostname and peer.hostname not in host_candidates:
+                host_candidates.append(peer.hostname)
+            port = peer.port or 8000
+            urls: list[str] = []
+            for host in host_candidates:
+                host = host.strip()
+                if not host:
+                    continue
+                if ":" in host and not host.startswith("["):
+                    host = f"[{host}]"
+                http_url = (
+                    f"http://{host}/nodes/register/"
+                    if port == 80
+                    else f"http://{host}:{port}/nodes/register/"
+                )
+                https_url = (
+                    f"https://{host}/nodes/register/"
+                    if port in {80, 443}
+                    else f"https://{host}:{port}/nodes/register/"
+                )
+                for url in (https_url, http_url):
+                    if url not in urls:
+                        urls.append(url)
+            if not urls:
+                continue
+            for url in urls:
+                try:
+                    response = requests.post(
+                        url, data=payload_json, headers=headers, timeout=2
+                    )
+                except Exception as exc:  # pragma: no cover - best effort
+                    logger.debug("Failed to update %s via %s: %s", peer, url, exc)
+                    continue
+                if response.ok:
+                    version_display = _format_upgrade_body(
+                        self.installed_version,
+                        self.installed_revision,
+                    )
+                    version_suffix = f" ({version_display})" if version_display else ""
+                    logger.info(
+                        "Announced startup to %s%s",
+                        peer,
+                        version_suffix,
+                    )
+                    break
+            else:
+                logger.warning("Unable to notify node %s of startup", peer)
+
     def ensure_keys(self):
         security_dir = Path(settings.BASE_DIR) / "security"
         security_dir.mkdir(parents=True, exist_ok=True)
         priv_path = security_dir / f"{self.public_endpoint}"
         pub_path = security_dir / f"{self.public_endpoint}.pub"
         if not priv_path.exists() or not pub_path.exists():
-            private_key = rsa.generate_private_key(
-                public_exponent=65537, key_size=2048
-            )
+            private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
             private_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.TraditionalOpenSSL,
@@ -199,22 +378,196 @@ class Node(Entity):
             self.mac_address = self.mac_address.lower()
         if not self.public_endpoint:
             self.public_endpoint = slugify(self.hostname)
-        previous_clipboard = previous_screenshot = None
-        if self.pk:
-            previous = Node.objects.get(pk=self.pk)
-            previous_clipboard = previous.clipboard_polling
-            previous_screenshot = previous.screenshot_polling
         super().save(*args, **kwargs)
-        if previous_clipboard != self.clipboard_polling:
-            self._sync_clipboard_task()
-        if previous_screenshot != self.screenshot_polling:
-            self._sync_screenshot_task()
+        if self.pk:
+            self.refresh_features()
+
+    def has_feature(self, slug: str) -> bool:
+        return self.features.filter(slug=slug).exists()
+
+    @classmethod
+    def _has_rpi_camera(cls) -> bool:
+        """Return ``True`` when the Raspberry Pi camera stack is available."""
+
+        device = cls.RPI_CAMERA_DEVICE
+        if not device.exists():
+            return False
+        device_path = str(device)
+        try:
+            mode = os.stat(device_path).st_mode
+        except OSError:
+            return False
+        if not stat.S_ISCHR(mode):
+            return False
+        if not os.access(device_path, os.R_OK | os.W_OK):
+            return False
+        for binary in cls.RPI_CAMERA_BINARIES:
+            tool_path = shutil.which(binary)
+            if not tool_path:
+                return False
+            try:
+                result = subprocess.run(
+                    [tool_path, "--help"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=5,
+                )
+            except Exception:
+                return False
+            if result.returncode != 0:
+                return False
+        return True
+
+    @classmethod
+    def _hosts_gelectriic_ap(cls) -> bool:
+        """Return ``True`` when the node is hosting the gelectriic access point."""
+
+        nmcli_path = shutil.which("nmcli")
+        if not nmcli_path:
+            return False
+        try:
+            result = subprocess.run(
+                [
+                    nmcli_path,
+                    "-t",
+                    "-f",
+                    "NAME,DEVICE,TYPE",
+                    "connection",
+                    "show",
+                    "--active",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=cls.NMCLI_TIMEOUT,
+            )
+        except Exception:
+            return False
+        if result.returncode != 0:
+            return False
+        for line in result.stdout.splitlines():
+            if not line:
+                continue
+            parts = line.split(":", 2)
+            if not parts:
+                continue
+            name = parts[0]
+            conn_type = ""
+            if len(parts) == 3:
+                conn_type = parts[2]
+            elif len(parts) > 1:
+                conn_type = parts[1]
+            if name != cls.AP_ROUTER_SSID:
+                continue
+            conn_type_normalized = conn_type.strip().lower()
+            if conn_type_normalized not in {"wifi", "802-11-wireless"}:
+                continue
+            try:
+                mode_result = subprocess.run(
+                    [
+                        nmcli_path,
+                        "-g",
+                        "802-11-wireless.mode",
+                        "connection",
+                        "show",
+                        name,
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=cls.NMCLI_TIMEOUT,
+                )
+            except Exception:
+                continue
+            if mode_result.returncode != 0:
+                continue
+            if mode_result.stdout.strip() == "ap":
+                return True
+        return False
+
+    @staticmethod
+    def _uses_postgres() -> bool:
+        """Return ``True`` when the default database uses PostgreSQL."""
 
-    def _sync_clipboard_task(self):
+        engine = settings.DATABASES.get("default", {}).get("ENGINE", "")
+        return "postgresql" in engine.lower()
+
+    def refresh_features(self):
+        if not self.pk:
+            return
+        if not self.is_local:
+            self.sync_feature_tasks()
+            return
+        detected_slugs = set()
+        base_path = Path(self.base_path or settings.BASE_DIR)
+        locks_dir = base_path / "locks"
+        for slug, filename in self.FEATURE_LOCK_MAP.items():
+            if (locks_dir / filename).exists():
+                detected_slugs.add(slug)
+        if self._has_rpi_camera():
+            detected_slugs.add("rpi-camera")
+        public_mode_lock = locks_dir / "public_wifi_mode.lck"
+        if self._hosts_gelectriic_ap():
+            if public_mode_lock.exists():
+                detected_slugs.add("ap-public-wifi")
+            else:
+                detected_slugs.add("ap-router")
+        if self._uses_postgres():
+            detected_slugs.add("postgres-db")
+        try:
+            from core.notifications import supports_gui_toast
+        except Exception:
+            pass
+        else:
+            try:
+                if supports_gui_toast():
+                    detected_slugs.add("gui-toast")
+            except Exception:
+                pass
+        current_slugs = set(
+            self.features.filter(slug__in=self.AUTO_MANAGED_FEATURES).values_list(
+                "slug", flat=True
+            )
+        )
+        add_slugs = detected_slugs - current_slugs
+        if add_slugs:
+            for feature in NodeFeature.objects.filter(slug__in=add_slugs):
+                NodeFeatureAssignment.objects.update_or_create(
+                    node=self, feature=feature
+                )
+        remove_slugs = current_slugs - detected_slugs
+        if remove_slugs:
+            NodeFeatureAssignment.objects.filter(
+                node=self, feature__slug__in=remove_slugs
+            ).delete()
+        self.sync_feature_tasks()
+
+    def update_manual_features(self, slugs: Iterable[str]):
+        desired = {slug for slug in slugs if slug in self.MANUAL_FEATURE_SLUGS}
+        remove_slugs = self.MANUAL_FEATURE_SLUGS - desired
+        if remove_slugs:
+            NodeFeatureAssignment.objects.filter(
+                node=self, feature__slug__in=remove_slugs
+            ).delete()
+        if desired:
+            for feature in NodeFeature.objects.filter(slug__in=desired):
+                NodeFeatureAssignment.objects.update_or_create(
+                    node=self, feature=feature
+                )
+        self.sync_feature_tasks()
+
+    def sync_feature_tasks(self):
+        clipboard_enabled = self.has_feature("clipboard-poll")
+        screenshot_enabled = self.has_feature("screenshot-poll")
+        self._sync_clipboard_task(clipboard_enabled)
+        self._sync_screenshot_task(screenshot_enabled)
+
+    def _sync_clipboard_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
 
         task_name = f"poll_clipboard_node_{self.pk}"
-        if self.clipboard_polling:
+        if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
                 every=5, period=IntervalSchedule.SECONDS
             )
@@ -228,12 +581,12 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
-    def _sync_screenshot_task(self):
+    def _sync_screenshot_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
         import json
 
         task_name = f"capture_screenshot_node_{self.pk}"
-        if self.screenshot_polling:
+        if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
                 every=1, period=IntervalSchedule.MINUTES
             )
@@ -254,45 +607,139 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
-
-    def send_mail(self, subject: str, message: str, recipient_list: list[str], from_email: str | None = None, **kwargs):
+    def send_mail(
+        self,
+        subject: str,
+        message: str,
+        recipient_list: list[str],
+        from_email: str | None = None,
+        **kwargs,
+    ):
         """Send an email using this node's configured outbox if available."""
         outbox = getattr(self, "email_outbox", None)
         logger.info(
-            "Node %s sending email to %s using %s backend",
+            "Node %s queueing email to %s using %s backend",
             self.pk,
             recipient_list,
             "outbox" if outbox else "default",
         )
-        if outbox:
-            result = outbox.send_mail(subject, message, recipient_list, from_email, **kwargs)
-            logger.info("Outbox send_mail result: %s", result)
-            return result
-        from_email = from_email or settings.DEFAULT_FROM_EMAIL
-        result = send_mail(subject, message, from_email, recipient_list, **kwargs)
-        logger.info("Default send_mail result: %s", result)
-        return result
+        return mailer.send(
+            subject,
+            message,
+            recipient_list,
+            from_email,
+            outbox=outbox,
+            **kwargs,
+        )
+
+
+node_information_updated = Signal()
+
+
+def _format_upgrade_body(version: str, revision: str) -> str:
+    version = (version or "").strip()
+    revision = (revision or "").strip()
+    parts: list[str] = []
+    if version:
+        normalized = version.lstrip("vV") or version
+        parts.append(f"v{normalized}")
+    if revision:
+        rev_clean = re.sub(r"[^0-9A-Za-z]", "", revision)
+        rev_short = (rev_clean[-6:] if rev_clean else revision[-6:])
+        parts.append(f"r{rev_short}")
+    return " ".join(parts).strip()
+
 
+@receiver(node_information_updated)
+def _announce_peer_startup(
+    sender,
+    *,
+    node: "Node",
+    previous_version: str = "",
+    previous_revision: str = "",
+    current_version: str = "",
+    current_revision: str = "",
+    **_: object,
+) -> None:
+    current_version = (current_version or "").strip()
+    current_revision = (current_revision or "").strip()
+    previous_version = (previous_version or "").strip()
+    previous_revision = (previous_revision or "").strip()
 
-class EmailOutbox(Entity):
-    """SMTP credentials for sending mail from a node."""
+    local = Node.get_local()
+    if local and node.pk == local.pk:
+        return
+
+    body = _format_upgrade_body(current_version, current_revision)
+    if not body:
+        body = "Online"
+
+    hostname = (node.hostname or "Node").strip() or "Node"
+    subject = f"UP {hostname}"
+    notify_async(subject, body)
+
+
+class NodeFeatureAssignment(Entity):
+    """Bridge between :class:`Node` and :class:`NodeFeature`."""
+
+    node = models.ForeignKey(
+        Node, on_delete=models.CASCADE, related_name="feature_assignments"
+    )
+    feature = models.ForeignKey(
+        NodeFeature, on_delete=models.CASCADE, related_name="node_assignments"
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ("node", "feature")
+        verbose_name = "Node Feature Assignment"
+        verbose_name_plural = "Node Feature Assignments"
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.node} -> {self.feature}"
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        self.node.sync_feature_tasks()
+
+
+@receiver(post_delete, sender=NodeFeatureAssignment)
+def _sync_tasks_on_assignment_delete(sender, instance, **kwargs):
+    node_id = getattr(instance, "node_id", None)
+    if not node_id:
+        return
+    node = Node.objects.filter(pk=node_id).first()
+    if node:
+        node.sync_feature_tasks()
+
+
+class EmailOutbox(Profile):
+    """SMTP credentials for sending mail."""
+
+    profile_fields = (
+        "host",
+        "port",
+        "username",
+        "password",
+        "use_tls",
+        "use_ssl",
+        "from_email",
+    )
 
     node = models.OneToOneField(
-        Node, on_delete=models.CASCADE, related_name="email_outbox"
+        Node,
+        on_delete=models.CASCADE,
+        related_name="email_outbox",
+        null=True,
+        blank=True,
     )
     host = SigilShortAutoField(
         max_length=100,
-        help_text=(
-            "Gmail: smtp.gmail.com. "
-            "GoDaddy: smtpout.secureserver.net"
-        ),
+        help_text=("Gmail: smtp.gmail.com. " "GoDaddy: smtpout.secureserver.net"),
     )
     port = models.PositiveIntegerField(
         default=587,
-        help_text=(
-            "Gmail: 587 (TLS). "
-            "GoDaddy: 587 (TLS) or 465 (SSL)"
-        ),
+        help_text=("Gmail: 587 (TLS). " "GoDaddy: 587 (TLS) or 465 (SSL)"),
     )
     username = SigilShortAutoField(
         max_length=100,
@@ -323,12 +770,35 @@ class EmailOutbox(Entity):
         verbose_name = "Email Outbox"
         verbose_name_plural = "Email Outboxes"
 
-    class Meta:
-        verbose_name = "Email Outbox"
-        verbose_name_plural = "Email Outboxes"
+    def __str__(self) -> str:
+        address = (self.from_email or "").strip()
+        if address:
+            return address
+
+        username = (self.username or "").strip()
+        host = (self.host or "").strip()
+        if username and host:
+            return f"{username}@{host}"
+        if username:
+            return username
+        if host:
+            return host
+
+        owner = self.owner_display()
+        if owner:
+            return owner
+
+        return super().__str__()
+
+    def clean(self):
+        if self.user_id or self.group_id:
+            super().clean()
+        else:
+            super(Profile, self).clean()
 
     def get_connection(self):
         return get_connection(
+            "django.core.mail.backends.smtp.EmailBackend",
             host=self.host,
             port=self.port,
             username=self.username or None,
@@ -338,17 +808,23 @@ class EmailOutbox(Entity):
         )
 
     def send_mail(self, subject, message, recipient_list, from_email=None, **kwargs):
-        connection = self.get_connection()
         from_email = from_email or self.from_email or settings.DEFAULT_FROM_EMAIL
-        return send_mail(
+        logger.info("EmailOutbox %s queueing email to %s", self.pk, recipient_list)
+        return mailer.send(
             subject,
             message,
-            from_email,
             recipient_list,
-            connection=connection,
+            from_email,
+            outbox=self,
             **kwargs,
         )
 
+    def owner_display(self):
+        owner = super().owner_display()
+        if owner:
+            return owner
+        return str(self.node) if self.node_id else ""
+
 
 class NetMessage(Entity):
     """Message propagated across nodes."""
@@ -359,6 +835,13 @@ class NetMessage(Entity):
         editable=False,
         verbose_name="UUID",
     )
+    node_origin = models.ForeignKey(
+        "Node",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="originated_net_messages",
+    )
     subject = models.CharField(max_length=64, blank=True)
     body = models.CharField(max_length=256, blank=True)
     reach = models.ForeignKey(
@@ -393,10 +876,12 @@ class NetMessage(Entity):
                 role = reach
             else:
                 role = NodeRole.objects.filter(name=reach).first()
+        origin = Node.get_local()
         msg = cls.objects.create(
             subject=subject[:64],
             body=body[:256],
             reach=role or get_terminal_role(),
+            node_origin=origin,
         )
         msg.propagate(seen=seen or [])
         return msg
@@ -406,8 +891,28 @@ class NetMessage(Entity):
         import random
         import requests
 
-        notify(self.subject, self.body)
+        displayed = notify(self.subject, self.body)
         local = Node.get_local()
+        if displayed:
+            cutoff = timezone.now() - timedelta(days=7)
+            prune_qs = type(self).objects.filter(created__lt=cutoff)
+            if local:
+                prune_qs = prune_qs.filter(
+                    models.Q(node_origin=local) | models.Q(node_origin__isnull=True)
+                )
+            else:
+                prune_qs = prune_qs.filter(node_origin__isnull=True)
+            if self.pk:
+                prune_qs = prune_qs.exclude(pk=self.pk)
+            prune_qs.delete()
+        if local and not self.node_origin_id:
+            self.node_origin = local
+            self.save(update_fields=["node_origin"])
+        origin_uuid = None
+        if self.node_origin_id:
+            origin_uuid = str(self.node_origin.uuid)
+        elif local:
+            origin_uuid = str(local.uuid)
         private_key = None
         seen = list(seen or [])
         local_id = None
@@ -448,12 +953,15 @@ class NetMessage(Entity):
 
         reach_name = self.reach.name if self.reach else "Terminal"
         role_map = {
-            "Particle": ["Particle"],
-            "Terminal": ["Terminal", "Particle"],
-            "Control": ["Control", "Terminal", "Particle"],
-            "Satellite": ["Satellite", "Control", "Terminal", "Particle"],
-            "Constellation": ["Constellation", "Satellite", "Control", "Terminal", "Particle"],
-            "Virtual": ["Virtual", "Constellation", "Satellite", "Control", "Terminal", "Particle"],
+            "Terminal": ["Terminal"],
+            "Control": ["Control", "Terminal"],
+            "Satellite": ["Satellite", "Control", "Terminal"],
+            "Constellation": [
+                "Constellation",
+                "Satellite",
+                "Control",
+                "Terminal",
+            ],
         }
         role_order = role_map.get(reach_name, ["Terminal"])
         selected: list[Node] = []
@@ -479,6 +987,7 @@ class NetMessage(Entity):
                 "seen": payload_seen,
                 "reach": reach_name,
                 "sender": local_id,
+                "origin": origin_uuid,
             }
             payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
             headers = {"Content-Type": "application/json"}
@@ -527,9 +1036,7 @@ class ContentSample(Entity):
         db_index=True,
         verbose_name="transaction UUID",
     )
-    node = models.ForeignKey(
-        Node, on_delete=models.SET_NULL, null=True, blank=True
-    )
+    node = models.ForeignKey(Node, on_delete=models.SET_NULL, null=True, blank=True)
     user = models.ForeignKey(
         settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True
     )
@@ -555,109 +1062,6 @@ class ContentSample(Entity):
         return str(self.name)
 
 
-class NodeTask(Entity):
-    """Script that can be executed on nodes."""
-
-    recipe = models.TextField()
-    role = models.ForeignKey(NodeRole, on_delete=models.SET_NULL, null=True, blank=True)
-    created = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ["-created"]
-        verbose_name = "Node Task"
-        verbose_name_plural = "Node Tasks"
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.recipe
-
-    def run(self, node: Node):
-        """Execute this script on ``node`` and return its output."""
-        if not node.is_local:
-            raise NotImplementedError("Remote node execution is not implemented")
-        import subprocess
-
-        result = subprocess.run(
-            self.recipe, shell=True, capture_output=True, text=True
-        )
-        return result.stdout + result.stderr
-
-
-class Operation(Entity):
-    """Action that can change node or constellation state."""
-
-    name = models.SlugField(unique=True)
-    template = SigilLongCheckField(blank=True)
-    command = SigilLongAutoField(blank=True)
-    is_django = models.BooleanField(default=False)
-    next_operations = models.ManyToManyField(
-        "self",
-        through="Interrupt",
-        through_fields=("from_operation", "to_operation"),
-        symmetrical=False,
-        related_name="previous_operations",
-    )
-
-    class Meta:
-        ordering = ["name"]
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.name
-
-
-class Interrupt(Entity):
-    """Intermediate transition between operations."""
-
-    name = models.CharField(max_length=100)
-    preview = SigilLongAutoField(blank=True)
-    priority = models.PositiveIntegerField(default=0)
-    from_operation = models.ForeignKey(
-        Operation,
-        on_delete=models.CASCADE,
-        related_name="outgoing_interrupts",
-    )
-    to_operation = models.ForeignKey(
-        Operation,
-        on_delete=models.CASCADE,
-        related_name="incoming_interrupts",
-    )
-
-    class Meta:
-        ordering = ["-priority"]
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.name
- 
-
-class Logbook(Entity):
-    """Record of executed operations."""
-
-    operation = models.ForeignKey(
-        Operation, on_delete=models.CASCADE, related_name="logs"
-    )
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        null=True,
-        blank=True,
-        on_delete=models.SET_NULL,
-    )
-    input_text = models.TextField(blank=True)
-    output = models.TextField(blank=True)
-    error = models.TextField(blank=True)
-    interrupted = models.BooleanField(default=False)
-    interrupt = models.ForeignKey(
-        Interrupt, null=True, blank=True, on_delete=models.SET_NULL
-    )
-    created = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ["-created"]
-        verbose_name = "Logbook Entry"
-        verbose_name_plural = "Logbook"
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return f"{self.operation} @ {self.created:%Y-%m-%d %H:%M:%S}"
-
-
 UserModel = get_user_model()
 
 
@@ -667,7 +1071,3 @@ class User(UserModel):
         app_label = "nodes"
         verbose_name = UserModel._meta.verbose_name
         verbose_name_plural = UserModel._meta.verbose_name_plural
-
-
-
-