sbxloop 0.5.1__tar.gz → 0.5.3__tar.gz

{sbxloop-0.5.1 → sbxloop-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sbxloop
-Version: 0.5.1
+Version: 0.5.3
 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

{sbxloop-0.5.1 → sbxloop-0.5.3}/src/sbxloop/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.5.3'
+__version_tuple__ = version_tuple = (0, 5, 3)
 
 __commit_id__ = commit_id = None

{sbxloop-0.5.1 → sbxloop-0.5.3}/src/sbxloop/engine/engine.py

@@ -32,8 +32,6 @@ from sbxloop.engine.phases import PhaseRunner, clip
 from sbxloop.engine.store import StateStore
 from sbxloop.errors import (
     BudgetExceededError,
-    DeliveryError,
-    GithubOpsError,
     SbxError,
     SdxloopError,
     StateError,
@@ -139,12 +137,17 @@ class LoopEngine:
                     agent.install(extras="copilot", ensure_dev_tools=True)
                     if github is not None:
                         github.install(extras="")
-                detach = self._attach_reporter(github, run_id)
+                reporter, detach = self._attach_reporter(github, run_id, outcome)
                 try:
                     phases = PhaseRunner(
                         agent, self.config, run_id, outcome, workdir=pair.agent_workdir
                     )
                     state = self._run_phases(run_id, phases, deadline, pair)
+                    # Summary must post while the github sandbox is alive;
+                    # on an infra exception the run is resumable and the
+                    # resumed run reopens the same tracking issue.
+                    if reporter is not None:
+                        reporter.close_run(run_id, state)
                 finally:
                     detach()
                     # Harvest even when a phase raised: the sandbox is still
@@ -167,13 +170,24 @@ class LoopEngine:
             mounted=pair.mounted,
         )
 
-    def _attach_reporter(self, github: WorkerClient | None, run_id: str) -> Callable[[], None]:
+    def _attach_reporter(
+        self, github: WorkerClient | None, run_id: str, outcome: str
+    ) -> tuple[GithubReporterHook | None, Callable[[], None]]:
+        """Attach progress reporting; opens the tracking issue immediately.
+
+        Run start/end go through explicit ``open_run``/``close_run`` calls
+        rather than bus events: RUN_START is emitted before the github
+        sandbox exists and RUN_END after it is gone, so the hook could never
+        observe them (#58).
+        """
         gh = self.config.github
         if not gh.report or github is None:
-            return lambda: None
+            return None, lambda: None
         assert gh.repo is not None  # report=True without a repo cannot provision a github worker
         hook = GithubReporterHook(GithubOps(github, run_id), gh.repo)
-        return self.bus.attach_hook(hook)
+        detach = self.bus.attach_hook(hook)
+        hook.open_run(run_id, outcome)
+        return hook, detach
 
     def _harvest(self, run_id: str, pair: SandboxPair) -> None:
         """Copy the in-VM work dir out to the host (unmounted runs only).
@@ -240,7 +254,12 @@ class LoopEngine:
                 base=gh.deliver_base,
                 draft=gh.deliver_draft,
             )
-        except (DeliveryError, GithubOpsError) as exc:
+        except SdxloopError as exc:
+            # Catches the whole family the delivery path can raise — not just
+            # DeliveryError/GithubOpsError but WorkerError/WorkerTimeoutError/
+            # SbxError from the op jobs themselves. Anything narrower lets an
+            # infra hiccup during this optional post-completion step escape
+            # _drive and leave the completed run looking failed (#59).
             logger.warning("delivery to %s failed for run %s", repo, run_id, exc_info=True)
             self.bus.emit(HostEventTypes.RUN_DELIVER, run_id, repo=repo, error=str(exc))
             return

sbxloop-0.5.3/src/sbxloop/gh/reporter.py

@@ -0,0 +1,99 @@
+"""GithubReporterHook: mirrors run progress to a GitHub tracking issue.
+
+The default consumer of the github-ops sandbox. When the GitHub integration
+is configured (``[github].repo``) and reporting is enabled (``report = true``
+or ``--report``), the engine opens a tracking issue right after the github
+sandbox is ready, comments as tasks finish, and posts a final summary while
+the sandbox is still alive.
+
+Run start/end are **explicit calls** (``open_run``/``close_run``) rather
+than bus events: the run lifecycle events are emitted outside the window in
+which the hook is attached and the github sandbox exists, so subscribing to
+them can never work — see #58. Only per-task progress arrives via the bus.
+
+Every entry point is guarded: a reporting failure must not fail a run — and
+the EventBus isolates ``on_event`` anyway.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from sbxloop.events import Event, HostEventTypes
+from sbxloop.gh.ops import GithubOps, IssueRef
+
+logger = logging.getLogger(__name__)
+
+
+class GithubReporterHook:
+    def __init__(self, ops: GithubOps, repo: str) -> None:
+        self.ops = ops
+        self.repo = repo
+        self.issue: IssueRef | None = None
+        self._task_lines: list[str] = []
+
+    # -- explicit lifecycle (called by the engine, sandbox guaranteed alive) --
+
+    def open_run(self, run_id: str, outcome: str) -> None:
+        """Open (or on resume, re-find) the run's tracking issue."""
+        try:
+            self.issue = self._find_existing(run_id) or self._create(run_id, outcome)
+        except Exception:
+            logger.warning("github reporting: opening tracking issue failed", exc_info=True)
+
+    def close_run(self, run_id: str, state: str) -> None:
+        """Post the final summary comment; call before sandbox teardown."""
+        if self.issue is None:
+            return
+        summary = "\n".join(self._task_lines) or "_no tasks were executed_"
+        try:
+            self.ops.issue_comment(
+                self.repo,
+                self.issue.number,
+                f"Run `{run_id}` finished: **{state}**\n\n{summary}",
+            )
+        except Exception:
+            logger.warning("github reporting: final summary failed", exc_info=True)
+
+    # -- Hook protocol (task progress only) ----------------------------------
+
+    def on_event(self, event: Event) -> None:
+        try:
+            if event.type == HostEventTypes.TASK_END:
+                self._on_task_end(event)
+        except Exception:
+            logger.warning("github reporting failed for %s", event.type, exc_info=True)
+
+    # -- internals -----------------------------------------------------------
+
+    def _find_existing(self, run_id: str) -> IssueRef | None:
+        """A resumed run reuses its issue instead of opening a duplicate."""
+        query = f'repo:{self.repo} is:issue in:title "sbxloop run {run_id}"'
+        for item in self.ops.search_issues(query, per_page=5):
+            if item.get("title") == f"sbxloop run {run_id}" and item.get("number"):
+                return IssueRef(number=int(item["number"]), url=str(item.get("html_url", "")))
+        return None
+
+    def _create(self, run_id: str, outcome: str) -> IssueRef:
+        body = (
+            f"sbxloop run `{run_id}` started.\n\n"
+            f"**Outcome:**\n\n> {outcome}\n\n"
+            "Progress is reported as comments on this issue."
+        )
+        return self.ops.issue_create(
+            self.repo,
+            title=f"sbxloop run {run_id}",
+            body=body,
+            labels=["sbxloop"],
+        )
+
+    def _on_task_end(self, event: Event) -> None:
+        if self.issue is None:
+            return
+        task_id = event.data.get("task_id", "?")
+        title = event.data.get("title", "")
+        state = event.data.get("state", "?")
+        marker = "✅" if state == "done" else "❌"
+        line = f"{marker} `{task_id}` {title} — **{state}**"
+        self._task_lines.append(line)
+        self.ops.issue_comment(self.repo, self.issue.number, line)

sbxloop-0.5.1/src/sbxloop/gh/reporter.py

@@ -1,76 +0,0 @@
-"""GithubReporterHook: mirrors run progress to a GitHub tracking issue.
-
-The default consumer of the github-ops sandbox. When the GitHub integration
-is configured (``[github].repo``) and reporting is enabled (``report = true``
-or ``--report``), the hook opens a tracking issue at run start, comments as
-tasks finish, and posts a final summary at run end. It never raises — a
-reporting failure must not fail a run — and the EventBus isolates it anyway.
-"""
-
-from __future__ import annotations
-
-import logging
-
-from sbxloop.events import Event, HostEventTypes
-from sbxloop.gh.ops import GithubOps, IssueRef
-
-logger = logging.getLogger(__name__)
-
-
-class GithubReporterHook:
-    def __init__(self, ops: GithubOps, repo: str) -> None:
-        self.ops = ops
-        self.repo = repo
-        self.issue: IssueRef | None = None
-        self._task_lines: list[str] = []
-
-    # -- Hook protocol -----------------------------------------------------
-
-    def on_event(self, event: Event) -> None:
-        try:
-            if event.type == HostEventTypes.RUN_START:
-                self._on_run_start(event)
-            elif event.type == HostEventTypes.TASK_END:
-                self._on_task_end(event)
-            elif event.type == HostEventTypes.RUN_END:
-                self._on_run_end(event)
-        except Exception:
-            logger.warning("github reporting failed for %s", event.type, exc_info=True)
-
-    # -- handlers ----------------------------------------------------------
-
-    def _on_run_start(self, event: Event) -> None:
-        outcome = str(event.data.get("outcome", ""))
-        body = (
-            f"sbxloop run `{event.run_id}` started.\n\n"
-            f"**Outcome:**\n\n> {outcome}\n\n"
-            "Progress is reported as comments on this issue."
-        )
-        self.issue = self.ops.issue_create(
-            self.repo,
-            title=f"sbxloop run {event.run_id}",
-            body=body,
-            labels=["sbxloop"],
-        )
-
-    def _on_task_end(self, event: Event) -> None:
-        if self.issue is None:
-            return
-        task_id = event.data.get("task_id", "?")
-        title = event.data.get("title", "")
-        state = event.data.get("state", "?")
-        marker = "✅" if state == "done" else "❌"
-        line = f"{marker} `{task_id}` {title} — **{state}**"
-        self._task_lines.append(line)
-        self.ops.issue_comment(self.repo, self.issue.number, line)
-
-    def _on_run_end(self, event: Event) -> None:
-        if self.issue is None:
-            return
-        state = event.data.get("state", "?")
-        summary = "\n".join(self._task_lines) or "_no tasks were executed_"
-        self.ops.issue_comment(
-            self.repo,
-            self.issue.number,
-            f"Run `{event.run_id}` finished: **{state}**\n\n{summary}",
-        )