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

core/workgroup_urls.py

@@ -1,4 +1,4 @@
-"""URL routes for chat profile endpoints."""
+"""URL routes for assistant profile endpoints."""
 
 from django.urls import path
 
@@ -7,7 +7,11 @@ from . import workgroup_views as views
 app_name = "workgroup"
 
 urlpatterns = [
-    path("chat-profiles/<int:user_id>/", views.issue_key, name="chatprofile-issue"),
+    path(
+        "assistant-profiles/<int:user_id>/",
+        views.issue_key,
+        name="assistantprofile-issue",
+    ),
     path("assistant/test/", views.assistant_test, name="assistant-test"),
+    path("chat/", views.chat, name="chat"),
 ]
-

core/workgroup_views.py

@@ -1,15 +1,17 @@
-"""REST endpoints for ChatProfile issuance and authentication."""
+"""REST endpoints for AssistantProfile issuance and authentication."""
 
 from __future__ import annotations
 
 from functools import wraps
 
+from django.apps import apps
 from django.contrib.auth import get_user_model
+from django.forms.models import model_to_dict
 from django.http import HttpResponse, JsonResponse
 from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_GET, require_POST
 
-from .models import ChatProfile, hash_key
+from .models import AssistantProfile, hash_key
 
 
 @csrf_exempt
@@ -21,7 +23,7 @@ def issue_key(request, user_id: int) -> JsonResponse:
     """
 
     user = get_user_model().objects.get(pk=user_id)
-    profile, key = ChatProfile.issue_key(user)
+    profile, key = AssistantProfile.issue_key(user)
     return JsonResponse({"user_id": user_id, "user_key": key})
 
 
@@ -36,11 +38,14 @@ def authenticate(view_func):
 
         key_hash = hash_key(header.split(" ", 1)[1])
         try:
-            profile = ChatProfile.objects.get(user_key_hash=key_hash, is_active=True)
-        except ChatProfile.DoesNotExist:
+            profile = AssistantProfile.objects.get(
+                user_key_hash=key_hash, is_active=True
+            )
+        except AssistantProfile.DoesNotExist:
             return HttpResponse(status=401)
 
         profile.touch()
+        request.assistant_profile = profile
         request.chat_profile = profile
         return view_func(request, *args, **kwargs)
 
@@ -52,6 +57,38 @@ def authenticate(view_func):
 def assistant_test(request):
     """Return a simple greeting to confirm authentication."""
 
-    user_id = request.chat_profile.user_id
+    profile = getattr(request, "assistant_profile", None)
+    user_id = profile.user_id if profile else None
     return JsonResponse({"message": f"Hello from user {user_id}"})
 
+
+@require_GET
+@authenticate
+def chat(request):
+    """Return serialized data from any model.
+
+    Clients must provide ``model`` as ``app_label.ModelName`` and may include a
+    ``pk`` to fetch a specific record. When ``pk`` is omitted, the view returns
+    up to 100 records.
+    """
+
+    model_label = request.GET.get("model")
+    if not model_label:
+        return JsonResponse({"error": "model parameter required"}, status=400)
+    try:
+        model = apps.get_model(model_label)
+    except LookupError:
+        return JsonResponse({"error": "unknown model"}, status=400)
+
+    qs = model.objects.all()
+    pk = request.GET.get("pk")
+    if pk is not None:
+        try:
+            obj = qs.get(pk=pk)
+        except model.DoesNotExist:
+            return JsonResponse({"error": "object not found"}, status=404)
+        data = model_to_dict(obj)
+    else:
+        data = [model_to_dict(o) for o in qs[:100]]
+
+    return JsonResponse({"data": data})

nodes/actions.py

@@ -68,5 +68,3 @@ class CaptureScreenshotAction(NodeAction):
         path = capture_screenshot(url)
         save_screenshot(path, node=node, method="NODE_ACTION")
         return path
-
-

nodes/admin.py

@@ -4,41 +4,29 @@ from django.shortcuts import redirect, render
 from django.utils.html import format_html
 from django import forms
 from django.contrib.admin.widgets import FilteredSelectMultiple
-from app.widgets import CopyColorWidget, CodeEditorWidget
-from django.db import models
+from core.widgets import CopyColorWidget
+from django.db.models import Count
 from django.conf import settings
 from pathlib import Path
 from django.http import HttpResponse
-from django.template.response import TemplateResponse
-from django.core.management import call_command
 import base64
 import pyperclip
 from pyperclip import PyperclipException
 import uuid
 import subprocess
-import io
-import threading
-import re
 from .utils import capture_screenshot, save_screenshot
 from .actions import NodeAction
 
 from .models import (
     Node,
-    EmailOutbox as NodeEmailOutbox,
+    EmailOutbox,
     NodeRole,
+    NodeFeature,
+    NodeFeatureAssignment,
     ContentSample,
-    NodeTask,
     NetMessage,
-    Operation,
-    Interrupt,
-    Logbook,
-    User,
 )
-from core.admin import UserAdmin as CoreUserAdmin
-
-
-RUN_CONTEXTS: dict[int, dict] = {}
-SIGIL_RE = re.compile(r"\[[A-Za-z0-9_]+\.[A-Za-z0-9_]+\]")
+from core.user_data import EntityModelAdmin
 
 
 class NodeAdminForm(forms.ModelForm):
@@ -48,8 +36,14 @@ class NodeAdminForm(forms.ModelForm):
         widgets = {"badge_color": CopyColorWidget()}
 
 
+class NodeFeatureAssignmentInline(admin.TabularInline):
+    model = NodeFeatureAssignment
+    extra = 0
+    autocomplete_fields = ("feature",)
+
+
 @admin.register(Node)
-class NodeAdmin(admin.ModelAdmin):
+class NodeAdmin(EntityModelAdmin):
     list_display = (
         "hostname",
         "mac_address",
@@ -62,8 +56,8 @@ class NodeAdmin(admin.ModelAdmin):
     change_list_template = "admin/nodes/node/change_list.html"
     change_form_template = "admin/nodes/node/change_form.html"
     form = NodeAdminForm
-    actions = ["run_task", "take_screenshots"]
-
+    actions = ["register_visitor", "run_task", "take_screenshots"]
+    inlines = [NodeFeatureAssignmentInline]
 
     def get_urls(self):
         urls = super().get_urls()
@@ -73,6 +67,11 @@ class NodeAdmin(admin.ModelAdmin):
                 self.admin_site.admin_view(self.register_current),
                 name="nodes_node_register_current",
             ),
+            path(
+                "register-visitor/",
+                self.admin_site.admin_view(self.register_visitor_view),
+                name="nodes_node_register_visitor",
+            ),
             path(
                 "<int:node_id>/action/<str:action>/",
                 self.admin_site.admin_view(self.action_view),
@@ -100,6 +99,29 @@ class NodeAdmin(admin.ModelAdmin):
         }
         return render(request, "admin/nodes/node/register_remote.html", context)
 
+    @admin.action(description="Register Visitor Node")
+    def register_visitor(self, request, queryset=None):
+        return self.register_visitor_view(request)
+
+    def register_visitor_view(self, request):
+        """Exchange registration data with the visiting node."""
+
+        node, created = Node.register_current()
+        if created:
+            self.message_user(
+                request, f"Current host registered as {node}", messages.SUCCESS
+            )
+
+        token = uuid.uuid4().hex
+        context = {
+            "token": token,
+            "info_url": reverse("node-info"),
+            "register_url": reverse("register-node"),
+            "visitor_info_url": "http://localhost:8000/nodes/info/",
+            "visitor_register_url": "http://localhost:8000/nodes/register/",
+        }
+        return render(request, "admin/nodes/node/register_visitor.html", context)
+
     def public_key(self, request, node_id):
         node = self.get_object(request, node_id)
         if not node:
@@ -117,11 +139,21 @@ class NodeAdmin(admin.ModelAdmin):
     def run_task(self, request, queryset):
         if "apply" in request.POST:
             recipe_text = request.POST.get("recipe", "")
-            task_obj, _ = NodeTask.objects.get_or_create(recipe=recipe_text)
             results = []
             for node in queryset:
                 try:
-                    output = task_obj.run(node)
+                    if not node.is_local:
+                        raise NotImplementedError(
+                            "Remote node execution is not implemented"
+                        )
+                    command = ["/bin/sh", "-c", recipe_text]
+                    result = subprocess.run(
+                        command,
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                    )
+                    output = result.stdout + result.stderr
                 except Exception as exc:
                     output = str(exc)
                 results.append((node, output))
@@ -194,21 +226,70 @@ class NodeAdmin(admin.ModelAdmin):
         return redirect(reverse("admin:nodes_node_change", args=[node_id]))
 
 
-class EmailOutbox(NodeEmailOutbox):
-    class Meta:
-        proxy = True
-        app_label = "post_office"
-        verbose_name = NodeEmailOutbox._meta.verbose_name
-        verbose_name_plural = NodeEmailOutbox._meta.verbose_name_plural
+@admin.register(EmailOutbox)
+class EmailOutboxAdmin(EntityModelAdmin):
+    list_display = ("owner_label", "host", "port", "username", "use_tls", "use_ssl")
+    change_form_template = "admin/nodes/emailoutbox/change_form.html"
+    fieldsets = (
+        ("Owner", {"fields": ("user", "group", "node")}),
+        (
+            None,
+            {
+                "fields": (
+                    "host",
+                    "port",
+                    "username",
+                    "password",
+                    "use_tls",
+                    "use_ssl",
+                    "from_email",
+                )
+            },
+        ),
+    )
 
+    @admin.display(description="Owner")
+    def owner_label(self, obj):
+        return obj.owner_display()
 
-@admin.register(EmailOutbox)
-class EmailOutboxAdmin(admin.ModelAdmin):
-    list_display = ("node", "host", "port", "username", "use_tls", "use_ssl")
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "<path:object_id>/test/",
+                self.admin_site.admin_view(self.test_outbox),
+                name="nodes_emailoutbox_test",
+            )
+        ]
+        return custom + urls
 
-    def save_model(self, request, obj, form, change):
-        super().save_model(request, obj, form, change)
-        obj.__class__ = EmailOutbox
+    def test_outbox(self, request, object_id):
+        outbox = self.get_object(request, object_id)
+        if not outbox:
+            self.message_user(request, "Unknown outbox", messages.ERROR)
+            return redirect("..")
+        recipient = request.user.email or outbox.username
+        try:
+            outbox.send_mail(
+                "Test email",
+                "This is a test email.",
+                [recipient],
+            )
+            self.message_user(request, "Test email sent", messages.SUCCESS)
+        except Exception as exc:  # pragma: no cover - admin feedback
+            self.message_user(request, str(exc), messages.ERROR)
+        return redirect("..")
+
+    def get_model_perms(self, request):  # pragma: no cover - hide from index
+        return {}
+
+    def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        if object_id:
+            extra_context["test_url"] = reverse(
+                "admin:nodes_emailoutbox_test", args=[object_id]
+            )
+        return super().changeform_view(request, object_id, form_url, extra_context)
 
 
 class NodeRoleAdminForm(forms.ModelForm):
@@ -229,16 +310,48 @@ class NodeRoleAdminForm(forms.ModelForm):
 
 
 @admin.register(NodeRole)
-class NodeRoleAdmin(admin.ModelAdmin):
+class NodeRoleAdmin(EntityModelAdmin):
     form = NodeRoleAdminForm
-    list_display = ("name", "description")
+    list_display = ("name", "description", "registered", "default_features")
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.annotate(_registered=Count("node", distinct=True)).prefetch_related(
+            "features"
+        )
+
+    @admin.display(description="Registered", ordering="_registered")
+    def registered(self, obj):
+        return getattr(obj, "_registered", obj.node_set.count())
+
+    @admin.display(description="Default Features")
+    def default_features(self, obj):
+        features = [feature.display for feature in obj.features.all()]
+        return ", ".join(features) if features else "—"
 
     def save_model(self, request, obj, form, change):
         obj.node_set.set(form.cleaned_data.get("nodes", []))
 
 
+@admin.register(NodeFeature)
+class NodeFeatureAdmin(EntityModelAdmin):
+    filter_horizontal = ("roles",)
+    list_display = ("display", "slug", "default_roles", "is_enabled")
+    readonly_fields = ("is_enabled",)
+    search_fields = ("display", "slug")
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.prefetch_related("roles")
+
+    @admin.display(description="Default Roles")
+    def default_roles(self, obj):
+        roles = [role.name for role in obj.roles.all()]
+        return ", ".join(roles) if roles else "—"
+
+
 @admin.register(ContentSample)
-class ContentSampleAdmin(admin.ModelAdmin):
+class ContentSampleAdmin(EntityModelAdmin):
     list_display = ("name", "kind", "node", "user", "created_at")
     readonly_fields = ("created_at", "name", "user", "image_preview")
 
@@ -267,13 +380,17 @@ class ContentSampleAdmin(admin.ModelAdmin):
         if not content:
             self.message_user(request, "Clipboard is empty.", level=messages.INFO)
             return redirect("..")
-        if ContentSample.objects.filter(content=content, kind=ContentSample.TEXT).exists():
+        if ContentSample.objects.filter(
+            content=content, kind=ContentSample.TEXT
+        ).exists():
             self.message_user(
                 request, "Duplicate sample not created.", level=messages.INFO
             )
             return redirect("..")
         user = request.user if request.user.is_authenticated else None
-        ContentSample.objects.create(content=content, user=user, kind=ContentSample.TEXT)
+        ContentSample.objects.create(
+            content=content, user=user, kind=ContentSample.TEXT
+        )
         self.message_user(
             request, "Text sample added from clipboard.", level=messages.SUCCESS
         )
@@ -291,9 +408,7 @@ class ContentSampleAdmin(admin.ModelAdmin):
         if sample:
             self.message_user(request, f"Screenshot saved to {path}", messages.SUCCESS)
         else:
-            self.message_user(
-                request, "Duplicate screenshot; not saved", messages.INFO
-            )
+            self.message_user(request, "Duplicate screenshot; not saved", messages.INFO)
         return redirect("..")
 
     @admin.display(description="Screenshot")
@@ -314,7 +429,7 @@ class ContentSampleAdmin(admin.ModelAdmin):
 
 
 @admin.register(NetMessage)
-class NetMessageAdmin(admin.ModelAdmin):
+class NetMessageAdmin(EntityModelAdmin):
     list_display = ("subject", "body", "reach", "created", "complete")
     search_fields = ("subject", "body")
     list_filter = ("complete", "reach")
@@ -328,243 +443,3 @@ class NetMessageAdmin(admin.ModelAdmin):
         self.message_user(request, f"{queryset.count()} messages sent")
 
     send_messages.short_description = "Send selected messages"
-
-
-class NodeTaskForm(forms.ModelForm):
-    class Meta:
-        model = NodeTask
-        fields = "__all__"
-        widgets = {"recipe": CodeEditorWidget()}
-
-
-@admin.register(NodeTask)
-class NodeTaskAdmin(admin.ModelAdmin):
-    form = NodeTaskForm
-    list_display = ("recipe", "role", "created")
-    actions = ["execute"]
-
-    def execute(self, request, queryset):
-        if queryset.count() != 1:
-            self.message_user(
-                request, "Please select exactly one task", messages.ERROR
-            )
-            return
-        task_obj = queryset.first()
-        if "apply" in request.POST:
-            node_ids = request.POST.getlist("nodes")
-            nodes_qs = Node.objects.filter(pk__in=node_ids)
-            results = []
-            for node in nodes_qs:
-                try:
-                    output = task_obj.run(node)
-                except Exception as exc:
-                    output = str(exc)
-                results.append((node, output))
-            context = {"recipe": task_obj.recipe, "results": results}
-            return render(request, "admin/nodes/task_result.html", context)
-        nodes = Node.objects.all()
-        context = {"nodes": nodes, "task_obj": task_obj}
-        return render(request, "admin/nodes/nodetask/run.html", context)
-
-    execute.short_description = "Run task on nodes"
-
-
-@admin.register(Operation)
-class OperationAdmin(admin.ModelAdmin):
-    list_display = ("name",)
-    formfield_overrides = {models.TextField: {"widget": CodeEditorWidget}}
-    change_form_template = "admin/nodes/operation/change_form.html"
-
-    def get_urls(self):
-        urls = super().get_urls()
-        custom = [
-            path(
-                "<path:object_id>/run/",
-                self.admin_site.admin_view(self.run_view),
-                name="nodes_operation_run",
-            )
-        ]
-        return custom + urls
-
-    def run_view(self, request, object_id):
-        operation = self.get_object(request, object_id)
-        if not operation:
-            self.message_user(request, "Unknown operation", messages.ERROR)
-            return redirect("..")
-        context = RUN_CONTEXTS.setdefault(operation.pk, {"inputs": {}})
-        template_text = operation.resolve_sigils("template")
-
-        # Interrupt handling
-        interrupt_id = request.GET.get("interrupt")
-        if interrupt_id:
-            try:
-                interrupt = operation.outgoing_interrupts.get(pk=interrupt_id)
-            except Interrupt.DoesNotExist:
-                self.message_user(request, "Unknown interrupt", messages.ERROR)
-                return redirect(request.path)
-            proc = context.get("process")
-            if proc and proc.poll() is None:
-                proc.terminate()
-                out, err = proc.communicate()
-                log = context.get("log")
-                if log:
-                    log.output = out
-                    log.error = err
-                    log.interrupted = True
-                    log.interrupt = interrupt
-                    log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            return redirect(
-                reverse("admin:nodes_operation_run", args=[interrupt.to_operation.pk])
-            )
-
-        # Check running processes
-        proc = context.get("process")
-        thread = context.get("thread")
-        if proc and proc.poll() is not None:
-            out, err = proc.communicate()
-            log = context.pop("log")
-            log.output = out
-            log.error = err
-            log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            self.message_user(request, "Operation executed", messages.SUCCESS)
-            return redirect("..")
-        if thread and not thread.is_alive():
-            out = context.pop("out")
-            err = context.pop("err")
-            log = context.pop("log")
-            log.output = out.getvalue()
-            log.error = err.getvalue()
-            log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            self.message_user(request, "Operation executed", messages.SUCCESS)
-            return redirect("..")
-
-        interrupts = [
-            (i, i.resolve_sigils("preview"))
-            for i in operation.outgoing_interrupts.all().order_by("-priority")
-        ]
-        logs = Logbook.objects.filter(operation=operation).order_by("created")
-
-        # Waiting for user-provided sigils
-        waiting = context.get("waiting_inputs")
-        if waiting:
-            if request.method == "POST":
-                for token in waiting:
-                    name = token[1:-1].replace(".", "__")
-                    context["inputs"][token] = request.POST.get(name, "")
-                command = context.pop("pending_command")
-                for token, value in context["inputs"].items():
-                    command = command.replace(token, value)
-                context["waiting_inputs"] = None
-                self._start_operation(context, operation, command, request.user)
-                return redirect(request.path)
-            form_fields = [(t, t[1:-1].replace(".", "__")) for t in waiting]
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "waiting_inputs": form_fields,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        # Waiting for user continuation
-        if context.get("waiting_continue"):
-            if request.method == "POST":
-                context["waiting_continue"] = False
-                RUN_CONTEXTS.pop(operation.pk, None)
-                self.message_user(request, "Operation executed", messages.SUCCESS)
-                return redirect("..")
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "waiting_continue": True,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        # If a process or thread is running, show running state
-        if context.get("process") or context.get("thread"):
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "running": True,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        if request.method == "POST":
-            command = operation.resolve_sigils("command")
-            for token, value in context["inputs"].items():
-                command = command.replace(token, value)
-            unresolved = SIGIL_RE.findall(command)
-            if unresolved:
-                context["waiting_inputs"] = unresolved
-                context["pending_command"] = command
-                return redirect(request.path)
-            if command.strip() == "...":
-                log = Logbook.objects.create(
-                    operation=operation,
-                    user=request.user,
-                    input_text=command,
-                    output="Waiting for user continuation",
-                )
-                context["log"] = log
-                context["waiting_continue"] = True
-                return redirect(request.path)
-            self._start_operation(context, operation, command, request.user)
-            return redirect(request.path)
-
-        tpl_context = {
-            **self.admin_site.each_context(request),
-            "operation": operation,
-            "interrupts": interrupts,
-            "logs": logs,
-            "template": template_text,
-        }
-        return TemplateResponse(request, "admin/nodes/operation/run.html", tpl_context)
-
-    def _start_operation(self, ctx, operation, command, user):
-        log = Logbook.objects.create(operation=operation, user=user, input_text=command)
-        if operation.is_django:
-            out = io.StringIO()
-            err = io.StringIO()
-
-            def target():
-                try:
-                    call_command(*command.split(), stdout=out, stderr=err)
-                except Exception as exc:  # pragma: no cover - unexpected errors
-                    err.write(str(exc))
-
-            thread = threading.Thread(target=target)
-            thread.start()
-            ctx.update({"thread": thread, "out": out, "err": err, "log": log})
-        else:
-            proc = subprocess.Popen(
-                command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-            )
-            ctx.update({"process": proc, "log": log})
-
-    def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        if object_id:
-            extra_context["run_url"] = reverse(
-                "admin:nodes_operation_run", args=[object_id]
-            )
-        return super().changeform_view(request, object_id, form_url, extra_context)
-
-
-admin.site.register(User, CoreUserAdmin)