aetherius 0.2.0__py3-none-any.whl

aetherius/console/console.tcss

@@ -0,0 +1,97 @@
+/* Aetherius Console stylesheet: screen-level layout only. Rules that belong to a single
+   reusable widget live in that widget's DEFAULT_CSS (scoped), not here. */
+
+Screen {
+    align: center top;
+}
+
+.console-title {
+    text-style: bold;
+    padding: 1 2 0 2;
+}
+
+.console-subtitle {
+    color: $text-muted;
+    padding: 0 2 1 2;
+}
+
+.console-body {
+    width: 100%;
+    height: 1fr;
+    padding: 0 2;
+}
+
+.console-placeholder {
+    width: 100%;
+    height: 1fr;
+    align: center middle;
+    padding: 2 4;
+}
+
+.console-placeholder Static {
+    text-align: center;
+}
+
+.pending-frame {
+    height: auto;
+    align: center middle;
+}
+
+.pending-column {
+    width: auto;
+    padding: 0 2;
+}
+
+.pending-content {
+    width: 1fr;
+    height: auto;
+}
+
+.console-footer-hint {
+    color: $text-muted;
+    padding: 1 2;
+}
+
+.run-actions {
+    height: auto;
+    padding: 1 0;
+}
+
+#run-debug-label {
+    padding: 1 0 0 1;
+    color: $text-muted;
+}
+
+RunsScreen BlueprintInputForm {
+    border: double $accent;
+}
+
+#run-button {
+    border: double $accent;
+    background: $panel;
+    color: $accent;
+    text-style: bold;
+    padding: 0 3;
+}
+
+#run-button:hover {
+    background: $accent 20%;
+}
+
+#run-button:focus {
+    text-style: bold;
+}
+
+#home-banner {
+    width: 100%;
+    padding: 1 0 0 0;
+    text-align: center;
+}
+
+#home-status {
+    text-align: center;
+}
+
+#home-menu {
+    margin: 1 0 0 0;
+}

aetherius/console/daemon_control.py

@@ -0,0 +1,83 @@
+"""Manage the local daemon as a child process, on behalf of the Console.
+
+The Console can start and stop ``aetherius serve`` without leaving the terminal. The daemon runs as a
+separate process (``python -m aetherius serve``) so it can be killed cleanly and, deliberately,
+survives navigating away from the Settings screen — it is a service, not a screen's state. It is
+owned by the App (one per session) and stopped on exit, with an ``atexit`` guard against orphans.
+"""
+
+from __future__ import annotations
+
+import atexit
+import os
+import subprocess
+import sys
+
+from ..server.config import DaemonConfig
+
+
+class DaemonController:
+    """Start, stop and probe a local daemon child process."""
+
+    def __init__(self) -> None:
+        self._config = DaemonConfig()
+        self._process: subprocess.Popen[bytes] | None = None
+        atexit.register(self.stop)
+
+    @property
+    def config(self) -> DaemonConfig:
+        return self._config
+
+    @property
+    def base_url(self) -> str:
+        return self._config.base_url
+
+    def is_running(self) -> bool:
+        return self._process is not None and self._process.poll() is None
+
+    def start(self) -> None:
+        """Spawn the daemon with the resolved config. No-op if already running."""
+        if self.is_running():
+            return
+        # The token is passed through the environment, never argv, so it does not leak into `ps`.
+        env = dict(os.environ)
+        if self._config.token:
+            env["AETHERIUS_DAEMON_TOKEN"] = self._config.token
+        self._process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m",
+                "aetherius",
+                "serve",
+                "--host",
+                self._config.host,
+                "--port",
+                str(self._config.port),
+            ],
+            env=env,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    def stop(self) -> None:
+        """Terminate the daemon if running. Idempotent."""
+        process = self._process
+        if process is None:
+            return
+        if process.poll() is None:
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+        self._process = None
+
+    def healthy(self) -> bool:
+        """True if the daemon answers its health probe. Never raises."""
+        import httpx
+
+        try:
+            response = httpx.get(f"{self.base_url}/health", timeout=1.0)
+            return response.status_code == 200
+        except httpx.HTTPError:
+            return False

aetherius/console/run_bridge.py

@@ -0,0 +1,43 @@
+"""Bridges RunEngine events (emitted on a worker thread) into a Textual widget on the UI thread.
+
+RunEngine.run() is synchronous and blocking (HTTP calls), so the Console drives it from a
+Textual `@work(thread=True)` worker. Sinks are called from that worker thread, but Textual
+widgets may only be touched from the app's own thread — `App.call_from_thread` is Textual's
+documented mechanism for crossing that boundary safely.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Protocol, runtime_checkable
+
+from textual.app import App
+
+from ..core.events.models import RunEvent
+
+_log = logging.getLogger("aetherius.console")
+
+
+@runtime_checkable
+class SupportsWriteEvent(Protocol):
+    """Structural type for the widget passed to TextualRunSink (e.g. EventLog)."""
+
+    def write_event(self, event: RunEvent) -> None: ...
+
+
+class TextualRunSink:
+    """Sink that forwards each RunEvent to an EventLog-like widget's `write_event` method.
+
+    Structurally satisfies core.events.sinks.Sink; never raises, so a widget failure cannot
+    abort the Blueprint run it is merely observing.
+    """
+
+    def __init__(self, app: App[object], writer: SupportsWriteEvent) -> None:
+        self._app = app
+        self._writer = writer
+
+    def on_event(self, event: RunEvent) -> None:
+        try:
+            self._app.call_from_thread(self._writer.write_event, event)
+        except Exception:
+            _log.exception("Failed to forward run event %r to the Console.", event.type)

aetherius/console/screens/__init__.py

@@ -0,0 +1 @@
+"""Console screens."""

aetherius/console/screens/_pending.py

@@ -0,0 +1,38 @@
+"""Shared base for the Console sections whose backing subsystem doesn't exist yet.
+
+Kept intentionally minimal: a static explanation of what the screen will do and which
+milestone it depends on, framed by mosaic columns. No interactivity to fake.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Static
+
+from ..theme import TYRIAN, frieze, frieze_column, starred
+
+
+class PendingScreen(Screen[None]):
+    """Base class for a Console section pending its underlying subsystem."""
+
+    title_text: str = ""
+    description_text: str = ""
+    milestone_text: str = ""
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(classes="console-placeholder"):
+            with Horizontal(classes="pending-frame"):
+                yield Static(Text(frieze_column(7), style=TYRIAN), classes="pending-column")
+                with Vertical(classes="pending-content"):
+                    yield Static(Text(frieze(24), style=TYRIAN))
+                    yield Static(starred(self.title_text), classes="console-title")
+                    yield Static(self.description_text, classes="console-subtitle")
+                    yield Static(f"Pending: {self.milestone_text}", classes="console-footer-hint")
+                    yield Static(Text(frieze(24), style=TYRIAN))
+                yield Static(Text(frieze_column(7), style=TYRIAN), classes="pending-column")
+        yield Footer()

aetherius/console/screens/builder/__init__.py

@@ -0,0 +1 @@
+"""The Blueprint Studio: guided Blueprint creation without writing JSON."""

aetherius/console/screens/builder/act_picker.py

@@ -0,0 +1,75 @@
+"""Act picker with inline explanations of each Act.
+
+A Select of the four Acts (their runnable status from the shared catalogue) plus a live one-line
+explanation. Emits :class:`ActPicker.ActChanged` so the Studio can re-key the available actions and
+re-validate when the Act changes.
+"""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Label, Select, Static
+
+from ....builder.catalog import act_infos, get_act_info
+from ...theme import ACT_LABELS
+
+
+def _option_label(act: str, implemented: bool) -> str:
+    return ACT_LABELS[act] + ("" if implemented else " (not runnable yet)")
+
+
+class ActPicker(Vertical):
+    """Choose the Blueprint's Act and show what it does."""
+
+    DEFAULT_CSS = """
+    ActPicker {
+        height: auto;
+        padding: 1 1 0 1;
+    }
+    ActPicker #act-explanation {
+        color: $text-muted;
+        padding: 1 0 0 0;
+    }
+    """
+
+    class ActChanged(Message):
+        """Posted when the selected Act changes."""
+
+        def __init__(self, act: str) -> None:
+            self.act = act
+            super().__init__()
+
+    def __init__(self, act: str = "vector") -> None:
+        super().__init__()
+        self._act = act
+
+    def compose(self) -> ComposeResult:
+        yield Label("Act")
+        yield Select(
+            [(_option_label(info.act, info.implemented), info.act) for info in act_infos()],
+            value=self._act,
+            allow_blank=False,
+            id="act-select",
+        )
+        yield Static(self._explanation(self._act), id="act-explanation")
+
+    @property
+    def act(self) -> str:
+        return self._act
+
+    def _explanation(self, act: str) -> str:
+        info = get_act_info(act)
+        note = (
+            "" if info.implemented else "  This Act has no driver yet — valid to author, not run."
+        )
+        return info.summary + note
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        # Handle it here and stop it, so the Studio only reacts to the dedicated ActChanged message.
+        event.stop()
+        act = str(event.value)
+        self._act = act
+        self.query_one("#act-explanation", Static).update(self._explanation(act))
+        self.post_message(self.ActChanged(act))

aetherius/console/screens/builder/io_editor.py

@@ -0,0 +1,167 @@
+"""Editors for a Blueprint's inputs, secrets, vars and outputs.
+
+``InputsEditor`` renders typed input rows (name, type, required) plus a secrets list, and preserves
+any extra keys of an existing input (default, format, description) so editing a file never drops
+them. ``VarsOutputsEditor`` edits the two free-form maps as JSON, keeping the last valid parse so the
+live preview stays consistent while the user is mid-edit.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.widgets import Button, Input, Label, Select, Switch, TextArea
+
+_INPUT_TYPES = ("string", "number", "integer", "boolean", "date", "path", "object", "array")
+
+
+class _InputRow(Horizontal):
+    """One input declaration; keeps the original spec's extra keys to stay lossless."""
+
+    DEFAULT_CSS = "_InputRow { height: auto; padding: 0 0 1 0; } _InputRow Input { width: 20; }"
+
+    def __init__(self, name: str = "", spec: dict[str, Any] | None = None) -> None:
+        super().__init__()
+        spec = dict(spec or {})
+        self._name = name
+        self._type = str(spec.pop("type", "string"))
+        self._required = bool(spec.pop("required", False))
+        self._extra = spec  # format / default / description preserved verbatim
+
+    def compose(self) -> ComposeResult:
+        yield Input(value=self._name, placeholder="name", classes="io-input-name")
+        yield Select(
+            [(t, t) for t in _INPUT_TYPES],
+            value=self._type,
+            allow_blank=False,
+            classes="io-input-type",
+        )
+        yield Switch(value=self._required, classes="io-input-required")
+        yield Label("required")
+        yield Button("✕", classes="io-input-remove")
+
+    def collect(self) -> tuple[str, dict[str, Any]] | None:
+        """Return (name, spec), or None when the row has no name yet or is still mounting."""
+        if not self.query(".io-input-name"):
+            return None  # children not composed yet (just mounted)
+        name = self.query_one(".io-input-name", Input).value.strip()
+        if not name:
+            return None
+        spec: dict[str, Any] = dict(self._extra)
+        spec["type"] = str(self.query_one(".io-input-type", Select).value)
+        if self.query_one(".io-input-required", Switch).value:
+            spec["required"] = True
+        return name, spec
+
+
+class InputsEditor(Vertical):
+    """Typed input rows plus a comma-separated secrets list."""
+
+    DEFAULT_CSS = """
+    InputsEditor { height: auto; padding: 1 1 0 1; }
+    /* Without this the empty rows container grabs 1fr and inflates the whole editor. */
+    InputsEditor #io-input-rows { height: auto; }
+    InputsEditor #io-add-input { margin: 0 0 1 0; }
+    """
+
+    class Changed(Message):
+        """Posted when a row is added or removed (text edits bubble as Input/Switch changes)."""
+
+    def compose(self) -> ComposeResult:
+        yield Label("Inputs")
+        yield Vertical(id="io-input-rows")
+        yield Button("+ Add input", id="io-add-input")
+        yield Label("Secrets (comma-separated names)")
+        yield Input(placeholder="password, api_key", id="io-secrets")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "io-add-input":
+            event.stop()
+            self.query_one("#io-input-rows", Vertical).mount(_InputRow())
+            self.post_message(self.Changed())
+        elif event.button.has_class("io-input-remove"):
+            event.stop()
+            row = event.button.parent
+            if isinstance(row, _InputRow):
+                row.remove()
+            self.post_message(self.Changed())
+
+    def collect(self) -> tuple[dict[str, dict[str, Any]], list[str]]:
+        """Read the rows and the secrets field into (inputs, secrets)."""
+        inputs: dict[str, dict[str, Any]] = {}
+        for row in self.query(_InputRow):
+            collected = row.collect()
+            if collected is not None:
+                inputs[collected[0]] = collected[1]
+        raw = self.query_one("#io-secrets", Input).value
+        secrets = [s.strip() for s in raw.split(",") if s.strip()]
+        return inputs, secrets
+
+    def load(self, inputs: dict[str, dict[str, Any]], secrets: list[str]) -> None:
+        rows = self.query_one("#io-input-rows", Vertical)
+        rows.remove_children()
+        for name, spec in inputs.items():
+            rows.mount(_InputRow(name, spec))
+        self.query_one("#io-secrets", Input).value = ", ".join(secrets)
+
+
+class VarsOutputsEditor(Vertical):
+    """JSON editors for the two free-form maps, tolerant of mid-edit invalid JSON."""
+
+    DEFAULT_CSS = """
+    VarsOutputsEditor { height: auto; padding: 1 1 0 1; }
+    VarsOutputsEditor TextArea { height: 6; margin: 0 0 1 0; }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._vars: dict[str, Any] = {}
+        self._outputs: dict[str, Any] = {}
+        self._invalid: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Label("Vars (JSON object)")
+        yield TextArea(id="io-vars")
+        yield Label("Outputs (JSON object)")
+        yield TextArea(id="io-outputs")
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        which = event.text_area.id
+        parsed = self._parse(event.text_area.text)
+        if parsed is None:
+            self._invalid.add(str(which))
+            return
+        self._invalid.discard(str(which))
+        if which == "io-vars":
+            self._vars = parsed
+        else:
+            self._outputs = parsed
+
+    @staticmethod
+    def _parse(text: str) -> dict[str, Any] | None:
+        if not text.strip():
+            return {}
+        try:
+            value = json.loads(text)
+        except ValueError:
+            return None
+        return value if isinstance(value, dict) else None
+
+    @property
+    def has_errors(self) -> bool:
+        return bool(self._invalid)
+
+    def collect(self) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Return the last valid (vars, outputs)."""
+        return dict(self._vars), dict(self._outputs)
+
+    def load(self, vars: dict[str, Any], outputs: dict[str, Any]) -> None:
+        self._vars, self._outputs, self._invalid = dict(vars), dict(outputs), set()
+        self.query_one("#io-vars", TextArea).text = json.dumps(vars, indent=2) if vars else ""
+        self.query_one("#io-outputs", TextArea).text = (
+            json.dumps(outputs, indent=2) if outputs else ""
+        )

aetherius/console/screens/builder/options_editor.py

@@ -0,0 +1,132 @@
+"""Editor for a Blueprint's durable options (debug, timeout, retries, stealth, session).
+
+These are the options the README says belong in the Studio, not the per-run Debug toggle of the Runs
+screen. ``collect`` returns only non-default keys (an empty dict when everything is default, so the
+options block is omitted); ``load`` restores them when editing an existing file. An advanced inline
+``stealth`` object is preserved verbatim, since the presets Select cannot represent it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Input, Label, Select, Switch
+
+from ....stealth.policy import preset_names
+
+_BACKOFFS = ("none", "linear", "exponential")
+
+
+def _as_int(raw: str) -> Any:
+    """Parse an int field: '' -> None (omit), a valid int -> int, anything else -> the raw string
+    (kept so the preview's schema check flags it rather than silently dropping the mistake)."""
+    text = raw.strip()
+    if not text:
+        return None
+    try:
+        return int(text)
+    except ValueError:
+        return text
+
+
+class OptionsEditor(Vertical):
+    """Form for ``options`` with a shape matching the schema's options object."""
+
+    DEFAULT_CSS = """
+    OptionsEditor { height: auto; padding: 1 1 0 1; }
+    OptionsEditor .opt-row { height: auto; padding: 0 0 1 0; }
+    OptionsEditor Label { padding: 1 1 0 0; }
+    OptionsEditor Input { width: 24; }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        # An inline stealth object (not a preset name) we cannot render in the Select; kept to avoid
+        # dropping it on save when the user leaves the Select untouched.
+        self._stealth_obj: dict[str, Any] | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="opt-row"):
+            yield Switch(value=False, id="opt-debug")
+            yield Label("Debug (visible browser + slow-mo)")
+        with Horizontal(classes="opt-row"):
+            yield Label("Timeout (ms)")
+            yield Input(placeholder="30000", id="opt-timeout")
+        with Horizontal(classes="opt-row"):
+            yield Label("Retries max")
+            yield Input(placeholder="0", id="opt-retries-max")
+            yield Label("backoff")
+            yield Select(
+                [(b, b) for b in _BACKOFFS], value="none", allow_blank=False, id="opt-backoff"
+            )
+        with Horizontal(classes="opt-row"):
+            yield Label("Stealth")
+            yield Select(
+                [(n, n) for n in preset_names()], value="off", allow_blank=False, id="opt-stealth"
+            )
+        with Horizontal(classes="opt-row"):
+            yield Label("Session profile")
+            yield Input(placeholder="my-profile", id="opt-session-profile")
+            yield Switch(value=False, id="opt-session-persist")
+            yield Label("persist")
+
+    def collect(self) -> dict[str, Any]:
+        """Read the widgets into an options dict, omitting anything left at its default."""
+        options: dict[str, Any] = {}
+        if self.query_one("#opt-debug", Switch).value:
+            options["debug"] = True
+
+        timeout = _as_int(self.query_one("#opt-timeout", Input).value)
+        if timeout is not None:
+            options["timeout_ms"] = timeout
+
+        retries_max = _as_int(self.query_one("#opt-retries-max", Input).value)
+        backoff = str(self.query_one("#opt-backoff", Select).value)
+        if retries_max is not None and retries_max != 0:
+            retries: dict[str, Any] = {"max": retries_max}
+            if backoff != "none":
+                retries["backoff"] = backoff
+            options["retries"] = retries
+
+        stealth = str(self.query_one("#opt-stealth", Select).value)
+        if stealth != "off":
+            options["stealth"] = stealth
+        elif self._stealth_obj is not None:
+            options["stealth"] = self._stealth_obj  # preserve an advanced inline config
+
+        profile = self.query_one("#opt-session-profile", Input).value.strip()
+        persist = self.query_one("#opt-session-persist", Switch).value
+        if profile or persist:
+            session: dict[str, Any] = {}
+            if profile:
+                session["profile"] = profile
+            if persist:
+                session["persist"] = True
+            options["session"] = session
+        return options
+
+    def load(self, options: dict[str, Any]) -> None:
+        """Restore the widgets from an existing options dict (edit mode)."""
+        self.query_one("#opt-debug", Switch).value = bool(options.get("debug", False))
+        timeout = options.get("timeout_ms")
+        self.query_one("#opt-timeout", Input).value = "" if timeout is None else str(timeout)
+
+        retries = options.get("retries") or {}
+        self.query_one("#opt-retries-max", Input).value = str(retries.get("max", "") or "")
+        self.query_one("#opt-backoff", Select).value = retries.get("backoff", "none")
+
+        stealth = options.get("stealth")
+        if isinstance(stealth, dict):
+            self._stealth_obj = stealth
+            self.query_one("#opt-stealth", Select).value = "off"
+        else:
+            self._stealth_obj = None
+            self.query_one("#opt-stealth", Select).value = (
+                stealth if stealth in preset_names() else "off"
+            )
+
+        session = options.get("session") or {}
+        self.query_one("#opt-session-profile", Input).value = str(session.get("profile", "") or "")
+        self.query_one("#opt-session-persist", Switch).value = bool(session.get("persist", False))