dynos-client 0.1.2__py3-none-any.whl

dynos_client/__init__.py

@@ -0,0 +1,17 @@
+"""dynos-client: distributable Python client for DYNOS.
+
+Infrastructure package: HTTP client, mission builder, CLI entry point.
+No domain vocabulary (that lives in per-platform packages like dynos-sentry-domain).
+"""
+
+from dynos_client.remote_orchestrator import RemoteAuthExpired, RemoteOrchestrator
+from dynos_client.mission import Mission, AnyActionBlock, ActionBlock, PlanBlock
+
+__all__ = [
+    "RemoteAuthExpired",
+    "RemoteOrchestrator",
+    "Mission",
+    "AnyActionBlock",
+    "ActionBlock",
+    "PlanBlock",
+]

dynos_client/__main__.py

@@ -0,0 +1,4 @@
+"""Allow ``python -m dynos_client`` to run the CLI."""
+from dynos_client.cli import main
+
+main()

dynos_client/action.py

@@ -0,0 +1,70 @@
+"""Client-side @Action and @Script decorators.
+
+Lightweight fallbacks that store transition metadata on decorated
+methods so ``dynos connect`` can discover transitions without the
+backend. When the backend IS installed, its @Action takes precedence.
+"""
+
+import inspect
+
+
+def Action(transition_or_func=None, *, transition=None, **_):
+    """Decorate a method as an action bound to a transition."""
+    if transition_or_func is None or not callable(transition_or_func):
+        t = transition_or_func or transition
+
+        def decorator(func):
+            func._client_transition_name = getattr(t, "name", None)
+            func._client_params_type = getattr(t, "params_type", None)
+            return func
+
+        return decorator
+    transition_or_func._client_transition_name = None
+    transition_or_func._client_params_type = None
+    return transition_or_func
+
+
+Script = Action
+
+
+def get_transition_names(cls):
+    """Scan a class for @Action-decorated methods and return transition names.
+
+    Works with both client-side and backend decorators.
+    """
+    names = []
+    for _, member in inspect.getmembers(cls):
+        t_name = getattr(member, "_client_transition_name", None)
+        if t_name is not None:
+            names.append(t_name)
+            continue
+        # Backend ActionCallback objects
+        if hasattr(member, "transition") and hasattr(member, "func"):
+            t = getattr(member, "transition", None)
+            if t is not None and hasattr(t, "name"):
+                names.append(t.name)
+    return names
+
+
+def get_action_methods(cls):
+    """Return ``[(transition_name, method_name, params_type), ...]`` for *cls*.
+
+    Used by ``RemoteOrchestrator.register_class`` to build the local
+    dispatch table. Handles both the client decorator
+    (``_client_transition_name`` / ``_client_params_type`` attrs) and
+    the backend ``ActionCallback`` shape (``.transition`` / ``.func``).
+    """
+    out = []
+    for member_name, member in inspect.getmembers(cls):
+        # Client decorator: attribute markers on the function itself.
+        t_name = getattr(member, "_client_transition_name", None)
+        if t_name is not None:
+            params_type = getattr(member, "_client_params_type", None)
+            out.append((t_name, member_name, params_type))
+            continue
+        # Backend ActionCallback: holds a Transition object and the func.
+        if hasattr(member, "transition") and hasattr(member, "func"):
+            t = getattr(member, "transition", None)
+            if t is not None and hasattr(t, "name"):
+                out.append((t.name, member_name, getattr(t, "params_type", None)))
+    return out

dynos_client/action_context.py

@@ -0,0 +1,56 @@
+"""Minimal client-side ``ActionContext`` for servant-dispatched actions.
+
+The backend's ``ActionContext`` (``src/dynos/symbols/types.py::ActionContext``)
+is a richer Protocol with hardware/sensor/cancellation hooks. Those rely on
+backend infrastructure that doesn't exist on a remote servant machine, so
+this module only implements the slice user ``@Action`` methods actually need
+when dispatched via ``dynos connect``: a structured logger, the audit ID, and
+the transition name.
+
+If a user's ``@Action`` reaches for ``ctx.report_progress`` /
+``ctx.check_cancelled`` / ``ctx.read_sensor`` / ``ctx.call_hardware`` from
+the servant side, an ``AttributeError`` is the right outcome; the action
+is using backend-only machinery that isn't available remotely.
+"""
+
+import logging
+from dataclasses import dataclass, field
+
+
+@dataclass
+class _ClientActionLogger:
+    """Adapter wrapping a stdlib ``logging.Logger`` to match the backend's
+    ``ActionLogger`` Protocol surface (``info``/``debug``/``warn``/``error``,
+    arbitrary kwargs accepted and dropped)."""
+
+    _log: logging.Logger
+
+    def info(self, msg: str, **_kw: object) -> None:
+        self._log.info(msg)
+
+    def debug(self, msg: str, **_kw: object) -> None:
+        self._log.debug(msg)
+
+    def warn(self, msg: str, **_kw: object) -> None:
+        self._log.warning(msg)
+
+    warning = warn
+
+    def error(self, msg: str, **_kw: object) -> None:
+        self._log.error(msg)
+
+
+@dataclass
+class ClientActionContext:
+    """Concrete ``ActionContext`` for client-side ``@Action`` dispatch.
+
+    Implements the ``log``, ``audit_id``, ``transition_name`` slice of the
+    backend ``ActionContext`` Protocol. Constructed per-call by
+    ``RemoteOrchestrator.trigger_action``.
+    """
+
+    transition_name: str
+    audit_id: str
+    log: _ClientActionLogger = field(
+        default_factory=lambda: _ClientActionLogger(logging.getLogger("dynos.servant"))
+    )

dynos_client/auth_cli.py

@@ -0,0 +1,128 @@
+"""``dynos login`` / ``dynos logout`` / ``dynos whoami`` subcommands.
+
+Authenticates against a DYNOS session gateway and caches the bearer token
+in ``~/.dynos/config.json`` (the same file that ``dynos session`` reads
+and writes). Subsequent ``dynos call``, ``dynos session``, and
+``dynos connect`` commands use the cached values automatically.
+"""
+
+from __future__ import annotations
+
+import getpass
+from typing import Optional
+
+import requests
+import typer
+from rich.console import Console
+from rich.table import Table, box
+
+from dynos_client.call import DEFAULT_BACKEND, _normalize_backend_url
+from dynos_client.session_cli import _read_cache, _write_cache
+
+console = Console()
+
+
+def login(
+    to: str = typer.Option(
+        DEFAULT_BACKEND,
+        "--to",
+        help=f"Backend URL (defaults to the hosted DYNOS gateway at {DEFAULT_BACKEND})",
+    ),
+    username: Optional[str] = typer.Option(
+        None, "--user", "-u", help="Username (prompts if omitted)"
+    ),
+    password: Optional[str] = typer.Option(
+        None,
+        "--password",
+        help="Password (prompts if omitted; prefer the prompt to keep it out of shell history)",
+    ),
+) -> None:
+    """Authenticate to a DYNOS session gateway and cache the token.
+
+    Writes ``~/.dynos/config.json`` with ``backend_url``, ``token``,
+    ``username``, and ``role``. Subsequent ``dynos call`` and ``dynos session``
+    commands use the cached values automatically.
+    """
+    url = _normalize_backend_url(to)
+    if username is None:
+        username = typer.prompt("Username")
+    if password is None:
+        password = getpass.getpass("Password: ")
+
+    try:
+        resp = requests.post(
+            f"{url}/auth/login",
+            json={"username": username, "password": password},
+            timeout=10,
+        )
+    except requests.RequestException as exc:
+        console.print(f"[red]Cannot reach {url}: {exc}[/red]")
+        raise typer.Exit(1)
+    if resp.status_code != 200:
+        detail = resp.text
+        try:
+            detail = resp.json().get("detail", detail)
+        except Exception:
+            pass
+        console.print(f"[red]Login failed ({resp.status_code}): {detail}[/red]")
+        raise typer.Exit(1)
+    body = resp.json()
+
+    cache = _read_cache()
+    cache["backend_url"] = url
+    cache["token"] = body["token"]
+    cache["username"] = body["username"]
+    cache["role"] = body.get("role", "user")
+    _write_cache(cache)
+    console.print(
+        f"[green]Logged in as {body['username']} "
+        f"({body.get('role', 'user')}) at {url}[/green]"
+    )
+
+
+def logout() -> None:
+    """Revoke the cached token and clear it from ``~/.dynos/config.json``."""
+    cache = _read_cache()
+    if not cache.get("token") or not cache.get("backend_url"):
+        console.print("[yellow]Not logged in.[/yellow]")
+        return
+    backend_url = cache["backend_url"]
+    token = cache["token"]
+    try:
+        resp = requests.post(
+            f"{backend_url.rstrip('/')}/auth/logout",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        if resp.status_code not in (200, 204, 401):
+            console.print(
+                f"[yellow]Server returned {resp.status_code} on logout; "
+                "clearing local token anyway[/yellow]"
+            )
+    except requests.RequestException as exc:
+        console.print(
+            f"[yellow]Could not reach {backend_url} ({exc}); "
+            "clearing local token anyway[/yellow]"
+        )
+    # backend_url left in place so a subsequent `dynos login` can reuse it.
+    for key in ("token", "username", "role", "default_session"):
+        cache.pop(key, None)
+    _write_cache(cache)
+    console.print("[green]Logged out.[/green]")
+
+
+def whoami() -> None:
+    """Print the currently cached auth identity, masking the token."""
+    cache = _read_cache()
+    token = cache.get("token")
+    if not token:
+        console.print("[yellow]Not logged in. Run `dynos login --to <url>`.[/yellow]")
+        raise typer.Exit(1)
+    masked = (token[:6] + "..." + token[-4:]) if len(token) >= 10 else "***"
+    table = Table(box=box.MINIMAL, show_header=False)
+    table.add_row("backend_url", cache.get("backend_url") or "(unset)")
+    table.add_row("username", cache.get("username") or "(unset)")
+    table.add_row("role", cache.get("role") or "(unset)")
+    table.add_row("token", masked)
+    table.add_row("default_session", cache.get("default_session") or "(none)")
+    console.print(table)