| """Daytona implementation of the standalone OpenCode sandbox protocol.""" |
|
|
| from __future__ import annotations |
|
|
| import math |
| import os |
| import shlex |
| import time |
| import uuid |
| from functools import lru_cache |
|
|
| from opencode_env.sandbox.base import ExecResult |
|
|
|
|
| @lru_cache(maxsize=1) |
| def client(): |
| from daytona import Daytona |
|
|
| return Daytona() |
|
|
|
|
| class DaytonaBgJob: |
| def __init__(self, handle, directory, pid): |
| self.handle, self.directory, self._pid = handle, directory, pid |
|
|
| @property |
| def pid(self): |
| return self._pid |
|
|
| def wait(self, timeout=None): |
| deadline = time.monotonic() + timeout if timeout is not None else float("inf") |
| while time.monotonic() < deadline: |
| if self.handle.exists(self.directory + "/exit"): |
| return int(self.handle.read_text(self.directory + "/exit").strip()) |
| time.sleep(min(0.5, max(0, deadline - time.monotonic()))) |
| raise TimeoutError("Background command exceeded its deadline") |
|
|
| def kill(self): |
| self.handle.exec(f"kill -TERM -- -{self.pid} 2>/dev/null || true", timeout=10) |
|
|
|
|
| class DaytonaSandboxHandle: |
| def __init__(self, sandbox): |
| self._sandbox = sandbox |
| self._deleted = False |
|
|
| @property |
| def sandbox_id(self): |
| return self._sandbox.id |
|
|
| def exec(self, cmd, *, envs=None, cwd=None, timeout=60): |
| |
| |
| result = self._sandbox.process.exec( |
| "bash -lc " + shlex.quote(cmd), |
| cwd=cwd, |
| env=envs, |
| timeout=max(1, math.ceil(timeout)) if timeout is not None else None, |
| ) |
| code = result.exit_code |
| return ExecResult(124 if code is None else int(code), result.result or "", "") |
|
|
| def write_text(self, path, content): |
| parent = path.rsplit("/", 1)[0] or "." |
| result = self.exec("mkdir -p " + shlex.quote(parent)) |
| if result.exit_code: |
| raise RuntimeError("Could not create sandbox directory") |
| self._sandbox.fs.upload_file(content.encode(), path) |
|
|
| def read_text(self, path): |
| return self._sandbox.fs.download_file(path).decode() |
|
|
| def exists(self, path): |
| return self.exec("test -e " + shlex.quote(path), timeout=15).exit_code == 0 |
|
|
| def start_bg(self, cmd, *, envs=None, cwd=None): |
| directory = "/tmp/openenv-process-" + uuid.uuid4().hex |
| self.write_text( |
| directory + "/run.sh", |
| "#!/bin/bash\n(\n" |
| + cmd |
| + "\n)" |
| + "\ncode=$?\nprintf '%s' \"$code\" > " |
| + shlex.quote(directory + "/exit") |
| + "\n", |
| ) |
| result = self.exec( |
| "setsid bash " |
| + shlex.quote(directory + "/run.sh") |
| + " > " |
| + shlex.quote(directory + "/output") |
| + " 2>&1 < /dev/null & echo $!", |
| envs=envs, |
| cwd=cwd, |
| timeout=15, |
| ) |
| if result.exit_code: |
| raise RuntimeError("Could not launch background command") |
| return DaytonaBgJob( |
| self, directory, int(result.stdout.strip().splitlines()[-1]) |
| ) |
|
|
| def kill(self): |
| if not self._deleted: |
| client().delete(self._sandbox, timeout=60, wait=True) |
| self._deleted = True |
|
|
|
|
| class DaytonaSandboxBackend: |
| def __init__(self, *, image, snapshot=None): |
| self.image, self.snapshot = ( |
| image, |
| snapshot or os.environ.get("DATA_AGENT_DAYTONA_SNAPSHOT"), |
| ) |
|
|
| def create(self, *, timeout_s=900, envs=None, metadata=None): |
| from daytona import ( |
| CreateSandboxFromImageParams, |
| CreateSandboxFromSnapshotParams, |
| Resources, |
| ) |
|
|
| options = { |
| "language": "python", |
| "os_user": "root", |
| "env_vars": envs, |
| "labels": { |
| **(metadata or {}), |
| "openenv_component": "blackbox-opencode", |
| "openenv_owner": os.environ.get("RUN_OWNER", "local"), |
| }, |
| "public": False, |
| "auto_stop_interval": max(30, math.ceil(timeout_s / 60)), |
| "auto_delete_interval": 0, |
| } |
| if self.snapshot: |
| params = CreateSandboxFromSnapshotParams(snapshot=self.snapshot, **options) |
| else: |
| params = CreateSandboxFromImageParams( |
| image=self.image, |
| resources=Resources(cpu=1, memory=4, disk=5), |
| **options, |
| ) |
| return DaytonaSandboxHandle(client().create(params, timeout=300)) |
|
|
