delos-cli 0.1.0__py3-none-any.whl

delos_cli/apps/chat/render.py

@@ -0,0 +1,188 @@
+"""Render v6 UI Message Stream events into an :class:`OutputBuffer`.
+
+The renderer is a pure translator: events in, buffer mutations out.  The
+prompt_toolkit application owns the terminal drawing and reads the
+buffer's ANSI representation on each redraw.
+
+A "thinking" spinner lives in the buffer's *live* slot whenever the
+agent is processing but hasn't started emitting text yet.  An owned
+asyncio task re-renders the spinner frame periodically so the dots
+animate; the task is cancelled the moment any text or tool event
+arrives.
+
+Streaming text also goes through the live slot so Markdown is
+re-rendered on every ``text-delta`` (the user sees formatting appear as
+it's typed).  Tool events go straight to history.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
+from typing import TYPE_CHECKING, Any
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.text import Text
+
+from delos_cli.agent import ToolRegistry, default_renderer
+
+if TYPE_CHECKING:
+    from delos_cli.ui.output import OutputBuffer
+
+
+_SPINNER_INTERVAL_S = 0.08
+
+
+class V6Renderer:
+    """Translate v6 events into :class:`OutputBuffer` operations."""
+
+    def __init__(
+        self,
+        output: OutputBuffer,
+        registry: ToolRegistry | None = None,
+    ) -> None:
+        """Bind to the REPL output buffer.  ``registry`` controls per-tool rendering."""
+        self._output = output
+        self._registry = registry or ToolRegistry()
+        self._assistant_text = ""
+        # toolCallId → toolName, populated from tool-input-available so we can
+        # look up the renderer for output / delta events that don't carry the
+        # tool name in their payload.
+        self._tool_names: dict[str, str] = {}
+        self._spinner = Spinner("dots", text=" thinking", style="dim")
+        self._thinking = False
+        self._anim_task: asyncio.Task[None] | None = None
+
+    def apply(self, event: dict[str, Any]) -> None:
+        """Apply a single v6 event to the output buffer."""
+        etype = event.get("type", "")
+
+        if etype == "start":
+            self._assistant_text = ""
+            self._show_thinking()
+
+        elif etype == "start-step":
+            # New step after a tool call resolves — go back to "thinking"
+            # until the next text or tool event.
+            self._show_thinking()
+
+        elif etype == "text-start":
+            self._assistant_text = ""
+
+        elif etype == "text-delta":
+            delta = event.get("delta", "")
+            if not delta:
+                return
+            self._stop_thinking()
+            self._assistant_text += delta
+            self._output.update_live(Markdown(self._assistant_text))
+
+        elif etype == "text-end":
+            self._end_inflight()
+
+        elif etype == "tool-input-available":
+            self._end_inflight()
+            tcid = event.get("toolCallId", "")
+            name = event.get("toolName", "")
+            if tcid:
+                self._tool_names[tcid] = name
+            self._render_tool(name, event)
+
+        elif etype == "tool-output-available":
+            self._end_inflight()
+            tcid = event.get("toolCallId", "")
+            name = self._tool_names.get(tcid, "")
+            self._render_tool(name, {**event, "toolName": name})
+
+        elif etype == "data-tool-output-delta":
+            payload = event.get("data") or {}
+            tcid = payload.get("toolCallId", "")
+            name = self._tool_names.get(tcid, "")
+            self._render_tool(name, {**event, "toolName": name, **payload})
+
+        elif etype == "error":
+            self._end_inflight()
+            msg = event.get("errorText", "unknown error")
+            self._output.append_block(
+                Panel(Text(msg, style="red"), title="error", border_style="red"),
+            )
+
+        elif etype == "data-stopped":
+            self._end_inflight()
+            self._output.append_block(Text("[stopped]", style="dim"))
+
+        elif etype == "parse-error":
+            self._end_inflight()
+            raw = event.get("raw", "")[:200]
+            self._output.append_block(
+                Text(f"[unparseable event] {raw}", style="dim red"),
+            )
+
+    def close(self) -> None:
+        """End the turn — cancel animation, finalize any in-flight live block."""
+        self._end_inflight()
+
+    @property
+    def assistant_text(self) -> str:
+        """The full assistant text accumulated across this turn."""
+        return self._assistant_text
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    def _render_tool(self, tool_name: str, event: dict[str, Any]) -> None:
+        """Look up the registered renderer for ``tool_name`` and append its block."""
+        renderer = (
+            self._registry.renderer_for(tool_name) if tool_name else default_renderer
+        )
+        rendered = renderer(event)
+        if rendered is not None:
+            self._output.append_block(rendered)
+
+    def _show_thinking(self) -> None:
+        """Start the spinner animation in the live slot."""
+        if self._thinking:
+            return
+        self._thinking = True
+        self._render_spinner_frame()
+        # Spawn the animator task lazily — needs a running event loop, which
+        # is guaranteed inside the REPL's async context.
+        if self._anim_task is None or self._anim_task.done():
+            self._anim_task = asyncio.create_task(self._animate())
+
+    def _stop_thinking(self) -> None:
+        """Cancel the spinner animation; leave the live slot untouched."""
+        self._thinking = False
+        if self._anim_task is not None and not self._anim_task.done():
+            self._anim_task.cancel()
+        self._anim_task = None
+
+    def _end_inflight(self) -> None:
+        """Close the in-flight live block.
+
+        - If the spinner was active, drop it (we don't want "thinking" in
+          scrollback).
+        - Otherwise commit the streaming markdown to history.
+        """
+        if self._thinking:
+            self._stop_thinking()
+            self._output.discard_live()
+        else:
+            self._output.commit_live()
+
+    def _render_spinner_frame(self) -> None:
+        """Push the spinner's current frame to the live slot."""
+        # Spinner.render(time) returns a renderable for the frame at that time.
+        self._output.update_live(self._spinner.render(time.monotonic()))
+
+    async def _animate(self) -> None:
+        """Re-render the spinner frame every tick until stopped."""
+        with contextlib.suppress(asyncio.CancelledError):
+            while self._thinking:
+                await asyncio.sleep(_SPINNER_INTERVAL_S)
+                if self._thinking:
+                    self._render_spinner_frame()

delos_cli/apps/chat/replay.py

@@ -0,0 +1,108 @@
+"""Render historical ``app_chat.messages`` rows into the :class:`OutputBuffer`.
+
+Translates each OpenAI-style row into the same Rich blocks the live
+:class:`V6Renderer` would produce, so resuming a conversation looks
+identical to what the user saw the first time around — including tool
+calls, which go through the app's :class:`ToolRegistry` so any custom
+renderers stay consistent across live and replayed turns.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from rich.markdown import Markdown
+from rich.text import Text
+
+from delos_cli.agent import default_renderer
+
+if TYPE_CHECKING:
+    from delos_cli.ui.output import OutputBuffer
+
+    from .app import ChatApp
+
+
+def replay_messages(
+    messages: list[dict[str, Any]],
+    app: ChatApp,
+    output: OutputBuffer,
+) -> None:
+    """Push every message into ``output`` as a finalized block.
+
+    No-op when ``messages`` is empty.  Each row maps to:
+
+    - ``role=user``     → ``» <text>`` echo (matches what live turns print).
+    - ``role=assistant`` → Markdown block for the text + a synthesized
+      ``tool-input-available`` event per ``tool_calls`` entry, routed
+      through the app's tool registry.
+    - ``role=tool``     → synthesized ``tool-output-available`` event,
+      also routed through the tool registry.
+    """
+    if not messages:
+        return
+    for msg in messages:
+        role = msg.get("role")
+        if role == "user":
+            text = _extract_text(msg.get("content"))
+            if text:
+                output.print(Text(f"» {text}", style="bold cyan"))
+        elif role == "assistant":
+            text = _extract_text(msg.get("content"))
+            if text:
+                output.append_block(Markdown(text))
+            for tc in msg.get("tool_calls") or []:
+                _replay_tool_call(tc, app, output)
+        elif role == "tool":
+            _replay_tool_output(msg, app, output)
+
+
+def _extract_text(content: Any) -> str:
+    """Pull plain text out of either a string or a multipart content list."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "text":
+                txt = part.get("text") or ""
+                if isinstance(txt, str):
+                    parts.append(txt)
+        return "".join(parts)
+    return ""
+
+
+def _replay_tool_call(tc: dict[str, Any], app: ChatApp, output: OutputBuffer) -> None:
+    """Synthesize a ``tool-input-available`` event and dispatch to the registry."""
+    fn = tc.get("function") or {}
+    args_str = fn.get("arguments") or ""
+    try:
+        args = json.loads(args_str) if isinstance(args_str, str) and args_str else {}
+    except (json.JSONDecodeError, ValueError):
+        args = {}
+    name = fn.get("name") or ""
+    event = {
+        "type": "tool-input-available",
+        "toolCallId": tc.get("id") or "",
+        "toolName": name,
+        "input": args,
+    }
+    renderer = app.tools.renderer_for(name) if name else default_renderer
+    rendered = renderer(event)
+    if rendered is not None:
+        output.append_block(rendered)
+
+
+def _replay_tool_output(msg: dict[str, Any], app: ChatApp, output: OutputBuffer) -> None:
+    """Synthesize a ``tool-output-available`` event for any custom renderer."""
+    name = msg.get("name") or ""
+    event = {
+        "type": "tool-output-available",
+        "toolCallId": msg.get("tool_call_id") or "",
+        "toolName": name,
+        "output": _extract_text(msg.get("content")),
+    }
+    renderer = app.tools.renderer_for(name) if name else default_renderer
+    rendered = renderer(event)
+    if rendered is not None:
+        output.append_block(rendered)

delos_cli/auth/__init__.py

@@ -0,0 +1,24 @@
+"""Auth: persisted config, OAuth PKCE flow, Supabase MFA upgrade."""
+
+from .config import (
+    Config,
+    Tokens,
+    available_regions,
+    internal_enabled,
+    load,
+    save,
+)
+from .oauth import LoginResult, OAuthError, refresh_tokens, run_login_flow
+
+__all__ = [
+    "Config",
+    "LoginResult",
+    "OAuthError",
+    "Tokens",
+    "available_regions",
+    "internal_enabled",
+    "load",
+    "refresh_tokens",
+    "run_login_flow",
+    "save",
+]

delos_cli/auth/config.py

@@ -0,0 +1,282 @@
+"""Config persistence for the delos CLI.
+
+Stores a region name (not raw URLs) in ~/.config/delos/config.json so that
+URL changes don't require users to re-login. Env vars override the persisted
+choice at runtime:
+
+    DELOS_REGION=dev delos        # one-shot override (DELOS_ENV works too)
+    DELOS_API_URL=...             # override a region's API base
+    DELOS_WEB_URL=...             # override a region's web URL
+
+For the `dev` region we additionally try to read backend/.env.local from the
+monorepo so each developer's local ngrok tunnel is picked up automatically.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import fcntl  # POSIX only; Windows support skipped for v1
+import json
+import os
+import tempfile
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "delos"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+LOCK_PATH = CONFIG_DIR / ".config.lock"
+
+DEFAULT_REGION = "eu"
+
+
+class RegionUrls(TypedDict):
+    """Web + API + Supabase endpoints + public anon key for one region."""
+
+    web: str
+    api: str
+    supabase_url: str
+    supabase_anon_key: str
+
+
+# Supabase anon keys are public; same values live in apps/web/.env.production.*
+# and are embedded in the web/extension bundles. Safe to ship here.
+_EU_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.ewogICJyb2xlIjogImFub24iLAogICJpc3MiOiAic3VwYWJhc2UiLAogICJpYXQiOiAxNzEyNTI3MjAwLAogICJleHAiOiAxODcwMjkzNjAwCn0.gO1qyjuG2g4yAZ3u820P9q5CUTQmDiDrHSurZjIePbA"
+_US_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlIiwiaWF0IjoxNzU5MjY5NjAwLCJleHAiOjE5MTcwMzYwMDB9.VYuiRrB3q9GaR3qsZauOm1oIH_bZ3iuOzmNQfDcqo40"
+_AE_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlIiwiaWF0IjoxNzY1MTQ4NDAwLCJleHAiOjE5MjI5MTQ4MDB9.TlD6gF-Q5K1drdnh-XPQgXGs410h5NcHJBRgV6aNXrY"
+_STAGING_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.ewogICJyb2xlIjogImFub24iLAogICJpc3MiOiAic3VwYWJhc2UiLAogICJpYXQiOiAxNzEyNTI3MjAwLAogICJleHAiOiAxODcwMjkzNjAwCn0.GDHgmBuu4XivLHq18P3A-sHblw99If9uqW-HChepSb8"
+_DEV_ANON = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0"
+
+
+PUBLIC_REGIONS: dict[str, RegionUrls] = {
+    "eu": {
+        "web": "https://app.delos.so",
+        "api": "https://app.delos.so/api/v1",
+        "supabase_url": "https://db.app.delos.so",
+        "supabase_anon_key": _EU_ANON,
+    },
+    "us": {
+        "web": "https://us.delos.so",
+        "api": "https://us.delos.so/api/v1",
+        "supabase_url": "https://db.app.us.delos.so",
+        "supabase_anon_key": _US_ANON,
+    },
+    "ae": {
+        "web": "https://ae.delos.so",
+        "api": "https://ae.delos.so/api/v1",
+        "supabase_url": "https://db.ae.delos.so",
+        "supabase_anon_key": _AE_ANON,
+    },
+}
+
+INTERNAL_REGIONS: dict[str, RegionUrls] = {
+    "dev": {
+        "web": "http://localhost:3000",
+        "api": "http://localhost:8000",
+        "supabase_url": "http://127.0.0.1:54321",
+        "supabase_anon_key": _DEV_ANON,
+    },
+    "staging": {
+        "web": "https://beta.delos.so",
+        "api": "https://beta.delos.so/api/v1",
+        "supabase_url": "https://db.beta.delos.so",
+        "supabase_anon_key": _STAGING_ANON,
+    },
+}
+
+
+def internal_enabled() -> bool:
+    """Whether dev/staging regions are unlocked for this process.
+
+    True when either (a) DELOS_INTERNAL=1 is set, or (b) the CLI is running
+    from a cosmos-saas monorepo checkout (detected by finding backend/pyproject.toml
+    relative to this file — works for editable installs; fails for PyPI installs,
+    which is what we want).
+    """
+    if os.environ.get("DELOS_INTERNAL", "").lower() in {"1", "true", "yes"}:
+        return True
+    pkg_dir = Path(__file__).resolve().parent
+    return (pkg_dir.parent.parent.parent / "backend" / "pyproject.toml").is_file()
+
+
+def available_regions() -> dict[str, RegionUrls]:
+    """Regions the current user is allowed to target."""
+    if internal_enabled():
+        return {**PUBLIC_REGIONS, **INTERNAL_REGIONS}
+    return dict(PUBLIC_REGIONS)
+
+
+@dataclass
+class Tokens:
+    """Supabase access + refresh token pair."""
+
+    access_token: str = ""
+    refresh_token: str = ""
+    expires_at: int = 0  # unix timestamp
+
+
+@dataclass
+class Config:
+    """Persisted CLI configuration: which region, who we're signed in as."""
+
+    region: str = DEFAULT_REGION
+    org_uuid: str = ""
+    user_id: str = ""
+    client_id: str = ""  # cached OAuth client_id from /api/oauth/register
+    tokens: Tokens = field(default_factory=Tokens)
+
+    @property
+    def api_url(self) -> str:
+        """Effective API base URL: env override → dev auto-detect → region default."""
+        if env := os.environ.get("DELOS_API_URL"):
+            return env.rstrip("/")
+        if self.region == "dev":
+            detected = _read_backend_env("COSMOS_BACKEND_BASE_URL")
+            if detected:
+                return detected.rstrip("/")
+        return (PUBLIC_REGIONS | INTERNAL_REGIONS)[self.region]["api"].rstrip("/")
+
+    @property
+    def web_url(self) -> str:
+        """Effective web base URL: env override → dev auto-detect → region default."""
+        if env := os.environ.get("DELOS_WEB_URL"):
+            return env.rstrip("/")
+        if self.region == "dev":
+            detected = _read_backend_env("COSMOS_FRONTEND_BASE_URL")
+            if detected:
+                return detected.rstrip("/")
+        return (PUBLIC_REGIONS | INTERNAL_REGIONS)[self.region]["web"].rstrip("/")
+
+    @property
+    def supabase_url(self) -> str:
+        """Effective Supabase auth URL: env override → dev auto-detect → region default."""
+        if env := os.environ.get("DELOS_SUPABASE_URL"):
+            return env.rstrip("/")
+        if self.region == "dev":
+            detected = _read_backend_env("COSMOS_SUPABASE_URL")
+            if detected:
+                return detected.rstrip("/")
+        return (PUBLIC_REGIONS | INTERNAL_REGIONS)[self.region]["supabase_url"].rstrip("/")
+
+    @property
+    def supabase_anon_key(self) -> str:
+        """Public Supabase anon key for this region."""
+        return (PUBLIC_REGIONS | INTERNAL_REGIONS)[self.region]["supabase_anon_key"]
+
+    @property
+    def is_signed_in(self) -> bool:
+        """True when we have enough to make authenticated calls."""
+        return bool(self.tokens.access_token and self.org_uuid)
+
+
+def load() -> Config:
+    """Load config from disk, apply DELOS_REGION/DELOS_ENV env overrides."""
+    cfg = Config()
+    if CONFIG_PATH.exists():
+        try:
+            data = json.loads(CONFIG_PATH.read_text())
+            cfg.region = data.get("region", cfg.region)
+            cfg.org_uuid = data.get("org_uuid", cfg.org_uuid)
+            cfg.user_id = data.get("user_id", cfg.user_id)
+            cfg.client_id = data.get("client_id", cfg.client_id)
+            tok = data.get("tokens") or {}
+            cfg.tokens = Tokens(
+                access_token=tok.get("access_token", ""),
+                refresh_token=tok.get("refresh_token", ""),
+                expires_at=int(tok.get("expires_at", 0)),
+            )
+        except (json.JSONDecodeError, OSError, ValueError):
+            pass
+
+    region_override = os.environ.get("DELOS_REGION") or os.environ.get("DELOS_ENV")
+    if region_override:
+        allowed = available_regions()
+        if region_override not in allowed:
+            known = ", ".join(sorted(allowed))
+            msg = f"Unknown region '{region_override}'. Known: {known}"
+            raise ValueError(msg)
+        cfg.region = region_override
+
+    if cfg.region not in available_regions():
+        cfg.region = DEFAULT_REGION
+
+    return cfg
+
+
+def save(cfg: Config) -> Path:
+    """Persist config atomically with chmod 0600.
+
+    Uses a tempfile in the same directory + ``fsync`` + ``os.replace`` so
+    readers can never observe a half-written ``config.json``. Callers that
+    want cross-process serialization with other writers should hold
+    :func:`config_file_lock` around their read-modify-write.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    payload = json.dumps(asdict(cfg), indent=2)
+    fd, tmp_path_str = tempfile.mkstemp(
+        prefix=".config-", suffix=".json.tmp", dir=CONFIG_DIR,
+    )
+    tmp_path = Path(tmp_path_str)
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(payload)
+            f.flush()
+            os.fsync(f.fileno())
+        tmp_path.chmod(0o600)
+        tmp_path.replace(CONFIG_PATH)
+    except Exception:
+        with contextlib.suppress(FileNotFoundError):
+            tmp_path.unlink()
+        raise
+    return CONFIG_PATH
+
+
+@contextmanager
+def config_file_lock() -> Iterator[None]:
+    """Advisory cross-process exclusive lock on ``~/.config/delos/.config.lock``.
+
+    Wrap any read-modify-write sequence on ``config.json`` with this so that
+    two concurrently-running ``delos`` processes can't both refresh tokens
+    against the same stale refresh_token (whichever loses the race would
+    otherwise be kicked out with ``invalid_grant``).
+
+    POSIX only (uses :mod:`fcntl`). The lockfile is created on first use and
+    left in place; only the lock state matters.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    f: IO[str] = LOCK_PATH.open("a+")
+    try:
+        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+        yield
+    finally:
+        with contextlib.suppress(OSError):
+            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        f.close()
+
+
+def _read_backend_env(key: str) -> str | None:
+    """Find monorepo root by walking up from CWD, then read a var from backend/.env.local.
+
+    Returns None if the file isn't found or the key is missing — callers should
+    fall back to the region's default URL.
+    """
+    cwd = Path.cwd()
+    for parent in (cwd, *cwd.parents):
+        candidate = parent / "backend" / ".env.local"
+        if candidate.is_file():
+            try:
+                for raw in candidate.read_text().splitlines():
+                    line = raw.strip()
+                    if not line or line.startswith("#") or "=" not in line:
+                        continue
+                    k, _, v = line.partition("=")
+                    if k.strip() == key:
+                        return v.strip().strip('"').strip("'")
+            except OSError:
+                return None
+            return None
+    return None