opencomputer-sdk 0.6.1__tar.gz → 0.6.3__tar.gz

{opencomputer_sdk-0.6.1 → opencomputer_sdk-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencomputer-sdk
-Version: 0.6.1
+Version: 0.6.3
 Summary: Python SDK for OpenComputer - cloud sandbox platform
 Project-URL: Homepage, https://github.com/diggerhq/opensandbox
 Project-URL: Repository, https://github.com/diggerhq/opensandbox

{opencomputer_sdk-0.6.1 → opencomputer_sdk-0.6.3}/opencomputer/__init__.py

@@ -65,4 +65,4 @@ __all__ = [
     "TagKeyInfo",
 ]
 
-__version__ = "0.6.0"
+__version__ = "0.6.3"

{opencomputer_sdk-0.6.1 → opencomputer_sdk-0.6.3}/opencomputer/image.py

@@ -6,7 +6,7 @@ import base64
 import hashlib
 import json
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import Any
 
 
@@ -47,6 +47,10 @@ class Image:
 
     _base: str = "base"
     _steps: tuple[ImageStep, ...] = field(default_factory=tuple)
+    # RAM for the build phase (apt/pip). 0 = server default. Does not pin the
+    # output image — the server re-snapshots at the default 1 GB floor, and you
+    # size the actual sandbox at create time via memory_mb.
+    _builder_memory_mb: int = 0
 
     @classmethod
     def base(cls) -> Image:
@@ -60,36 +64,36 @@ class Image:
 
     def apt_install(self, packages: list[str]) -> Image:
         """Install system packages via apt-get."""
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("apt_install", {"packages": packages})),
         )
 
     def pip_install(self, packages: list[str]) -> Image:
         """Install Python packages via pip."""
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("pip_install", {"packages": packages})),
         )
 
     def run_commands(self, *commands: str) -> Image:
         """Run one or more shell commands."""
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("run", {"commands": list(commands)})),
         )
 
     def env(self, vars: dict[str, str]) -> Image:
         """Set environment variables (written to /etc/environment)."""
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("env", {"vars": vars})),
         )
 
     def workdir(self, path: str) -> Image:
         """Set the default working directory."""
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("workdir", {"path": path})),
         )
 
@@ -101,8 +105,8 @@ class Image:
             content: String content of the file.
         """
         encoded = base64.b64encode(content.encode()).decode()
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("add_file", {
                 "path": remote_path,
                 "content": encoded,
@@ -121,8 +125,8 @@ class Image:
         """
         with open(local_path, "rb") as f:
             encoded = base64.b64encode(f.read()).decode()
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("add_file", {
                 "path": remote_path,
                 "content": encoded,
@@ -147,22 +151,33 @@ class Image:
                 with open(full, "rb") as f:
                     encoded = base64.b64encode(f.read()).decode()
                 files.append({"relativePath": rel, "content": encoded})
-        return Image(
-            _base=self._base,
+        return replace(
+            self,
             _steps=(*self._steps, ImageStep("add_dir", {
                 "path": remote_path,
                 "files": files,
             })),
         )
 
+    def builder_memory(self, mb: int) -> Image:
+        """Set the RAM (MB) for the build phase. Use this when a build OOMs at the
+        default 4 GB (e.g. heavy ``apt``/``pip``/``npm``). Does not affect the
+        resulting image's memory — size the sandbox at create time via ``memory_mb``."""
+        return replace(self, _builder_memory_mb=mb)
+
     def to_dict(self) -> dict[str, Any]:
         """Returns the manifest as a plain dict (for JSON serialization)."""
-        return {
+        d: dict[str, Any] = {
             "base": self._base,
             "steps": [s.to_dict() for s in self._steps],
         }
+        if self._builder_memory_mb > 0:
+            d["builderMemoryMB"] = self._builder_memory_mb
+        return d
 
     def cache_key(self) -> str:
-        """Compute a deterministic content hash for caching."""
-        canonical = json.dumps(self.to_dict(), sort_keys=True, separators=(",", ":"))
+        """Deterministic content hash for caching. Memory knobs are resource
+        params, not image content, so they're excluded (matches the server)."""
+        content = {"base": self._base, "steps": [s.to_dict() for s in self._steps]}
+        canonical = json.dumps(content, sort_keys=True, separators=(",", ":"))
         return hashlib.sha256(canonical.encode()).hexdigest()

{opencomputer_sdk-0.6.1 → opencomputer_sdk-0.6.3}/opencomputer/sandbox.py

@@ -70,6 +70,12 @@ class Sandbox:
     sandbox_id: str
     status: str = "running"
     template: str = ""
+    #: Plaintext preview-URL bearer token, available immediately after a
+    #: ``Sandbox.create(preview_auth=...)`` call. Read it once and store
+    #: it somewhere durable — the server will not return it again. After
+    #: a successful ``rotate_preview_auth_token()`` this value is replaced
+    #: with the new token. Empty string when not enabled or when reconnecting.
+    preview_auth_token: str = ""
     _api_url: str = ""
     _api_key: str = ""
     _connect_url: str = ""
@@ -77,6 +83,10 @@ class Sandbox:
     _client: httpx.AsyncClient = field(default=None, repr=False)
     _data_client: httpx.AsyncClient = field(default=None, repr=False)
 
+    @property
+    def id(self) -> str:
+        return self.sandbox_id
+
     @classmethod
     async def create(
         cls,
@@ -94,6 +104,7 @@ class Sandbox:
         image: Image | None = None,
         snapshot: str | None = None,
         on_build_log: Callable[[str], None] | None = None,
+        preview_auth: dict[str, str] | None = None,
     ) -> Sandbox:
         """Create a new sandbox instance.
 
@@ -121,6 +132,15 @@ class Sandbox:
             image: Declarative Image definition. The server builds and caches it as a checkpoint.
             snapshot: Name of a pre-built snapshot to create the sandbox from.
             on_build_log: Callback for build log streaming when using image/snapshot.
+            preview_auth: Require a bearer token on the sandbox's preview URLs.
+                When set, every request to ``https://sb-{id}-p{port}.<domain>``
+                must include the token in an ``Authorization: Bearer <token>``
+                or ``X-OC-Preview-Token`` header. The check happens at the edge
+                before traffic reaches the VM. Pass ``{"token": "auto"}`` (or
+                omit the key) to have the server generate a 256-bit random
+                token; pass an explicit string (>=16 chars) to bring your own.
+                The plaintext is returned exactly once and assigned to
+                ``sandbox.preview_auth_token``.
         """
         url = api_url or os.environ.get("OPENCOMPUTER_API_URL", "https://app.opencomputer.dev")
         url = url.rstrip("/")
@@ -165,6 +185,11 @@ class Sandbox:
             body["image"] = image.to_dict()
         if snapshot is not None:
             body["snapshot"] = snapshot
+        if preview_auth is not None:
+            body["previewAuth"] = {
+                "scheme": preview_auth.get("scheme", "bearer"),
+                "token": preview_auth.get("token", "auto"),
+            }
 
         if use_sse:
             data = await cls._create_with_sse(client, body, on_build_log)
@@ -189,6 +214,7 @@ class Sandbox:
             sandbox_id=data["sandboxID"],
             status=data.get("status", "running"),
             template=template,
+            preview_auth_token=data.get("previewAuthToken", ""),
             _api_url=url,
             _api_key=key,
             _connect_url=connect_url,
@@ -809,6 +835,25 @@ class Sandbox:
         if resp.status_code != 404:
             resp.raise_for_status()
 
+    async def rotate_preview_auth_token(self) -> str:
+        """Issue a new preview-URL bearer token; invalidate the previous one.
+
+        The old token stops working immediately — there is no zero-downtime
+        dual-token mode in v1, so coordinate the rollover with whoever is
+        calling your preview URL. If the sandbox was created without
+        ``preview_auth``, calling this enables the auth gate from now on.
+
+        Returns the new plaintext token (also written to
+        ``self.preview_auth_token``).
+        """
+        resp = await self._client.post(
+            f"/sandboxes/{self.sandbox_id}/preview/rotate",
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        self.preview_auth_token = data["previewAuthToken"]
+        return self.preview_auth_token
+
     async def create_preview_url(self, port: int, domain: str | None = None, auth_config: dict | None = None) -> dict:
         """Create a preview URL targeting a specific container port.
 

{opencomputer_sdk-0.6.1 → opencomputer_sdk-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencomputer-sdk"
-version = "0.6.1"
+version = "0.6.3"
 description = "Python SDK for OpenComputer - cloud sandbox platform"
 readme = "README.md"
 requires-python = ">=3.10"