use-computer 0.0.41__tar.gz → 0.0.43__tar.gz

{use_computer-0.0.41 → use_computer-0.0.43}/.env.example

@@ -1,5 +1,5 @@
 # SDK runtime
-USE_COMPUTER_API_KEY=mk_live_...
+USE_COMPUTER_API_KEY=uc_live_...
 USE_COMPUTER_BASE_URL=https://api.use.computer
 
 # Local PyPI publish only. Prefer CI Trusted Publishing when possible.

{use_computer-0.0.41 → use_computer-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: use-computer
-Version: 0.0.41
+Version: 0.0.43
 Summary: Python SDK for use.computer sandboxes across macOS, iOS simulators, Windows, and Ubuntu
 Project-URL: Homepage, https://use.computer
 Project-URL: Documentation, https://api.use.computer/docs
@@ -38,31 +38,31 @@ Python client for [use.computer](https://use.computer) — rent dedicated VMs ac
 
 ```bash
 pip install use-computer
-export USE_COMPUTER_API_KEY=mk_live_...
+export USE_COMPUTER_API_KEY=uc_live_...
 ```
 
 Optional agent and Harbor integrations are installed explicitly:
 
 ```bash
 pip install "use-computer[agents]"        # computer-use agents and provider SDKs
-pip install "use-computer[harbor]"        # Harbor environment adapter (Python 3.12+)
-pip install "use-computer[harbor,agents]" # Harbor adapter plus agents
+pip install "use-computer[harbor]"        # Harbor agent wrapper dependencies
+pip install "use-computer[harbor,agents]" # Harbor agent wrappers plus agents
 ```
 
 Base installs only the SDK client and `httpx`. The `agents` extra installs the
-agent runtime plus model-provider dependencies; `harbor` installs Harbor plus
-the environment adapter dependencies.
+agent runtime plus model-provider dependencies; `harbor` installs Harbor for
+`use_computer.harbor.agents`.
 
 ```python
 from use_computer.agents import AnthropicComputerAgent
-from use_computer.harbor.environment import UseComputerEnvironment
 ```
 
-In Harbor job YAML, use the SDK paths directly:
+In Harbor job YAML, use Harbor's built-in use.computer environment and the SDK
+agent wrappers:
 
 ```yaml
 environment:
-  import_path: use_computer.harbor.environment:UseComputerEnvironment
+  type: use-computer
   kwargs:
     platform: macos
 agents:
@@ -73,7 +73,10 @@ agents:
 ```python
 from use_computer import Computer, SandboxType, SimulatorFamily
 
-with Computer().create() as mac:
+client = Computer()
+reservation = client.reserve(hours=24)
+
+with client.create(type="macos", reservation_id=reservation.id) as mac:
     mac.exec_ssh("open -a TextEdit")
     mac.keyboard.type("hello")
     png = mac.screenshot.take_full_screen()
@@ -85,6 +88,10 @@ with Computer().create(type=SandboxType.IOS, family=SimulatorFamily.TV) as tv:
 with Computer().create(type=SandboxType.IOS) as ios:
     ios.input.long_press(120, 300, duration=1.0)
     print(ios.exec("simctl getenv $UDID HOME").stdout)  # CoreSimulator exec, not SSH
+
+# Only needed when the same account key has more than one active Mac reservation.
+with Computer().create(type="macos", reservation_id="...") as mac:
+    print(mac.exec_ssh("uname -a").stdout)
 ```
 
 ### Windows (Beta)
@@ -148,12 +155,16 @@ that snapshot version.
 ```python
 client = Computer()
 
+# Configure the desktop by hand over VNC, then snapshot it.
 with client.create(type="ubuntu", version="ubuntu-24.04") as ubuntu:
-    ubuntu.run("google-chrome-stable --no-first-run https://example.com >/tmp/chrome.log 2>&1 &")
+    print("Set up the desktop here:", ubuntu.vnc_url)
+    # install apps, sign into accounts, pre-open the windows your agent starts from
+    input("Press Enter once the desktop is ready to snapshot...")
     snapshot = ubuntu.snapshot("chrome-seeded-ubuntu")
 
+# New sandboxes boot from that exact state, no setup needed.
 with client.create(type="ubuntu", snapshot=snapshot.version) as seeded:
-    print(seeded.run("pgrep -af 'chrome|chromium' | head").stdout)
+    print(seeded.vnc_url)  # apps, logins, and open windows restored
 ```
 
 Use `client.snapshots("ubuntu")` or `client.snapshots("windows")` to list saved
@@ -198,7 +209,7 @@ visionOS yet. Use it for read-only flows for now.
 | [`examples/_9_seeding.py`](examples/_9_seeding.py)             | typed setup: files, hosts, open URLs/apps      |
 | [`examples/_10_snapshots.py`](examples/_10_snapshots.py)       | snapshot seeded Ubuntu/Windows desktop state   |
 
-For agent loops and evals: [use-computer-cookbook](https://github.com/josancamon19/use-computer-cookbook). Its Harbor job YAMLs use `use_computer.harbor.environment:UseComputerEnvironment` and `use_computer.harbor.agents:*` as the canonical import paths.
+For agent loops and evals: [use-computer-cookbook](https://github.com/josancamon19/use-computer-cookbook). Harbor job YAMLs should use Harbor's `type: use-computer` environment plus `use_computer.harbor.agents:*` agent wrappers.
 
 ## Skill for AI coding assistants
 
@@ -206,4 +217,4 @@ Point your assistant at [`use-computer-cookbook/skills/SKILL.md`](https://github
 
 ## HTTP API
 
-Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer mk_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).
+Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer uc_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).

{use_computer-0.0.41 → use_computer-0.0.43}/README.md

@@ -4,31 +4,31 @@ Python client for [use.computer](https://use.computer) — rent dedicated VMs ac
 
 ```bash
 pip install use-computer
-export USE_COMPUTER_API_KEY=mk_live_...
+export USE_COMPUTER_API_KEY=uc_live_...
 ```
 
 Optional agent and Harbor integrations are installed explicitly:
 
 ```bash
 pip install "use-computer[agents]"        # computer-use agents and provider SDKs
-pip install "use-computer[harbor]"        # Harbor environment adapter (Python 3.12+)
-pip install "use-computer[harbor,agents]" # Harbor adapter plus agents
+pip install "use-computer[harbor]"        # Harbor agent wrapper dependencies
+pip install "use-computer[harbor,agents]" # Harbor agent wrappers plus agents
 ```
 
 Base installs only the SDK client and `httpx`. The `agents` extra installs the
-agent runtime plus model-provider dependencies; `harbor` installs Harbor plus
-the environment adapter dependencies.
+agent runtime plus model-provider dependencies; `harbor` installs Harbor for
+`use_computer.harbor.agents`.
 
 ```python
 from use_computer.agents import AnthropicComputerAgent
-from use_computer.harbor.environment import UseComputerEnvironment
 ```
 
-In Harbor job YAML, use the SDK paths directly:
+In Harbor job YAML, use Harbor's built-in use.computer environment and the SDK
+agent wrappers:
 
 ```yaml
 environment:
-  import_path: use_computer.harbor.environment:UseComputerEnvironment
+  type: use-computer
   kwargs:
     platform: macos
 agents:
@@ -39,7 +39,10 @@ agents:
 ```python
 from use_computer import Computer, SandboxType, SimulatorFamily
 
-with Computer().create() as mac:
+client = Computer()
+reservation = client.reserve(hours=24)
+
+with client.create(type="macos", reservation_id=reservation.id) as mac:
     mac.exec_ssh("open -a TextEdit")
     mac.keyboard.type("hello")
     png = mac.screenshot.take_full_screen()
@@ -51,6 +54,10 @@ with Computer().create(type=SandboxType.IOS, family=SimulatorFamily.TV) as tv:
 with Computer().create(type=SandboxType.IOS) as ios:
     ios.input.long_press(120, 300, duration=1.0)
     print(ios.exec("simctl getenv $UDID HOME").stdout)  # CoreSimulator exec, not SSH
+
+# Only needed when the same account key has more than one active Mac reservation.
+with Computer().create(type="macos", reservation_id="...") as mac:
+    print(mac.exec_ssh("uname -a").stdout)
 ```
 
 ### Windows (Beta)
@@ -114,12 +121,16 @@ that snapshot version.
 ```python
 client = Computer()
 
+# Configure the desktop by hand over VNC, then snapshot it.
 with client.create(type="ubuntu", version="ubuntu-24.04") as ubuntu:
-    ubuntu.run("google-chrome-stable --no-first-run https://example.com >/tmp/chrome.log 2>&1 &")
+    print("Set up the desktop here:", ubuntu.vnc_url)
+    # install apps, sign into accounts, pre-open the windows your agent starts from
+    input("Press Enter once the desktop is ready to snapshot...")
     snapshot = ubuntu.snapshot("chrome-seeded-ubuntu")
 
+# New sandboxes boot from that exact state, no setup needed.
 with client.create(type="ubuntu", snapshot=snapshot.version) as seeded:
-    print(seeded.run("pgrep -af 'chrome|chromium' | head").stdout)
+    print(seeded.vnc_url)  # apps, logins, and open windows restored
 ```
 
 Use `client.snapshots("ubuntu")` or `client.snapshots("windows")` to list saved
@@ -164,7 +175,7 @@ visionOS yet. Use it for read-only flows for now.
 | [`examples/_9_seeding.py`](examples/_9_seeding.py)             | typed setup: files, hosts, open URLs/apps      |
 | [`examples/_10_snapshots.py`](examples/_10_snapshots.py)       | snapshot seeded Ubuntu/Windows desktop state   |
 
-For agent loops and evals: [use-computer-cookbook](https://github.com/josancamon19/use-computer-cookbook). Its Harbor job YAMLs use `use_computer.harbor.environment:UseComputerEnvironment` and `use_computer.harbor.agents:*` as the canonical import paths.
+For agent loops and evals: [use-computer-cookbook](https://github.com/josancamon19/use-computer-cookbook). Harbor job YAMLs should use Harbor's `type: use-computer` environment plus `use_computer.harbor.agents:*` agent wrappers.
 
 ## Skill for AI coding assistants
 
@@ -172,4 +183,4 @@ Point your assistant at [`use-computer-cookbook/skills/SKILL.md`](https://github
 
 ## HTTP API
 
-Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer mk_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).
+Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer uc_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).

{use_computer-0.0.41 → use_computer-0.0.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "use-computer"
-version = "0.0.41"
+version = "0.0.43"
 description = "Python SDK for use.computer sandboxes across macOS, iOS simulators, Windows, and Ubuntu"
 readme = "README.md"
 requires-python = ">=3.10"

{use_computer-0.0.41 → use_computer-0.0.43}/scripts/smoke_wheel.py

@@ -45,7 +45,7 @@ from use_computer.agents import (
     OpenAIComputerAgent,
 )
 from use_computer.agents.debug import DebugComputerAgent
-from use_computer.models import ExecResult
+from use_computer.core.models import ExecResult
 
 PNG_BYTES = (
     b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01"
@@ -116,14 +116,14 @@ import importlib.util
 
 for name in ["harbor", "yaml", "tomli"]:
     assert importlib.util.find_spec(name) is not None, name
-for path in ["use_computer.harbor", "use_computer.harbor.environment"]:
+for path in ["use_computer.harbor"]:
     importlib.import_module(path)
 """
 
 HARBOR_AGENTS_SMOKE = r"""
 import importlib
 
-for path in ["use_computer.harbor.environment", "use_computer.harbor.agents"]:
+for path in ["use_computer.harbor", "use_computer.harbor.agents"]:
     importlib.import_module(path)
 """
 
@@ -156,7 +156,6 @@ def _check_wheel_contents(wheel: Path) -> None:
         "use_computer/agents/prompts/ios.txt",
         "use_computer/agents/prompts/openai.txt",
         "use_computer/agents/prompts/pyautogui.txt",
-        "use_computer/harbor/environment/use_computer.py",
         "use_computer/harbor/agents.py",
     }
     missing = sorted(required - names)

{use_computer-0.0.41 → use_computer-0.0.43}/use_computer/__init__.py

@@ -1,7 +1,13 @@
-from use_computer.client import AsyncComputer, Computer, RunStatus
-from use_computer.errors import PlatformNotSupportedError, UseComputerError
-from use_computer.ios.input import Button, Key, RemoteButton
-from use_computer.models import (
+from use_computer.automation.osworld import AsyncOSWorldClient, OSWorldClient
+from use_computer.automation.parsers import Action, parse_pyautogui, parse_xdotool
+from use_computer.core.client import AsyncComputer, Computer, Reservation, RunStatus
+from use_computer.core.errors import (
+    BillingRequiredError,
+    PlatformNotSupportedError,
+    ReservationRequiredError,
+    UseComputerError,
+)
+from use_computer.core.models import (
     AccessibilityTree,
     ActionResult,
     ActResult,
@@ -10,8 +16,7 @@ from use_computer.models import (
     ExecResult,
     RecordingInfo,
 )
-from use_computer.parsers import Action, parse_pyautogui, parse_xdotool
-from use_computer.sandbox import (
+from use_computer.core.sandbox import (
     AsyncIOSSandbox,
     AsyncMacOSSandbox,
     AsyncSandbox,
@@ -26,7 +31,8 @@ from use_computer.sandbox import (
     UbuntuSandbox,
     WindowsSandbox,
 )
-from use_computer.simulators import (
+from use_computer.ios.input import Button, Key, RemoteButton
+from use_computer.ios.simulators import (
     SimulatorChoice,
     SimulatorFamily,
     family_for_device,
@@ -45,9 +51,11 @@ __all__ = [
     "AsyncIOSSandbox",
     "AsyncMacOSSandbox",
     "AsyncComputer",
+    "AsyncOSWorldClient",
     "AsyncSandbox",
     "AsyncUbuntuSandbox",
     "AsyncWindowsSandbox",
+    "BillingRequiredError",
     "Button",
     "Computer",
     "CursorPosition",
@@ -57,8 +65,11 @@ __all__ = [
     "IOSSandbox",
     "Key",
     "MacOSSandbox",
+    "OSWorldClient",
     "PlatformNotSupportedError",
     "RecordingInfo",
+    "Reservation",
+    "ReservationRequiredError",
     "RemoteButton",
     "RunStatus",
     "Sandbox",

{use_computer-0.0.41 → use_computer-0.0.43}/use_computer/agents/__init__.py

@@ -26,6 +26,8 @@ _LAZY_EXPORTS = {
     "IOSComputerAgent": ("use_computer.agents.ios.agent", "IOSComputerAgent"),
     "OpenAIComputerAgent": ("use_computer.agents.providers.openai", "OpenAIComputerAgent"),
     "OpenAICUAAgent": ("use_computer.agents.providers.openai", "OpenAICUAAgent"),
+    "OSWorldAgent": ("use_computer.agents.providers.osworld", "OSWorldAgent"),
+    "OSWorldComputerAgent": ("use_computer.agents.providers.osworld", "OSWorldComputerAgent"),
 }
 
 __all__ = [

{use_computer-0.0.41 → use_computer-0.0.43}/use_computer/agents/base/agent.py

@@ -16,6 +16,7 @@ from use_computer.agents.base.desktop import (
 from use_computer.agents.base.final_state import FinalStateMixin
 from use_computer.agents.base.recordings import RecordingMixin
 from use_computer.agents.base.sandbox import ComputerSandbox
+from use_computer.agents.base.task_setup import run_task_setup
 from use_computer.agents.base.trajectory import write_trajectory
 from use_computer.agents.core import (
     AgentRunOptions,
@@ -25,7 +26,7 @@ from use_computer.agents.core import (
     DirectSandboxEnvironment,
 )
 from use_computer.agents.types import Platform
-from use_computer.sandbox import AsyncSandbox
+from use_computer.core.sandbox import AsyncSandbox
 
 
 def _task_dir_from_env(environment: Any) -> Path:
@@ -59,6 +60,8 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         platform_notes: str | None = None,
         openai_environment: OpenAIComputerEnvironment | str | None = None,
         save_on_finish: bool | str = False,
+        recording_enabled: bool | str = True,
+        final_state_enabled: bool | str = True,
         **kwargs: Any,
     ):
         self.logs_dir = Path(logs_dir or "runs/agent").resolve()
@@ -78,6 +81,8 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         self.desktop = self._desktop_profile_for(platform or Platform.MACOS)
         self.task_dir: Path | None = Path(task_dir) if task_dir else None
         self._recording_id: str | None = None
+        self.recording_enabled = _as_bool(recording_enabled)
+        self.final_state_enabled = _as_bool(final_state_enabled)
         self.sandbox: AsyncSandbox | None = None
         self.images_dir: Path = (self.logs_dir / "images").resolve()
         self.steps: list[dict[str, Any]] = []
@@ -120,7 +125,7 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         return "1.0.0"
 
     async def setup(self, environment: Any) -> None:
-        pass
+        await run_task_setup(environment, self.logger)
 
     async def run(
         self,
@@ -164,7 +169,8 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         if self.task_dir is None:
             self.task_dir = _task_dir_from_env(environment)
             self.logger.info(f"task_dir={self.task_dir}")
-        await self.start_recording(sandbox)
+        if self.recording_enabled:
+            await self.start_recording(sandbox)
         self.images_dir.mkdir(parents=True, exist_ok=True)
         self.steps = [{"step_id": 1, "source": "user", "message": ""}]
         self.total_in = 0
@@ -193,10 +199,12 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         assert self.sandbox is not None
         if self.save_on_finish:
             await self._save_focused_app(self.sandbox)
-        await self._save_final_ax_tree(self.sandbox)
-        await self._log_final_state_metrics(self.sandbox)
+        if self.final_state_enabled:
+            await self._save_final_ax_tree(self.sandbox)
+            await self._log_final_state_metrics(self.sandbox)
         await self._capture_artifacts(context)
-        await self.stop_recording(self.sandbox)
+        if self.recording_enabled:
+            await self.stop_recording(self.sandbox)
         self.checkpoint(context, model, agent_name)
 
     async def run_direct(

{use_computer-0.0.41 → use_computer-0.0.43}/use_computer/agents/base/final_state.py

@@ -10,7 +10,7 @@ from typing import Any
 import httpx
 from PIL import Image
 
-from use_computer.sandbox import AsyncSandbox
+from use_computer.core.sandbox import AsyncSandbox
 
 
 class FinalStateMixin:

use_computer-0.0.43/use_computer/agents/base/recordings.py

@@ -0,0 +1,253 @@
+"""Recording helpers for CUA agents."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+
+from use_computer.core.sandbox import AsyncSandbox
+
+_OSWORLD_FFMPEG_RECORDING_ID = "__osworld_ffmpeg__"
+
+
+class RecordingMixin:
+    async def start_recording(self: Any, sandbox: AsyncSandbox) -> None:
+        if getattr(getattr(sandbox, "type", None), "value", "") == "ios":
+            try:
+                await sandbox.screenshot.take_full_screen()
+            except Exception as e:
+                self.logger.warning(f"iOS recording warm-up screenshot failed: {e}")
+        try:
+            result = await sandbox.recording.start(name="trial")
+            self._recording_id = result.id
+            self.logger.info(f"Recording started: {self._recording_id}")
+        except Exception as e:
+            self.logger.warning(f"Failed to start recording: {e}")
+            if await self._start_osworld_ffmpeg_recording(sandbox):
+                return
+
+    async def stop_recording(self: Any, sandbox: AsyncSandbox) -> None:
+        if not self._recording_id:
+            return
+        await asyncio.sleep(3.0)
+        rec_path = self.logs_dir / "recording.mp4"
+        if self._recording_id == _OSWORLD_FFMPEG_RECORDING_ID:
+            await self._stop_osworld_ffmpeg_recording(sandbox, rec_path)
+            self._recording_id = None
+            return
+        try:
+            info = await sandbox.recording.stop(self._recording_id)
+            self.logger.info(
+                f"Recording stopped: id={self._recording_id} "
+                f"name={info.name!r} filename={info.filename!r} "
+                f"server_size={info.file_size}B "
+                f"({info.file_size / (1024 * 1024):.2f} MB)"
+            )
+            if info.file_size <= 0:
+                raise RuntimeError("server recording is empty")
+
+            await asyncio.sleep(2)
+
+            await self._download_recording(sandbox, rec_path)
+        except Exception as e:
+            self.logger.warning(f"Recording save failed: {type(e).__name__}: {e}")
+            try:
+                await self._download_recording(sandbox, rec_path)
+            except Exception as fallback:
+                self.logger.warning(
+                    f"Recording fallback download failed: {type(fallback).__name__}: {fallback}"
+                )
+                self._write_screenshot_recording(
+                    rec_path,
+                    reason=(
+                        f"server recording failed: {type(e).__name__}: {e}; "
+                        f"download fallback failed: {type(fallback).__name__}: {fallback}"
+                    ),
+                )
+
+    async def _download_recording(self: Any, sandbox: AsyncSandbox, rec_path) -> None:
+        self.logger.info(f"Downloading recording → {rec_path}")
+        t_dl = time.monotonic()
+        await sandbox.recording.download(self._recording_id, str(rec_path), timeout=180.0)
+        dl_elapsed = time.monotonic() - t_dl
+        local_size = rec_path.stat().st_size
+        if local_size <= 0:
+            raise RuntimeError("downloaded recording is empty")
+        self.logger.info(
+            f"Recording saved: {rec_path} "
+            f"local_size={local_size}B ({local_size / (1024 * 1024):.2f} MB) "
+            f"download_elapsed={dl_elapsed:.1f}s"
+        )
+
+    def _write_screenshot_recording(self: Any, rec_path: Path, reason: str) -> bool:
+        image_dir = self.logs_dir / "images"
+        images = sorted(image_dir.glob("*.png")) if image_dir.exists() else []
+        if not images:
+            self.logger.warning("Screenshot recording fallback skipped: no saved screenshots")
+            return False
+
+        ffmpeg = shutil.which("ffmpeg")
+        if not ffmpeg:
+            self.logger.warning("Screenshot recording fallback skipped: ffmpeg not found")
+            return False
+
+        try:
+            from PIL import Image
+        except Exception as e:
+            self.logger.warning(f"Screenshot recording fallback skipped: Pillow unavailable: {e}")
+            return False
+
+        rec_path.parent.mkdir(parents=True, exist_ok=True)
+        t0 = time.monotonic()
+        try:
+            with Image.open(images[0]) as first:
+                width, height = first.size
+            width -= width % 2
+            height -= height % 2
+            if width <= 0 or height <= 0:
+                raise RuntimeError(f"invalid screenshot size {width}x{height}")
+
+            with tempfile.TemporaryDirectory(prefix="use-computer-recording-") as tmp:
+                tmp_dir = Path(tmp)
+                frame_count = 0
+                for idx, src in enumerate(images, start=1):
+                    with Image.open(src) as img:
+                        frame = img.convert("RGB")
+                        if frame.size != (width, height):
+                            frame = frame.resize((width, height))
+                        frame.save(tmp_dir / f"frame{idx:06d}.png")
+                    frame_count += 1
+
+                if frame_count == 1:
+                    shutil.copyfile(tmp_dir / "frame000001.png", tmp_dir / "frame000002.png")
+                    frame_count = 2
+
+                cmd = [
+                    ffmpeg,
+                    "-y",
+                    "-loglevel",
+                    "error",
+                    "-framerate",
+                    "1",
+                    "-i",
+                    str(tmp_dir / "frame%06d.png"),
+                    "-vf",
+                    "format=yuv420p",
+                    "-movflags",
+                    "+faststart",
+                    str(rec_path),
+                ]
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+                if result.returncode != 0:
+                    raise RuntimeError(
+                        result.stderr.strip() or f"ffmpeg exited {result.returncode}"
+                    )
+
+            local_size = rec_path.stat().st_size
+            if local_size <= 0:
+                raise RuntimeError("ffmpeg wrote an empty recording")
+
+            meta = {
+                "source": "screenshots",
+                "reason": reason,
+                "frames": len(images),
+                "width": width,
+                "height": height,
+                "file_size": local_size,
+                "elapsed_sec": round(time.monotonic() - t0, 3),
+            }
+            (self.logs_dir / "recording.json").write_text(json.dumps(meta, indent=2))
+            self.logger.info(
+                f"Screenshot recording fallback saved: {rec_path} "
+                f"frames={len(images)} local_size={local_size}B "
+                f"({local_size / (1024 * 1024):.2f} MB)"
+            )
+            return True
+        except Exception as e:
+            self.logger.warning(f"Screenshot recording fallback failed: {type(e).__name__}: {e}")
+            return False
+
+    async def _start_osworld_ffmpeg_recording(self: Any, sandbox: AsyncSandbox) -> bool:
+        osworld: Any = getattr(sandbox, "osworld", None)
+        if osworld is None:
+            return False
+        if getattr(getattr(sandbox, "type", None), "value", "") != "ubuntu":
+            self.logger.warning("OSWorld ffmpeg recording fallback is only implemented for Ubuntu")
+            return False
+
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
+        script = """
+set -eux
+rm -f /tmp/osworld-recording.mp4 /tmp/osworld-recording.log /tmp/osworld-recording.pid
+export DISPLAY=:0
+nohup ffmpeg -y \
+  -video_size 1920x1080 \
+  -framerate 2 \
+  -f x11grab \
+  -i :0 \
+  -t 120 \
+  -pix_fmt yuv420p \
+  /tmp/osworld-recording.mp4 > /tmp/osworld-recording.log 2>&1 &
+echo $! > /tmp/osworld-recording.pid
+cat /tmp/osworld-recording.pid
+"""
+        try:
+            result = await osworld.execute(["bash", "-lc", script], timeout=10)
+        except Exception as e:
+            self.logger.warning(f"OSWorld ffmpeg recording start failed: {type(e).__name__}: {e}")
+            return False
+
+        (self.logs_dir / "recording-start.json").write_text(json.dumps(result, indent=2))
+        if result.get("returncode") != 0:
+            self.logger.warning(f"OSWorld ffmpeg recording start failed: {result}")
+            return False
+
+        self._recording_id = _OSWORLD_FFMPEG_RECORDING_ID
+        self.logger.info("OSWorld ffmpeg recording started")
+        return True
+
+    async def _stop_osworld_ffmpeg_recording(self: Any, sandbox: AsyncSandbox, rec_path) -> None:
+        osworld: Any = getattr(sandbox, "osworld", None)
+        if osworld is None:
+            return
+        stop_script = """
+set -eux
+if [ -f /tmp/osworld-recording.pid ]; then
+  pid="$(cat /tmp/osworld-recording.pid)"
+  if kill -0 "$pid" 2>/dev/null; then
+    kill -INT "$pid" || true
+  fi
+  for _ in $(seq 1 40); do
+    if kill -0 "$pid" 2>/dev/null; then
+      sleep 0.25
+    else
+      break
+    fi
+  done
+fi
+ls -lh /tmp/osworld-recording.mp4 /tmp/osworld-recording.log
+tail -80 /tmp/osworld-recording.log
+"""
+        t_dl = time.monotonic()
+        try:
+            meta: dict[str, Any] = {
+                "stop": await osworld.execute(["bash", "-lc", stop_script], timeout=30)
+            }
+            data = await osworld.file("/tmp/osworld-recording.mp4")
+            rec_path.write_bytes(data)
+            local_size = rec_path.stat().st_size
+            meta["downloaded_size"] = local_size
+            (self.logs_dir / "recording.json").write_text(json.dumps(meta, indent=2))
+            self.logger.info(
+                f"OSWorld ffmpeg recording saved: {rec_path} "
+                f"local_size={local_size}B ({local_size / (1024 * 1024):.2f} MB) "
+                f"download_elapsed={time.monotonic() - t_dl:.1f}s"
+            )
+        except Exception as e:
+            self.logger.warning(f"OSWorld ffmpeg recording save failed: {type(e).__name__}: {e}")

{use_computer-0.0.41 → use_computer-0.0.43}/use_computer/agents/base/sandbox.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from use_computer.sandbox import (
+from use_computer.core.sandbox import (
     AsyncMacOSSandbox,
     AsyncUbuntuSandbox,
     AsyncWindowsSandbox,