sbxloop 0.2.0__tar.gz → 0.4.0__tar.gz

{sbxloop-0.2.0 → sbxloop-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sbxloop
-Version: 0.2.0
+Version: 0.4.0
 Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop
@@ -19,7 +19,7 @@ Requires-Python: >=3.11
 Requires-Dist: pydantic>=2.7
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: rich>=13.7
-Requires-Dist: sbxloop-worker==0.2.0
+Requires-Dist: sbxloop-worker==0.4.0
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 

{sbxloop-0.2.0 → sbxloop-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sbxloop"
-version = "0.2.0"
+version = "0.4.0"
 description = "Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -21,7 +21,7 @@ dependencies = [
     "python-dotenv>=1.0",
     "typer>=0.12",
     "rich>=13.7",
-    "sbxloop-worker==0.2.0",
+    "sbxloop-worker==0.4.0",
 ]
 
 [project.scripts]

{sbxloop-0.2.0 → sbxloop-0.4.0}/src/sbxloop/__init__.py

@@ -6,7 +6,7 @@ agentic layer, and a GitHub-ops sandbox holding only ``GH_TOKEN`` for
 user-facing GitHub interactions. The balanced network policy is the default.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"
 
 from sbxloop.config import Budgets, Config, load_config
 from sbxloop.engine import LoopEngine, RunResult, run_outcome

{sbxloop-0.2.0 → sbxloop-0.4.0}/src/sbxloop/cli/app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import queue
 import threading
 import time
 from pathlib import Path
@@ -11,15 +12,17 @@ import typer
 from rich.console import Console
 from rich.live import Live
 from rich.table import Table
+from rich.tree import Tree
 
 import sbxloop
 from sbxloop.cli.doctor import run_doctor
-from sbxloop.cli.tui import Dashboard, format_event, plain_printer
+from sbxloop.cli.tui import Dashboard, format_event, plain_printer, render_event
 from sbxloop.config import Config, load_config, load_config_with_sources, load_dotenv_file
 from sbxloop.engine.engine import LoopEngine
-from sbxloop.engine.model import RunResult
+from sbxloop.engine.model import RunResult, artifact_files, artifacts_dir
 from sbxloop.engine.store import StateStore
 from sbxloop.errors import SdxloopError
+from sbxloop.events import Event
 from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.provision import sandbox_name
 
@@ -66,13 +69,23 @@ def _store(config: Config) -> StateStore:
 
 
 def _drive_with_ui(engine: LoopEngine, *, tui: bool, action: Any) -> RunResult:
-    """Run start/resume with either the live dashboard or plain event logs."""
+    """Run start/resume with the scrollback transcript + pinned status, or
+    plain event logs (--no-tui).
+
+    Transcript entries print permanently to the terminal's scrollback (via
+    ``live.console.print``, which renders above the live region), so the
+    full conversation history survives; only the compact status panel at
+    the bottom is redrawn in place. Events arrive on the engine thread but
+    every terminal write happens here on the main thread, via a queue —
+    ordering stays deterministic and rich's Live never interleaves.
+    """
     if not tui:
         engine.bus.subscribe(plain_printer(console))
         return action()  # type: ignore[no-any-return]
 
     dashboard = Dashboard()
-    engine.bus.subscribe(dashboard.on_event)
+    pending: queue.SimpleQueue[Event] = queue.SimpleQueue()
+    engine.bus.subscribe(pending.put)
     outcome: dict[str, Any] = {}
 
     def target() -> None:
@@ -83,29 +96,97 @@ def _drive_with_ui(engine: LoopEngine, *, tui: bool, action: Any) -> RunResult:
 
     thread = threading.Thread(target=target, daemon=True)
     with Live(dashboard.renderable(), console=console, refresh_per_second=8) as live:
+
+        def drain() -> None:
+            while True:
+                try:
+                    event = pending.get_nowait()
+                except queue.Empty:
+                    return
+                dashboard.on_event(event)
+                rendered = render_event(event)
+                if rendered is not None:
+                    live.console.print(rendered)
+
         thread.start()
         while thread.is_alive():
+            drain()
             live.update(dashboard.renderable())
             time.sleep(0.15)
+        drain()
         live.update(dashboard.renderable())
     if "error" in outcome:
         raise outcome["error"]
     return outcome["result"]  # type: ignore[no-any-return]
 
 
-def _finish(result: RunResult) -> None:
+_TREE_MAX_FILES = 50
+
+
+def _human_size(size: int) -> str:
+    value = float(size)
+    for unit in ("B", "KB", "MB"):
+        if value < 1024 or unit == "MB":
+            return f"{value:.0f} {unit}" if unit == "B" else f"{value:.1f} {unit}"
+        value /= 1024
+    raise AssertionError("unreachable")  # pragma: no cover
+
+
+def _artifacts_tree(root: Path, files: list[Path], cap: int = _TREE_MAX_FILES) -> Tree:
+    tree = Tree(f"[bold]{root}[/]")
+    nodes: dict[Path, Tree] = {root: tree}
+    for path in files[:cap]:
+        rel = path.relative_to(root)
+        parent = root
+        for part in rel.parts[:-1]:
+            child = parent / part
+            if child not in nodes:
+                nodes[child] = nodes[parent].add(f"{part}/")
+            parent = child
+        nodes[parent].add(f"{rel.name} [dim]({_human_size(path.stat().st_size)})[/]")
+    if len(files) > cap:
+        tree.add(f"[dim]… +{len(files) - cap} more[/]")
+    return tree
+
+
+def _print_artifacts_summary(result: RunResult, config: Config) -> None:
+    target = artifacts_dir(result, config.state_dir)
+    if target is None or not target.is_dir():
+        return
+    files = artifact_files(target)
+    if not files:
+        console.print(f"\nartifacts: none produced (workspace: {target})")
+        return
+    via = "live workspace mount" if result.mounted else "harvested from the sandbox"
+    console.print(f"\nartifacts: {len(files)} file(s), {via}")
+    console.print(_artifacts_tree(target, files))
+
+
+def _finish(result: RunResult, config: Config) -> None:
     style = "green" if result.succeeded else "red"
     console.print(f"\nrun [bold cyan]{result.run_id}[/] finished: [bold {style}]{result.state}[/]")
     for task in result.tasks:
         console.print(f"  {task.spec.id}: {task.state}  ({task.spec.title})")
+    _print_artifacts_summary(result, config)
     raise typer.Exit(0 if result.succeeded else 1)
 
 
 @app.command()
 def run(
     outcome: Annotated[str, typer.Argument(help="The outcome to achieve.")],
-    repo: Annotated[
-        str | None, typer.Option("--repo", help="owner/repo for GitHub progress reporting.")
+    report: Annotated[
+        bool | None,
+        typer.Option(
+            "--report/--no-report",
+            help="Post run progress to the configured [github].repo.",
+        ),
+    ] = None,
+    deliver: Annotated[
+        bool | None,
+        typer.Option(
+            "--deliver/--no-deliver",
+            help="Publish the completed run's artifacts as a PR to the configured [github].repo.",
+        ),
     ] = None,
     model: Annotated[str | None, typer.Option("--model", help="Copilot model id.")] = None,
     keep_sandboxes: Annotated[
@@ -115,17 +196,36 @@ def run(
 ) -> None:
     """Run an agentic loop for OUTCOME in a fresh sandbox pair."""
     config = _config_with_overrides(model=model, keep_sandboxes=keep_sandboxes or None)
-    if repo:
+    if report is not None:
+        config = config.model_copy(
+            update={"github": config.github.model_copy(update={"report": report})}
+        )
+    if deliver is not None:
         config = config.model_copy(
-            update={"github": config.github.model_copy(update={"report_repo": repo})}
+            update={"github": config.github.model_copy(update={"deliver": deliver})}
         )
+    wanted = [
+        feature
+        for feature, enabled in (
+            ("progress reporting (--report)", config.github.report),
+            ("PR delivery (--deliver)", config.github.deliver),
+        )
+        if enabled
+    ]
+    if wanted and not config.github.enabled:
+        console.print(
+            f"[bold red]GitHub integration is not configured.[/] {', '.join(wanted)} "
+            'needs a repository: set [cyan]\\[github] repo = "owner/repo"[/] in '
+            "sbxloop.toml (see `sbxloop init`), then re-run."
+        )
+        raise typer.Exit(2)
     engine = LoopEngine(config)
     try:
         result = _drive_with_ui(engine, tui=tui, action=lambda: engine.start(outcome))
     except SdxloopError as exc:
         console.print(f"[bold red]run failed:[/] {exc}")
         raise typer.Exit(2) from exc
-    _finish(result)
+    _finish(result, config)
 
 
 @app.command()
@@ -134,13 +234,14 @@ def resume(
     tui: Annotated[bool, typer.Option("--tui/--no-tui")] = True,
 ) -> None:
     """Resume an unfinished run (fresh sandboxes, persisted state)."""
-    engine = LoopEngine(load_config())
+    config = load_config()
+    engine = LoopEngine(config)
     try:
         result = _drive_with_ui(engine, tui=tui, action=lambda: engine.resume(run_id))
     except SdxloopError as exc:
         console.print(f"[bold red]resume failed:[/] {exc}")
         raise typer.Exit(2) from exc
-    _finish(result)
+    _finish(result, config)
 
 
 @app.command()
@@ -229,6 +330,49 @@ def logs(
         time.sleep(0.5)
 
 
+@app.command()
+def artifacts(
+    run_id: Annotated[str, typer.Argument(help="Run id.")],
+    path: Annotated[
+        bool, typer.Option("--path", help="Print only the artifacts directory (for scripting).")
+    ] = False,
+    tree: Annotated[
+        bool, typer.Option("--tree/--list", help="Render a file tree instead of a flat list.")
+    ] = False,
+) -> None:
+    """Show where a run's artifacts live on the host, and what is in there."""
+    config = load_config()
+    store = _store(config)
+    try:
+        record = store.get_run(run_id)
+    except SdxloopError as exc:
+        console.print(f"[bold red]{exc}[/]")
+        raise typer.Exit(2) from exc
+    target = artifacts_dir(record, config.state_dir)
+    if target is None:
+        console.print(
+            f"[bold red]run {run_id} has no artifacts:[/] it never provisioned a workspace "
+            f"(state: {record.state})"
+        )
+        raise typer.Exit(2)
+    if path:
+        # bare path on stdout, nothing else — `cd $(sbxloop artifacts R --path)`
+        typer.echo(str(target))
+        return
+    if not target.is_dir():
+        console.print(f"[bold red]artifacts directory is gone:[/] {target}")
+        raise typer.Exit(2)
+    files = artifact_files(target)
+    via = "live workspace mount" if record.mounted else "harvested copy"
+    console.print(f"run [bold cyan]{run_id}[/]: {len(files)} file(s) ({via}) in [bold]{target}[/]")
+    if tree:
+        console.print(_artifacts_tree(target, files))
+        return
+    for file in files:
+        size = _human_size(file.stat().st_size)
+        console.print(f"  {file.relative_to(target)}  [dim]{size}[/]")
+
+
 @sandbox_app.command("ls")
 def sandbox_ls() -> None:
     """List sbxloop-managed sandboxes."""
@@ -345,8 +489,18 @@ secret_strategy = "proxy"
 extra_allow_domains = []
 
 [github]
-# Report run progress to a GitHub repo ("owner/repo"); empty disables.
-# report_repo = "you/your-repo"
+# The GitHub integration. Unset (the default) disables GitHub entirely:
+# no github sandbox is provisioned, GH_TOKEN is not required, and
+# repo-facing features refuse to run. Set `repo` to the ONE repository
+# sbxloop may work with; the toggles below act on it.
+# repo = "you/your-repo"
+# Post run progress (issues/comments) to the configured repo.
+# report = false
+# Open a PR with the run's artifacts when a run completes (or `--deliver`).
+# GH_TOKEN needs contents:write + pull_requests:write on the repo.
+# deliver = false
+# deliver_base = "main"   # base branch; unset uses the repo's default
+# deliver_draft = false
 
 [budgets]
 max_revisions_per_task = 2

{sbxloop-0.2.0 → sbxloop-0.4.0}/src/sbxloop/cli/doctor.py

@@ -109,17 +109,31 @@ def collect_checks(
             f"permission and export {COPILOT_TOKEN_ENV}",
         )
     )
-    gh_set = any(env.get(name) for name in GH_TOKEN_ENVS)
-    checks.append(
-        Check(
-            "/".join(GH_TOKEN_ENVS),
-            gh_set,
-            "set"
-            if gh_set
-            else "not set — create a fine-grained PAT (issues:write, contents:read, ...) "
-            "and export GH_TOKEN",
+    # GH_TOKEN matters only when the GitHub integration is configured; an
+    # unconfigured integration is a valid (GitHub-less) setup, not a failure.
+    if config.github.enabled:
+        gh_set = any(env.get(name) for name in GH_TOKEN_ENVS)
+        checks.append(
+            Check(
+                "/".join(GH_TOKEN_ENVS),
+                gh_set,
+                f"set (github integration: {config.github.repo})"
+                if gh_set
+                else f"not set but [github].repo = {config.github.repo!r} is configured — "
+                "create a fine-grained PAT (issues:write, contents:read, ...) "
+                "and export GH_TOKEN",
+            )
+        )
+    else:
+        checks.append(
+            Check(
+                "github integration",
+                True,
+                'not configured — GitHub features disabled (set [github] repo = "owner/repo" '
+                "in sbxloop.toml to enable)",
+                hard=False,
+            )
         )
-    )
 
     # worker wheel
     wheel = resolve_worker_wheel()

{sbxloop-0.2.0 → sbxloop-0.4.0}/src/sbxloop/cli/tui.py

@@ -1,16 +1,20 @@
-"""Rich rendering for runs: a chat-style live transcript and plain logging.
-
-Agent output is conversational (markdown, fenced code blocks), so the live
-view renders it as a chat thread — markdown panels with syntax-highlighted
-code — rather than truncated log lines. Host lifecycle events stay compact
-one-liners. ``format_event`` remains the dense single-line form used by
+"""Rich rendering for runs: a permanent scrollback transcript plus a small
+pinned status region.
+
+Agent output is conversational (markdown, fenced code blocks), so the
+transcript renders it as a chat thread — markdown panels with
+syntax-highlighted code — rather than truncated log lines. Transcript
+entries are printed to the terminal's normal scrollback as they happen and
+are never rewritten or dropped: the full history of a run stays scrollable.
+Only the compact status region (run state + task table) is live-updated in
+place at the bottom. Host lifecycle events stay compact one-liners.
+``format_event`` remains the dense single-line form used by
 ``sbxloop logs``.
 """
 
 from __future__ import annotations
 
 import datetime
-from collections import deque
 from typing import Any
 
 from rich.console import Console, Group, RenderableType
@@ -50,12 +54,24 @@ _TRANSCRIPT_SKIP = {
 }
 
 AGENT_MESSAGE_CLIP = 4000
+# One-line clip for tool arguments; output tail lines shown on tool failure.
+TOOL_ARGS_LINE_CLIP = 160
+TOOL_FAIL_TAIL_LINES = 6
 
 
 def _stamp(event: Event) -> str:
     return datetime.datetime.fromtimestamp(event.ts).strftime("%H:%M:%S")
 
 
+def _one_line(text: str, limit: int = TOOL_ARGS_LINE_CLIP) -> str:
+    """Collapse to a single display line, eliding the middle beyond limit."""
+    flat = " ".join(text.split())
+    if len(flat) <= limit:
+        return flat
+    keep = (limit - 1) // 2
+    return f"{flat[:keep]}…{flat[-keep:]}"
+
+
 def render_event(event: Event) -> RenderableType | None:
     """One transcript entry for an event, or None when it should be skipped."""
     if event.type in _TRANSCRIPT_SKIP:
@@ -88,10 +104,36 @@ def render_event(event: Event) -> RenderableType | None:
 
     if event.type == EventTypes.AGENT_TOOL_START:
         tool = data.get("tool") or "tool"
-        return Text(f"{_stamp(event)}  ⚙ {tool}", style="yellow", overflow="fold")
+        start = Text(f"{_stamp(event)}  ⚙ {tool}", style="yellow")
+        args = _one_line(str(data.get("args") or ""))
+        if args:
+            start.append(" $ ", style="bold yellow")
+            start.append(args, style="yellow dim")
+        start.overflow = "fold"
+        return start
 
     if event.type == EventTypes.AGENT_TOOL_END:
-        return None  # start lines carry enough signal for the transcript
+        tool = data.get("tool") or "tool"
+        success = data.get("success")
+        exit_code = data.get("exit_code")
+        if success is None and exit_code is None:
+            return None  # nothing informative beyond the start line
+        if success or (success is None and exit_code == 0):
+            suffix = " exit 0" if exit_code == 0 else ""
+            return Text(f"{_stamp(event)}  ✓ {tool}{suffix}", style="green dim")
+        suffix = f" exit {exit_code}" if exit_code is not None else ""
+        failure = Text(f"{_stamp(event)}  ✗ {tool}{suffix}", style="red")
+        tail = str(data.get("output") or "").strip()
+        if tail:
+            return Group(
+                failure,
+                Text(
+                    "\n".join(tail.splitlines()[-TOOL_FAIL_TAIL_LINES:]),
+                    style="red dim",
+                    overflow="fold",
+                ),
+            )
+        return failure
 
     if event.type.startswith(_LIFECYCLE_PREFIXES):
         line = format_event(event)
@@ -106,14 +148,16 @@ def render_event(event: Event) -> RenderableType | None:
 
 
 class Dashboard:
-    """Accumulates run state from the event stream and renders it."""
+    """Accumulates run status from the event stream and renders the pinned
+    region. Transcript entries are NOT kept here — the drive loop prints
+    them straight to scrollback via ``render_event`` so history is never
+    truncated or rewritten."""
 
-    def __init__(self, max_entries: int = 6) -> None:
+    def __init__(self) -> None:
         self.run_id: str | None = None
         self.run_state: str = "starting"
         self.outcome: str = ""
         self.tasks: dict[str, dict[str, Any]] = {}
-        self.transcript: deque[RenderableType] = deque(maxlen=max_entries)
 
     # -- event intake ------------------------------------------------------
 
@@ -139,9 +183,6 @@ class Dashboard:
             if data.get("title"):
                 entry["title"] = str(data["title"])
             entry["state"] = str(data.get("state", entry["state"]))
-        rendered = render_event(event)
-        if rendered is not None:
-            self.transcript.append(rendered)
 
     # -- rendering ---------------------------------------------------------
 
@@ -170,15 +211,10 @@ class Dashboard:
         if not self.tasks:
             table.add_row("…", "decomposing outcome", Text("pending", style="dim"), "")
 
-        transcript: RenderableType
-        if self.transcript:
-            transcript = Group(*self.transcript)
-        else:
-            transcript = Text("waiting for events…", style="dim")
-        return Group(
-            Panel(Group(header, outcome), border_style="cyan"),
-            table,
-            transcript,
+        return Panel(
+            Group(header, outcome, table),
+            border_style="cyan",
+            padding=(0, 1),
         )
 
 
@@ -187,11 +223,14 @@ def format_event(event: Event) -> str:
     parts = [_stamp(event), event.type]
     if event.data.get("task_id"):
         parts.append(f"[{event.data['task_id']}]")
-    for key in ("state", "content", "tool", "op", "line", "message", "outcome"):
+    keys = ("state", "content", "tool", "op", "line", "message", "outcome", "error", "url", "path")
+    for key in keys:
         if event.data.get(key):
             value = str(event.data[key]).replace("\n", " ")
             parts.append(value[:160])
             break
+    if event.data.get("args"):
+        parts.append(_one_line(str(event.data["args"]), 120))
     return " ".join(parts)
 
 

{sbxloop-0.2.0 → sbxloop-0.4.0}/src/sbxloop/config.py

@@ -12,12 +12,13 @@ strings.
 from __future__ import annotations
 
 import os
+import re
 import tomllib
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, ValidationError
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator
 
 from sbxloop.errors import ConfigError
 
@@ -42,7 +43,29 @@ class SandboxConfig(_ConfigModel):
 
 
 class GithubConfig(_ConfigModel):
-    report_repo: str | None = None
+    """The GitHub integration. ``repo`` is the gate: unset (the default)
+    disables GitHub entirely — no github sandbox is provisioned, no GH_TOKEN
+    is required, and repo-facing features (progress reporting, delivery)
+    refuse to run. Setting it makes ``repo`` the one repository sbxloop is
+    allowed to work with; behavior toggles like ``report`` act on it."""
+
+    repo: str | None = None
+    report: bool = False
+    # Publish a completed run's artifacts as a PR to `repo`.
+    deliver: bool = False
+    deliver_base: str | None = None  # base branch; None → the repo's default
+    deliver_draft: bool = False
+
+    @field_validator("repo")
+    @classmethod
+    def _check_repo(cls, value: str | None) -> str | None:
+        if value is not None and not re.fullmatch(r"[\w.-]+/[\w.-]+", value):
+            raise ValueError(f"github.repo must be owner/name, got {value!r}")
+        return value
+
+    @property
+    def enabled(self) -> bool:
+        return self.repo is not None
 
 
 class Budgets(_ConfigModel):