sbxloop 0.2.0__py3-none-any.whl

sbxloop/worker/client.py

@@ -0,0 +1,397 @@
+"""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 logging
+import queue
+import shlex
+import threading
+import time
+from collections import deque
+from pathlib import Path
+
+import sbxloop
+from sbxloop.config import WorkerTransport
+from sbxloop.errors import SbxError, WorkerError, WorkerTimeoutError
+from sbxloop.events import EventBus
+from sbxloop.sbx.models import ExecResult
+from sbxloop.sbx.sandbox import ENV_FILE, EVENTS_DIR, JOBS_DIR, RESULTS_DIR, VENV_DIR, Sandbox
+from sbxloop.sbx.sandbox import VENV_PYTHON as DEFAULT_PYTHON
+from sbxloop.worker.wheel import resolve_worker_wheel
+from sbxloop_worker.protocol import Event, EventTypes, JobRequest, JobResult
+
+# Wheels must keep their canonical filename when staged: pip validates the
+# name-version-python-abi-platform structure of the FILENAME itself and
+# refuses to install a renamed wheel ("Invalid wheel filename").
+STAGED_WHEEL_DIR = "/tmp"
+
+logger = logging.getLogger(__name__)
+
+
+def _output_tail(result: ExecResult, limit: int = 2000) -> str:
+    """Combined stderr+stdout tail: sbx exec surfaces some in-sandbox errors
+    on stdout, so stderr alone can be empty exactly when it matters."""
+    combined = "\n".join(part.strip() for part in (result.stderr, result.stdout) if part.strip())
+    return combined[-limit:] if combined else "(no output)"
+
+
+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:
+        """Install sbxloop-worker into the sandbox, venv-first with fallbacks.
+
+        Sandbox templates ship python3 but often lack python3-venv
+        (Debian/Ubuntu split ensurepip out). The ladder:
+
+        1. ``python3 -m venv`` — the clean path.
+        2. On a venv/ensurepip failure: ``sudo -n apt-get install
+           python3-venv python3-pip`` (the template's agent user has sudo;
+           apt hosts are on the balanced allowlist), then retry the venv.
+        3. Still no venv: **user-site fallback** — ``python3 -m pip install
+           --user`` (adding ``--break-system-packages`` when pip reports an
+           externally-managed environment), and the worker runs under the
+           system ``python3``. ``self.python`` is updated so submit() uses
+           the right interpreter either way.
+
+        ``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()
+        if wheel is not None:
+            staged = f"{STAGED_WHEEL_DIR}/{wheel.name}"
+            self.sandbox.cp_in(wheel, staged)
+            base_target = staged
+        else:
+            base_target = f"sbxloop-worker=={sbxloop.__version__}"
+        target = f"{base_target}[{extras}]" if extras else base_target
+
+        if self._create_venv(timeout, system_site_packages):
+            self.python = DEFAULT_PYTHON
+            pip = [f"{VENV_DIR}/bin/pip", "install", "--quiet"]
+            if no_deps:
+                pip.append("--no-deps")
+            self._check(self.sandbox.exec([*pip, target], timeout=timeout), "worker install")
+        else:
+            self.python = "python3"
+            self._pip_user_install(target, timeout=timeout, no_deps=no_deps)
+
+        verify = self.sandbox.exec(
+            [self.python, "-c", "import sbxloop_worker; print(sbxloop_worker.__version__)"]
+        )
+        self._check(verify, "worker import check")
+        installed = verify.stdout.strip()
+        if installed != sbxloop.__version__:
+            raise WorkerError(
+                f"worker version {installed!r} does not match host {sbxloop.__version__!r}"
+            )
+
+        # Entrypoint smoke check: importing the package proves nothing about
+        # `python -m sbxloop_worker` actually executing under sbx exec. A run
+        # against a missing job file must exit 64 (the worker's usage-error
+        # code) — anything else means jobs would die with no result file,
+        # so fail HERE with full output instead of at the first real job.
+        smoke = self.sandbox.exec(
+            [
+                self.python,
+                "-m",
+                "sbxloop_worker",
+                "run",
+                "--job",
+                "/tmp/sbxloop-smoke-missing.json",
+                "--events",
+                "/tmp/sbxloop-smoke.events.jsonl",
+                "--result",
+                "/tmp/sbxloop-smoke.result.json",
+            ]
+        )
+        if smoke.returncode != 64:
+            raise WorkerError(
+                "worker entrypoint check failed "
+                f"(rc={smoke.returncode}, expected 64): {_output_tail(smoke)}"
+            )
+
+    def _create_venv(self, timeout: float, system_site_packages: bool) -> bool:
+        venv_cmd = ["python3", "-m", "venv"]
+        if system_site_packages:
+            venv_cmd.append("--system-site-packages")
+        venv_cmd.append(VENV_DIR)
+
+        result = self.sandbox.exec(venv_cmd, timeout=timeout)
+        if result.ok:
+            return True
+        output = f"{result.stdout} {result.stderr}".lower()
+        if "ensurepip" in output or "venv" in output:
+            # Self-heal: the official templates run Ubuntu with a sudo-capable
+            # agent user, and apt hosts are on the balanced allowlist.
+            self.sandbox.exec(
+                [
+                    "sh",
+                    "-c",
+                    "sudo -n apt-get update -q && "
+                    "sudo -n apt-get install -y -q python3-venv python3-pip",
+                ],
+                timeout=timeout,
+            )
+            result = self.sandbox.exec(venv_cmd, timeout=timeout)
+            if result.ok:
+                return True
+        logger.warning(
+            "venv creation failed (rc=%s): %s — falling back to a user-site install "
+            "with the system python3",
+            result.returncode,
+            _output_tail(result),
+        )
+        return False
+
+    def _pip_user_install(self, target: str, *, timeout: float, no_deps: bool) -> None:
+        pip = ["python3", "-m", "pip", "install", "--quiet", "--user"]
+        if no_deps:
+            pip.append("--no-deps")
+        result = self.sandbox.exec([*pip, target], timeout=timeout)
+        if not result.ok and "externally-managed" in f"{result.stdout} {result.stderr}".lower():
+            # PEP 668 (Ubuntu 24.04+): system pip refuses --user without an
+            # explicit opt-out.
+            result = self.sandbox.exec([*pip, "--break-system-packages", target], timeout=timeout)
+        self._check(result, "worker install (user-site fallback)")
+
+    @staticmethod
+    def _check(result: ExecResult, step: str) -> None:
+        if not result.ok:
+            raise WorkerError(f"{step} failed (rc={result.returncode}): {_output_tail(result)}")
+
+    # -- 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",
+            "sbxloop_worker",
+            "run",
+            "--job",
+            job_path,
+            "--events",
+            events_path,
+            "--result",
+            result_path,
+            "--env-file",
+            ENV_FILE,
+        ]
+        # sbx injects secrets through the sandbox session/profile machinery;
+        # a bare exec'd process may not see them. Run the worker under a
+        # login shell so the sandbox environment is fully loaded.
+        wrapped = ["sh", "-lc", shlex.join(argv)]
+        deadline = time.monotonic() + job.timeout_s + self.grace_s
+        if self.transport == "poll":
+            self._run_poll(job, wrapped, events_path, result_path, deadline)
+            diagnostics = ""
+        else:
+            diagnostics = self._run_stream(job, wrapped, deadline)
+        return self._fetch_result(job, result_path, events_path, diagnostics)
+
+    # -- stream transport --------------------------------------------------
+
+    def _run_stream(self, job: JobRequest, argv: list[str], deadline: float) -> str:
+        """Run the worker via a blocking exec; returns diagnostics (exit code
+        + stderr tail) for the no-result failure path."""
+        proc = self.sandbox.exec_stream(argv)
+        lines: queue.Queue[str | None] = queue.Queue()
+        stderr_tail: deque[str] = deque(maxlen=50)
+
+        def reader() -> None:
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                lines.put(line)
+            lines.put(None)
+
+        def err_reader() -> None:
+            # stderr must be drained: an unread PIPE deadlocks a chatty
+            # worker once the 64KB buffer fills — and its content is the
+            # only clue when the process dies before writing a result.
+            assert proc.stderr is not None
+            for line in proc.stderr:
+                stderr_tail.append(line.rstrip())
+
+        threading.Thread(target=reader, name="sbxloop-stream-reader", daemon=True).start()
+        threading.Thread(target=err_reader, name="sbxloop-stderr-reader", daemon=True).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)
+        parts = [f"exec rc={proc.returncode}"]
+        if stderr_tail:
+            parts.append("stderr: " + " | ".join(stderr_tail)[-1500:])
+        return "; ".join(parts)
+
+    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 = shlex.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"sbxloop_worker.*{job.job_id}"])
+        if proc is not None:
+            with contextlib.suppress(Exception):
+                proc.kill()  # type: ignore[attr-defined]
+
+    def _events_tail(self, events_path: str, lines: int = 5) -> str:
+        if not events_path:
+            return ""
+        with contextlib.suppress(Exception):
+            result = self.sandbox.exec(
+                ["sh", "-c", f"tail -n {lines} {events_path} 2>/dev/null || true"]
+            )
+            return result.stdout.strip().replace("\n", " | ")[-1500:]
+        return ""
+
+    def _fetch_result(
+        self,
+        job: JobRequest,
+        result_path: str,
+        events_path: str = "",
+        diagnostics: str = "",
+    ) -> JobResult:
+        try:
+            raw = self.sandbox.read_text(result_path)
+        except SbxError as exc:
+            detail = [f"worker for job {job.job_id} produced no result file ({result_path})"]
+            if diagnostics:
+                detail.append(diagnostics)
+            tail = self._events_tail(events_path)
+            if tail:
+                detail.append(f"last events: {tail}")
+            raise WorkerError("; ".join(detail)) 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

sbxloop/worker/wheel.py

@@ -0,0 +1,73 @@
+"""Locate (or build) the sbxloop-worker wheel to install into sandboxes.
+
+Resolution order:
+
+1. **Vendored** — the wheel embedded in the installed sbxloop package at
+   ``sbxloop/_vendor/`` (placed there by the hatch build hook). This is the
+   production path and works with zero network access to PyPI for sbxloop
+   itself.
+2. **Workspace build** — when running from a source checkout (no vendor dir),
+   build the wheel from the sibling ``packages/sbxloop-worker`` tree with
+   ``uv build``. Cached per process.
+3. **None** — the caller falls back to installing ``sbxloop-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 sbxloop
+
+logger = logging.getLogger(__name__)
+
+
+def _vendored_wheel() -> Path | None:
+    expected = f"sbxloop_worker-{sbxloop.__version__}-py3-none-any.whl"
+    try:
+        vendor = resources.files("sbxloop") / "_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/sbxloop/src/sbxloop/__init__.py -> <repo>/packages/sbxloop-worker
+    package_dir = Path(sbxloop.__file__).resolve().parent
+    candidate = package_dir.parent.parent.parent / "sbxloop-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="sbxloop-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("sbxloop_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()

sbxloop-0.2.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: sbxloop
+Version: 0.2.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
+Project-URL: Issues, https://github.com/brettbergin/sbxloop/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: python-dotenv>=1.0
+Requires-Dist: rich>=13.7
+Requires-Dist: sbxloop-worker==0.2.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# sbxloop
+
+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 `sbxloop` CLI.
+
+See the [project README](https://github.com/brettbergin/sbxloop) for full
+documentation.

sbxloop-0.2.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+sbxloop/__init__.py,sha256=RQcCoppqAISnZXZNTm9VXGKa5xtz38vXNHRW4rSUs9Y,741
+sbxloop/config.py,sha256=VjjmQ-mjRBYw8AHHmo6D2-InqS5A5OO4tCoCy_ACim0,6757
+sbxloop/errors.py,sha256=ncVqK66R2ir1k5q9K_HcOYU7XAnWy6CbaJxxOjjX2UE,1847
+sbxloop/events.py,sha256=DVVTk_v5GrDdHa8XbcKh20VLIivVoW3JIIMnuKjccSM,2499
+sbxloop/ids.py,sha256=fbROK_3iWl8PahvlX33ucPO3d9p_5Kih63h5EexhA6c,847
+sbxloop/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sbxloop/_vendor/sbxloop_worker-0.2.0-py3-none-any.whl,sha256=_0AhTlG7dc3IyGUI8lnzPgZcohyQv49uwvmdPXLiR7s,16994
+sbxloop/cli/__init__.py,sha256=pjFZzGSZoDSr17oD0ay8d7jElyNl3YliaFDEgsnmKvE,42
+sbxloop/cli/app.py,sha256=HupCo1DWL6fXpIP395ykBBEYXP7rr4ISdWPMqTDSyLs,12577
+sbxloop/cli/doctor.py,sha256=4PfvOH6rg7kSigIwMlR0ACiM0c5BOqAPs0wOBuYnvoQ,5582
+sbxloop/cli/tui.py,sha256=DE2AXG5ifL3VRelvU8S3a2RAbrAm15rbvZ4W4KnAzVY,7608
+sbxloop/engine/__init__.py,sha256=87MAO9S35sn8k30mTPvOUJnDTHRjFNZOfAAu3wqQ2_M,461
+sbxloop/engine/engine.py,sha256=cQO1lx58sZb5n2MpfbrOO1BD4o88-7Ryk6_Ft-HZwjE,14960
+sbxloop/engine/model.py,sha256=ZwrwgOxvi6IfXS61eM_tGMYl0DijkogGfgJraA2ivzk,4312
+sbxloop/engine/phases.py,sha256=jrlAlblGxKsaAApk4Kki16_H9IL8EqHrHA-vb0SchM0,8903
+sbxloop/engine/store.py,sha256=YfsxQ5bp71rw6ukGHb4wH1NXkzdmIREduPeW78Xg8uk,8772
+sbxloop/engine/prompts/__init__.py,sha256=GyVOTZ_QO0V27xdmV8sPbI3WK5911_ysiZrX_FMGw7E,937
+sbxloop/engine/prompts/decompose.md,sha256=_oQ931PknBXW7mtNIQWrjWl1JNPr4vznicYaIj6v14I,1160
+sbxloop/engine/prompts/execute.md,sha256=sFQDHFBwXd5snAi-i3rFdXe9PJPyR7Ry6SIrMOsSwVs,695
+sbxloop/engine/prompts/plan.md,sha256=rgU5OSovIuW6BTBv90Y3QAKeC9o6fgX8rcytp81v7eM,770
+sbxloop/engine/prompts/scrutinize.md,sha256=HMHlXiKXwIM4zf7vmI46GxMk8E0uk_BPBK7F-UVW3f8,1106
+sbxloop/engine/prompts/validate.md,sha256=a8lAKaSoSz16qWJ2oNL5WXR7L4AxSeEbIRPoZlKyNYE,940
+sbxloop/gh/__init__.py,sha256=fepcbuGH_PghbrMopE0hIkQ2M7AvQ79v8mmCEgieuOc,246
+sbxloop/gh/ops.py,sha256=loeqsv98t3725DxrBvcPeoXbsRvC74-x8bJEoPioFsk,4205
+sbxloop/gh/reporter.py,sha256=gNp5jxG9MofOo6A_xXkGL95mpso16ODpiLNCWUw9SpA,2732
+sbxloop/sbx/__init__.py,sha256=BbxXDte1P8QUf8EEq1QvPdqdpLbUmh6tVOIh3ZD8dVw,264
+sbxloop/sbx/cli.py,sha256=YaZwCY5iDRV5eKtcbyRxIsMEX0rqc5x3iFL8GU3MAxM,7764
+sbxloop/sbx/models.py,sha256=czUotIcyPxz9RYYP19cuv8CYwePvO62Kw8oG55iyjr4,2410
+sbxloop/sbx/pair.py,sha256=I7o9eOG7BexPxQFpcIW_OwM1YdAEmryYraiT2hYW7js,3961
+sbxloop/sbx/parse.py,sha256=D3evxMonvYsw9Mx0ozyfKRC_IDt7vXMg-zs7Expozi8,2144
+sbxloop/sbx/provision.py,sha256=0wPWtI9V2Od13tcDQDyzK6UR6-DFvOsPyZTfFwgZRK4,14866
+sbxloop/sbx/sandbox.py,sha256=EYspkBKj5JEt-Y4Ma-D-608BEkEeckIRWDLzj-Gv0Oo,2613
+sbxloop/worker/__init__.py,sha256=1YZ4g5YF6MBaH8Bt_ZZtEIM5ltdhRCu-iFReZ5LGcbE,227
+sbxloop/worker/client.py,sha256=_3btiIM9OmtsCp9UBqBDQ1VfP7Wts-ZNj_OvsffBOto,15963
+sbxloop/worker/wheel.py,sha256=vSFwQHRWVLo124pEHmKKji1_q1Tr4hRofEfKOb0aqV8,2564
+sbxloop-0.2.0.dist-info/METADATA,sha256=-7sPQrRJjOtDldZEMYSWdadhr-wY9oZkeviVqGRxOw8,1269
+sbxloop-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sbxloop-0.2.0.dist-info/entry_points.txt,sha256=47smbBU306_uO80byyBBoEyx-8mo6vLf-FPL5vKX23o,49
+sbxloop-0.2.0.dist-info/RECORD,,

sbxloop-0.2.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

sbxloop-0.2.0.dist-info/entry_points.txt

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