delos-cli 1.0.2__tar.gz → 1.0.4__tar.gz

delos_cli-1.0.4/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "disabledMcpjsonServers": [
+    "sentry",
+    "agent-analysis-localhost",
+    "agent-analysis-staging",
+    "agent-analysis-prod"
+  ]
+}

{delos_cli-1.0.2 → delos_cli-1.0.4}/.gitignore

@@ -96,6 +96,12 @@ yarn-error.log*
 !apps/vscode/.vscode/
 .zed
 
+# versioned editor defaults (format-on-save) — keep personal settings in VS Code user settings
+!/.vscode
+/.vscode/*
+!/.vscode/settings.json
+!/.vscode/extensions.json
+
 # contentlayer
 .contentlayer/
 
@@ -138,6 +144,10 @@ apps/mobile/*.p12
 apps/mobile/*.key
 apps/mobile/.metro-health-check*
 
+# Desktop App (Electron) — build output (node_modules/build already ignored above)
+apps/desktop/dist/
+apps/desktop/release/
+
 
 .gitnexus
 

{delos_cli-1.0.2 → delos_cli-1.0.4}/DELOS.md

@@ -136,8 +136,8 @@ Executed locally on the user's machine; results posted back via `POST /cli/agent
 |---|---|---|---|---|
 | `run_shell` | ✓ | ✓ | ✅ | Allowlist for safe commands; otherwise prompts via `ctx.confirm` |
 | `read` | ✓ | ✓ | ✅ | UTF-8 only, line-numbered slice; skips binaries |
-| `write_content` | ✓ | ✓ | ✅ | Write to **empty files only** (no clobber) |
-| `edit_content` | ✓ | ✓ | ✅ | Strict find/replace |
+| `write_content` | ✓ | ✓ | ✅ | Creates the file (+ parent dirs) if missing; refuses to clobber non-empty files |
+| `edit_content` | ✓ | ✓ | ✅ | Strict find/replace — single (`old_content`/`new_content`) or batched (`edits: [{old_content, new_content}, ...]`), all-or-nothing |
 | `grep` | ✓ | ✓ | ✅ | ripgrep wrapper (read-only) |
 | `glob` | ✓ | ✓ | ✅ | Glob pattern matching (read-only) |
 | `todo_write` | ✓ | ✓ (silent) | — | Replaces full plan in [TodoStore](cli/delos_cli/state.py); panel above input shows state |

{delos_cli-1.0.2 → delos_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: delos-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Terminal REPL for the Delos agent — the Claude-Code-style CLI for Delos.
 Project-URL: Homepage, https://delos.so
 Project-URL: Repository, https://github.com/Delos-Intelligence/cosmos-saas
@@ -24,8 +24,8 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: prompt-toolkit>=3.0.47
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: rich>=13.8.0
-Requires-Dist: ripgrep>=15; sys_platform == 'darwin' and platform_machine == 'arm64'
-Requires-Dist: ripgrep>=15; sys_platform == 'linux' and platform_machine == 'x86_64'
+Requires-Dist: ripgrep<15,>=14; sys_platform == 'darwin' and platform_machine == 'arm64'
+Requires-Dist: ripgrep<15,>=14; sys_platform == 'linux' and platform_machine == 'x86_64'
 Requires-Dist: typer>=0.12.5
 Description-Content-Type: text/markdown
 

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/apps/chat/app.py

@@ -25,20 +25,26 @@ from delos_cli.apps.replay import replay_messages
 from delos_cli.git_context import collect_git_context
 from delos_cli.state import TodoStore
 from delos_cli.tools import (
+    handle_ask_user_input,
     handle_edit_content,
     handle_explore,
     handle_glob,
     handle_grep,
+    handle_lint_target,
     handle_read,
     handle_run_shell,
+    handle_run_tests,
     handle_todo_write,
     handle_write_content,
+    render_ask_user_input,
     render_edit_content,
     render_explore,
     render_glob,
     render_grep,
+    render_lint_target,
     render_read,
     render_run_shell,
+    render_run_tests,
     render_task,
     render_todo_write,
     render_write_content,
@@ -75,6 +81,8 @@ def default_tool_registry() -> ToolRegistry:
     reg.handlers["todo_write"] = handle_todo_write
     # Silent renderer — the permanent panel above the input shows the state.
     reg.renderers["todo_write"] = render_todo_write
+    reg.handlers["ask_user_input"] = handle_ask_user_input
+    reg.renderers["ask_user_input"] = render_ask_user_input
     # `task` is server-side (no handler needed); the renderer shows the
     # sub-agent's input/output lifecycle in the terminal.
     reg.renderers["task"] = render_task
@@ -82,6 +90,11 @@ def default_tool_registry() -> ToolRegistry:
     # only its report — see delos_cli.tools.explore.
     reg.handlers["explore"] = handle_explore
     reg.renderers["explore"] = render_explore
+    # Verification tools — runner/linter auto-detection, see delos_cli.tools.verify.
+    reg.handlers["run_tests"] = handle_run_tests
+    reg.renderers["run_tests"] = render_run_tests
+    reg.handlers["lint_target"] = handle_lint_target
+    reg.renderers["lint_target"] = render_lint_target
     return reg
 
 
@@ -151,7 +164,13 @@ class ChatApp(App):
 
         self._current_session = session
         try:
-            async for event in session.send_turn(body, ctx):
+            # emit_tool_output=True so client tools that render a completion
+            # line (explore's ✓) get a synthetic tool-output-available — the
+            # backend never sends one for client-side tools. Without it the
+            # 🔎 explore line hangs with no closing ✓. Matches the serve.py
+            # (VSCode) path. Input-only renderers (read/grep/glob/run_shell)
+            # return None on the output event, so nothing double-renders.
+            async for event in session.send_turn(body, ctx, emit_tool_output=True):
                 yield event
         finally:
             self._current_session = None

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/apps/chat/commands.py

@@ -18,6 +18,7 @@ Two modes:
 from __future__ import annotations
 
 import contextlib
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from prompt_toolkit.application import get_app
@@ -25,6 +26,8 @@ from rich.text import Text
 
 from delos_cli.commands.base import CommandSpec, registry_from
 from delos_cli.commands.prompts import EXECUTE_PROMPT, INIT_PROMPT_NEW, INIT_PROMPT_UPDATE
+from delos_cli.context_report import fetch_context_report, render_report
+from delos_cli.git_context import collect_git_context
 from delos_cli.transport.chats import patch_chat_model
 from delos_cli.transport.client import TransportError
 
@@ -128,4 +131,34 @@ EXECUTE = CommandSpec(
 )
 
 
-CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL, INIT, EXECUTE])
+# ---------------------------------------------------------------------------
+# /context — token breakdown of the next turn's LLM payload
+# ---------------------------------------------------------------------------
+
+
+async def _handle_context(ctx: Ctx, args: str) -> None:
+    """Fetch the backend context-report for this chat and render it."""
+    _ = args
+    sink = _sink(ctx)
+    git_ctx = await collect_git_context(Path.cwd())
+    try:
+        report = await fetch_context_report(
+            ctx.http,
+            ctx.state.conv_id,
+            custom_instructions=ctx.custom_instructions or None,
+            git_context=git_ctx,
+        )
+    except TransportError as e:
+        sink.print(Text(f"context report failed: {e}", style="red"))
+        return
+    sink.print(render_report(report))
+
+
+CONTEXT = CommandSpec(
+    name="/context",
+    summary="show what fills the agent's context window (token breakdown)",
+    handler=_handle_context,
+)
+
+
+CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL, INIT, EXECUTE, CONTEXT])

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/apps/chat/render.py

@@ -55,6 +55,10 @@ class V6Renderer:
         self._spinner = Spinner("dots", text=" thinking", style="dim")
         self._thinking = False
         self._anim_task: asyncio.Task[None] | None = None
+        # Inside a <think>…</think> fence — AgentV2 streams model reasoning
+        # inline between literal tag deltas. Reasoning is swallowed (the
+        # spinner keeps running) so it never lands in scrollback.
+        self._in_think = False
 
     def apply(self, event: dict[str, Any]) -> None:
         """Apply a single v6 event to the output buffer."""
@@ -76,6 +80,16 @@ class V6Renderer:
             delta = event.get("delta", "")
             if not delta:
                 return
+            # Each <think> / </think> tag arrives as its own delta
+            # (agent_v2 injects them around reasoning), so plain equality
+            # checks are enough — no tag can be split across deltas.
+            if delta == "<think>":
+                self._in_think = True
+                return
+            if self._in_think:
+                if delta.startswith("</think>"):
+                    self._in_think = False
+                return
             self._stop_thinking()
             self._assistant_text += delta
             self._output.update_live(Markdown(self._assistant_text))

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/apps/replay.py

@@ -20,6 +20,7 @@ from rich.markdown import Markdown
 from rich.text import Text
 
 from delos_cli.agent import default_renderer
+from delos_cli.ui.style import user_echo
 
 if TYPE_CHECKING:
     from delos_cli.apps.base import App
@@ -49,7 +50,8 @@ def replay_messages(
         if role == "user":
             text = _extract_text(msg.get("content"))
             if text:
-                output.print(Text(f"» {text}\n", style="bold cyan"))
+                output.print(user_echo(text))
+                output.print(Text(""))
         elif role == "assistant":
             text = _extract_text(msg.get("content"))
             if text:

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/auth/config.py

@@ -22,7 +22,7 @@ import tempfile
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import IO, TYPE_CHECKING, TypedDict
+from typing import IO, TYPE_CHECKING, Any, TypedDict
 
 from delos_cli import _editable_source_dir
 
@@ -121,6 +121,23 @@ class Tokens:
     expires_at: int = 0  # unix timestamp
 
 
+@dataclass
+class Session:
+    """Signed-in identity + token pair for one region.
+
+    Refresh tokens are region-scoped (each region is a separate Supabase
+    project), so sending region A's refresh token to region B's auth server
+    yields ``invalid_grant`` and forces a re-login. Keeping one Session per
+    region lets ``--region`` / ``DELOS_REGION`` switches round-trip without
+    burning the other region's session.
+    """
+
+    org_uuid: str = ""
+    user_id: str = ""
+    client_id: str = ""
+    tokens: Tokens = field(default_factory=Tokens)
+
+
 @dataclass
 class Config:
     """Persisted CLI configuration: which region, who we're signed in as."""
@@ -130,6 +147,10 @@ class Config:
     user_id: str = ""
     client_id: str = ""  # cached OAuth client_id from /api/oauth/register
     tokens: Tokens = field(default_factory=Tokens)
+    # Stashed sessions for non-active regions, keyed by region name. The
+    # active region's session lives in the flat fields above (kept flat for
+    # backward compatibility with older CLI builds reading the same file).
+    sessions: dict[str, Session] = field(default_factory=dict)
 
     @property
     def api_url(self) -> str:
@@ -175,6 +196,44 @@ class Config:
         return bool(self.tokens.access_token and self.org_uuid)
 
 
+def _parse_tokens(tok: dict[str, Any]) -> Tokens:
+    """Build a ``Tokens`` from a raw JSON dict, tolerating missing fields."""
+    return Tokens(
+        access_token=tok.get("access_token", ""),
+        refresh_token=tok.get("refresh_token", ""),
+        expires_at=int(tok.get("expires_at", 0)),
+    )
+
+
+def _current_session(cfg: Config) -> Session:
+    """Snapshot the active region's flat fields as a ``Session``."""
+    return Session(
+        org_uuid=cfg.org_uuid,
+        user_id=cfg.user_id,
+        client_id=cfg.client_id,
+        tokens=cfg.tokens,
+    )
+
+
+def set_region(cfg: Config, region: str) -> None:
+    """Switch the active region, swapping sessions instead of leaking tokens.
+
+    Stashes the current region's session into ``cfg.sessions`` and adopts the
+    target region's stashed session (empty if never signed in there). Without
+    this swap, a region switch keeps the old region's refresh token and burns
+    it against the wrong auth server.
+    """
+    if region == cfg.region:
+        return
+    cfg.sessions[cfg.region] = _current_session(cfg)
+    cfg.region = region
+    adopted = cfg.sessions.get(region, Session())
+    cfg.org_uuid = adopted.org_uuid
+    cfg.user_id = adopted.user_id
+    cfg.client_id = adopted.client_id
+    cfg.tokens = adopted.tokens
+
+
 def load() -> Config:
     """Load config from disk, apply DELOS_REGION/DELOS_ENV env overrides."""
     cfg = Config()
@@ -185,12 +244,15 @@ def load() -> Config:
             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)),
-            )
+            cfg.tokens = _parse_tokens(data.get("tokens") or {})
+            for name, raw in (data.get("sessions") or {}).items():
+                if isinstance(raw, dict):
+                    cfg.sessions[name] = Session(
+                        org_uuid=raw.get("org_uuid", ""),
+                        user_id=raw.get("user_id", ""),
+                        client_id=raw.get("client_id", ""),
+                        tokens=_parse_tokens(raw.get("tokens") or {}),
+                    )
         except (json.JSONDecodeError, OSError, ValueError):
             pass
 
@@ -201,10 +263,10 @@ def load() -> Config:
             known = ", ".join(sorted(allowed))
             msg = f"Unknown region '{region_override}'. Known: {known}"
             raise ValueError(msg)
-        cfg.region = region_override
+        set_region(cfg, region_override)
 
     if cfg.region not in available_regions():
-        cfg.region = DEFAULT_REGION
+        set_region(cfg, DEFAULT_REGION)
 
     return cfg
 
@@ -218,6 +280,9 @@ def save(cfg: Config) -> Path:
     :func:`config_file_lock` around their read-modify-write.
     """
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    # Mirror the active region's session into the stash so a later region
+    # switch (or an older CLI build rewriting the file) can't lose it.
+    cfg.sessions[cfg.region] = _current_session(cfg)
     payload = json.dumps(asdict(cfg), indent=2)
     fd, tmp_path_str = tempfile.mkstemp(
         prefix=".config-",
@@ -239,6 +304,33 @@ def save(cfg: Config) -> Path:
     return CONFIG_PATH
 
 
+def region_tokens(cfg: Config, region: str) -> Tokens:
+    """Tokens for ``region``: the flat pair if active, else the stashed one."""
+    if cfg.region == region:
+        return cfg.tokens
+    stashed = cfg.sessions.get(region)
+    return stashed.tokens if stashed else Tokens()
+
+
+def save_tokens(cfg: Config) -> Path:
+    """Persist ``cfg``'s token pair for ``cfg.region`` without anything else.
+
+    Re-reads the file and only updates this region's tokens, so a refresh
+    happening in one process (e.g. the VSCode extension's ``delos serve``)
+    can't clobber another region's session, flip the file's active region,
+    or overwrite identity fields written since. Callers should hold
+    :func:`config_file_lock` around their read-refresh-save sequence.
+    """
+    disk = load()
+    if disk.region == cfg.region:
+        disk.tokens = cfg.tokens
+    else:
+        stashed = disk.sessions.get(cfg.region, Session())
+        stashed.tokens = cfg.tokens
+        disk.sessions[cfg.region] = stashed
+    return save(disk)
+
+
 @contextmanager
 def config_file_lock() -> Iterator[None]:
     """Advisory cross-process exclusive lock on ``~/.config/delos/.config.lock``.

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/auth/oauth.py

@@ -333,34 +333,44 @@ def _pick_factor(factors: list[MfaFactor], on_message: Callable[[str], None]) ->
 
 
 HTTP_BAD_REQUEST = 400
+HTTP_TOO_MANY_REQUESTS = 429
+HTTP_SERVER_ERROR = 500
 
 
 async def refresh_tokens(cfg: Config) -> Tokens:
-    """Swap the refresh token for a fresh access token at /api/oauth/token.
-
-    Raises :class:`RefreshTokenInvalidError` when the server reports
-    ``invalid_grant`` (token revoked, expired, or already rotated by another
-    client) — the caller should prompt for re-login. Other failures raise
-    :class:`OAuthError` and are generally transient.
+    """Swap the refresh token for a fresh pair, directly against GoTrue.
+
+    Our refresh tokens ARE Supabase refresh tokens (the web ``/api/oauth/token``
+    refresh grant just proxies to ``auth.refreshSession``), so we talk to
+    ``{supabase_url}/auth/v1/token`` like every other Supabase client does.
+    This keeps the web frontend out of the refresh path — in the dev region
+    the Next server may be down or HTTPS-only, and that must not read as an
+    auth failure.
+
+    Raises :class:`RefreshTokenInvalidError` only when GoTrue rejects the
+    token itself (4xx) — the caller should prompt for re-login. Everything
+    else (network, TLS, 5xx) raises :class:`OAuthError` and is transient.
     """
     if not cfg.tokens.refresh_token:
         msg = "no refresh_token stored — run `delos login` again"
         raise RefreshTokenInvalidError(msg)
-    async with httpx.AsyncClient(timeout=30.0) as http:
-        resp = await http.post(
-            f"{cfg.web_url}/api/oauth/token",
-            json={
-                "grant_type": "refresh_token",
-                "refresh_token": cfg.tokens.refresh_token,
-                "client_id": CLIENT_ID,
-            },
-        )
-    if resp.status_code == HTTP_BAD_REQUEST:
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as http:
+            resp = await http.post(
+                f"{cfg.supabase_url}/auth/v1/token?grant_type=refresh_token",
+                json={"refresh_token": cfg.tokens.refresh_token},
+                headers={"apikey": cfg.supabase_anon_key},
+            )
+    except httpx.HTTPError as e:
+        msg = f"refresh failed: {type(e).__name__}: {e}"
+        raise OAuthError(msg) from e
+    if HTTP_BAD_REQUEST <= resp.status_code < HTTP_SERVER_ERROR and resp.status_code != HTTP_TOO_MANY_REQUESTS:
+        detail = "refresh token is invalid or expired"
         with contextlib.suppress(json.JSONDecodeError, ValueError):
             err = resp.json()
-            if isinstance(err, dict) and err.get("error") == "invalid_grant":
-                msg = str(err.get("error_description") or "refresh token is invalid or expired")
-                raise RefreshTokenInvalidError(msg)
+            if isinstance(err, dict):
+                detail = str(err.get("msg") or err.get("error_description") or detail)
+        raise RefreshTokenInvalidError(detail)
     if resp.status_code >= HTTP_ERROR_THRESHOLD:
         msg = f"refresh failed: HTTP {resp.status_code}: {resp.text[:300]}"
         raise OAuthError(msg)

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/auth/token_manager.py

@@ -31,7 +31,7 @@ import json
 import time
 from typing import TYPE_CHECKING
 
-from .config import Tokens, config_file_lock, load, save
+from .config import Tokens, config_file_lock, load, region_tokens, save_tokens
 from .oauth import refresh_tokens
 
 if TYPE_CHECKING:
@@ -91,17 +91,20 @@ class TokenManager:
 
             # Cross-process lock. Re-read the file inside it — another CLI
             # may have refreshed and written fresh tokens since we started.
+            # Compare against OUR region's tokens: the file's active region
+            # can differ (e.g. `delos serve --region X` next to a terminal
+            # signed into Y) and cross-region pairs must never be adopted.
             with config_file_lock():
-                disk = load()
-                if not force and _is_fresher(disk.tokens, self._cfg.tokens):
-                    self._cfg.tokens = disk.tokens
+                disk_tokens = region_tokens(load(), self._cfg.region)
+                if not force and _is_fresher(disk_tokens, self._cfg.tokens):
+                    self._cfg.tokens = disk_tokens
                     return
 
                 # We're the one doing the refresh. Use whichever refresh
                 # token is most recent (ours if unchanged, or the one from
                 # disk if another process wrote a newer pair we missed).
-                if _is_fresher(disk.tokens, self._cfg.tokens):
-                    self._cfg.tokens = disk.tokens
+                if _is_fresher(disk_tokens, self._cfg.tokens):
+                    self._cfg.tokens = disk_tokens
 
                 # On failure (RefreshTokenInvalidError / OAuthError) we
                 # let the exception propagate and intentionally do NOT
@@ -110,7 +113,7 @@ class TokenManager:
                 # shouldn't cost the user their session.  The caller
                 # surfaces "run delos login" and the user decides.
                 self._cfg.tokens = await refresh_tokens(self._cfg)
-                save(self._cfg)
+                save_tokens(self._cfg)
 
 
 def _jwt_exp(access_token: str) -> int | None:

{delos_cli-1.0.2 → delos_cli-1.0.4}/delos_cli/commands/prompts.py

@@ -40,6 +40,8 @@ as you go. If no plan exists in this conversation, say so instead of \
 improvising one."""
 
 #: Catalogue served to frontends (``list_commands`` RPC) for autocomplete.
+#: ``/context`` is not a prompt expansion — serve intercepts it and answers
+#: locally — but it belongs in the same autocomplete list.
 PROMPT_COMMANDS: tuple[dict[str, str], ...] = (
     {
         "name": "/init",
@@ -49,6 +51,10 @@ PROMPT_COMMANDS: tuple[dict[str, str], ...] = (
         "name": "/execute",
         "summary": "execute the plan from the previous plan-mode turn (loads it into todos)",
     },
+    {
+        "name": "/context",
+        "summary": "show what fills the agent's context window (token breakdown)",
+    },
 )