virtuai-cli 0.9.0__tar.gz → 1.0.0__tar.gz

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.9.0
+Version: 1.0.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.9.0"
+version = "1.0.0"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.9.0"
+__version__ = "1.0.0"

virtuai_cli-1.0.0/src/virtuai_cli/pull.py

@@ -0,0 +1,335 @@
+"""The runner pulls its work over HTTPS instead of holding a WebSocket.
+
+CLI 1.0, phase 3 of docs/workitems/cli-http-transport.md, after the worker in
+Claude Managed Agents' self-hosted sandboxes: the server never calls this
+machine. The runner says hello, keeps one request open asking for work,
+acknowledges each job as it starts it, heartbeats while it runs — carrying
+the output so far and learning whether the caller gave up — and posts the
+result.
+
+A job is the same frame the socket used to carry, so it runs through the same
+handler (runner._handle_frame / runner._spawn) with the same session order,
+concurrency limits and path jails. Only where its replies go changes: a
+_JobSocket collects what the handler would have sent down the WebSocket.
+
+A server that does not offer this answers the hello with 404; run_pull then
+raises PullUnavailable and the caller uses the WebSocket, so a 1.0 runner
+works against any server.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Callable, Optional
+
+import httpx
+
+from virtuai_cli import runner
+
+logger = logging.getLogger(__name__)
+
+_HEARTBEAT_SECONDS = 5.0
+#: Output is sent this often while there is some, so a stream reads as one.
+_FLUSH_SECONDS = 0.25
+_RETRY_DELAYS = (1, 2, 5, 10, 20, 30)
+#: How long a finished job keeps trying to hand in its result.
+_RESULT_RETRY_SECONDS = 120.0
+#: Past this many jobs in hand, wait for some to finish before asking for more.
+_MAX_IN_HAND = 16
+
+#: Output that goes back while a job runs. Only model tokens: the server
+#: reads a model's stream as it grows, but nothing reads execute_output (the
+#: socket router drops it too), and forwarding it put every command's output
+#: through Redis twice — 1 MB commands filled dev's Redis in the benchmark.
+_STREAM_TYPES = {"model_token"}
+#: Output a handler sends that is dropped rather than forwarded.
+_LOCAL_ONLY_TYPES = {"execute_output"}
+#: This many 404s in a row on the work endpoint means the server turned pull
+#: off (VIRTUAI_CLI_PULL unset); fall back to the socket rather than retry
+#: forever. One or two can be a rolling deploy reaching an older pod.
+_GONE_AFTER_404S = 5
+#: Job ids remembered, so a job delivered twice is only taken once.
+_SEEN_MAX = 2_000
+
+
+class PullUnavailable(Exception):
+    """The server does not offer pull; use the WebSocket."""
+
+
+class TokenRejected(Exception):
+    """The server rejected this runner's token.
+
+    Not PermissionError: that is an OSError, which the network retries catch —
+    a revoked token was retried forever.
+    """
+
+
+class _JobSocket:
+    """Stands in for the WebSocket: output is kept for the heartbeat, the reply ends the job."""
+
+    def __init__(self):
+        self.events: list[dict] = []
+        self.final: Optional[dict] = None
+        self.done = asyncio.Event()
+        self.flush = asyncio.Event()
+
+    async def send(self, raw: str) -> None:
+        msg = json.loads(raw)
+        if msg.get("type") in _LOCAL_ONLY_TYPES:
+            return
+        if msg.get("type") in _STREAM_TYPES:
+            self.events.append(msg)
+            self.flush.set()
+        elif self.final is None:
+            self.final = msg
+            self.done.set()
+
+    def take_events(self) -> list[dict]:
+        events, self.events = self.events, []
+        self.flush.clear()
+        return events
+
+
+async def _wait(event: asyncio.Event, timeout: float) -> None:
+    try:
+        await asyncio.wait_for(event.wait(), timeout=timeout)
+    except asyncio.TimeoutError:
+        pass
+
+
+async def _wait_any(events, timeout: float) -> None:
+    waiters = [asyncio.ensure_future(e.wait()) for e in events]
+    try:
+        await asyncio.wait(waiters, timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
+    finally:
+        for w in waiters:
+            w.cancel()
+
+
+class _Session:
+    def __init__(self, server_url: str, token: str, workdir: Path,
+                 on_status: Callable, on_output: Optional[Callable], kind: str):
+        import certifi
+
+        self.workdir = workdir
+        self.on_status = on_status
+        self.on_output = on_output
+        self.kind = kind
+        self.runner_id: Optional[str] = None
+        self.wait = 25
+        self.heartbeat = _HEARTBEAT_SECONDS
+        self.jobs: set = set()
+        self.seen: dict = {}  # job id -> time seen; insertion-ordered, trimmed
+        self.stopping: Optional[BaseException] = None
+        self.stop = asyncio.Event()
+        self.http = httpx.AsyncClient(
+            base_url=server_url.rstrip("/"),
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=httpx.Timeout(10.0, read=40.0),
+            verify=certifi.where(),
+        )
+
+    # -- registration ------------------------------------------------------
+
+    async def hello(self) -> None:
+        body = {
+            "kind": self.kind,
+            "previous_runner_id": self.runner_id,
+            "ready": await runner._ready_payload(self.workdir),
+        }
+        resp = await self.http.post("/api/cli/v2/hello", json=body)
+        if resp.status_code == 404:
+            raise PullUnavailable()
+        if resp.status_code == 401:
+            raise TokenRejected("the server rejected this runner's token; pair it again")
+        resp.raise_for_status()
+        data = resp.json()
+        self.runner_id = data["runner_id"]
+        self.wait = int(data.get("wait_seconds", self.wait))
+        self.heartbeat = float(data.get("heartbeat_seconds", self.heartbeat))
+        self.on_status("info", f"Connected (pull). Workdir: {self.workdir}")
+
+    async def bye(self) -> None:
+        if not self.runner_id:
+            return
+        try:
+            await self.http.post(f"/api/cli/v2/runners/{self.runner_id}/bye", timeout=5.0)
+        except Exception:
+            pass
+
+    # -- the loop ----------------------------------------------------------
+
+    async def serve(self) -> None:
+        attempt = 0
+        not_found = 0
+        while True:
+            if self.stopping is not None:
+                raise self.stopping
+            if len(self.jobs) >= _MAX_IN_HAND:
+                await asyncio.wait(self.jobs, return_when=asyncio.FIRST_COMPLETED)
+                continue
+            try:
+                # The poll can wait 25 s; a shutdown must not wait with it.
+                poll = asyncio.ensure_future(self.http.get(
+                    f"/api/cli/v2/runners/{self.runner_id}/work",
+                    params={"max": max(1, _MAX_IN_HAND - len(self.jobs)), "wait": self.wait},
+                ))
+                stopper = asyncio.ensure_future(self.stop.wait())
+                await asyncio.wait({poll, stopper}, return_when=asyncio.FIRST_COMPLETED)
+                stopper.cancel()
+                if self.stopping is not None:
+                    poll.cancel()
+                    raise self.stopping
+                resp = poll.result()
+                if resp.status_code == 410:
+                    # The server no longer knows this runner (it expired, or
+                    # Redis lost it): register again and carry on.
+                    await self.hello()
+                    continue
+                if resp.status_code == 401:
+                    raise TokenRejected("the server rejected this runner's token; pair it again")
+                if resp.status_code == 404:
+                    not_found += 1
+                    if not_found >= _GONE_AFTER_404S:
+                        raise PullUnavailable()
+                    await asyncio.sleep(1)
+                    continue
+                resp.raise_for_status()
+                attempt = 0
+                not_found = 0
+            except (httpx.HTTPError, OSError) as exc:
+                delay = _RETRY_DELAYS[min(attempt, len(_RETRY_DELAYS) - 1)]
+                self.on_status("error", f"Could not reach the server: {exc}. Retrying in {delay}s ...")
+                await asyncio.sleep(delay)
+                attempt += 1
+                continue
+            for job in resp.json().get("jobs", []):
+                key = job.get("job_id") or job.get("id")
+                if key in self.seen:
+                    # Delivered again while its first copy is still ours: the
+                    # server's acknowledgement decides, and ours already went.
+                    continue
+                self._remember(key)
+                task = asyncio.ensure_future(self._run(job))
+                self.jobs.add(task)
+                task.add_done_callback(self.jobs.discard)
+
+    def _remember(self, job_id) -> None:
+        self.seen[job_id] = time.monotonic()
+        while len(self.seen) > _SEEN_MAX:
+            self.seen.pop(next(iter(self.seen)))
+
+    async def _run(self, job: dict) -> None:
+        # The job's id addresses the queue; the frame's id is what the
+        # handler answers with, as it would over a socket.
+        job_id, entry = job.pop("job_id", None) or job.get("id"), job.pop("_entry", None)
+        base = f"/api/cli/v2/runners/{self.runner_id}/jobs/{job_id}"
+        start = None
+        for attempt in range(3):
+            try:
+                resp = await self.http.post(f"{base}/ack", json={"entry": entry})
+                if resp.status_code == 200:
+                    start = bool(resp.json().get("start"))
+                    break
+            except Exception as exc:
+                logger.warning("Could not acknowledge job %s: %s", job_id, exc)
+            await asyncio.sleep(0.5 * (attempt + 1))
+        if not start:
+            # Not acknowledged: the server delivers it again. Acknowledged by
+            # another delivery: that one runs it. Either way, not this one.
+            if start is None:
+                self.seen.pop(job_id, None)  # let its redelivery through
+            return
+
+        sock = _JobSocket()
+        task: Optional[asyncio.Task] = None
+        if job.get("type") in runner._INLINE_TYPES:
+            # browser_action starts its own task. shutdown raises SystemExit,
+            # which inside this task would end nothing (a task keeps its
+            # exception): hand it to the loop in serve() instead.
+            try:
+                await runner._handle_frame(job, self.workdir, sock, self.on_status, self.on_output)
+            except SystemExit as exc:
+                sock.final = {"v": 1, "id": job.get("id"), "type": "error", "error": "the runner is shutting down"}
+                sock.done.set()
+                self.stopping = exc
+                self.stop.set()
+        else:
+            task = runner._spawn(job, self.workdir, sock, self.on_status, self.on_output)
+
+        last_beat = time.monotonic()
+        while not sock.done.is_set():
+            if task is not None and task.done():
+                break  # the handler ended without a reply; answer for it below
+            if sock.events:
+                # Let a little more output gather — but the moment the job
+                # ends, its output goes with the result instead.
+                await _wait(sock.done, _FLUSH_SECONDS)
+            else:
+                await _wait_any((sock.done, sock.flush),
+                                max(0.05, self.heartbeat - (time.monotonic() - last_beat)))
+                if not sock.events and time.monotonic() - last_beat < self.heartbeat:
+                    continue
+            if sock.done.is_set():
+                break
+            try:
+                reply = await self.http.post(f"{base}/heartbeat", json={"events": sock.take_events()})
+                last_beat = time.monotonic()
+                if reply.status_code == 200 and reply.json().get("cancel"):
+                    self.on_status("warn", f"Job {job_id} cancelled by the server")
+                    if task is not None:
+                        task.cancel()
+                    sock.final = sock.final or runner._busy_reply(job, "cancelled by the server") or {
+                        "v": 1, "id": job.get("id"), "type": "error", "error": "cancelled by the server"}
+                    sock.done.set()
+            except Exception as exc:
+                logger.debug("Heartbeat for %s failed: %s", job_id, exc)
+
+        final = sock.final or runner._busy_reply(job, "the runner finished this request without a reply") or {
+            "v": 1, "id": job.get("id"), "type": "error", "error": "no reply"}
+        # The work is done; losing its result now would waste it. Keep trying
+        # through a deploy or a network blip — every replica can take it —
+        # for as long as the caller could still be waiting.
+        deadline = time.monotonic() + _RESULT_RETRY_SECONDS
+        events = sock.take_events()
+        attempt = 0
+        while True:
+            try:
+                resp = await self.http.post(f"{base}/result", json={"result": final, "events": events})
+                if resp.status_code < 500:
+                    return
+            except Exception as exc:
+                logger.warning("Could not post the result of %s: %s", job_id, exc)
+            if time.monotonic() >= deadline:
+                logger.error("Gave up posting the result of %s after %.0f s", job_id, _RESULT_RETRY_SECONDS)
+                return
+            await asyncio.sleep(min(5.0, 0.5 * 2 ** attempt))
+            attempt += 1
+
+
+async def run_pull(server_url: str, token: str, workdir: Path,
+                   on_status: Callable, on_output: Optional[Callable] = None,
+                   *, kind: str = "host") -> None:
+    """Serve work until the process ends. Raises PullUnavailable on an old server."""
+    session = _Session(server_url, token, workdir, on_status, on_output, kind)
+    try:
+        attempt = 0
+        while True:
+            try:
+                await session.hello()
+                break
+            except (PullUnavailable, TokenRejected):
+                raise
+            except (httpx.HTTPError, OSError) as exc:
+                delay = _RETRY_DELAYS[min(attempt, len(_RETRY_DELAYS) - 1)]
+                on_status("error", f"Could not reach the server: {exc}. Retrying in {delay}s ...")
+                await asyncio.sleep(delay)
+                attempt += 1
+        await session.serve()
+    finally:
+        await session.bye()
+        await session.http.aclose()

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/src/virtuai_cli/runner.py

@@ -470,6 +470,40 @@ async def _reap(proc) -> None:
         exec_.untrack_group(proc.pid)
 
 
+async def _ready_payload(workdir: Path) -> dict:
+    """What this runner reports about itself: in its ready frame, or its hello."""
+    return {
+        "cli_version": __version__,
+        "os": platform.system(),
+        "arch": platform.machine(),
+        # The server only ever recorded a fingerprint at pairing time, so a
+        # container reusing a stored token reported the machine that paired
+        # months ago. Reporting it on every ready frame keeps the row honest.
+        "host": socket.gethostname(),
+        "python": f"{sys.version_info.major}.{sys.version_info.minor}",
+        "workdir": str(workdir),
+        # Lets the server and the portal tell a shared runner apart from a
+        # personal one without guessing from the hostname.
+        "isolate_sessions": _isolation_enabled(),
+        # Which person this runner serves, when it serves exactly one.
+        #
+        # A browser session is one person's — their Chrome, their profile,
+        # their signed-in accounts. The server used to pick the newest
+        # connection for a workspace, which is right while there is one
+        # runner and wrong the moment a workspace has a sandbox per person:
+        # the action lands in whoever connected last. Reporting this lets
+        # the server route by owner instead of by recency.
+        #
+        # Empty for a laptop or a shared container, which serve anyone —
+        # that is the pre-per-person deployment and stays supported.
+        "sandbox_owner": _sandbox_owner(),
+        "local_skills": _read_local_skills(workdir),
+        "local_memory": _read_local_memory(workdir),
+        "ollama": await _probe_ollama(),
+        "browser": _probe_browser(),
+    }
+
+
 async def _handle_frame(
     frame: dict,
     workdir: Path,
@@ -482,39 +516,7 @@ async def _handle_frame(
     fid = frame.get("id")
 
     if ftype == "hello":
-        reply = {
-            "v": 1,
-            "id": fid,
-            "type": "ready",
-            "cli_version": __version__,
-            "os": platform.system(),
-            "arch": platform.machine(),
-            # The server only ever recorded a fingerprint at pairing time, so a
-            # container reusing a stored token reported the machine that paired
-            # months ago. Reporting it on every ready frame keeps the row honest.
-            "host": socket.gethostname(),
-            "python": f"{sys.version_info.major}.{sys.version_info.minor}",
-            "workdir": str(workdir),
-            # Lets the server and the portal tell a shared runner apart from a
-            # personal one without guessing from the hostname.
-            "isolate_sessions": _isolation_enabled(),
-            # Which person this runner serves, when it serves exactly one.
-            #
-            # A browser session is one person's — their Chrome, their profile,
-            # their signed-in accounts. The server used to pick the newest
-            # connection for a workspace, which is right while there is one
-            # runner and wrong the moment a workspace has a sandbox per person:
-            # the action lands in whoever connected last. Reporting this lets
-            # the server route by owner instead of by recency.
-            #
-            # Empty for a laptop or a shared container, which serve anyone —
-            # that is the pre-per-person deployment and stays supported.
-            "sandbox_owner": _sandbox_owner(),
-            "local_skills": _read_local_skills(workdir),
-            "local_memory": _read_local_memory(workdir),
-            "ollama": await _probe_ollama(),
-            "browser": _probe_browser(),
-        }
+        reply = {"v": 1, "id": fid, "type": "ready", **(await _ready_payload(workdir))}
         await ws.send(json.dumps(reply))
         on_status("info", f"Connected. Workdir: {workdir}")
         return
@@ -895,19 +897,24 @@ def _work_task_done(task: asyncio.Task) -> None:
         logger.warning("Frame handling error: %s", exc)
 
 
-def _spawn(frame: dict, workdir: Path, ws, on_status, on_output) -> None:
-    """Hand a frame to a task, or refuse it while we still can answer."""
+def _spawn(frame: dict, workdir: Path, ws, on_status, on_output) -> Optional[asyncio.Task]:
+    """Hand a frame to a task, or refuse it while we still can answer.
+
+    Returns the task, or None when refused: the pull transport cancels it
+    when the server says the caller gave up (virtuai_cli/pull.py).
+    """
     if len(_WORK_TASKS) >= _int_env("VIRTUAI_MAX_QUEUED_FRAMES", _MAX_QUEUED_FRAMES):
         reply = _busy_reply(frame, "the runner has too many requests queued")
         if reply is not None:
             asyncio.ensure_future(_safe_send(ws, reply))
         logger.warning("Refused a %r frame: %d already queued",
                        frame.get("type"), len(_WORK_TASKS))
-        return
+        return None
     task = asyncio.ensure_future(_dispatch(frame, workdir, ws, on_status, on_output))
     _WORK_TASKS.add(task)
     _TASK_PHASE[task] = "queued"
     task.add_done_callback(_work_task_done)
+    return task
 
 
 async def _run_browser_action(frame: dict, ws, on_status: StatusCallback) -> None:
@@ -1079,6 +1086,22 @@ async def run_forever(
 
     attempt = 0
     try:
+        # Pull first (virtuai_cli/pull.py): the server never has to reach
+        # this machine. A server that does not offer it answers 404, and the
+        # socket below is the fallback. VIRTUAI_TRANSPORT=socket skips pull.
+        if os.environ.get("VIRTUAI_TRANSPORT", "auto").strip().lower() != "socket":
+            from virtuai_cli import pull
+
+            try:
+                await pull.run_pull(server_url, token, workdir, on_status, on_output)
+                return
+            except pull.PullUnavailable:
+                on_status("info", "The server does not offer pull; using the WebSocket.")
+            except pull.TokenRejected as exc:
+                # The socket below retries with backoff, as it always has.
+                on_status("error", str(exc))
+            except SystemExit:
+                return
         while True:
             try:
                 await run_session(ws_url, token, workdir, on_status, on_output)

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.9.0
+Version: 1.0.0
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/src/virtuai_cli.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/virtuai_cli/config.py
 src/virtuai_cli/executor.py
 src/virtuai_cli/main.py
 src/virtuai_cli/opencode.py
+src/virtuai_cli/pull.py
 src/virtuai_cli/runner.py
 src/virtuai_cli/security.py
 src/virtuai_cli.egg-info/PKG-INFO

{virtuai_cli-0.9.0 → virtuai_cli-1.0.0}/tests/test_browser.py

@@ -1215,6 +1215,9 @@ def test_cli_shutdown_closes_the_browser(monkeypatch):
         closed.append(True)
 
     monkeypatch.setattr(B, "close_all_sessions", track)
+    # The socket path: CLI 1.0 otherwise tries pull first, against a server
+    # that does not exist, and keeps retrying.
+    monkeypatch.setenv("VIRTUAI_TRANSPORT", "socket")
 
     async def go():
         async def bye(*a, **kw):