virtuai-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -14,10 +14,12 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: websockets>=12.0
 Requires-Dist: httpx[http2]>=0.27
+Requires-Dist: httpx-sse>=0.4
 Requires-Dist: certifi>=2024.0
 Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.50
 
 # VirtuAI CLI
 

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -22,10 +22,12 @@ classifiers = [
 dependencies = [
     "websockets>=12.0",
     "httpx[http2]>=0.27",
+    "httpx-sse>=0.4",
     "certifi>=2024.0",
     "keyring>=25.0",
     "typer>=0.12",
     "rich>=13.0",
+    "textual>=0.50",
 ]
 
 [project.urls]

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.1.0"
+__version__ = "0.2.0"

virtuai_cli-0.2.0/src/virtuai_cli/chat/__init__.py

@@ -0,0 +1,4 @@
+"""TUI chat — Claude-Code-style terminal interface for VirtuAI agents."""
+from virtuai_cli.chat.command import run_chat
+
+__all__ = ["run_chat"]

virtuai_cli-0.2.0/src/virtuai_cli/chat/command.py

@@ -0,0 +1,97 @@
+"""Entry point for `virtuai chat` — wires auth + agent picker + TUI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import certifi
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from virtuai_cli import config as cfg
+from virtuai_cli.chat.tui import ChatApp
+
+console = Console()
+
+_HTTPX_KWARGS = {"verify": certifi.where()}
+
+
+def _fetch_agents(server_url: str, token: str) -> dict:
+    resp = httpx.get(
+        f"{server_url.rstrip('/')}/api/cli/agents",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=15,
+        **_HTTPX_KWARGS,
+    )
+    if resp.status_code == 401:
+        raise typer.BadParameter("CLI token is invalid or revoked — run `virtuai pair <code>` again.")
+    if resp.status_code == 404:
+        raise typer.BadParameter("Workspace not available — run `virtuai pair <code>` again.")
+    resp.raise_for_status()
+    return resp.json()
+
+
+def _pick_agent(agents: list[dict], requested: Optional[str]) -> dict:
+    if not agents:
+        raise typer.BadParameter("No chat-enabled agents are available in this workspace.")
+
+    if requested:
+        for a in agents:
+            if a["agent_id"] == requested or a["name"] == requested:
+                return a
+        raise typer.BadParameter(f"Agent '{requested}' not found in this workspace.")
+
+    if len(agents) == 1:
+        return agents[0]
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("#", style="cyan", width=4)
+    table.add_column("Agent")
+    table.add_column("Model", style="dim")
+    for i, a in enumerate(agents, start=1):
+        table.add_row(str(i), a["name"], a.get("default_model_id") or "")
+    console.print(table)
+    choice = typer.prompt("Pick an agent by number", default="1")
+    try:
+        idx = int(choice) - 1
+        return agents[idx]
+    except (ValueError, IndexError):
+        raise typer.BadParameter(f"Invalid choice: {choice}")
+
+
+def run_chat(
+    workdir: Optional[Path],
+    server: Optional[str],
+    agent: Optional[str],
+) -> None:
+    """Launch the chat TUI. Called by the `chat` command in main.py."""
+    server_url = (server or cfg.get_server_url()).rstrip("/")
+    token = cfg.load_token(cfg._KEYRING_CLI_TOKEN_KEY)
+    if not token:
+        console.print("[red]Not paired.[/red] Run [bold]virtuai pair <code>[/bold] first.")
+        raise typer.Exit(1)
+
+    base = workdir or Path.cwd()
+    base.mkdir(parents=True, exist_ok=True)
+
+    try:
+        info = _fetch_agents(server_url, token)
+    except httpx.HTTPError as exc:
+        console.print(f"[red]Could not reach server:[/red] {exc}")
+        raise typer.Exit(1)
+
+    picked = _pick_agent(info["agents"], agent)
+
+    app = ChatApp(
+        server_url=server_url,
+        token=token,
+        workdir=base,
+        agent_id=picked["agent_id"],
+        agent_name=picked["name"],
+        workspace_name=info["workspace_name"],
+        default_model_id=picked.get("default_model_id"),
+    )
+    app.run()

virtuai_cli-0.2.0/src/virtuai_cli/chat/sse.py

@@ -0,0 +1,51 @@
+"""Async SSE chat client — POSTs a user message and yields parsed events."""
+
+from __future__ import annotations
+
+import json
+import ssl
+from typing import AsyncIterator, Optional
+
+import certifi
+import httpx
+from httpx_sse import aconnect_sse
+
+
+def _ssl_context() -> ssl.SSLContext:
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+async def stream_chat(
+    server_url: str,
+    token: str,
+    agent_id: str,
+    message: str,
+    session_id: Optional[str] = None,
+    model_id: Optional[str] = None,
+    timeout: float = 600.0,
+) -> AsyncIterator[dict]:
+    """Open an SSE chat stream and yield each event as a parsed dict.
+
+    The CLI token is passed as `Authorization: Bearer <token>`; the chat
+    principal now accepts CLI tokens (see web_chat/deps.py).
+    """
+    payload: dict = {"message": message}
+    if session_id:
+        payload["session_id"] = session_id
+    if model_id:
+        payload["model_id"] = model_id
+
+    headers = {"Authorization": f"Bearer {token}"}
+    url = f"{server_url.rstrip('/')}/api/web-chat/chat/{agent_id}/stream"
+    verify = certifi.where()
+
+    async with httpx.AsyncClient(verify=verify, timeout=httpx.Timeout(timeout, connect=15.0)) as client:
+        async with aconnect_sse(client, "POST", url, json=payload, headers=headers) as event_source:
+            async for sse in event_source.aiter_sse():
+                if not sse.data:
+                    continue
+                try:
+                    yield json.loads(sse.data)
+                except json.JSONDecodeError:
+                    # Server occasionally emits non-JSON keepalive lines; skip.
+                    continue

virtuai_cli-0.2.0/src/virtuai_cli/chat/tui.py

@@ -0,0 +1,244 @@
+"""Textual application — Claude-Code-style chat over the VirtuAI agent stream."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.reactive import reactive
+from textual.widgets import Footer, Header, Input, Static
+
+from virtuai_cli import runner as ws_runner
+from virtuai_cli.chat.sse import stream_chat
+from virtuai_cli.chat.widgets import AssistantTurn, UserBubble
+
+
+class ChatApp(App):
+    CSS = """
+    Screen { background: $surface; }
+
+    #conversation {
+        height: 1fr;
+        padding: 0 1;
+        scrollbar-gutter: stable;
+    }
+
+    #status {
+        dock: top;
+        height: 1;
+        padding: 0 1;
+        background: $panel;
+        color: $text-muted;
+    }
+
+    #input {
+        dock: bottom;
+        height: 3;
+        border: round $primary;
+        margin: 0 1 1 1;
+    }
+
+    #placeholder {
+        margin: 1 2;
+        color: $text-muted;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel_stream", "Cancel", show=True),
+        Binding("ctrl+c", "quit", "Quit", show=True),
+        Binding("ctrl+l", "clear_conversation", "New chat", show=True),
+    ]
+
+    status_line = reactive("")
+
+    def __init__(
+        self,
+        server_url: str,
+        token: str,
+        workdir: Path,
+        agent_id: str,
+        agent_name: str,
+        workspace_name: str,
+        default_model_id: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self.server_url = server_url
+        self.token = token
+        self.workdir = workdir
+        self.agent_id = agent_id
+        self.agent_name = agent_name
+        self.workspace_name = workspace_name
+        self.default_model_id = default_model_id
+
+        self.session_id: Optional[str] = None
+        self._stream_task: Optional[asyncio.Task] = None
+        self._runner_task: Optional[asyncio.Task] = None
+        self._current_turn: Optional[AssistantTurn] = None
+
+    # ── Layout ────────────────────────────────────────────────────────────
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        yield Static(self._initial_status(), id="status")
+        with VerticalScroll(id="conversation"):
+            yield Static(
+                f"[b]{self.agent_name}[/b] in {self.workspace_name}\n"
+                f"Workdir: {self.workdir}\n"
+                f"[dim]Type a message and press Enter. Esc cancels. /help for commands.[/dim]",
+                id="placeholder",
+            )
+        yield Input(placeholder="Message…", id="input")
+        yield Footer()
+
+    def _initial_status(self) -> str:
+        model = f" · {self.default_model_id}" if self.default_model_id else ""
+        return f"{self.workspace_name} · {self.agent_name}{model} · connecting…"
+
+    # ── Mount: start the WS runner in the background ──────────────────────
+    async def on_mount(self) -> None:
+        self.title = "VirtuAI"
+        self.sub_title = f"{self.agent_name} · {self.workspace_name}"
+        self.query_one(Input).focus()
+        self._runner_task = asyncio.create_task(self._run_ws())
+
+    async def _run_ws(self) -> None:
+        def on_status(level: str, msg: str) -> None:
+            # Called from the runner; mutate the status bar safely.
+            self.call_from_thread(self._set_status, f"{msg}")
+
+        try:
+            await ws_runner.run_forever(self.server_url, self.token, self.workdir, on_status=on_status)
+        except Exception as exc:
+            self.call_from_thread(self._set_status, f"runner error: {exc}")
+
+    def _set_status(self, text: str) -> None:
+        self.query_one("#status", Static).update(
+            f"{self.workspace_name} · {self.agent_name} · {text}"
+        )
+
+    # ── Input submission ──────────────────────────────────────────────────
+    @on(Input.Submitted, "#input")
+    async def _on_submit(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        if not text:
+            return
+        event.input.value = ""
+
+        if text.startswith("/"):
+            await self._handle_slash(text)
+            return
+
+        if self._stream_task and not self._stream_task.done():
+            self._set_status("a response is already streaming — press Esc to cancel first")
+            return
+
+        await self._append(UserBubble(text))
+        turn = AssistantTurn()
+        await self._append(turn)
+        self._current_turn = turn
+        self._stream_task = asyncio.create_task(self._stream_response(text, turn))
+
+    async def _append(self, widget) -> None:
+        ph = self.query("#placeholder")
+        for p in ph:
+            await p.remove()
+        scroll = self.query_one("#conversation", VerticalScroll)
+        await scroll.mount(widget)
+        scroll.scroll_end(animate=False)
+
+    # ── Slash commands ────────────────────────────────────────────────────
+    async def _handle_slash(self, cmd: str) -> None:
+        parts = cmd.split(None, 1)
+        head = parts[0].lower()
+        if head in ("/exit", "/quit"):
+            self.exit()
+        elif head in ("/clear", "/new"):
+            await self.action_clear_conversation()
+        elif head == "/help":
+            await self._append(Static(
+                "[b]Commands[/b]\n"
+                "  /help          this list\n"
+                "  /clear, /new   start a fresh conversation\n"
+                "  /exit, /quit   close the TUI\n"
+                "  Esc            cancel current response\n"
+            ))
+        else:
+            await self._append(Static(f"[red]Unknown command: {head}[/red]"))
+
+    async def action_clear_conversation(self) -> None:
+        self.session_id = None
+        self._current_turn = None
+        scroll = self.query_one("#conversation", VerticalScroll)
+        for child in list(scroll.children):
+            await child.remove()
+        await scroll.mount(Static(
+            "[dim]New conversation. Type a message and press Enter.[/dim]",
+            id="placeholder",
+        ))
+
+    def action_cancel_stream(self) -> None:
+        if self._stream_task and not self._stream_task.done():
+            self._stream_task.cancel()
+            self._set_status("response cancelled")
+
+    # ── SSE stream → widget mutations ─────────────────────────────────────
+    async def _stream_response(self, message: str, turn: AssistantTurn) -> None:
+        try:
+            async for event in stream_chat(
+                self.server_url,
+                self.token,
+                self.agent_id,
+                message,
+                session_id=self.session_id,
+                model_id=self.default_model_id,
+            ):
+                await self._handle_event(event, turn)
+        except asyncio.CancelledError:
+            self._set_status("response cancelled")
+            raise
+        except Exception as exc:
+            await turn.append_token(f"\n\n*[error: {exc}]*")
+            self._set_status(f"stream error: {exc}")
+        finally:
+            turn.mark_final()
+            scroll = self.query_one("#conversation", VerticalScroll)
+            scroll.scroll_end(animate=False)
+
+    async def _handle_event(self, event: dict, turn: AssistantTurn) -> None:
+        etype = event.get("type")
+        if etype == "start":
+            sid = event.get("session_id")
+            if sid:
+                self.session_id = sid
+        elif etype == "token":
+            content = event.get("content", "")
+            if content:
+                await turn.append_token(content)
+        elif etype == "text_segment":
+            content = event.get("content", "")
+            if content:
+                await turn.append_token(content)
+        elif etype == "tool_start":
+            await turn.start_tool(
+                event.get("id", ""),
+                event.get("name", "tool"),
+                str(event.get("input", "")),
+            )
+        elif etype == "tool_end":
+            turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)
+        elif etype == "todos":
+            await turn.set_todos(event.get("items", []))
+        elif etype == "truncated":
+            await turn.append_token("\n\n*[response truncated]*")
+        elif etype == "error":
+            msg = event.get("error") or event.get("message") or "unknown error"
+            await turn.append_token(f"\n\n*[error: {msg}]*")
+        elif etype in ("done", "complete"):
+            return
+        # Other event types (subagent_*, skill_loaded, memory_updated, etc.)
+        # are silently ignored in v1.

virtuai_cli-0.2.0/src/virtuai_cli/chat/widgets.py

@@ -0,0 +1,164 @@
+"""Textual widgets for the chat TUI.
+
+Each assistant turn is one AssistantTurn widget containing a sequence of
+text segments, tool-call cards, and an optional todo list. Events from the
+SSE stream mutate these widgets in place — no full re-renders.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from rich.markdown import Markdown
+from rich.text import Text
+from textual.containers import Vertical
+from textual.widgets import Static
+
+
+class UserBubble(Static):
+    """One line at the top of a turn showing the user's message."""
+
+    DEFAULT_CSS = """
+    UserBubble {
+        margin: 1 0 0 0;
+        padding: 0 1;
+        color: $accent;
+        text-style: bold;
+    }
+    """
+
+    def __init__(self, content: str) -> None:
+        super().__init__(Text("> ", style="bold cyan").append(content, style=""))
+
+
+class TextSegment(Static):
+    """A streaming markdown segment of assistant text."""
+
+    DEFAULT_CSS = """
+    TextSegment { margin: 0 0 0 2; }
+    """
+
+    def __init__(self) -> None:
+        super().__init__("")
+        self._buf = ""
+
+    def append(self, chunk: str) -> None:
+        self._buf += chunk
+        self.update(Markdown(self._buf))
+
+    @property
+    def content(self) -> str:
+        return self._buf
+
+
+class ToolCallCard(Static):
+    """A single tool invocation: running → complete, with output preview."""
+
+    DEFAULT_CSS = """
+    ToolCallCard {
+        margin: 0 0 0 2;
+        padding: 0 1;
+        color: $text-muted;
+    }
+    ToolCallCard.-running { color: $warning; }
+    ToolCallCard.-done    { color: $success; }
+    ToolCallCard.-error   { color: $error;   }
+    """
+
+    def __init__(self, tool_id: str, name: str, input_str: str) -> None:
+        super().__init__()
+        self.tool_id = tool_id
+        self.name = name
+        self.input_str = input_str or ""
+        self.output_preview: Optional[str] = None
+        self.add_class("-running")
+        self._render()
+
+    def _render(self) -> None:
+        marker = "✓" if "-done" in self.classes else ("✗" if "-error" in self.classes else "▶")
+        head = Text(f"{marker} {self.name}", style="bold")
+        if self.input_str:
+            preview = self.input_str.strip().splitlines()[0][:120]
+            head.append(f"  {preview}", style="dim")
+        body_lines = [head]
+        if self.output_preview:
+            for line in self.output_preview.strip().splitlines()[:8]:
+                body_lines.append(Text(f"  {line[:160]}", style="dim"))
+        self.update(Text("\n").join(body_lines))
+
+    def finish(self, output_preview: Optional[str], errored: bool = False) -> None:
+        self.output_preview = output_preview
+        self.remove_class("-running")
+        self.add_class("-error" if errored else "-done")
+        self._render()
+
+
+class TodoList(Static):
+    """Live checklist that updates whenever a `todos` event arrives."""
+
+    DEFAULT_CSS = """
+    TodoList {
+        margin: 0 0 0 2;
+        padding: 0 1;
+        color: $text-muted;
+    }
+    """
+
+    def set_items(self, items: list[dict]) -> None:
+        if not items:
+            self.update("")
+            return
+        lines: list[Text] = []
+        for item in items:
+            status = item.get("status", "pending")
+            mark = {"completed": "[x]", "in_progress": "[~]", "pending": "[ ]"}.get(status, "[ ]")
+            style = {"completed": "green", "in_progress": "yellow"}.get(status, "")
+            lines.append(Text(f"{mark} {item.get('content', '')}", style=style))
+        self.update(Text("\n").join(lines))
+
+
+class AssistantTurn(Vertical):
+    """Container for one assistant response — text segments + tool cards + todos."""
+
+    DEFAULT_CSS = """
+    AssistantTurn {
+        height: auto;
+        margin: 0 0 1 0;
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._tools: dict[str, ToolCallCard] = {}
+        self._todo: Optional[TodoList] = None
+        self._last_text: Optional[TextSegment] = None
+        self._final = False
+
+    async def append_token(self, content: str) -> None:
+        if self._last_text is None:
+            self._last_text = TextSegment()
+            await self.mount(self._last_text)
+        self._last_text.append(content)
+
+    async def start_tool(self, tool_id: str, name: str, input_str: str) -> None:
+        card = ToolCallCard(tool_id, name, input_str)
+        self._tools[tool_id] = card
+        await self.mount(card)
+        # Break the text run — next tokens start a fresh paragraph below the card.
+        self._last_text = None
+
+    def finish_tool(self, tool_id: str, output_preview: Optional[str], errored: bool = False) -> None:
+        card = self._tools.get(tool_id)
+        if card is not None:
+            card.finish(output_preview, errored)
+        # Force a new text segment after a tool, even without a tool_start break.
+        self._last_text = None
+
+    async def set_todos(self, items: list[dict]) -> None:
+        if self._todo is None:
+            self._todo = TodoList()
+            await self.mount(self._todo)
+        self._todo.set_items(items)
+
+    def mark_final(self) -> None:
+        self._final = True

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli/executor.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import shlex
 import subprocess
 from pathlib import Path
 from typing import Optional
@@ -12,6 +13,25 @@ from virtuai_cli.security import check_command, jail_path, scrub_env
 _EXECUTE_TIMEOUT = 300  # seconds
 
 
+def _jail_wrap(command: str, workdir: Path) -> str:
+    """Wrap command in a bash subshell that overrides cd to stay within workdir."""
+    jail = shlex.quote(str(workdir.resolve()))
+    script = "\n".join([
+        f"VIRTUAI_JAIL={jail}",
+        "cd() {",
+        "  local dest",
+        '  dest=$(builtin cd "${@:-$VIRTUAI_JAIL}" 2>/dev/null && pwd -P)',
+        '  case "$dest" in',
+        '    "$VIRTUAI_JAIL"|"$VIRTUAI_JAIL"/*) builtin cd "${@:-$VIRTUAI_JAIL}" ;;',
+        '    *) echo "cd: permission denied (outside workdir)" >&2; return 1 ;;',
+        "  esac",
+        "}",
+        "export -f cd",
+        command,
+    ])
+    return f"bash -c {shlex.quote(script)}"
+
+
 def execute(command: str, workdir: Path, timeout: int = _EXECUTE_TIMEOUT, extra_env: list[str] | None = None) -> dict:
     """Run a shell command. Returns {output, exit_code}."""
     denial = check_command(command)
@@ -19,9 +39,10 @@ def execute(command: str, workdir: Path, timeout: int = _EXECUTE_TIMEOUT, extra_
         return {"output": f"blocked by local denylist: {denial}", "exit_code": 126}
 
     env = scrub_env(workdir, extra_env)
+    wrapped = _jail_wrap(command, workdir)
     try:
         result = subprocess.run(
-            command,
+            wrapped,
             shell=True,
             cwd=str(workdir),
             env=env,

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli/main.py

@@ -145,6 +145,17 @@ def run(
 # status — show pairing and connection state
 # ---------------------------------------------------------------------------
 
+@app.command()
+def chat(
+    agent: Optional[str] = typer.Option(None, "--agent", help="Agent ID or name (skipped if only one agent exists)"),
+    workdir: Optional[Path] = typer.Option(None, "--workdir", help="Working directory the agent can act on"),
+    server: Optional[str] = typer.Option(None, "--server"),
+):
+    """Open the chat TUI and talk to an agent from this terminal."""
+    from virtuai_cli.chat import run_chat
+    run_chat(workdir=workdir, server=server, agent=agent)
+
+
 @app.command()
 def status(
     server: Optional[str] = typer.Option(None, "--server"),

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli/runner.py

@@ -9,7 +9,7 @@ import platform
 import sys
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Awaitable, Callable, Optional
 
 _AUDIT_DIR = Path.home() / ".virtuai"
 
@@ -20,6 +20,10 @@ from virtuai_cli import __version__
 from virtuai_cli import executor as exec_
 from virtuai_cli.security import resolve_workdir
 
+# Callback the TUI uses to capture connection events (level, message) instead
+# of printing to stdout (which would scramble the Textual screen).
+StatusCallback = Callable[[str, str], None]
+
 logger = logging.getLogger(__name__)
 console = Console()
 
@@ -38,7 +42,12 @@ def _audit(workdir: Path, command: str, exit_code: int, elapsed: float) -> None:
 _RECONNECT_DELAYS = [1, 2, 4, 8, 16, 30]  # backoff steps
 
 
-async def _handle_frame(frame: dict, workdir: Path, ws) -> None:
+def _default_on_status(level: str, msg: str) -> None:
+    style = {"info": "green", "warn": "yellow", "error": "red"}.get(level, "")
+    console.print(f"[{style}]{msg}[/{style}]" if style else msg)
+
+
+async def _handle_frame(frame: dict, workdir: Path, ws, on_status: StatusCallback) -> None:
     """Dispatch a server frame and send the result back."""
     ftype = frame.get("type")
     fid = frame.get("id")
@@ -55,7 +64,7 @@ async def _handle_frame(frame: dict, workdir: Path, ws) -> None:
             "workdir": str(workdir),
         }
         await ws.send(json.dumps(reply))
-        console.print(f"[green]Connected.[/green] Workdir: [bold]{workdir}[/bold]")
+        on_status("info", f"Connected. Workdir: {workdir}")
         return
 
     if ftype == "ping":
@@ -65,7 +74,8 @@ async def _handle_frame(frame: dict, workdir: Path, ws) -> None:
     if ftype == "execute":
         command = frame.get("command", "")
         timeout = int(frame.get("timeout_secs", 300))
-        console.print(f"[dim]exec:[/dim] {command[:80]}{'...' if len(command) > 80 else ''}")
+        preview = command[:80] + ("..." if len(command) > 80 else "")
+        on_status("exec", preview)
         t0 = time.monotonic()
         loop = asyncio.get_event_loop()
         result = await loop.run_in_executor(
@@ -97,7 +107,7 @@ async def _handle_frame(frame: dict, workdir: Path, ws) -> None:
         return
 
     if ftype == "shutdown":
-        console.print(f"[yellow]Server requested shutdown:[/yellow] {frame.get('reason', '')}")
+        on_status("warn", f"Server requested shutdown: {frame.get('reason', '')}")
         raise SystemExit(0)
 
 
@@ -114,8 +124,14 @@ def _ssl_context():
     return ctx
 
 
-async def run_session(ws_url: str, token: str, workdir: Path) -> None:
+async def run_session(
+    ws_url: str,
+    token: str,
+    workdir: Path,
+    on_status: Optional[StatusCallback] = None,
+) -> None:
     """Run a single connected session until the WebSocket closes."""
+    on_status = on_status or _default_on_status
     url = f"{ws_url}?token={token}"
     # Use certifi CA bundle for SSL so WSS works on macOS without the
     # 'Install Certificates.command' workaround.
@@ -126,30 +142,40 @@ async def run_session(ws_url: str, token: str, workdir: Path) -> None:
         async for raw in ws:
             try:
                 frame = json.loads(raw)
-                await _handle_frame(frame, workdir, ws)
+                await _handle_frame(frame, workdir, ws, on_status)
             except SystemExit:
                 raise
             except Exception as exc:
                 logger.warning("Frame handling error: %s", exc)
 
 
-async def run_forever(server_url: str, token: str, workdir: Path) -> None:
-    """Connect with exponential backoff, reconnecting on drop."""
+async def run_forever(
+    server_url: str,
+    token: str,
+    workdir: Path,
+    on_status: Optional[StatusCallback] = None,
+) -> None:
+    """Connect with exponential backoff, reconnecting on drop.
+
+    Pass `on_status` to redirect connection messages to a TUI/log sink
+    instead of printing to stdout (which would scramble a Textual screen).
+    """
+    on_status = on_status or _default_on_status
     ws_url = server_url.rstrip("/").replace("https://", "wss://").replace("http://", "ws://")
     ws_url = f"{ws_url}/api/cli/ws"
 
     workdir.mkdir(parents=True, exist_ok=True)
-    console.print(f"Connecting to [bold]{server_url}[/bold] …")
+    on_status("info", f"Connecting to {server_url} ...")
 
     attempt = 0
     while True:
         try:
-            await run_session(ws_url, token, workdir)
+            await run_session(ws_url, token, workdir, on_status)
             attempt = 0  # successful session resets backoff
         except SystemExit:
             return
         except Exception as exc:
             delay = _RECONNECT_DELAYS[min(attempt, len(_RECONNECT_DELAYS) - 1)]
-            console.print(f"[red]Disconnected:[/red] {exc}. Retrying in {delay}s …")
+            on_status("error", f"Disconnected: {exc}. Retrying in {delay}s ...")
             await asyncio.sleep(delay)
             attempt += 1

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -14,10 +14,12 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: websockets>=12.0
 Requires-Dist: httpx[http2]>=0.27
+Requires-Dist: httpx-sse>=0.4
 Requires-Dist: certifi>=2024.0
 Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.50
 
 # VirtuAI CLI
 

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli.egg-info/SOURCES.txt

@@ -11,4 +11,9 @@ src/virtuai_cli.egg-info/SOURCES.txt
 src/virtuai_cli.egg-info/dependency_links.txt
 src/virtuai_cli.egg-info/entry_points.txt
 src/virtuai_cli.egg-info/requires.txt
-src/virtuai_cli.egg-info/top_level.txt
+src/virtuai_cli.egg-info/top_level.txt
+src/virtuai_cli/chat/__init__.py
+src/virtuai_cli/chat/command.py
+src/virtuai_cli/chat/sse.py
+src/virtuai_cli/chat/tui.py
+src/virtuai_cli/chat/widgets.py

{virtuai_cli-0.1.0 → virtuai_cli-0.2.0}/src/virtuai_cli.egg-info/requires.txt

@@ -1,6 +1,8 @@
 websockets>=12.0
 httpx[http2]>=0.27
+httpx-sse>=0.4
 certifi>=2024.0
 keyring>=25.0
 typer>=0.12
 rich>=13.0
+textual>=0.50