sbxloop 0.5.76__tar.gz → 0.5.78__tar.gz

{sbxloop-0.5.76 → sbxloop-0.5.78}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sbxloop
-Version: 0.5.76
+Version: 0.5.78
 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.76 → sbxloop-0.5.78}/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.76'
-__version_tuple__ = version_tuple = (0, 5, 76)
+__version__ = version = '0.5.78'
+__version_tuple__ = version_tuple = (0, 5, 78)
 
 __commit_id__ = commit_id = None

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/cli/app.py

@@ -1274,11 +1274,24 @@ deny = []
 # deliver_draft = false
 
 [artifacts]
-# Path components excluded from artifact listings and delivery, matched at
-# any depth (a bare name each, no slashes). The default drops only noisy
-# state dirs — dot-path artifacts like .github/ or .gitignore are kept.
-# Exclusions are counted and surfaced, never silent.
-exclude = [".git", ".sbxloop"]
+# Path components excluded from artifact listings, harvest and delivery,
+# matched at any depth (a bare name each, no slashes). Setting this replaces
+# the default list below rather than adding to it. The default drops run/VCS
+# state plus regenerable dependency and build trees — dot-path artifacts like
+# .github/ or .gitignore are kept, and so are the ambiguous generic names
+# (bin, build, dist, out, lib, vendor), which you can add if you want them
+# dropped. Exclusions are counted and surfaced, never silent.
+exclude = [
+  ".git", ".sbxloop",
+  ".mypy_cache", ".nox", ".pytest_cache", ".ruff_cache", ".tox",
+  ".venv", "venv", "__pycache__",           # Python
+  "node_modules",                            # JavaScript / TypeScript
+  "target",                                  # Rust (cargo), Java (Maven)
+  ".gradle",                                 # Java (Gradle)
+  "obj",                                     # C# / .NET
+  ".bundle",                                 # Ruby (bundler)
+  "CMakeFiles",                              # C / C++
+]
 
 [budgets]
 max_revisions_per_task = 2

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/cli/doctor.py

@@ -31,7 +31,7 @@ from sbxloop.sbx.secretstate import COPILOT_TOKEN_ENV
 from sbxloop.worker.wheel import resolve_worker_wheel
 from sbxloop_worker.backends.copilot import SDK_PERMISSION_KINDS, installed_sdk_permission_kinds
 
-TESTED_SBX_SERIES = "0.35"
+TESTED_SBX_SERIES = "0.38"
 
 
 @dataclass
@@ -163,7 +163,7 @@ def collect_checks(
                 "consider filing an issue to prefer host-side stats"
                 if stats_available
                 else "no host-side `sbx stats`; resource telemetry samples in-VM "
-                f"on the worker heartbeat (expected on {TESTED_SBX_SERIES}.x)",
+                "on the worker heartbeat",
                 hard=False,
             )
         )

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/config.py

@@ -153,10 +153,28 @@ class ArtifactsConfig(_ConfigModel):
     """What artifact listings and delivery leave out, and how harvesting works.
 
     ``exclude`` entries are single path components matched at any depth;
-    a file is excluded when any component of its path matches. The default
-    drops only genuinely noisy state dirs (``.git``, ``.sbxloop``) — dot-path
-    artifacts like ``.github/`` or ``.gitignore`` are delivered. Exclusions
-    are always counted and surfaced, never silent.
+    a file is excluded when any component of its path matches. Setting it
+    replaces the default list wholesale rather than adding to it.
+
+    The default drops run/VCS state (``.git``, ``.sbxloop``) plus the
+    machine-generated dependency and build trees of the supported languages
+    — ``node_modules``, ``__pycache__``, ``.venv``/``venv``, ``target``,
+    ``obj``, ``.gradle``, ``.bundle``, ``CMakeFiles`` and the Python tool
+    caches. Those are regenerable, can reach hundreds of MB, and are exactly
+    what nobody wants in an ``sbxloop artifacts`` listing or a ``--deliver``
+    PR diff. Dot-path artifacts like ``.github/`` or ``.gitignore`` are still
+    delivered.
+
+    Generic names that mean build output in one ecosystem and hand-written
+    content in another — ``bin``, ``build``, ``dist``, ``out``, ``lib``,
+    ``vendor`` — are deliberately *not* excluded; add them here if your
+    project wants them dropped. Exclusions are always counted and surfaced,
+    never silent.
+
+    The list covers every supported language regardless of
+    ``[sandbox] languages``: that key governs which toolchains are
+    pre-installed, not which ones the agent ends up using, and it defaults to
+    Python alone — see ``engine.model.DEFAULT_ARTIFACT_EXCLUDES``.
 
     ``harvest_mode`` controls when unmounted-run artifacts are copied to the
     host.  ``"per-task"`` (default) copies after every task boundary plus the
@@ -166,8 +184,29 @@ class ArtifactsConfig(_ConfigModel):
     """
 
     # Mirrors engine.model.DEFAULT_ARTIFACT_EXCLUDES (kept literal here —
-    # importing engine.model from config would be a circular import).
-    exclude: list[str] = Field(default_factory=lambda: [".git", ".sbxloop"])
+    # importing engine.model from config would be a circular import). See
+    # that module for why each entry is in and why "bin"/"build"/"vendor"
+    # are out; test_config_default_mirrors_model_default pins the two.
+    exclude: list[str] = Field(
+        default_factory=lambda: [
+            ".git",
+            ".sbxloop",
+            ".mypy_cache",
+            ".nox",
+            ".pytest_cache",
+            ".ruff_cache",
+            ".tox",
+            ".venv",
+            "__pycache__",
+            "venv",
+            "node_modules",
+            "target",
+            ".gradle",
+            "obj",
+            ".bundle",
+            "CMakeFiles",
+        ]
+    )
     harvest_mode: HarvestMode = "per-task"
 
     @field_validator("exclude")

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/engine/model.py

@@ -226,12 +226,60 @@ class RunResult(_Model):
         return self.state == "completed"
 
 
-# Path components excluded from artifact listings and delivery by default.
-# A denylist, not "anything dot-prefixed": agents legitimately produce
-# .github/workflows, .gitignore, .env.example and friends — only genuinely
-# noisy state dirs are dropped (an agent's .git would otherwise swamp
-# listings and deliveries). Overridable via [artifacts] exclude.
-DEFAULT_ARTIFACT_EXCLUDES = (".git", ".sbxloop")
+# Path components excluded from artifact listings, harvest and delivery by
+# default. A denylist, not "anything dot-prefixed": agents legitimately
+# produce .github/workflows, .gitignore, .env.example and friends — only
+# machine-generated dependency and build trees are dropped. An agent's .git
+# or node_modules would otherwise swamp listings, balloon an unmounted run's
+# harvest, and land in a delivery PR diff. Overridable via [artifacts]
+# exclude (which replaces this list wholesale).
+#
+# The list is static rather than derived from [sandbox] languages, which
+# selects what gets PRE-INSTALLED, not what the workspace ends up holding.
+# That key defaults to toolchains.DEFAULT_LANGUAGES ("python",) and setting
+# it replaces rather than extends, so deriving from it would leave every
+# non-Python default run harvesting node_modules/target/obj — the exact bug
+# this list exists to fix — and would drop __pycache__ back into listings for
+# anyone who set languages = ["rust"]. Provisioning is only a head start
+# besides: agents self-heal missing toolchains mid-run, so a Rust-configured
+# run that npm-installs a docs site still grows a node_modules. A name that
+# never occurs costs nothing to carry, so the narrowing buys nothing either.
+# Entries earn a place only if they are (i) conventionally
+# gitignored in their ecosystem and (ii) implausible as hand-written content
+# in any other. That rule deliberately keeps out the generic names —
+# "bin", "build", "dist", "out", "lib", "vendor" — which are build output in
+# one ecosystem and checked-in scripts or deps in the next; a project that
+# wants those dropped can say so in [artifacts] exclude. Exclusions are
+# always counted and surfaced, never silent (#67), so a wrong call here is
+# visible and recoverable rather than a quiet truncation.
+DEFAULT_ARTIFACT_EXCLUDES = (
+    # Run/VCS state, any ecosystem.
+    ".git",
+    ".sbxloop",
+    # Python: virtualenvs, bytecode, tool caches.
+    ".mypy_cache",
+    ".nox",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    ".venv",
+    "__pycache__",
+    "venv",
+    # JavaScript / TypeScript.
+    "node_modules",
+    # Rust (cargo) and Java (Maven) both name their build tree "target".
+    "target",
+    # Java (Gradle's project-local cache; "build" is deliberately kept).
+    ".gradle",
+    # C# / .NET intermediate objects ("bin" is deliberately kept — too many
+    # ecosystems check hand-written scripts into it).
+    "obj",
+    # Ruby (bundler's project-local config/cache).
+    ".bundle",
+    # C / C++ (CMake scratch; Go needs no entry — GOCACHE and the module
+    # cache live under $HOME, outside the harvested workspace).
+    "CMakeFiles",
+)
 
 
 @dataclass(frozen=True)

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/sbx/conformance.py

@@ -135,8 +135,16 @@ def _probe_ls_columns(ctx: ProbeContext) -> tuple[str, str]:
     stdout = ctx.cli.run("ls").stdout
     lines = [line for line in stdout.splitlines() if line.strip()]
     header = lines[0].strip() if lines else ""
-    have = {cell.lower() for cell in _CELL_SPLIT.split(header)} if header else set()
-    missing = [col for col in ("name", "agent", "status", "workspace") if col not in have]
+    if not header or header.lower().startswith("no sandboxes"):
+        # An empty listing has no header row to inspect (0.38 prints "No
+        # sandboxes found."); parse_ls returns [] for it either way, so this
+        # is not drift evidence — the column check waits for a real listing.
+        return "expected-columns", f"empty sandbox list ({header!r}) — no header to check"
+    have = {cell.lower() for cell in _CELL_SPLIT.split(header)}
+    missing = [col for col in ("agent", "status", "workspace") if col not in have]
+    if not {"name", "sandbox"} & have:
+        # NAME on 0.35.x, renamed to SANDBOX in 0.38 — parse_ls accepts both.
+        missing.insert(0, "name|sandbox")
     if missing:
         return f"drifted({','.join(missing)})", f"header: {header!r}"
     return "expected-columns", f"header: {header!r}"
@@ -183,22 +191,18 @@ def _probe_cp_dir_semantics(ctx: ProbeContext) -> tuple[str, str]:
 
 def _probe_workspace_mount(ctx: ProbeContext) -> tuple[str, str]:
     assert ctx.sandbox is not None and ctx.workspace is not None
-    from sbxloop.sbx.provision import MOUNT_SEARCH_MAXDEPTH, MOUNT_SEARCH_ROOTS
+    from sbxloop.sbx.provision import mount_probe_command, mount_search_roots
 
     marker = f".sbxloop-conformance-{_secrets.token_hex(8)}"
     (ctx.workspace / marker).write_text("")
     try:
-        command = (
-            f"find -L {' '.join(MOUNT_SEARCH_ROOTS)} "
-            f"-maxdepth {MOUNT_SEARCH_MAXDEPTH} -name {marker} -print 2>/dev/null | head -1"
-        )
-        result = ctx.sandbox.exec(["sh", "-c", command])
+        result = ctx.sandbox.exec(["sh", "-c", mount_probe_command(ctx.workspace, marker)])
         hit = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else ""
     finally:
         (ctx.workspace / marker).unlink(missing_ok=True)
     if hit.endswith(f"/{marker}"):
         return "discoverable", f"workspace mounted at {hit[: -len(f'/{marker}')] or '/'}"
-    return "not-found", f"marker not found under {', '.join(MOUNT_SEARCH_ROOTS)}"
+    return "not-found", f"marker not found under {', '.join(mount_search_roots(ctx.workspace))}"
 
 
 def _probe_python3_venv(ctx: ProbeContext) -> tuple[str, str]:
@@ -317,7 +321,7 @@ CATALOG: tuple[Probe, ...] = (
     ),
     Probe(
         id=PROBE_LS_COLUMNS,
-        summary="`sbx ls` header carries the NAME/AGENT/STATUS/WORKSPACE columns",
+        summary="`sbx ls` header carries the NAME|SANDBOX/AGENT/STATUS/WORKSPACE columns",
         tier="cheap",
         expected="expected-columns",
         depends="parse_ls (sandbox listing, `sandbox rm --all`, pair cleanup)",

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/sbx/parse.py

@@ -3,13 +3,15 @@
 The sbx binary is proprietary and its output format is not a stable API, so
 parsing is column-header-driven and deliberately forgiving: unknown columns
 are ignored and malformed lines are skipped rather than raising. Formats are
-pinned by fixture tests captured from sbx v0.35.x; ``sbxloop doctor`` warns
-on version mismatch.
+pinned by fixture tests captured from sbx v0.35.x and v0.38.x (which renamed
+the ``NAME`` column to ``SANDBOX`` and added a frequently-empty ``PORTS``
+column); ``sbxloop doctor`` warns on version mismatch.
 """
 
 from __future__ import annotations
 
 import re
+from bisect import bisect_right
 
 from sbxloop.sbx.models import SandboxInfo
 
@@ -18,36 +20,52 @@ _VERSION_RE = re.compile(r"(\d+\.\d+\.\d+)")
 
 _CELL_SPLIT = re.compile(r"\s{2,}")
 
+# A cell is a run of words separated by single spaces; runs of two or more
+# spaces separate cells.
+_CELL_ITER = re.compile(r"\S+(?: \S+)*")
+
 
 def parse_columns(text: str) -> list[dict[str, str]]:
     """Parse a left-aligned column table using the header row for names.
 
-    Cells are split on runs of two or more spaces, which survives cells that
-    overflow their column width (unlike offset slicing). Rows with fewer
-    cells than headers get empty strings; extra cells are dropped.
+    Cells are assigned to columns by their start offset against the header
+    positions rather than by index, so a row with an empty middle cell
+    (sbx 0.38's ``PORTS`` column) doesn't shift its later cells into the
+    wrong columns. A cell that overflows its column width still lands on
+    the nearest header at or left of where it starts; if that column is
+    already taken the cell spills into the next free one. Missing cells
+    stay empty strings.
     """
     lines = [line.rstrip() for line in text.splitlines() if line.strip()]
     if not lines:
         return []
-    headers = [h.lower() for h in _CELL_SPLIT.split(lines[0].strip())]
+    headers = [(match.group().lower(), match.start()) for match in _CELL_ITER.finditer(lines[0])]
     if not headers:
         return []
+    starts = [start for _, start in headers]
 
     rows: list[dict[str, str]] = []
     for line in lines[1:]:
-        cells = _CELL_SPLIT.split(line.strip())
-        row = {
-            header: cells[i].strip() if i < len(cells) else "" for i, header in enumerate(headers)
-        }
+        row = {name: "" for name, _ in headers}
+        for match in _CELL_ITER.finditer(line):
+            i = max(bisect_right(starts, match.start()) - 1, 0)
+            while i < len(headers) and row[headers[i][0]]:
+                i += 1
+            if i < len(headers):
+                row[headers[i][0]] = match.group()
         rows.append(row)
     return rows
 
 
 def parse_ls(text: str) -> list[SandboxInfo]:
-    """Parse ``sbx ls`` output into SandboxInfo rows (nameless rows skipped)."""
+    """Parse ``sbx ls`` output into SandboxInfo rows (nameless rows skipped).
+
+    The name column is ``NAME`` on sbx 0.35.x and ``SANDBOX`` since 0.38;
+    both are accepted.
+    """
     infos: list[SandboxInfo] = []
     for row in parse_columns(text):
-        name = row.get("name", "")
+        name = row.get("name") or row.get("sandbox") or ""
         if not name:
             continue
         infos.append(

{sbxloop-0.5.76 → sbxloop-0.5.78}/src/sbxloop/sbx/provision.py

@@ -76,6 +76,36 @@ GITHUB_ALLOW_DOMAINS = (
 MOUNT_SEARCH_ROOTS = ("/workspace", "/home/agent", "/mnt", "/host", "/root")
 MOUNT_SEARCH_MAXDEPTH = 4
 
+
+def mount_search_roots(workspace: Path | None) -> tuple[str, ...]:
+    """The in-VM roots to search for the workspace mount, most likely first.
+
+    sbx 0.38 mounts the host workspace at its own host absolute path inside
+    the VM (identity mount, field-verified on 0.38.0), so the workspace path
+    itself is probed first; the 0.35-era candidate roots remain as fallback.
+    """
+    if workspace is None:
+        return MOUNT_SEARCH_ROOTS
+    return (str(workspace), *MOUNT_SEARCH_ROOTS)
+
+
+def mount_probe_command(workspace: Path | None, marker: str) -> str:
+    """One bounded in-VM marker search over the candidate mount roots.
+
+    Roots are existence-filtered before the ``find`` and the command always
+    exits 0 on a clean answer: on sbx 0.38 most candidate roots don't exist
+    in the VM, and a bare ``find`` over missing roots exits nonzero — which
+    would misclassify every clean "not mounted" answer as a broken probe
+    (the probe="answered" vs probe="error" split, #63).
+    """
+    roots = " ".join(shlex.quote(root) for root in mount_search_roots(workspace))
+    return (
+        f'set --; for r in {roots}; do [ -e "$r" ] && set -- "$@" "$r"; done; '
+        f'[ $# -eq 0 ] || find -L "$@" -maxdepth {MOUNT_SEARCH_MAXDEPTH} '
+        f"-name {marker} -print 2>/dev/null | head -1; :"
+    )
+
+
 PostCreate = Callable[[Sandbox, SandboxRole], None]
 
 
@@ -433,11 +463,7 @@ class Provisioner:
             return None
         probe_error = ""
         try:
-            command = (
-                f"find -L {' '.join(MOUNT_SEARCH_ROOTS)} "
-                f"-maxdepth {MOUNT_SEARCH_MAXDEPTH} -name {marker} -print 2>/dev/null"
-                " | head -1"
-            )
+            command = mount_probe_command(workspace, marker)
             result = sandbox.exec(["sh", "-c", command])
             hit = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else ""
             if not result.ok: