sbxloop 0.6.2__tar.gz → 0.6.3__tar.gz

{sbxloop-0.6.2 → sbxloop-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sbxloop
-Version: 0.6.2
+Version: 0.6.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.6.2 → sbxloop-0.6.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.6.2'
-__version_tuple__ = version_tuple = (0, 6, 2)
+__version__ = version = '0.6.3'
+__version_tuple__ = version_tuple = (0, 6, 3)
 
 __commit_id__ = commit_id = None

{sbxloop-0.6.2 → sbxloop-0.6.3}/src/sbxloop/cli/app.py

@@ -42,7 +42,12 @@ from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.models import SandboxRole
 from sbxloop.sbx.pair import cleanup_registry
 from sbxloop.sbx.provision import sandbox_name
-from sbxloop.sbx.prune import classify_sandboxes, format_age, remove_sandbox
+from sbxloop.sbx.prune import (
+    classify_sandboxes,
+    format_age,
+    remove_run_sandbox,
+    remove_sandbox,
+)
 from sbxloop.sbx.secretstate import (
     COPILOT_TOKEN_ENV,
     SANDBOX_SCOPE_PREFIX,
@@ -1084,7 +1089,13 @@ def sandbox_prune(
     failures = 0
     for v in orphans:
         try:
-            remove_sandbox(cli, v.name)
+            if v.role in ("agent", "github"):
+                # A pruned run sandbox takes its secret registrations with
+                # it; otherwise a later run under the same name (resume)
+                # cannot replace them and comes up with the proxy sentinel.
+                remove_run_sandbox(cli, v.name, v.role)  # type: ignore[arg-type]
+            else:
+                remove_sandbox(cli, v.name)
         except SbxloopError as exc:
             failures += 1
             console.print(f"[yellow]skip {v.name}:[/] {exc}")

{sbxloop-0.6.2 → sbxloop-0.6.3}/src/sbxloop/daemon/loop.py

@@ -35,7 +35,7 @@ from sbxloop.events import EventBus, HostEventTypes
 from sbxloop.ids import new_run_id
 from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.provision import sandbox_name
-from sbxloop.sbx.sandbox import Sandbox
+from sbxloop.sbx.prune import remove_run_sandbox, remove_run_sandbox_secrets
 
 logger = logging.getLogger(__name__)
 
@@ -531,15 +531,22 @@ class DaemonLoop:
                 self.dstore.mark_requeued_unstarted(item.item_id, now)
 
     def _remove_stale_run_sandboxes(self, run_id: str) -> None:
+        """A dead process leaves the run's microVMs — and their secret
+        registrations — behind. Both must go before resume re-provisions
+        under the same names: a lingering secret cannot be replaced, so the
+        agent would come up holding the proxy sentinel and the Copilot SDK
+        401s (field failure rgn9ccjam)."""
         if self.sbx is None:
             return
         for role in ("agent", "github"):
             name = sandbox_name(run_id, role)
             try:
-                Sandbox(self.sbx, name).rm()
-                self._notify(f"recovery: removed stale sandbox {name}")
+                remove_run_sandbox(self.sbx, name, role)
+                self._notify(f"recovery: removed stale sandbox {name} (and its secrets)")
             except SbxError:
-                pass  # not there — the common case
+                # No such sandbox — the common case — but a secret may
+                # still linger from a rollback race; clearing it is cheap.
+                remove_run_sandbox_secrets(self.sbx, name, role)
 
     def _result_from_record(self, run_id: str) -> RunResult:
         record = self.store.get_run(run_id)

{sbxloop-0.6.2 → sbxloop-0.6.3}/src/sbxloop/sbx/cli.py

@@ -336,9 +336,20 @@ class SbxCLI:
         existing secret, so provisioning removes and re-sets. Removal syntax
         for custom secrets is not a stable documented API, hence best-effort
         (callers keep the existing value when removal is rejected).
+
+        ``-f`` is load-bearing: sbx 0.38 asks "Delete selected secret?
+        (y/N)" and, with no TTY, prints "Cancelled" and exits 0 — the
+        removal silently does nothing while looking accepted (field
+        failure rgn9ccjam: every run leaked its registrations, and a
+        daemon resume then could not replace the stale one). Scope goes
+        via ``--sandbox``; the positional form is deprecated in 0.38.
+        "No secret found" also exits 0, so the exit code alone cannot tell
+        removed from absent: the return value is "something was actually
+        deleted" — sbx 0.38 says ``Deleted ...``; a silent exit 0 (older
+        sbx) is trusted. Callers that ladder through candidate scopes
+        depend on this to keep trying instead of stopping at a no-op.
         """
-        scope = [sandbox] if sandbox else ["-g"]
-        args = ["secret", "rm", *scope]
+        args = ["secret", "rm"]
         if service:
             args.append(service)
         else:
@@ -346,4 +357,8 @@ class SbxCLI:
             if host:
                 args += ["--host", host]
             args += ["--env", env]
-        return self.run(*args, check=False).ok
+        if sandbox:
+            args += ["--sandbox", sandbox]
+        args.append("-f")
+        result = self.run(*args, check=False)
+        return result.ok and (not result.stdout.strip() or "Deleted" in result.stdout)

{sbxloop-0.6.2 → sbxloop-0.6.3}/src/sbxloop/sbx/pair.py

@@ -22,6 +22,8 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
+from sbxloop.sbx.models import SandboxRole
+from sbxloop.sbx.prune import remove_run_sandbox_secrets
 from sbxloop.sbx.sandbox import WORK_DIR, Sandbox
 
 logger = logging.getLogger(__name__)
@@ -68,12 +70,22 @@ class SandboxPair:
             self.cleanup()
 
     def cleanup(self) -> None:
-        """Stop and remove the pair's sandboxes. Idempotent, best-effort each."""
+        """Stop and remove the pair's sandboxes and their secret registrations.
+        Idempotent, best-effort each.
+
+        ``sbx rm`` does not unregister the secrets scoped to the sandbox's
+        name; left behind they accrete per run and block a later provision
+        under the same name (daemon resume) from replacing them.
+        """
         if self._cleaned:
             return
         self._cleaned = True
         cleanup_registry.unregister(self)
-        for sandbox in (self.agent, self.github):
+        roles: tuple[tuple[Sandbox | None, SandboxRole], ...] = (
+            (self.agent, "agent"),
+            (self.github, "github"),
+        )
+        for sandbox, role in roles:
             if sandbox is None:
                 continue
             try:
@@ -84,6 +96,10 @@ class SandboxPair:
                 sandbox.rm()
             except Exception:
                 logger.warning("failed to remove sandbox %s", sandbox.name, exc_info=True)
+            try:
+                remove_run_sandbox_secrets(sandbox.cli, sandbox.name, role)
+            except Exception:
+                logger.warning("failed to remove secrets of %s", sandbox.name, exc_info=True)
 
 
 class CleanupRegistry:

{sbxloop-0.6.2 → sbxloop-0.6.3}/src/sbxloop/sbx/prune.py

@@ -23,7 +23,8 @@ from sbxloop.engine.store import StateStore
 from sbxloop.errors import SbxError, StateError
 from sbxloop.ids import is_run_id
 from sbxloop.sbx.cli import SbxCLI
-from sbxloop.sbx.models import SandboxInfo
+from sbxloop.sbx.models import SandboxInfo, SandboxRole
+from sbxloop.sbx.secretstate import COPILOT_TOKEN_ENV, COPILOT_TOKEN_HOST
 
 # A run in one of these states has already had (or never needed) its
 # teardown: any of its sandboxes still present are leaked. "failed" is safe
@@ -186,6 +187,33 @@ def remove_sandbox(cli: SbxCLI, name: str) -> None:
     cli.rm(name, force=True)
 
 
+def remove_run_sandbox_secrets(cli: SbxCLI, name: str, role: SandboxRole) -> None:
+    """Best-effort: unregister the secrets provisioning bound to ``name``.
+
+    ``sbx rm`` removes the microVM but not the secret registrations keyed
+    by its name. Left behind, they poison the next provision under the same
+    name: replace-on-exists cannot replace, keeps the stale entry, and the
+    agent sandbox ends up with the proxy sentinel instead of a usable token
+    (field failure rgn9ccjam — a daemon recovery resumed a killed run and
+    the Copilot SDK got 401). Agent sandboxes carry the Copilot custom
+    secret; github sandboxes the built-in ``github`` service secret.
+    """
+    with contextlib.suppress(SbxError):
+        if role == "agent":
+            cli.secret_rm(host=COPILOT_TOKEN_HOST, env=COPILOT_TOKEN_ENV, sandbox=name)
+        else:
+            cli.secret_rm(service="github", sandbox=name)
+
+
+def remove_run_sandbox(cli: SbxCLI, name: str, role: SandboxRole) -> None:
+    """Remove a run's sandbox AND its registered secrets — the pair that a
+    dead process leaves behind and a re-provision under the same name
+    trips over. Sandbox removal errors propagate; secret removal is
+    best-effort (registration syntax is not a stable sbx API)."""
+    remove_sandbox(cli, name)
+    remove_run_sandbox_secrets(cli, name, role)
+
+
 def count_orphans(cli: SbxCLI, store: StateStore) -> int:
     """Orphan-candidate count with default thresholds (doctor's view)."""
     return sum(1 for v in classify_sandboxes(cli.ls(), store) if v.orphan)