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

{opencomputer_sdk-0.6.3 → opencomputer_sdk-0.6.5}/.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.3 → opencomputer_sdk-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencomputer-sdk
-Version: 0.6.3
+Version: 0.6.5
 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.3 → opencomputer_sdk-0.6.5}/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.3 → opencomputer_sdk-0.6.5}/opencomputer/sandbox.py

@@ -602,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 | None = None,
+        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
+                automatically prepares a full artifact for faster future forks.
+            promote_to_full: Advanced override for disk-only checkpoints.
+                Defaults to server behavior.
+            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 is not None:
+            body["promoteToFull"] = promote_to_full
+        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.3 → opencomputer_sdk-0.6.5}/pyproject.toml

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