sdxloop 0.1.0__py3-none-any.whl

sdxloop/sbx/sandbox.py

@@ -0,0 +1,70 @@
+"""A handle to one live sandbox: exec, file transfer, lifecycle."""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+
+from sdxloop.sbx.cli import SbxCLI
+from sdxloop.sbx.models import ExecResult
+
+# Canonical in-sandbox layout. The sandbox user is `agent` in the official
+# Docker sandbox templates.
+SANDBOX_HOME = "/home/agent"
+SDXLOOP_DIR = f"{SANDBOX_HOME}/.sdxloop"
+JOBS_DIR = f"{SDXLOOP_DIR}/jobs"
+RESULTS_DIR = f"{SDXLOOP_DIR}/results"
+EVENTS_DIR = f"{SDXLOOP_DIR}/events"
+ENV_FILE = f"{SDXLOOP_DIR}/env.sh"
+VENV_DIR = f"{SDXLOOP_DIR}/venv"
+VENV_PYTHON = f"{VENV_DIR}/bin/python"
+
+
+class Sandbox:
+    """Operations on one existing sandbox. Does not own creation."""
+
+    def __init__(self, cli: SbxCLI, name: str) -> None:
+        self.cli = cli
+        self.name = name
+
+    def __repr__(self) -> str:
+        return f"Sandbox({self.name!r})"
+
+    def exec(self, cmd: Sequence[str], *, timeout: float | None = None) -> ExecResult:
+        return self.cli.exec(self.name, cmd, timeout=timeout)
+
+    def exec_stream(self, cmd: Sequence[str]) -> subprocess.Popen[str]:
+        """Start a streaming exec; caller owns the returned process."""
+        return self.cli.popen("exec", self.name, *cmd)
+
+    def cp_in(self, host_path: Path, sb_path: str) -> None:
+        self.cli.cp(str(host_path), f"{self.name}:{sb_path}")
+
+    def cp_out(self, sb_path: str, host_path: Path) -> None:
+        self.cli.cp(f"{self.name}:{sb_path}", str(host_path))
+
+    def write_text(self, sb_path: str, text: str) -> None:
+        with tempfile.NamedTemporaryFile("w", suffix=".sdxloop", delete=False) as f:
+            f.write(text)
+            tmp = Path(f.name)
+        try:
+            self.cp_in(tmp, sb_path)
+        finally:
+            tmp.unlink(missing_ok=True)
+
+    def read_text(self, sb_path: str) -> str:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            target = Path(tmpdir) / "out"
+            self.cp_out(sb_path, target)
+            return target.read_text()
+
+    def mkdirs(self, *sb_paths: str) -> None:
+        self.exec(["mkdir", "-p", *sb_paths])
+
+    def stop(self) -> None:
+        self.cli.stop(self.name)
+
+    def rm(self) -> None:
+        self.cli.rm(self.name, force=True)

sdxloop/worker/__init__.py

@@ -0,0 +1,6 @@
+"""Host-side worker transport: wheel resolution and the WorkerClient."""
+
+from sdxloop.worker.client import WorkerClient
+from sdxloop.worker.wheel import resolve_worker_wheel
+
+__all__ = ["WorkerClient", "resolve_worker_wheel"]

sdxloop/worker/client.py

@@ -0,0 +1,260 @@
+"""WorkerClient: install the worker into a sandbox and run jobs through it.
+
+Two transports:
+
+- **stream** (default): one blocking ``sbx exec`` per job; the worker mirrors
+  its JSONL events to stdout, which the host parses line-by-line and
+  republishes on the EventBus. The result file is fetched afterwards with
+  ``cp`` — stdout is telemetry, the result file is the outcome.
+- **poll**: the worker is launched detached (``nohup ... &``); the host tails
+  the in-sandbox events file by byte offset every ``poll_interval`` seconds.
+  Fallback for environments where long-running exec streams are unreliable.
+
+Host-side timeouts are ``job.timeout_s`` plus a grace period; on expiry the
+worker process is killed inside the sandbox (pattern-scoped pkill) and
+WorkerTimeoutError is raised.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import queue
+import threading
+import time
+from pathlib import Path
+
+import sdxloop
+from sdxloop.config import WorkerTransport
+from sdxloop.errors import SbxError, WorkerError, WorkerTimeoutError
+from sdxloop.events import EventBus
+from sdxloop.sbx.models import ExecResult
+from sdxloop.sbx.sandbox import ENV_FILE, EVENTS_DIR, JOBS_DIR, RESULTS_DIR, VENV_DIR, Sandbox
+from sdxloop.sbx.sandbox import VENV_PYTHON as DEFAULT_PYTHON
+from sdxloop.worker.wheel import resolve_worker_wheel
+from sdxloop_worker.protocol import Event, EventTypes, JobRequest, JobResult
+
+STAGED_WHEEL = "/tmp/sdxloop_worker.whl"
+
+
+class WorkerClient:
+    def __init__(
+        self,
+        sandbox: Sandbox,
+        bus: EventBus | None = None,
+        *,
+        transport: WorkerTransport = "stream",
+        python: str = DEFAULT_PYTHON,
+        poll_interval: float = 2.0,
+        grace_s: float = 60.0,
+    ) -> None:
+        self.sandbox = sandbox
+        self.bus = bus or EventBus()
+        self.transport = transport
+        self.python = python
+        self.poll_interval = poll_interval
+        self.grace_s = grace_s
+
+    # -- install -----------------------------------------------------------
+
+    def install(
+        self,
+        *,
+        extras: str = "copilot",
+        wheel: Path | None = None,
+        timeout: float = 600.0,
+        no_deps: bool = False,
+        system_site_packages: bool = False,
+    ) -> None:
+        """Create the worker venv in the sandbox and install sdxloop-worker.
+
+        ``no_deps``/``system_site_packages`` are test seams for hermetic
+        installs; production uses full dependency resolution (PyPI is
+        reachable under the balanced network policy).
+        """
+        wheel = wheel if wheel is not None else resolve_worker_wheel()
+        venv_cmd = ["python3", "-m", "venv"]
+        if system_site_packages:
+            venv_cmd.append("--system-site-packages")
+        self._check(self.sandbox.exec([*venv_cmd, VENV_DIR], timeout=timeout), "venv creation")
+
+        pip = [f"{VENV_DIR}/bin/pip", "install", "--quiet"]
+        if no_deps:
+            pip.append("--no-deps")
+        if wheel is not None:
+            self.sandbox.cp_in(wheel, STAGED_WHEEL)
+            target = f"{STAGED_WHEEL}[{extras}]" if extras else STAGED_WHEEL
+        else:
+            spec = f"sdxloop-worker=={sdxloop.__version__}"
+            target = f"sdxloop-worker[{extras}]=={sdxloop.__version__}" if extras else spec
+        self._check(self.sandbox.exec([*pip, target], timeout=timeout), "worker install")
+
+        verify = self.sandbox.exec(
+            [DEFAULT_PYTHON, "-c", "import sdxloop_worker; print(sdxloop_worker.__version__)"]
+        )
+        self._check(verify, "worker import check")
+        installed = verify.stdout.strip()
+        if installed != sdxloop.__version__:
+            raise WorkerError(
+                f"worker version {installed!r} does not match host {sdxloop.__version__!r}"
+            )
+
+    @staticmethod
+    def _check(result: ExecResult, step: str) -> None:
+        if not result.ok:
+            raise WorkerError(
+                f"{step} failed (rc={result.returncode}): {result.stderr.strip()[:2000]}"
+            )
+
+    # -- submit ------------------------------------------------------------
+
+    def submit(self, job: JobRequest) -> JobResult:
+        job_path = f"{JOBS_DIR}/{job.job_id}.json"
+        events_path = f"{EVENTS_DIR}/{job.job_id}.jsonl"
+        result_path = f"{RESULTS_DIR}/{job.job_id}.json"
+        self.sandbox.write_text(job_path, job.model_dump_json())
+
+        argv = [
+            self.python,
+            "-m",
+            "sdxloop_worker",
+            "run",
+            "--job",
+            job_path,
+            "--events",
+            events_path,
+            "--result",
+            result_path,
+            "--env-file",
+            ENV_FILE,
+        ]
+        deadline = time.monotonic() + job.timeout_s + self.grace_s
+        if self.transport == "poll":
+            self._run_poll(job, argv, events_path, result_path, deadline)
+        else:
+            self._run_stream(job, argv, deadline)
+        return self._fetch_result(job, result_path)
+
+    # -- stream transport --------------------------------------------------
+
+    def _run_stream(self, job: JobRequest, argv: list[str], deadline: float) -> None:
+        proc = self.sandbox.exec_stream(argv)
+        lines: queue.Queue[str | None] = queue.Queue()
+
+        def reader() -> None:
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                lines.put(line)
+            lines.put(None)
+
+        thread = threading.Thread(target=reader, name="sdxloop-stream-reader", daemon=True)
+        thread.start()
+
+        try:
+            while True:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    self._kill(job, proc)
+                    raise WorkerTimeoutError(
+                        f"job {job.job_id} exceeded {job.timeout_s}s (+{self.grace_s}s grace)"
+                    )
+                try:
+                    line = lines.get(timeout=min(remaining, 0.5))
+                except queue.Empty:
+                    continue
+                if line is None:
+                    break
+                self._handle_line(job, line)
+        finally:
+            with contextlib.suppress(Exception):
+                proc.wait(timeout=self.grace_s)
+
+    def _handle_line(self, job: JobRequest, line: str) -> None:
+        line = line.strip()
+        if not line:
+            return
+        try:
+            event = Event.from_json_line(line)
+        except ValueError:
+            self.bus.publish(
+                Event.now(EventTypes.WORKER_STDOUT, job.run_id, job_id=job.job_id, line=line)
+            )
+            return
+        self.bus.publish(event)
+
+    # -- poll transport ----------------------------------------------------
+
+    def _run_poll(
+        self,
+        job: JobRequest,
+        argv: list[str],
+        events_path: str,
+        result_path: str,
+        deadline: float,
+    ) -> None:
+        quoted = " ".join(argv)
+        launch = self.sandbox.exec(["sh", "-c", f"nohup {quoted} >/dev/null 2>&1 & echo $!"])
+        if not launch.ok:
+            raise WorkerError(f"failed to launch worker: {launch.stderr.strip()[:2000]}")
+        pid = launch.stdout.strip().splitlines()[-1] if launch.stdout.strip() else ""
+
+        offset = 0
+        buffer = ""
+
+        def drain() -> bool:
+            """Read new event bytes; return True once worker.end is seen."""
+            nonlocal offset, buffer
+            chunk = self.sandbox.exec(
+                ["sh", "-c", f"tail -c +{offset + 1} {events_path} 2>/dev/null || true"]
+            )
+            finished = False
+            if chunk.stdout:
+                offset += len(chunk.stdout.encode())
+                *complete, buffer = (buffer + chunk.stdout).split("\n")
+                for line in complete:
+                    self._handle_line(job, line)
+                    if '"worker.end"' in line:
+                        finished = True
+            return finished
+
+        while True:
+            if time.monotonic() > deadline:
+                self._kill(job, None)
+                raise WorkerTimeoutError(
+                    f"job {job.job_id} exceeded {job.timeout_s}s (+{self.grace_s}s grace)"
+                )
+            time.sleep(self.poll_interval)
+            if drain():
+                break
+            if pid:
+                alive = self.sandbox.exec(
+                    ["sh", "-c", f"kill -0 {pid} 2>/dev/null && echo alive || echo dead"]
+                )
+                if "dead" in alive.stdout:
+                    # Worker exited between polls: drain whatever remains.
+                    drain()
+                    break
+
+    # -- helpers -----------------------------------------------------------
+
+    def _kill(self, job: JobRequest, proc: object) -> None:
+        # Pattern is job-id scoped so concurrent workers are never collateral.
+        with contextlib.suppress(Exception):
+            self.sandbox.exec(["pkill", "-f", f"sdxloop_worker.*{job.job_id}"])
+        if proc is not None:
+            with contextlib.suppress(Exception):
+                proc.kill()  # type: ignore[attr-defined]
+
+    def _fetch_result(self, job: JobRequest, result_path: str) -> JobResult:
+        try:
+            raw = self.sandbox.read_text(result_path)
+        except SbxError as exc:
+            raise WorkerError(
+                f"worker for job {job.job_id} produced no result file ({result_path})"
+            ) from exc
+        try:
+            result = JobResult.model_validate_json(raw)
+        except ValueError as exc:
+            raise WorkerError(f"invalid result file for job {job.job_id}: {exc}") from exc
+        if result.job_id != job.job_id:
+            raise WorkerError(f"result job_id mismatch: expected {job.job_id}, got {result.job_id}")
+        return result

sdxloop/worker/wheel.py

@@ -0,0 +1,73 @@
+"""Locate (or build) the sdxloop-worker wheel to install into sandboxes.
+
+Resolution order:
+
+1. **Vendored** — the wheel embedded in the installed sdxloop package at
+   ``sdxloop/_vendor/`` (placed there by the hatch build hook). This is the
+   production path and works with zero network access to PyPI for sdxloop
+   itself.
+2. **Workspace build** — when running from a source checkout (no vendor dir),
+   build the wheel from the sibling ``packages/sdxloop-worker`` tree with
+   ``uv build``. Cached per process.
+3. **None** — the caller falls back to installing ``sdxloop-worker`` from
+   PyPI inside the sandbox at the exact lockstep version.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import subprocess
+import tempfile
+from functools import lru_cache
+from importlib import resources
+from pathlib import Path
+
+import sdxloop
+
+logger = logging.getLogger(__name__)
+
+
+def _vendored_wheel() -> Path | None:
+    expected = f"sdxloop_worker-{sdxloop.__version__}-py3-none-any.whl"
+    try:
+        vendor = resources.files("sdxloop") / "_vendor"
+        candidate = Path(str(vendor)) / expected
+    except (ModuleNotFoundError, TypeError):  # pragma: no cover - defensive
+        return None
+    return candidate if candidate.is_file() else None
+
+
+def _workspace_worker_root() -> Path | None:
+    # <repo>/packages/sdxloop/src/sdxloop/__init__.py -> <repo>/packages/sdxloop-worker
+    package_dir = Path(sdxloop.__file__).resolve().parent
+    candidate = package_dir.parent.parent.parent / "sdxloop-worker"
+    return candidate if (candidate / "pyproject.toml").is_file() else None
+
+
+@lru_cache(maxsize=1)
+def _workspace_build() -> Path | None:
+    worker_root = _workspace_worker_root()
+    if worker_root is None or shutil.which("uv") is None:
+        return None
+    out_dir = Path(tempfile.mkdtemp(prefix="sdxloop-worker-wheel-"))
+    try:
+        subprocess.run(
+            ["uv", "build", "--wheel", "-o", str(out_dir), str(worker_root)],
+            check=True,
+            capture_output=True,
+            timeout=300,
+        )
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
+        logger.warning("workspace worker wheel build failed: %s", exc)
+        return None
+    wheels = sorted(out_dir.glob("sdxloop_worker-*.whl"))
+    return wheels[-1] if wheels else None
+
+
+def resolve_worker_wheel() -> Path | None:
+    """Best available worker wheel on this host, or None to use PyPI."""
+    wheel = _vendored_wheel()
+    if wheel is not None:
+        return wheel
+    return _workspace_build()

sdxloop-0.1.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: sdxloop
+Version: 0.1.0
+Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
+Project-URL: Homepage, https://github.com/brettbergin/sdxloop
+Project-URL: Repository, https://github.com/brettbergin/sdxloop
+Project-URL: Issues, https://github.com/brettbergin/sdxloop/issues
+Author: Brett Bergin
+License-Expression: MIT
+Keywords: agents,copilot,docker,orchestration,sandbox
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.7
+Requires-Dist: rich>=13.7
+Requires-Dist: sdxloop-worker==0.1.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# sdxloop
+
+Agentic loop orchestration on Docker Sandboxes (`sbx`) with isolated credential
+domains. This is the host-side orchestrator package: sandbox provisioning, the
+loop engine, and the `sdxloop` CLI.
+
+See the [project README](https://github.com/brettbergin/sdxloop) for full
+documentation.

sdxloop-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+sdxloop/__init__.py,sha256=KhX7QUkDPgqudf_H_yLGJAzw-stge28AtS6yNjCT0MA,741
+sdxloop/config.py,sha256=RDy4ImUNroUPgFDVCHKzoj6ndATSy51trYSM7VO8RtY,5692
+sdxloop/errors.py,sha256=uD5THzpjLS7CMkBzVAyE2HySK7F3VIRcYlD3dgIK5IQ,1847
+sdxloop/events.py,sha256=pJjPI6jaJOb7rbyVFGfl9uwt39g94Ah9PBGYe2W7rIA,2499
+sdxloop/ids.py,sha256=fbROK_3iWl8PahvlX33ucPO3d9p_5Kih63h5EexhA6c,847
+sdxloop/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdxloop/_vendor/sdxloop_worker-0.1.0-py3-none-any.whl,sha256=1UhPfHt_RbmZeEx-bTm9N9xbu22dflqbGDEpxrRPDEE,16397
+sdxloop/cli/__init__.py,sha256=FxivpRL36ALgWz0Mzo5Led1UqQP1ZpDHZ1WpiOAtqyE,42
+sdxloop/cli/app.py,sha256=yRNsqDj0XgUYgRGUkAFYbGJXzTvf1zpVwO5PQl9u1pQ,12213
+sdxloop/cli/doctor.py,sha256=1E4MXbGukQRcrzpdUmR3hRZiSeKXZC5W8Qf6weV56I0,4462
+sdxloop/cli/tui.py,sha256=Lxiv0VdwkU_CtZowGeYuLGUTidxAhi1zwx1iUVnO9NU,4724
+sdxloop/engine/__init__.py,sha256=8UJ3y0FEYyOcIkFboQBtXXkmsB3D6Npo2dJwkjXS6Io,461
+sdxloop/engine/engine.py,sha256=69cyoUpwCYSf84w9b9ztCnqK5TwECvtFg6W0ZJ_UZ68,14759
+sdxloop/engine/model.py,sha256=ZwrwgOxvi6IfXS61eM_tGMYl0DijkogGfgJraA2ivzk,4312
+sdxloop/engine/phases.py,sha256=RrdtTh1pzJmtlgLDJO8EMO4nAFxMdyn7zY9feeT5VRI,8903
+sdxloop/engine/store.py,sha256=jHudRJs-HXXS_957Hw1-AZk-CZ_LgtFZ5Ze1fwLSKhw,8772
+sdxloop/engine/prompts/__init__.py,sha256=GyVOTZ_QO0V27xdmV8sPbI3WK5911_ysiZrX_FMGw7E,937
+sdxloop/engine/prompts/decompose.md,sha256=_oQ931PknBXW7mtNIQWrjWl1JNPr4vznicYaIj6v14I,1160
+sdxloop/engine/prompts/execute.md,sha256=sFQDHFBwXd5snAi-i3rFdXe9PJPyR7Ry6SIrMOsSwVs,695
+sdxloop/engine/prompts/plan.md,sha256=rgU5OSovIuW6BTBv90Y3QAKeC9o6fgX8rcytp81v7eM,770
+sdxloop/engine/prompts/scrutinize.md,sha256=HMHlXiKXwIM4zf7vmI46GxMk8E0uk_BPBK7F-UVW3f8,1106
+sdxloop/engine/prompts/validate.md,sha256=a8lAKaSoSz16qWJ2oNL5WXR7L4AxSeEbIRPoZlKyNYE,940
+sdxloop/gh/__init__.py,sha256=fqroiIpvQp2EqSqlzAa0c_zmMN3-eUR9qo-av8Z1yEA,246
+sdxloop/gh/ops.py,sha256=-1RD8DP30Nj3ySrEDnTU4O2lk_rp_gdatUYOtV_s3cI,4205
+sdxloop/gh/reporter.py,sha256=KzuTpfpjOIH7dtZkeopGBUDMAnwpYtf7HrgrRS18jRk,2732
+sdxloop/sbx/__init__.py,sha256=EA6RrZUrOsfP7oWByQ_l9MJaAvbQhwvIa3aq1rlA6gY,264
+sdxloop/sbx/cli.py,sha256=kjZKiVPmT70XtXJdKMXOXlGxRNqaSw0CqjDlboI3ht4,6858
+sdxloop/sbx/models.py,sha256=czUotIcyPxz9RYYP19cuv8CYwePvO62Kw8oG55iyjr4,2410
+sdxloop/sbx/pair.py,sha256=ARkOGu2UpHms59oL2O0-9SsJwAbPBP5gcZH2f_tOmfs,3961
+sdxloop/sbx/parse.py,sha256=qCMMXjjMCe-VEmAg2OVfp_1MUVA91eaI0nUIgroz0LQ,2144
+sdxloop/sbx/provision.py,sha256=Z1yTK1lgZe999dkZMHp7cCPkeDxnUdfG9XVjxGFAos0,8051
+sdxloop/sbx/sandbox.py,sha256=P7A4x_NF1Nr7clTx4g9VlYKiEDTJoYJ3PCg1klLF92s,2286
+sdxloop/worker/__init__.py,sha256=CfOP1joUZRLWZKiqQ0hpEHX8-NY8LSW3W5ZCEWbxTdE,227
+sdxloop/worker/client.py,sha256=5Y8DTesKK7p2iUTtD_VgntQ98GyCkPz0bujsGzO-ZeU,9796
+sdxloop/worker/wheel.py,sha256=0wiqOWfy3W0k-GnBW7B1n5ZlykZF82qA61yvG4fH_0I,2564
+sdxloop-0.1.0.dist-info/METADATA,sha256=lCmXPTJYE_L-RnOH7IjOpgBeDCzdex898r3BnIf1ebk,1235
+sdxloop-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sdxloop-0.1.0.dist-info/entry_points.txt,sha256=s2Me94C3iGEfT_9rs_O1ojQIy2UfNlUUBYH4yjWj9Fg,49
+sdxloop-0.1.0.dist-info/RECORD,,

sdxloop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sdxloop-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sdxloop = sdxloop.cli.app:main