delos-cli 0.1.0__py3-none-any.whl

delos_cli/transport/chats.py

@@ -0,0 +1,235 @@
+"""Read/write access to ``app_cli`` + ``app_cli_messages`` via PostgREST.
+
+The CLI talks to Supabase directly for picker / replay / row-creation —
+the backend only sees streaming completions and tool-results.  This
+module is the entire data-access layer:
+
+- :class:`ChatListItem` + :func:`list_recent` — picker rows.
+- :func:`fetch_messages`                       — replay payload (OpenAI-format).
+- :func:`create_chat`                          — INSERT a new ``app_cli`` row.
+
+All requests go through :meth:`AuthedClient.supabase_get` /
+:meth:`AuthedClient.supabase_post` so token refresh + the single
+connection pool are shared with the rest of the CLI.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlencode
+
+from delos_cli import __version__ as _cli_version
+
+from .client import HTTP_ERROR_THRESHOLD, TransportError
+
+if TYPE_CHECKING:
+    from .client import AuthedClient
+
+_DEFAULT_LIMIT = 30
+
+
+@dataclass(frozen=True)
+class ChatListItem:
+    """One row from ``app_cli`` for the recent-chats picker."""
+
+    id: str
+    name: str | None
+    updated_at: datetime
+    message_count: int
+    summary: str | None
+
+
+# ---------------------------------------------------------------------------
+# Picker — list recent chats
+# ---------------------------------------------------------------------------
+
+
+async def list_recent(
+    http: AuthedClient,
+    org_uuid: str,
+    *,
+    folder: str | None = None,
+    limit: int = _DEFAULT_LIMIT,
+) -> list[ChatListItem]:
+    """Return the most-recently-updated ``app_cli`` rows for ``org_uuid``.
+
+    RLS scopes the result to the signed-in user (CLI conversations are
+    personal — see the ``app_cli_owner_policy`` policy).  When ``folder``
+    is set, the query is also scoped to chats created from that
+    working directory; pre-folder rows (``folder IS NULL``) are excluded
+    by the equality filter.
+    """
+    params = {
+        "select": "id,name,updated_at,message_count,summary",
+        "org_uuid": f"eq.{org_uuid}",
+        "order": "updated_at.desc",
+        "limit": str(limit),
+    }
+    if folder is not None:
+        params["folder"] = f"eq.{folder}"
+    resp = await http.supabase_get(f"/rest/v1/app_cli?{urlencode(params)}")
+    if resp.status_code >= HTTP_ERROR_THRESHOLD:
+        msg = f"HTTP {resp.status_code}: {resp.text[:400]}"
+        raise TransportError(msg)
+    rows = resp.json()
+    return [_row_to_item(r) for r in rows]
+
+
+# ---------------------------------------------------------------------------
+# Replay — load every message of one chat
+# ---------------------------------------------------------------------------
+
+
+async def fetch_messages(http: AuthedClient, chat_id: str) -> list[dict[str, Any]]:
+    """Load ``app_cli_messages`` rows for one chat, mapped to OpenAI format.
+
+    Returned list is ordered by ``seq`` (oldest first), matching what
+    :func:`apps.chat.replay.replay_messages` expects.
+    """
+    params = {
+        "select": (
+            "seq,role,content,content_parts,tool_call_id,tool_name,tool_calls,metadata"
+        ),
+        "chat_id": f"eq.{chat_id}",
+        "order": "seq.asc",
+    }
+    resp = await http.supabase_get(f"/rest/v1/app_cli_messages?{urlencode(params)}")
+    if resp.status_code >= HTTP_ERROR_THRESHOLD:
+        msg = f"HTTP {resp.status_code}: {resp.text[:400]}"
+        raise TransportError(msg)
+    return [_message_row_to_openai(r) for r in (resp.json() or [])]
+
+
+# ---------------------------------------------------------------------------
+# Row creation — INSERT a fresh chat
+# ---------------------------------------------------------------------------
+
+
+async def create_chat(
+    http: AuthedClient,
+    *,
+    folder: str,
+    name: str | None = None,
+    model: str | None = None,
+) -> str:
+    """INSERT a new row in ``app_cli`` and return its id.
+
+    The CLI generates the UUID client-side so the caller has the id
+    immediately (no need to re-read the inserted row).  ``user_id`` is
+    filled by the DB default (``auth.uid()``); ``model`` falls back to
+    the column default (``claude-4.6-sonnet``) when omitted.  ``folder``
+    is required (the column is ``NOT NULL``) — pass the cwd so the
+    picker can scope its recent-chats list.
+    """
+    chat_id = str(uuid.uuid4())
+    body: dict[str, Any] = {
+        "id": chat_id,
+        "org_uuid": http.cfg.org_uuid,
+        "client_version": _cli_version,
+        "region": http.cfg.region,
+        "folder": folder,
+    }
+    if name is not None:
+        body["name"] = name
+    if model is not None:
+        body["model"] = model
+
+    resp = await http.supabase_post("/rest/v1/app_cli", body, prefer="return=minimal")
+    if resp.status_code >= HTTP_ERROR_THRESHOLD:
+        msg = f"failed to create chat: HTTP {resp.status_code}: {resp.text[:400]}"
+        raise TransportError(msg)
+    return chat_id
+
+
+# ---------------------------------------------------------------------------
+# Mutations — rename + delete
+# ---------------------------------------------------------------------------
+
+
+async def rename_chat(http: AuthedClient, chat_id: str, name: str) -> None:
+    """PATCH ``app_cli.name`` for one chat.
+
+    RLS scopes the UPDATE to the signed-in owner; a 0-row UPDATE on a
+    chat owned by someone else returns 200 but changes nothing — same
+    semantics as Supabase's REST layer everywhere else.
+    """
+    body = {"name": name}
+    resp = await http.supabase_patch(
+        f"/rest/v1/app_cli?id=eq.{chat_id}",
+        body,
+        prefer="return=minimal",
+    )
+    if resp.status_code >= HTTP_ERROR_THRESHOLD:
+        msg = f"failed to rename chat: HTTP {resp.status_code}: {resp.text[:400]}"
+        raise TransportError(msg)
+
+
+async def delete_chat(http: AuthedClient, chat_id: str) -> None:
+    """DELETE one ``app_cli`` row.
+
+    ``app_cli_messages`` rows cascade away via the FK constraint; RLS
+    again scopes the DELETE to the owner.
+    """
+    resp = await http.supabase_delete(f"/rest/v1/app_cli?id=eq.{chat_id}")
+    if resp.status_code >= HTTP_ERROR_THRESHOLD:
+        msg = f"failed to delete chat: HTTP {resp.status_code}: {resp.text[:400]}"
+        raise TransportError(msg)
+
+
+# ---------------------------------------------------------------------------
+# Internals
+# ---------------------------------------------------------------------------
+
+
+def _row_to_item(row: dict[str, Any]) -> ChatListItem:
+    raw_updated = row.get("updated_at")
+    if isinstance(raw_updated, str):
+        updated_at = datetime.fromisoformat(raw_updated)
+    else:
+        updated_at = datetime.fromtimestamp(0, tz=UTC)
+
+    name = row.get("name")
+    summary = row.get("summary")
+    raw_count = row.get("message_count")
+    message_count = int(raw_count) if isinstance(raw_count, (int, str)) else 0
+
+    return ChatListItem(
+        id=str(row["id"]),
+        name=str(name) if isinstance(name, str) and name else None,
+        updated_at=updated_at,
+        message_count=message_count,
+        summary=str(summary) if isinstance(summary, str) and summary else None,
+    )
+
+
+def _message_row_to_openai(row: dict[str, Any]) -> dict[str, Any]:
+    """Translate one ``app_cli_messages`` row into an OpenAI-style dict.
+
+    Mirrors the backend's ``cli_message_to_openai`` so the replay logic
+    sees the same shape as a live agent run.
+    """
+    msg: dict[str, Any] = {"role": row["role"]}
+
+    parts = row.get("content_parts")
+    if parts:
+        msg["content"] = parts
+    else:
+        msg["content"] = row.get("content")
+
+    if row.get("tool_call_id"):
+        msg["tool_call_id"] = row["tool_call_id"]
+    if row.get("tool_name"):
+        msg["name"] = row["tool_name"]
+    if row.get("tool_calls"):
+        msg["tool_calls"] = row["tool_calls"]
+
+    metadata = row.get("metadata") or {}
+    if isinstance(metadata, dict):
+        for k, v in metadata.items():
+            if k not in msg:
+                msg[k] = v
+
+    return msg

delos_cli/transport/client.py

@@ -0,0 +1,321 @@
+"""AuthedClient — one httpx session, one place where token refresh lives.
+
+Every backend + Supabase REST call in the CLI flows through this class so
+token refresh isn't duplicated, and so we keep a single connection pool for
+the lifetime of the REPL.
+
+Entry points:
+    * :meth:`json_get`       — plain JSON GET against ``{api_url}`` (backend)
+    * :meth:`sse_post`       — SSE POST that yields parsed ``data:`` events
+    * :meth:`supabase_post`  — POST to ``{supabase_url}`` (e.g. ``/rest/v1/...``)
+    * :meth:`supabase_get`   — GET to ``{supabase_url}``
+
+Each entry point proactively refreshes via the :class:`TokenManager` before
+the first attempt (based on the JWT's ``exp`` claim), and reactively refreshes
+once on 401/403 before giving up with :class:`TransportError`.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Self
+
+import httpx
+
+from delos_cli.auth.oauth import OAuthError, RefreshTokenInvalidError
+from delos_cli.auth.token_manager import TokenManager
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+    from types import TracebackType
+
+    from delos_cli.auth.config import Config
+
+HTTP_UNAUTHORIZED = 401
+HTTP_FORBIDDEN = 403
+HTTP_ERROR_THRESHOLD = 400
+DONE_SENTINEL = "[DONE]"
+_DEFAULT_GET_TIMEOUT_S = 10.0
+_DEFAULT_POST_TIMEOUT_S = 30.0
+_AUTH_REJECTED: frozenset[int] = frozenset({HTTP_UNAUTHORIZED, HTTP_FORBIDDEN})
+
+
+class TransportError(RuntimeError):
+    """Raised when a request fails (HTTP error, auth dead after refresh, bad SSE)."""
+
+
+class _AuthExpiredError(Exception):
+    """Internal signal: got a 401/403, caller should force-refresh and retry."""
+
+
+class AuthedClient:
+    """Shared authenticated HTTP client for the REPL lifetime.
+
+    Use as an async context manager so the underlying connection pool is
+    cleanly closed on shutdown.
+    """
+
+    def __init__(self, cfg: Config) -> None:
+        """Build the shared httpx client + a :class:`TokenManager` around ``cfg``."""
+        self._tokens = TokenManager(cfg)
+        self._http = httpx.AsyncClient(timeout=httpx.Timeout(None, connect=10.0))
+
+    async def __aenter__(self) -> Self:
+        """Enter the async context — returns self for ``async with`` binding."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        """Close the underlying connection pool on exit."""
+        _ = exc_type, exc, tb
+        await self._http.aclose()
+
+    @property
+    def cfg(self) -> Config:
+        """The live ``Config`` (URL properties, org_uuid, etc.)."""
+        return self._tokens.cfg
+
+    @property
+    def tokens(self) -> TokenManager:
+        """The :class:`TokenManager`. Mainly exposed for tests."""
+        return self._tokens
+
+    # ------------------------------------------------------------------
+    # Backend API calls
+    # ------------------------------------------------------------------
+
+    async def json_get(self, path: str) -> dict[str, Any]:
+        """GET ``{api_url}{path}``; decode JSON. Force-refresh once on 401/403."""
+        return await self.json_request("GET", path, None)
+
+    async def json_post(
+        self, path: str, body: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """POST ``{api_url}{path}`` with optional JSON body; decode JSON."""
+        return await self.json_request("POST", path, body)
+
+    async def json_request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        """Generic JSON request against the backend.
+
+        Force-refreshes once on 401/403 and retries.  Returns ``{}`` for
+        empty bodies (e.g. 204) or non-JSON responses so callers don't have
+        to special-case them.
+        """
+        resp = await self._send_json_request(method, path, body)
+        if resp.status_code in _AUTH_REJECTED:
+            await self._force_refresh_or_fail()
+            resp = await self._send_json_request(method, path, body)
+            if resp.status_code in _AUTH_REJECTED:
+                msg = "still unauthorized after refresh; run `delos login`"
+                raise TransportError(msg)
+        if resp.status_code >= HTTP_ERROR_THRESHOLD:
+            msg = f"HTTP {resp.status_code}: {resp.text[:400]}"
+            raise TransportError(msg)
+        if not resp.content:
+            return {}
+        try:
+            return resp.json()
+        except ValueError:
+            return {}
+
+    async def sse_post(
+        self, path: str, body: dict[str, Any],
+    ) -> AsyncIterator[dict[str, Any]]:
+        """POST ``{api_url}{path}`` → parsed SSE ``data:`` events.
+
+        Yields parsed JSON dicts. A ``{"type": "[DONE]"}`` dict signals end.
+        Force-refreshes once on 401/403 and retries.
+        """
+        try:
+            async for event in self._stream_sse(path, body):
+                yield event
+        except _AuthExpiredError:
+            pass
+        else:
+            return
+
+        await self._force_refresh_or_fail()
+        try:
+            async for event in self._stream_sse(path, body):
+                yield event
+        except _AuthExpiredError as e:
+            msg = "still unauthorized after refresh; run `delos login`"
+            raise TransportError(msg) from e
+
+    # ------------------------------------------------------------------
+    # Supabase REST (supabase_url)
+    # ------------------------------------------------------------------
+
+    async def supabase_post(
+        self,
+        path: str,
+        body: dict[str, Any],
+        *,
+        prefer: str | None = None,
+    ) -> httpx.Response:
+        """POST ``{supabase_url}{path}``, with Supabase auth headers.
+
+        Returns the raw :class:`httpx.Response` so callers can inspect
+        status (useful for upsert/409 handling); non-auth failures are NOT
+        raised here. Force-refreshes once on 401/403.
+        """
+        return await self._supabase_request("POST", path, body=body, prefer=prefer)
+
+    async def supabase_get(self, path: str) -> httpx.Response:
+        """GET ``{supabase_url}{path}`` with Supabase auth headers. Raw response."""
+        return await self._supabase_request("GET", path)
+
+    async def supabase_patch(
+        self,
+        path: str,
+        body: dict[str, Any],
+        *,
+        prefer: str | None = None,
+    ) -> httpx.Response:
+        """PATCH ``{supabase_url}{path}`` with Supabase auth headers."""
+        return await self._supabase_request("PATCH", path, body=body, prefer=prefer)
+
+    async def supabase_delete(self, path: str) -> httpx.Response:
+        """DELETE ``{supabase_url}{path}`` with Supabase auth headers."""
+        return await self._supabase_request("DELETE", path)
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    async def _send_json_request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        headers = await self._backend_headers()
+        kwargs: dict[str, Any] = {
+            "headers": headers,
+            "timeout": _DEFAULT_GET_TIMEOUT_S if method == "GET" else _DEFAULT_POST_TIMEOUT_S,
+        }
+        if body is not None:
+            kwargs["json"] = body
+            headers["Content-Type"] = "application/json"
+        return await self._http.request(method, f"{self.cfg.api_url}{path}", **kwargs)
+
+    async def _stream_sse(
+        self, path: str, body: dict[str, Any],
+    ) -> AsyncIterator[dict[str, Any]]:
+        url = f"{self.cfg.api_url}{path}"
+        headers = {
+            **(await self._backend_headers()),
+            "Accept": "text/event-stream",
+            "Content-Type": "application/json",
+        }
+        async with self._http.stream("POST", url, headers=headers, json=body) as resp:
+            if resp.status_code in _AUTH_REJECTED:
+                raise _AuthExpiredError
+            if resp.status_code >= HTTP_ERROR_THRESHOLD:
+                text = (await resp.aread()).decode(errors="replace")
+                msg = f"HTTP {resp.status_code}: {text[:400]}"
+                raise TransportError(msg)
+
+            buffer = ""
+            async for chunk in resp.aiter_text():
+                buffer += chunk
+                while "\n\n" in buffer:
+                    raw, buffer = buffer.split("\n\n", 1)
+                    event = _parse_sse_event(raw)
+                    if event is None:
+                        continue
+                    yield event
+                    if event.get("type") == DONE_SENTINEL:
+                        return
+
+    async def _supabase_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: dict[str, Any] | None = None,
+        prefer: str | None = None,
+    ) -> httpx.Response:
+        """Send a Supabase REST request, refreshing once on 401/403.
+
+        Generic across POST / GET / PATCH / DELETE — the per-verb public
+        wrappers just delegate here.  Returns the raw response so callers
+        can inspect status codes (e.g. 409 on upsert race).
+        """
+        resp = await self._send_supabase_request(method, path, body, prefer)
+        if resp.status_code in _AUTH_REJECTED:
+            await self._force_refresh_or_fail()
+            resp = await self._send_supabase_request(method, path, body, prefer)
+        return resp
+
+    async def _send_supabase_request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None,
+        prefer: str | None,
+    ) -> httpx.Response:
+        headers = await self._supabase_headers()
+        if prefer:
+            headers["Prefer"] = prefer
+        timeout = _DEFAULT_GET_TIMEOUT_S if method == "GET" else _DEFAULT_POST_TIMEOUT_S
+        kwargs: dict[str, Any] = {"headers": headers, "timeout": timeout}
+        if body is not None:
+            kwargs["json"] = body
+        return await self._http.request(
+            method, f"{self.cfg.supabase_url}{path}", **kwargs,
+        )
+
+    async def _backend_headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {await self._tokens.access_token()}"}
+
+    async def _supabase_headers(self) -> dict[str, str]:
+        return {
+            "apikey": self.cfg.supabase_anon_key,
+            "Authorization": f"Bearer {await self._tokens.access_token()}",
+            "Content-Type": "application/json",
+        }
+
+    async def _force_refresh_or_fail(self) -> None:
+        """Translate token-refresh errors into :class:`TransportError`."""
+        try:
+            await self._tokens.force_refresh()
+        except RefreshTokenInvalidError as e:
+            msg = f"session expired ({e}); run `delos login`"
+            raise TransportError(msg) from e
+        except OAuthError as e:
+            msg = f"token refresh failed ({e}); try again or run `delos login`"
+            raise TransportError(msg) from e
+
+
+def _parse_sse_event(raw: str) -> dict[str, Any] | None:
+    """Parse one SSE event block into a JSON dict.
+
+    Handles the ``data: <payload>`` form, including the ``[DONE]`` sentinel.
+    Returns ``None`` for keepalive/comment lines.
+    """
+    data_lines = [
+        line[5:].lstrip() if line.startswith("data:") else ""
+        for line in raw.splitlines()
+        if line.startswith("data:")
+    ]
+    if not data_lines:
+        return None
+    payload = "\n".join(data_lines).strip()
+    if not payload:
+        return None
+    if payload == DONE_SENTINEL:
+        return {"type": DONE_SENTINEL}
+    try:
+        return json.loads(payload)
+    except json.JSONDecodeError:
+        return {"type": "parse-error", "raw": payload}

delos_cli/transport/models.py

@@ -0,0 +1,19 @@
+"""Thin wrapper around ``GET /client/models/{org_uuid}``.
+
+Mirrors the data the web frontend uses for its chat model picker —
+filtered server-side by sigma flag, deployment plan, and config fallbacks.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import AuthedClient
+
+
+async def fetch_models(client: AuthedClient) -> list[str]:
+    """Return model ids available to the signed-in user/org."""
+    path = f"/client/models/{client.cfg.org_uuid}"
+    payload = await client.json_get(path)
+    return [m["id"] for m in payload.get("models", [])]

delos_cli/ui/__init__.py

@@ -0,0 +1,6 @@
+"""UI layer: REPL Application, output buffer, completer, lexer, style."""
+
+from .output import OutputBuffer
+from .repl import run as run_repl
+
+__all__ = ["OutputBuffer", "run_repl"]