contree-cli 0.7.1__tar.gz → 0.8.0__tar.gz

{contree_cli-0.7.1 → contree_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: contree-cli
-Version: 0.7.1
+Version: 0.8.0
 Summary: CLI client for the ConTree sandbox platform
 Keywords: sandbox,cli,vm,ai-agent,contree
 Author: Dmitry Orlov

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/cli/operation.py

@@ -13,6 +13,7 @@ Subcommands:
 from __future__ import annotations
 
 import argparse
+import contextlib
 import itertools
 import json
 import logging
@@ -21,7 +22,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any
 
-from contree_cli import CLIENT, FORMATTER, ArgumentsProtocol, SetupResult
+from contree_cli import CLIENT, FORMATTER, SESSION_STORE, ArgumentsProtocol, SetupResult
 from contree_cli.cli.show import ShowArgs, cmd_show
 from contree_cli.client import ApiError, ContreeClient, PaginatedFetcher
 from contree_cli.output import OutputFormatter
@@ -496,11 +497,23 @@ def cmd_wait(args: WaitArgs) -> int | None:
     exit_status = 0
     sleep_time = 0.5
 
+    # Op cache is best-effort — `wait` doesn't strictly need the
+    # session store, and the cmd is reachable from contexts that don't
+    # set one (e.g. standalone scripts).
+    try:
+        store = SESSION_STORE.get()
+    except LookupError:
+        store = None
+
     while pending and time.monotonic() < deadline:
         for uuid in list(pending):
             resp = client.get(f"/v1/operations/{uuid}")
             op = json.loads(resp.read())
+
             if op.get("status") in TERMINAL_STATUSES:
+                if store is not None:
+                    with contextlib.suppress(Exception):
+                        store.cache[(uuid, "operation")] = op
                 pending.discard(uuid)
                 exit_code = extract_exit_code(op)
                 formatter(

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/cli/run.py

@@ -48,6 +48,7 @@ from __future__ import annotations
 
 import argparse
 import base64
+import contextlib
 import fnmatch
 import functools
 import io
@@ -62,9 +63,18 @@ import time
 import uuid
 from dataclasses import dataclass, field
 from multiprocessing.pool import ThreadPool
+from typing import Any
 
 from contree_cli import CLIENT, FORMATTER, SESSION_STORE, ArgumentsProtocol, SetupResult
-from contree_cli.client import ApiError, ContreeClient, decode_stream, resolve_image
+from contree_cli.client import (
+    RETRYABLE_NETWORK_ERRORS,
+    ApiError,
+    ContreeClient,
+    decode_event_chunk,
+    decode_stream,
+    iter_sse_events,
+    resolve_image,
+)
 from contree_cli.mapped_file import MAPPING_RULES, MappedFile
 from contree_cli.output import (
     DefaultFormatter,
@@ -505,11 +515,227 @@ def _build_payload(
     return payload
 
 
+TERMINAL_OP_STATUSES = frozenset({"SUCCESS", "FAILED", "CANCELLED"})
+
+
+@dataclass
+class TerminalSummary:
+    """Authoritative end-of-stream snapshot built from the SSE events
+    themselves — `cmd_run` consumes this directly instead of doing a
+    second ``GET /operations/{uuid}``.
+
+    If SSE ends without a `completion` frame but a between-attempt GET
+    detects the op is already terminal, the full op dict lands in
+    ``fallback_op`` so `cmd_run` can use it directly."""
+
+    completion: dict[str, Any] | None = None
+    exit_event: dict[str, Any] | None = None
+    stdout: bytearray = field(default_factory=bytearray)
+    stderr: bytearray = field(default_factory=bytearray)
+    fallback_op: dict[str, Any] | None = None
+
+
+def _check_terminal_via_get(
+    client: ContreeClient, op_uuid: str, summary: TerminalSummary
+) -> bool:
+    """Poll `GET /v1/operations/{uuid}`; if the op is in a terminal
+    status, park the full response on ``summary.fallback_op`` and
+    return True.  Any GET failure or non-terminal status returns False
+    so the caller keeps retrying SSE."""
+    try:
+        resp = client.request("GET", f"/v1/operations/{op_uuid}")
+        op = json.loads(resp.read())
+    except (ApiError, ValueError) as exc:
+        logger.debug("terminal check GET failed: %s", exc)
+        return False
+    except RETRYABLE_NETWORK_ERRORS as exc:
+        logger.debug("terminal check GET failed: %s", exc)
+        return False
+    if isinstance(op, dict) and op.get("status") in TERMINAL_OP_STATUSES:
+        summary.fallback_op = op
+        return True
+    return False
+
+
+TIGHT_LOOP_FLOOR = 0.5
+
+
+def _stream_events_until_close(
+    client: ContreeClient,
+    op_uuid: str,
+    formatter: OutputFormatter,
+) -> TerminalSummary:
+    """Open `follow=1` SSE for *op_uuid* and write events to stdio,
+    transparently resuming on network drops / mid-stream errors using
+    ``Last-Event-Id`` for replay-free continuation.
+
+    For ``DefaultFormatter``: ``stdout`` / ``stderr`` events go to
+    ``sys.std*.buffer`` directly so the user sees output as it arrives.
+    For JSON formatters: data goes to ``log.debug`` so the JSON output
+    isn't polluted, but the chunks are accumulated into the returned
+    ``TerminalSummary`` so the caller can render full stdout/stderr
+    without a follow-up GET.
+
+    Loops until one of: `completion` event received, GET-detected
+    terminal status, ``BrokenPipeError`` from a local stdio write, or
+    ``KeyboardInterrupt``.  Backoff between attempts is delegated to
+    ``client.request`` — every SSE reconnect goes through its
+    ``RETRY_DELAYS`` ladder before raising, so an extra streamer-level
+    ramp would double up.  The one floor kept here (``TIGHT_LOOP_FLOOR``)
+    only kicks in when a cycle made no forward progress, guarding
+    against a server that returns immediate empty streams for an
+    executing op.
+
+    ``BrokenPipeError`` from a local stdio write propagates unchanged —
+    it means the shell pipe closed and retrying cannot help; the
+    caller cancels the op and exits.
+    """
+    is_default = isinstance(formatter, DefaultFormatter)
+    last_id: int = -1
+    summary = TerminalSummary()
+
+    while True:
+        headers: dict[str, str] | None = None
+        if last_id >= 0:
+            headers = {"Last-Event-Id": str(last_id)}
+        try:
+            resp = client.request(
+                "GET",
+                f"/v1/operations/{op_uuid}/events?follow=1",
+                headers=headers,
+            )
+        except ApiError as exc:
+            logger.debug("SSE connect failed after client retries: %s", exc)
+            if _check_terminal_via_get(client, op_uuid, summary):
+                return summary
+            continue
+        except RETRYABLE_NETWORK_ERRORS as exc:
+            logger.debug("SSE connect network error after client retries: %s", exc)
+            if _check_terminal_via_get(client, op_uuid, summary):
+                return summary
+            continue
+
+        events_before = last_id
+        try:
+            for ev in iter_sse_events(resp):
+                ev_id = ev.get("id")
+                if isinstance(ev_id, int):
+                    last_id = ev_id
+                ev_type = ev.get("type")
+                data = ev.get("data")
+                match ev_type:
+                    case "stdout":
+                        chunk = decode_event_chunk(data)
+                        summary.stdout.extend(chunk)
+                        if is_default:
+                            sys.stdout.buffer.write(chunk)
+                            sys.stdout.buffer.flush()
+                    case "stderr":
+                        chunk = decode_event_chunk(data)
+                        summary.stderr.extend(chunk)
+                        if is_default:
+                            sys.stderr.buffer.write(chunk)
+                            sys.stderr.buffer.flush()
+                    case "exit":
+                        # spid=1 is the main process — its exit code/timed_out
+                        # drive the CLI's own exit code.
+                        if ev.get("spid") == 1:
+                            summary.exit_event = ev
+                        logger.debug("event: %s", ev)
+                    case "sse_error":
+                        logger.warning(
+                            "server-side stream error (last_id=%s): %s",
+                            last_id,
+                            ev.get("message"),
+                        )
+                    case "completion":
+                        # Authoritative terminal frame — don't wait for the server
+                        # to close, return the summary for the caller.
+                        summary.completion = ev
+                        logger.debug("event: %s", ev)
+                        return summary
+                    case _:
+                        logger.debug("event: %s", ev)
+        except BrokenPipeError:
+            # Local stdout/stderr was closed by the shell (e.g. piping
+            # into `head`).  Retrying cannot help — the caller cancels
+            # the op and exits.
+            raise
+        except RETRYABLE_NETWORK_ERRORS as exc:
+            logger.debug("SSE stream broken (last_id=%s): %s", last_id, exc)
+        finally:
+            with contextlib.suppress(Exception):
+                resp.close()
+
+        if _check_terminal_via_get(client, op_uuid, summary):
+            return summary
+
+        # No forward progress this cycle → briefly floor the loop so a
+        # server that keeps returning immediate EOFs doesn't spin us.
+        if last_id == events_before:
+            time.sleep(TIGHT_LOOP_FLOOR)
+
+
+def _build_op_from_summary(op_uuid: str, summary: TerminalSummary) -> dict[str, Any]:
+    """Synthesize a `GET /operations/{uuid}` shape from the SSE terminal
+    summary — completion event drives status / error / duration / image
+    metadata; exit event drives exit_code + timed_out; stdout/stderr
+    are reassembled from the streamed chunks.
+
+    Lets `cmd_run` avoid a second HTTP round-trip on the happy path
+    while keeping the downstream `_display_operation` consumers
+    (default and JSON formatters) untouched."""
+    assert summary.completion is not None
+    completion_data = summary.completion.get("data") or {}
+    status = completion_data.get("status")
+    state: dict[str, Any] = {}
+    if summary.exit_event:
+        exit_data = summary.exit_event.get("data") or {}
+        if "code" in exit_data:
+            state["exit_code"] = int(exit_data["code"])
+        if "timed_out" in exit_data:
+            state["timed_out"] = bool(exit_data["timed_out"])
+    result_image_uuid = completion_data.get("result_image_uuid")
+    return {
+        "uuid": op_uuid,
+        "kind": "instance",
+        "status": status,
+        "error": completion_data.get("error"),
+        "duration": (completion_data.get("duration_ms") or 0) / 1000.0,
+        "image_size": completion_data.get("image_size_bytes"),
+        "result_image_uuid": result_image_uuid,
+        "metadata": {
+            "result": {
+                "stdout": {
+                    "value": bytes(summary.stdout).decode("utf-8", errors="replace"),
+                    "encoding": "ascii",
+                    "truncated": False,
+                },
+                "stderr": {
+                    "value": bytes(summary.stderr).decode("utf-8", errors="replace"),
+                    "encoding": "ascii",
+                    "truncated": False,
+                },
+                "state": state or None,
+            }
+        },
+        "result": {"image": result_image_uuid, "tag": None},
+    }
+
+
 def _display_operation(
     op: dict[str, object],
     formatter: OutputFormatter,
+    live_streamed: bool = False,
 ) -> None:
-    """Display an operation result using the given formatter."""
+    """Display an operation result using the given formatter.
+
+    ``live_streamed=True`` means the SSE path already wrote stdout/
+    stderr to stdio incrementally — DefaultFormatter then has nothing
+    left to print.  ``live_streamed=False`` is the GET-fallback path
+    (legacy server or aborted stream) — DefaultFormatter prints
+    sanitized stdout/stderr from the operation's metadata blob.
+    """
     result = op.get("result") or {}
     assert isinstance(result, dict)
     metadata = op.get("metadata") or {}
@@ -544,10 +770,14 @@ def _display_operation(
             "only json/json-pretty/default are supported"
         )
 
-    # For DefaultFormatter, just only print stdout/stderr
+    if live_streamed:
+        # stdout/stderr already streamed live via SSE — nothing more to print.
+        return
+
+    # Legacy / fallback path (no completion event received): print
+    # sanitized stdout/stderr from op metadata.
     stdout = _BREAKING_ESC_RE.sub("", decode_stream(instance_result.get("stdout")))
     stderr = _BREAKING_ESC_RE.sub("", decode_stream(instance_result.get("stderr")))
-
     if stdout:
         sys.stdout.write(stdout)
         if not stdout.endswith("\n"):
@@ -688,19 +918,27 @@ def cmd_run(args: RunArgs) -> int | None:
         formatter.flush()
         return None
 
-    # 5. Poll until terminal status
-    sleep_time = 0.5
+    # 5. Stream events (follow=1) — write stdout/stderr to stdtio as they
+    # come, log other events at debug, accumulate the terminal frame.
+    store = SESSION_STORE.get()
     try:
-        time.sleep(sleep_time)
-        sleep_time += sleep_time
-        while True:
+        summary = _stream_events_until_close(client, op_uuid, formatter)
+        if summary.completion is not None:
+            # Authoritative terminal frame from the server — build the
+            # full op dict from the SSE events themselves, no GET.
+            op = _build_op_from_summary(op_uuid, summary)
+        elif summary.fallback_op is not None:
+            # SSE couldn't deliver `completion`, but a GET between
+            # retries confirmed the op is terminal — use that dict.
+            op = summary.fallback_op
+        else:
+            # Safety net: streamer normally loops until either
+            # completion or a terminal GET, so this path is only hit
+            # in tests where the stub queue drains early.
             resp = client.get(f"/v1/operations/{op_uuid}")
             op = json.loads(resp.read())
-            if op["status"] in TERMINAL_STATUSES:
-                break
-            time.sleep(sleep_time)
-            if sleep_time < 5:
-                sleep_time += sleep_time
+        cache_key = (op_uuid, "operation")
+        store.cache[cache_key] = op
     except KeyboardInterrupt:
         try:
             client.delete(f"/v1/operations/{op_uuid}")
@@ -708,6 +946,17 @@ def cmd_run(args: RunArgs) -> int | None:
         except (ApiError, KeyboardInterrupt, OSError):
             pass
         raise
+    except BrokenPipeError:
+        # Local stdout/stderr was closed (e.g. `contree run | head`).
+        # Cancel the op, silence further stdio writes, then exit 141
+        # so callers see the SIGPIPE convention (128 + 13).
+        with contextlib.suppress(ApiError, OSError):
+            client.delete(f"/v1/operations/{op_uuid}")
+        with contextlib.suppress(OSError):
+            devnull = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull, sys.stdout.fileno())
+            os.close(devnull)
+        raise SystemExit(141) from None
 
     # 6. Cache terminal operation result
     store.cache[(op_uuid, "operation")] = op
@@ -735,7 +984,7 @@ def cmd_run(args: RunArgs) -> int | None:
         )
 
     # 7. Display result
-    _display_operation(op, formatter)
+    _display_operation(op, formatter, live_streamed=summary.completion is not None)
 
     result = op.get("result") or {}
     assert isinstance(result, dict)

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/cli/show.py

@@ -61,7 +61,7 @@ def cmd_show(args: ShowArgs) -> int | None:
 
     cache_key = (op_uuid, "operation")
     cached = store.cache.get(cache_key)
-    if cached is not None:
+    if isinstance(cached, dict) and cached.get("status") in TERMINAL:
         op = cast(dict[str, Any], cached)
     else:
         resp = client.get(f"/v1/operations/{op_uuid}")

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import base64
+import binascii
 import collections
 import contextlib
 import http.client
@@ -12,10 +13,12 @@ import socket
 import sys
 import threading
 import time
+import zlib
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Iterator
 from concurrent.futures import Future, ThreadPoolExecutor
-from importlib.metadata import PackageNotFoundError, version
+from contextlib import suppress
+from importlib.metadata import PackageNotFoundError, distribution
 from typing import IO, Any, cast
 from urllib.parse import urlencode, urlsplit
 
@@ -23,7 +26,33 @@ from contree_cli.config import AuthType, ConfigProfile
 
 log = logging.getLogger(__name__)
 
-RETRY_DELAYS = (1, 2, 4, 5, 10, 10, 10)
+RETRY_DELAYS = (0.1, 0.2, 0.5, 1, 2, 5)
+
+
+def retry_generator() -> Iterator[float]:
+    """Return a primed generator that yields successive backoff delays.
+
+    The first ``next(g)`` returns ``RETRY_DELAYS[0]``; subsequent calls
+    walk the ladder and, once exhausted, keep yielding the tail delay
+    forever.  Callers don't have to guard against ``StopIteration`` —
+    ``next(g)`` always returns a valid sleep time — and don't have to
+    do any index arithmetic to derive it.  A caller that wants a
+    finite retry budget bounds it externally (e.g. an attempt counter)."""
+
+    def gen() -> Iterator[float]:
+        # `yield 0` gives a caller who *doesn't* prime a clean way to
+        # sleep uniformly before every attempt (including the first,
+        # which is a no-op).  We prime here so callers who don't want
+        # that get the real first delay straight away.
+        yield 0
+        yield from RETRY_DELAYS
+        while True:
+            yield RETRY_DELAYS[-1]
+
+    g = gen()
+    next(g)
+    return g
+
 
 # Socket-level / connection-level errors that warrant a retry. DNS hiccups
 # (gaierror), refused/reset connections, and broken HTTP framing are all
@@ -38,9 +67,17 @@ RETRYABLE_NETWORK_ERRORS: tuple[type[BaseException], ...] = (
 
 def cli_version() -> str:
     try:
-        return version("contree-cli")
+        dist = distribution("contree-cli")
     except PackageNotFoundError:
         return "editable"
+    raw = dist.read_text("direct_url.json")
+    if raw:
+        try:
+            if json.loads(raw).get("dir_info", {}).get("editable"):
+                return "editable"
+        except ValueError:
+            pass
+    return dist.version
 
 
 CLI_USER_AGENT = (
@@ -138,6 +175,88 @@ class BodyFormatter:
         return f"<binary {len(data)}B>"
 
 
+class GzipResponse:
+    """Wrap an HTTPResponse, inflating `Content-Encoding: gzip` via
+    `zlib.decompressobj(wbits=31)` so Z_SYNC_FLUSH'd SSE frames decode
+    incrementally without buffering whole responses."""
+
+    def __init__(self, resp: http.client.HTTPResponse) -> None:
+        self.resp = resp
+        self.decomp = zlib.decompressobj(wbits=31)
+        self.buf = bytearray()
+        self.eof = False
+
+    def pump(self, want: int = -1) -> None:
+        while not self.eof and (want < 0 or len(self.buf) < want):
+            # read1() returns whatever's in the socket buffer after one
+            # underlying read; plain read(n) blocks for n bytes, which
+            # stalls SSE streaming because tiny frames never fill it.
+            chunk = self.resp.read1(8192)
+            if not chunk:
+                tail = self.decomp.flush()
+                if tail:
+                    self.buf.extend(tail)
+                self.eof = True
+                return
+            decoded = self.decomp.decompress(chunk)
+            if decoded:
+                self.buf.extend(decoded)
+
+    def read(self, amt: int | None = None) -> bytes:
+        if amt is None or amt < 0:
+            self.pump()
+            out = bytes(self.buf)
+            self.buf.clear()
+            return out
+        self.pump(amt)
+        out = bytes(self.buf[:amt])
+        del self.buf[:amt]
+        return out
+
+    def readline(self, limit: int = -1) -> bytes:
+        while True:
+            nl = self.buf.find(b"\n")
+            if nl >= 0:
+                end = nl + 1
+                if 0 <= limit < end:
+                    end = limit
+                out = bytes(self.buf[:end])
+                del self.buf[:end]
+                return out
+            if self.eof:
+                out = bytes(self.buf)
+                self.buf.clear()
+                return out
+            self.pump(want=len(self.buf) + 1)
+
+    def close(self) -> None:
+        with contextlib.suppress(Exception):
+            self.resp.close()
+
+    def getheader(self, name: str, default: str | None = None) -> str | None:
+        # Hide Content-Encoding so downstream readers don't try a
+        # second decompression; Content-Length is bogus post-inflate.
+        lname = name.lower()
+        if lname in ("content-encoding", "content-length"):
+            return default
+        return self.resp.getheader(name, default)
+
+    def getheaders(self) -> list[tuple[str, str]]:
+        return [
+            (k, v)
+            for k, v in self.resp.getheaders()
+            if k.lower() not in ("content-encoding", "content-length")
+        ]
+
+    @property
+    def status(self) -> int:
+        return self.resp.status
+
+    @property
+    def reason(self) -> str:
+        return self.resp.reason
+
+
 class BufferedResponse:
     """Replay an HTTPResponse from buffered bytes (for debug body logging)."""
 
@@ -221,6 +340,7 @@ class ContreeClient(ABC):
         merged: dict[str, str] = {
             **self._build_headers(),
             "User-Agent": CLI_USER_AGENT,
+            "Accept-Encoding": "gzip",
         }
         if body is not None:
             merged.setdefault("Content-Type", "application/json")
@@ -228,9 +348,6 @@ class ContreeClient(ABC):
             merged.update(headers)
 
         full_path = self._prefix + path
-        last_error: ApiError | None = None
-        last_network_error: BaseException | None = None
-        attempts = len(RETRY_DELAYS) + 1
 
         log.debug(
             "%s %s headers=%s body=%s",
@@ -240,25 +357,21 @@ class ContreeClient(ABC):
             BodyFormatter(body, content_type=merged.get("Content-Type", "")),
         )
 
-        for attempt in range(attempts):
-            if last_error is not None or last_network_error is not None:
-                delay = RETRY_DELAYS[attempt - 1]
-                if last_network_error is not None:
-                    log.warning(
-                        "Network error (%s), retrying in %ds…",
-                        type(last_network_error).__name__,
-                        delay,
-                    )
-                else:
-                    assert last_error is not None
-                    log.warning(
-                        "Server error %d, retrying in %ds…",
-                        last_error.status,
-                        delay,
-                    )
-                time.sleep(delay)
-
-            if attempt > 0 and hasattr(body, "seek"):
+        # Backoff delays come from a primed `retry_generator()` — each
+        # failure just calls `next(delays)` and gets the next value.
+        # The generator yields the tail delay forever, and there is no
+        # outer retry budget: transient errors are retried until either
+        # the server returns a non-retryable response or the user hits
+        # Ctrl+C.  Non-retryable 4xx responses raise immediately.
+        delays = retry_generator()
+
+        def sleep_for_retry(reason_fmt: str, *reason_args: object) -> None:
+            """Pull the next backoff delay, log the reason, sleep, and
+            rewind the request body if it's seekable."""
+            delay = next(delays)
+            log.warning(reason_fmt + " retrying in %ss…", *reason_args, delay)
+            time.sleep(delay)
+            if body is not None and hasattr(body, "seek"):
                 stream = cast(IO[bytes], body)
                 if not stream.seekable():
                     raise ApiError(
@@ -267,6 +380,8 @@ class ContreeClient(ABC):
                         "Cannot retry: streaming body is not seekable",
                     )
                 stream.seek(0)
+
+        while True:
             try:
                 conn = self._connect()
                 conn.request(method, full_path, body, merged)
@@ -278,13 +393,11 @@ class ContreeClient(ABC):
                 # would just spin through the back-off ladder for nothing.
                 raise
             except RETRYABLE_NETWORK_ERRORS as exc:
-                last_network_error = exc
-                last_error = None
+                sleep_for_retry("Network error (%s),", type(exc).__name__)
                 continue
 
-            # Successful round-trip clears the network-error trail so the
-            # final raise below doesn't pick up stale failure context.
-            last_network_error = None
+            if (resp.getheader("Content-Encoding", "") or "").lower() == "gzip":
+                resp = cast(http.client.HTTPResponse, GzipResponse(resp))
 
             if 200 <= resp.status < 300:
                 log.debug(
@@ -321,17 +434,12 @@ class ContreeClient(ABC):
             )
             error = ApiError(resp.status, resp.reason, resp_body)
 
-            if 500 <= resp.status < 600:
-                last_error = error
+            if resp.status in (410, 425) or 500 <= resp.status < 600:
+                sleep_for_retry("Server error %d,", resp.status)
                 continue
 
             raise error
 
-        if last_network_error is not None:
-            raise last_network_error
-        assert last_error is not None
-        raise last_error
-
     def log_and_buffer(
         self,
         method: str,
@@ -340,8 +448,10 @@ class ContreeClient(ABC):
     ) -> http.client.HTTPResponse:
         """Read & log a textual response body; pass binary streams through."""
         content_type = resp.getheader("Content-Type", "") or ""
+        # event-stream is line-streamed and unbounded — buffering it would block.
+        is_event_stream = "event-stream" in content_type
         textual = not content_type or "json" in content_type or "text" in content_type
-        if not textual:
+        if is_event_stream or not textual:
             log.debug(
                 "%s %s response body: <stream Content-Type=%r>",
                 method,
@@ -535,6 +645,73 @@ def stream_response(
         yield chunk
 
 
+def iter_sse_events(resp: http.client.HTTPResponse) -> Iterator[dict[str, object]]:
+    """Yield one dict per SSE frame.
+
+    Normal frames carry a JSON object in ``data:`` — that object is
+    yielded as-is.  Server-pushed error frames use ``event: sse_error``
+    with a plain-text ``data:`` body (the exception message) — those
+    surface as ``{"type": "sse_error", "message": <text>, "id": ...}``
+    so callers can log + decide whether to reconnect with
+    ``Last-Event-Id`` set to the last good id.
+    """
+    data_lines: list[str] = []
+    event_name: str | None = None
+    event_id: str | None = None
+
+    def emit() -> Iterator[dict[str, object]]:
+        nonlocal event_name, event_id
+        if not data_lines:
+            return
+        body = "\n".join(data_lines)
+        if event_name == "sse_error":
+            payload: dict[str, object] = {"type": "sse_error", "message": body}
+            if event_id is not None:
+                payload["id"] = event_id
+            yield payload
+        else:
+            with suppress(json.JSONDecodeError):
+                decoded = json.loads(body)
+                if isinstance(decoded, dict):
+                    yield decoded
+        data_lines.clear()
+        event_name = None
+        event_id = None
+
+    while True:
+        line_bytes = resp.readline()
+        if not line_bytes:
+            yield from emit()
+            return
+        line = line_bytes.decode("utf-8", errors="replace").rstrip("\r\n")
+        match line:
+            case "":
+                yield from emit()
+            case _ if line.startswith(":"):
+                pass  # SSE comment / keepalive
+            case _ if line.startswith("data:"):
+                data_lines.append(line[5:].lstrip(" "))
+            case _ if line.startswith("event:"):
+                event_name = line[6:].lstrip(" ").strip() or None
+            case _ if line.startswith("id:"):
+                event_id = line[3:].lstrip(" ").strip() or None
+
+
+def decode_event_chunk(data: object) -> bytes:
+    """Decode `{value, encoding}` event payload to raw bytes (ascii or base64)."""
+    if not isinstance(data, dict):
+        return b""
+    value = data.get("value", "")
+    if not isinstance(value, str) or not value:
+        return b""
+    encoding = data.get("encoding", "ascii")
+    if encoding == "base64":
+        with suppress(binascii.Error, ValueError):
+            return base64.b64decode(value)
+        return b""
+    return value.encode("utf-8", errors="replace")
+
+
 def decode_stream(stream: dict[str, object] | None) -> str:
     """Decode an API StreamRepr object to a string."""
     if not stream:

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/docker/kw_run.py

@@ -5,19 +5,22 @@ from __future__ import annotations
 import json
 import logging
 import shlex
-import time
 from dataclasses import dataclass, field
-from typing import ClassVar
+from typing import Any, ClassVar
 
+from contree_cli.cli.run import (
+    TERMINAL_OP_STATUSES,
+    _build_op_from_summary,
+    _stream_events_until_close,
+)
 from contree_cli.client import decode_stream
+from contree_cli.output import DefaultFormatter
 
 from .context import BuildContext
 from .keyword import DockerKeyword, parse_command_form
 
 logger = logging.getLogger(__name__)
 
-TERMINAL_STATUSES = frozenset({"SUCCESS", "FAILED", "CANCELLED"})
-
 
 @dataclass(frozen=True, repr=False)
 class RunKeyword(DockerKeyword):
@@ -91,33 +94,42 @@ class RunKeyword(DockerKeyword):
             payload["files"] = ctx.pending_files_payload()
 
         resp = ctx.client.post_json("/v1/instances", payload)
-        op = json.loads(resp.read())
-        op_uuid: str = op["uuid"]
+        spawn_op = json.loads(resp.read())
+        op_uuid: str = spawn_op["uuid"]
         logger.info(
             "RUN spawned op=%s: %s", op_uuid, display_title(parts, self.shell_form)
         )
 
-        op = poll(ctx, op_uuid)
+        op = stream_and_resolve(ctx, op_uuid)
         check_success(op, parts, self.shell_form)
         result = op.get("result") or {}
         assert isinstance(result, dict)
         new_image = result.get("image")
         if not new_image:
             raise RuntimeError("RUN succeeded but no image was produced")
-        log_streams(op)
         return str(new_image), op_uuid
 
 
-def poll(ctx: BuildContext, op_uuid: str) -> dict[str, object]:
-    delay = 0.5
-    while True:
-        time.sleep(delay)
-        resp = ctx.client.get(f"/v1/operations/{op_uuid}")
-        op = json.loads(resp.read())
-        if op["status"] in TERMINAL_STATUSES:
-            return op  # type: ignore[no-any-return]
-        if delay < 5:
-            delay += delay
+def stream_and_resolve(ctx: BuildContext, op_uuid: str) -> dict[str, Any]:
+    """Stream RUN output live (docker-style), then materialise the
+    full op dict.
+
+    Preference order for the op payload matches ``cmd_run``:
+    ``completion`` event → SSE `fallback_op` from a terminal GET →
+    safety-net GET.  When we fell back to the plain endpoint (no
+    live stream), replay the captured stdout/stderr from the op's
+    metadata so build users still see what the RUN produced."""
+    summary = _stream_events_until_close(ctx.client, op_uuid, DefaultFormatter())
+    if summary.completion is not None:
+        return _build_op_from_summary(op_uuid, summary)
+    if summary.fallback_op is not None:
+        log_streams(summary.fallback_op)
+        return summary.fallback_op
+    resp = ctx.client.get(f"/v1/operations/{op_uuid}")
+    op: dict[str, Any] = json.loads(resp.read())
+    if op.get("status") in TERMINAL_OP_STATUSES:
+        log_streams(op)
+    return op
 
 
 def check_success(

{contree_cli-0.7.1 → contree_cli-0.8.0}/contree_cli/docker/url_fetch.py

@@ -23,7 +23,6 @@ import urllib.error
 import urllib.parse
 import urllib.request
 from dataclasses import dataclass
-from typing import IO, cast
 
 from contree_cli.client import ApiError, ContreeClient
 from contree_cli.session import SessionStore
@@ -79,27 +78,25 @@ def fetch_and_upload(
 
     assert source is not None
     try:
-        reader = HashingReader(source)
-        upload_headers: dict[str, str] = {"Content-Type": "application/octet-stream"}
-        content_length = parse_content_length(response_headers)
-        if content_length > 0:
-            upload_headers["Content-Length"] = str(content_length)
-
-        resp = client.request(
-            "POST",
-            "/v1/files",
-            body=cast(IO[bytes], reader),
-            headers=upload_headers,
-        )
-        data = json.loads(resp.read())
+        body_bytes = source.read()  # type: ignore[attr-defined]
     finally:
         close = getattr(source, "close", None)
         if callable(close):
             close()
+    assert isinstance(body_bytes, (bytes, bytearray))
+    body_bytes = bytes(body_bytes)
+
+    resp = client.request(
+        "POST",
+        "/v1/files",
+        body=body_bytes,
+        headers={"Content-Type": "application/octet-stream"},
+    )
+    data = json.loads(resp.read())
 
     file_uuid = str(data["uuid"])
-    sha = reader.hasher.hexdigest()
-    size = reader.bytes_read
+    sha = hashlib.sha256(body_bytes).hexdigest()
+    size = len(body_bytes)
 
     write_metadata(
         store,
@@ -195,38 +192,6 @@ def conditional_headers(meta: dict[str, object]) -> dict[str, str]:
     return headers
 
 
-def parse_content_length(headers: dict[str, str]) -> int:
-    raw = headers.get("content-length")
-    if not raw:
-        return -1
-    try:
-        return int(raw)
-    except ValueError:
-        return -1
-
-
-class HashingReader:
-    """Read-only adapter that hashes bytes as they flow through.
-
-    Intentionally has no ``seek`` attribute so ``ContreeClient.request``
-    does not attempt to rewind the upstream HTTP body on retry.
-    """
-
-    __slots__ = ("bytes_read", "hasher", "source")
-
-    def __init__(self, source: object) -> None:
-        self.source = source
-        self.hasher = hashlib.sha256()
-        self.bytes_read = 0
-
-    def read(self, amt: int | None = None) -> bytes:
-        chunk = self.source.read() if amt is None else self.source.read(amt)  # type: ignore[attr-defined]
-        if chunk:
-            self.hasher.update(chunk)
-            self.bytes_read += len(chunk)
-        return chunk  # type: ignore[no-any-return]
-
-
 def http_head(url: str, *, timeout: int = DOWNLOAD_TIMEOUT_DEFAULT) -> dict[str, str]:
     """Best-effort ``HEAD`` request. Returns empty headers on any failure.
 

{contree_cli-0.7.1 → contree_cli-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "contree-cli"
-version = "0.7.1"
+version = "0.8.0"
 description = "CLI client for the ConTree sandbox platform"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -58,6 +58,7 @@ docs = [
     "furo",
     "sphinx-design",
     "myst-parser",
+    "sphinx-mintlify-output",
 ]
 
 [tool.pytest.ini_options]