mv37-workdir 0.1.0__py3-none-any.whl

mv37_workdir-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: mv37-workdir
+Version: 0.1.0
+Summary: Python SDK for workdir
+Project-URL: Homepage, https://workdir.dev
+Project-URL: Repository, https://github.com/mv37-org/workdir
+Project-URL: Issues, https://github.com/mv37-org/workdir/issues
+Author: mv37
+License-Expression: AGPL-3.0-only
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# mv37-workdir
+
+Python SDK for [workdir](https://workdir.dev).
+
+```bash
+pip install mv37-workdir
+```
+
+```python
+from workdir import Client
+
+workdir = Client("https://api.workdir.dev", api_key="...")
+
+box = workdir.sandboxes.create()
+print(box.exec("echo hello").stdout)
+box.delete()
+```
+
+The SDK uses only the Python standard library.

mv37_workdir-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+workdir/__init__.py,sha256=qTMhHl-vHH6-_vSfn9zOX3ixCche7_BRGnXOjBe7k_4,8312
+workdir/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mv37_workdir-0.1.0.dist-info/METADATA,sha256=jGaPC6X4UMfmRY5H8cty1By08aMD_wTDLgLGS7yhkbc,998
+mv37_workdir-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+mv37_workdir-0.1.0.dist-info/RECORD,,

mv37_workdir-0.1.0.dist-info/WHEEL

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

workdir/__init__.py

@@ -0,0 +1,251 @@
+"""Minimal Python SDK for workdir.
+
+The default path is one call::
+
+    from workdir import Client
+    client = Client("https://api.sandboxes.example.com", api_key="sk_live_...")
+    sandbox = client.sandboxes.create()          # cheap default path
+    print(sandbox.exec("echo ok").stdout)
+    sandbox.delete()
+
+Heavier sandboxes require explicit options (spec §3.4)::
+
+    sandbox = client.sandboxes.create(
+        image="browser",
+        resources={"cpu": 2, "memory_mb": 4096, "disk_gb": 16},
+        browser={"enabled": True, "vnc": True, "cdp": True},
+        startup={
+            "git": {"url": "https://github.com/acme/app.git", "ref": "main", "depth": 1},
+            "commands": [{"name": "install", "run": "pnpm install --frozen-lockfile"}],
+            "ports": [3000, 6080],
+            "ready": {"http": "http://127.0.0.1:3000", "timeout_seconds": 30},
+        },
+    )
+    print(sandbox.urls["vnc"])
+
+Opt in to an in-sandbox coding agent (opencode), installed on demand::
+
+    sandbox = client.sandboxes.create(
+        coding_agent={"enabled": True},
+        startup={"secrets": ["ANTHROPIC_API_KEY"]},
+    )
+    sandbox.exec("opencode run 'add a test for utils.py'")
+
+Uses only the standard library (urllib), so it has zero dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Optional
+
+__all__ = ["Client", "ExecResult", "Sandbox", "SandboxError"]
+
+
+class SandboxError(Exception):
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(f"[{status} {code}] {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+
+
+@dataclass
+class ExecResult:
+    exit_code: int
+    stdout: str
+    stderr: str
+
+
+class _Http:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 60.0):
+        self.base = base_url.rstrip("/")
+        self.key = api_key
+        self.timeout = timeout
+
+    def request(self, method: str, path: str, body: Optional[dict] = None) -> Any:
+        url = f"{self.base}{path}"
+        data = json.dumps(body).encode() if body is not None else None
+        req = urllib.request.Request(url, data=data, method=method)
+        req.add_header("Authorization", f"Bearer {self.key}")
+        req.add_header("Content-Type", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                return json.loads(raw) if raw else {}
+        except urllib.error.HTTPError as e:
+            raw = e.read()
+            try:
+                err = json.loads(raw)["error"]
+                raise SandboxError(e.code, err.get("code", "error"), err.get("message", "")) from None
+            except (ValueError, KeyError):
+                raise SandboxError(e.code, "error", raw.decode(errors="replace")) from None
+
+
+class Sandbox:
+    def __init__(self, http: _Http, data: dict):
+        self._http = http
+        self._data = data
+
+    @property
+    def id(self) -> str:
+        return self._data["id"]
+
+    @property
+    def state(self) -> str:
+        return self._data["state"]
+
+    @property
+    def boot_path(self) -> str:
+        return self._data["boot_path"]
+
+    @property
+    def timings(self) -> dict:
+        return self._data.get("timings", {})
+
+    @property
+    def urls(self) -> dict:
+        return self._data.get("urls", {})
+
+    @property
+    def price(self) -> dict:
+        return self._data.get("price", {})
+
+    def refresh(self) -> "Sandbox":
+        self._data = self._http.request("GET", f"/v1/sandboxes/{self.id}")
+        return self
+
+    def exec(self, cmd: str, cwd: Optional[str] = None, env: Optional[dict] = None,
+             background: bool = False) -> ExecResult:
+        body = {"cmd": cmd, "background": background}
+        if cwd:
+            body["cwd"] = cwd
+        if env:
+            body["env"] = env
+        r = self._http.request("POST", f"/v1/sandboxes/{self.id}/exec", body)
+        return ExecResult(r["exit_code"], r["stdout"], r["stderr"])
+
+    def write_file(self, path: str, content: str) -> None:
+        self._http.request("PUT", f"/v1/sandboxes/{self.id}/files",
+                           {"path": path, "content": content})
+
+    def read_file(self, path: str) -> str:
+        q = urllib.parse.urlencode({"path": path})
+        r = self._http.request("GET", f"/v1/sandboxes/{self.id}/files?{q}")
+        return r["content"]
+
+    def expose_port(self, port: int) -> str:
+        r = self._http.request("POST", f"/v1/sandboxes/{self.id}/ports/{port}/expose")
+        return r["url"]
+
+    def browser(self) -> dict:
+        return self._http.request("GET", f"/v1/sandboxes/{self.id}/browser")
+
+    def snapshot(self) -> dict:
+        return self._http.request("POST", f"/v1/sandboxes/{self.id}/snapshot")
+
+    def pause(self) -> "Sandbox":
+        self._data = self._http.request("POST", f"/v1/sandboxes/{self.id}/pause")
+        return self
+
+    def resume(self) -> "Sandbox":
+        self._data = self._http.request("POST", f"/v1/sandboxes/{self.id}/resume")
+        return self
+
+    def delete(self) -> None:
+        self._http.request("DELETE", f"/v1/sandboxes/{self.id}")
+
+
+class _Sandboxes:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def create(self, **options) -> Sandbox:
+        # `create()` with no args yields the cheapest, fastest default path.
+        body = {k: v for k, v in options.items() if v is not None}
+        data = self._http.request("POST", "/v1/sandboxes", body)
+        return Sandbox(self._http, data)
+
+    def get(self, sandbox_id: str) -> Sandbox:
+        return Sandbox(self._http, self._http.request("GET", f"/v1/sandboxes/{sandbox_id}"))
+
+    def list(self) -> list[Sandbox]:
+        data = self._http.request("GET", "/v1/sandboxes")
+        return [Sandbox(self._http, s) for s in data.get("sandboxes", [])]
+
+
+class _Images:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def create(self, name: str, source: dict, resources_hint: Optional[dict] = None) -> dict:
+        body = {"name": name, "source": source}
+        if resources_hint:
+            body["resources_hint"] = resources_hint
+        return self._http.request("POST", "/v1/images", body)
+
+    def get(self, image_id: str) -> dict:
+        return self._http.request("GET", f"/v1/images/{image_id}")
+
+    def list(self) -> dict:
+        return self._http.request("GET", "/v1/images")
+
+    def delete(self, image_id: str) -> dict:
+        return self._http.request("DELETE", f"/v1/images/{image_id}")
+
+
+class _Nodes:
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def list(self) -> dict:
+        return self._http.request("GET", "/v1/nodes")
+
+    def join_token(self) -> dict:
+        return self._http.request("POST", "/v1/nodes/join-token")
+
+    def drain(self, node_id: str) -> dict:
+        return self._http.request("POST", f"/v1/nodes/{node_id}/drain")
+
+
+class _Secrets:
+    """Org-scoped secrets. Values are encrypted at rest and never returned."""
+
+    def __init__(self, http: _Http):
+        self._http = http
+
+    def set(self, name: str, value: str) -> dict:
+        return self._http.request("PUT", f"/v1/secrets/{name}", {"value": value})
+
+    def list(self) -> list[dict]:
+        return self._http.request("GET", "/v1/secrets").get("secrets", [])
+
+    def delete(self, name: str) -> dict:
+        return self._http.request("DELETE", f"/v1/secrets/{name}")
+
+
+class Client:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 60.0):
+        self._http = _Http(base_url, api_key, timeout)
+        self.sandboxes = _Sandboxes(self._http)
+        self.images = _Images(self._http)
+        self.nodes = _Nodes(self._http)
+        self.secrets = _Secrets(self._http)
+
+    def usage(self) -> dict:
+        return self._http.request("GET", "/v1/usage")
+
+
+if __name__ == "__main__":
+    import os
+    client = Client(os.environ.get("WORKDIR_URL", "http://127.0.0.1:8080"),
+                    os.environ["WORKDIR_API_KEY"])
+    sb = client.sandboxes.create()
+    print("created", sb.id, "boot_path", sb.boot_path, "boot_ms", sb.timings.get("boot_ms"))
+    print("echo:", sb.exec("echo ok").stdout.strip())
+    sb.delete()
+    print("deleted")

workdir/py.typed

@@ -0,0 +1 @@
+