opencomputer-sdk 0.6.2__tar.gz → 0.6.4__tar.gz

{opencomputer_sdk-0.6.2 → opencomputer_sdk-0.6.4}/.gitignore

@@ -18,6 +18,9 @@ Thumbs.db
 .env
 .env.*
 !.env.example
+# Cloudflare Worker local secrets (wrangler dev)
+.dev.vars
+.dev.vars.*
 
 # Per-developer dev-box lifecycle state (written by deploy/*/deploy-qemu-dev.sh)
 deploy/**/.qemu-dev-state-*

{opencomputer_sdk-0.6.2 → opencomputer_sdk-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencomputer-sdk
-Version: 0.6.2
+Version: 0.6.4
 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.2 → opencomputer_sdk-0.6.4}/opencomputer/__init__.py

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

{opencomputer_sdk-0.6.2 → opencomputer_sdk-0.6.4}/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.2 → opencomputer_sdk-0.6.4}/opencomputer/mounts.py

@@ -1,15 +1,20 @@
-"""FUSE-backed remote filesystem mounts inside a sandbox.
-
-Mounts use ``rclone mount`` under the hood — one driver covering ~40 backends
-(S3, GCS, Azure Blob, SFTP, WebDAV, Dropbox, etc.). Credentials are passed
-inline, written to a tmpfs file inside the VM (mode 0600), and never persisted
-on the worker. v1 does NOT auto-restore mounts on hibernate/wake — callers
-re-issue ``add(...)`` after a wake if they need the mount back.
+"""FUSE-backed filesystem mounts inside a sandbox.
+
+Two drivers:
+
+- ``rclone`` (default, via :meth:`Mounts.add`): wrap any of rclone's ~40
+  backends (S3, GCS, Azure Blob, SFTP, WebDAV, Dropbox, …) behind a simple
+  remote+creds shape. Creds are written to a tmpfs file (mode 0600), never
+  persisted on the worker.
+- ``command`` (via :meth:`Mounts.add_command`): run your own FUSE daemon /
+  mount command. Use this when you already have a FUSE-ready filesystem and
+  don't want rclone as a middle layer. Secrets are injected into the daemon's
+  process env (never the command line) and never persisted.
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Literal
 
 import httpx
@@ -21,17 +26,22 @@ MountBackend = Literal["s3", "gcs", "azureblob", "sftp", "webdav", "dropbox"]
 class MountInfo:
     """An active mount as tracked by the worker.
 
-    ``rclone_version`` is the rclone version inside the sandbox captured at
-    mount-add time (e.g. ``"v1.65.2"``). rclone is baked into the rootfs, so
-    different sandboxes may carry different versions; this lets ops triage
-    backend-specific bug reports quickly.
+    ``rclone_version`` (rclone driver) is the rclone version inside the sandbox
+    captured at mount-add time (e.g. ``"v1.65.2"``). rclone is baked into the
+    rootfs, so different sandboxes may carry different versions; this lets ops
+    triage backend-specific bug reports quickly.
     """
 
     path: str
-    remote: str
     read_only: bool
+    driver: str = "rclone"
+    # rclone driver
+    remote: str = ""
     backend: str = ""
     rclone_version: str = ""
+    # command driver
+    command: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
 
 
 @dataclass
@@ -90,6 +100,57 @@ class Mounts:
         data = resp.json()
         return _mount_from_dict(data)
 
+    async def add_command(
+        self,
+        path: str,
+        command: list[str],
+        env: dict[str, str] | None = None,
+        secrets: dict[str, str] | None = None,
+        read_only: bool = True,
+    ) -> MountInfo:
+        """Mount a filesystem by running your own FUSE daemon / mount command.
+
+        Use this when you already have a FUSE-ready filesystem (your own VFS,
+        gcsfuse, s3fs, …) and don't want rclone as a middle layer. The platform
+        manages the mountpoint, env/secret injection, and teardown; ``command``
+        establishes the mount.
+
+        Args:
+            path: Absolute mountpoint inside the VM.
+            command: argv for the FUSE daemon. Any ``"{mountpoint}"`` token is
+                replaced with ``path``.
+            env: Env vars for the command (returned by :meth:`list`).
+            secrets: Secret env vars — injected into the daemon's process env
+                (never the command line, so they don't leak via ``ps``), and
+                never recorded or returned by :meth:`list`.
+            read_only: Advisory for this driver — your command must honor it.
+                Also exported to the daemon as ``OC_MOUNT_READONLY=1``. Default
+                ``True``.
+
+        Example:
+            >>> await sandbox.mounts.add_command(
+            ...     path="/mnt/data",
+            ...     command=["gcsfuse", "my-bucket", "{mountpoint}"],
+            ...     secrets={"GOOGLE_APPLICATION_CREDENTIALS_JSON": sa_json},
+            ... )
+        """
+        body: dict[str, object] = {
+            "path": path,
+            "driver": "command",
+            "command": command,
+            "readOnly": read_only,
+        }
+        if env is not None:
+            body["env"] = env
+        if secrets is not None:
+            body["secrets"] = secrets
+
+        resp = await self._client.post(
+            f"/sandboxes/{self._sandbox_id}/mounts", json=body
+        )
+        resp.raise_for_status()
+        return _mount_from_dict(resp.json())
+
     async def list(self) -> list[MountInfo]:
         """List the mounts this worker is tracking for the sandbox.
 
@@ -117,8 +178,11 @@ class Mounts:
 def _mount_from_dict(data: dict) -> MountInfo:
     return MountInfo(
         path=data["path"],
-        remote=data["remote"],
-        backend=data.get("backend", ""),
+        driver=data.get("driver", "rclone"),
         read_only=data.get("readOnly", True),
+        remote=data.get("remote", ""),
+        backend=data.get("backend", ""),
         rclone_version=data.get("rcloneVersion", ""),
+        command=data.get("command", []) or [],
+        env=data.get("env", {}) or {},
     )

{opencomputer_sdk-0.6.2 → opencomputer_sdk-0.6.4}/opencomputer/sandbox.py

@@ -83,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,
@@ -598,18 +602,41 @@ class Sandbox:
         pty_key = self._token or self._api_key
         return Pty(self._ops_client, self.sandbox_id, pty_url, pty_key)
 
-    async def create_checkpoint(self, name: str) -> dict:
+    async def create_checkpoint(
+        self,
+        name: str,
+        kind: str | None = None,
+        promote_to_full: bool = False,
+        retention_policy: dict | None = None,
+    ) -> dict:
         """Create a named checkpoint of the running sandbox.
 
         Args:
             name: A unique name for this checkpoint.
+            kind: Optional checkpoint kind. Use "full" for disk, memory, and
+                device state, or "disk_only" for a disk-only checkpoint that
+                restores with a cold boot.
+            promote_to_full: For disk-only checkpoints, asynchronously create
+                a derived full checkpoint so future forks can use warm restore.
+            retention_policy: Optional policy such as
+                {"mode": "delete_oldest", "maxCount": 10}. When set, the
+                server may delete older eligible checkpoints before creating
+                this one.
 
         Returns:
             Checkpoint info dict with id, sandboxId, name, status, etc.
         """
+        body = {"name": name}
+        if kind is not None:
+            body["kind"] = kind
+        if promote_to_full:
+            body["promoteToFull"] = True
+        if retention_policy is not None:
+            body["retentionPolicy"] = retention_policy
+
         resp = await self._client.post(
             f"/sandboxes/{self.sandbox_id}/checkpoints",
-            json={"name": name},
+            json=body,
         )
         resp.raise_for_status()
         return resp.json()

{opencomputer_sdk-0.6.2 → opencomputer_sdk-0.6.4}/pyproject.toml

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