use-computer 0.0.45__tar.gz → 0.0.46__tar.gz

use_computer-0.0.46/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: use-computer
+Version: 0.0.46
+Summary: Python SDK for use.computer macOS sandboxes
+Project-URL: Homepage, https://use.computer
+Project-URL: Documentation, https://api.use.computer/docs
+Project-URL: Repository, https://github.com/josancamon19/use-computer-sdk
+Author: use.computer
+Keywords: automation,computer-use,macos,sandbox,vnc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: agents
+Requires-Dist: anthropic>=0.86; extra == 'agents'
+Requires-Dist: google-genai>=1; extra == 'agents'
+Requires-Dist: litellm>=1; extra == 'agents'
+Requires-Dist: openai>=1; extra == 'agents'
+Requires-Dist: pillow>=10; extra == 'agents'
+Requires-Dist: tinker-cookbook>=0.1.0; (python_full_version >= '3.11') and extra == 'agents'
+Requires-Dist: tinker>=0.14.0; (python_full_version >= '3.11') and extra == 'agents'
+Description-Content-Type: text/markdown
+
+# use-computer Python SDK
+
+use.computer gives you macOS sandboxes: VMs on dedicated Apple M4 Mac minis that you reserve for 24 hours or more, up to 2 VMs at a time per Mac.
+
+```bash
+pip install use-computer
+export USE_COMPUTER_API_KEY=uc_live_...
+```
+
+Optional agent integrations are installed explicitly:
+
+```bash
+pip install "use-computer[agents]"        # computer-use agents and provider SDKs
+```
+
+Base installs only the SDK client and `httpx`. The `agents` extra installs the agent runtime plus model-provider dependencies (Anthropic, OpenAI, Gemini, LiteLLM).
+
+## Quickstart
+
+Flow: sign up → $100 starter credit → reserve a Mac mini (dashboard, or `client.reserve(hours=24)` in the SDK) → `create()` a macOS sandbox → drive it (mouse, keyboard, screenshot, exec, files, recording, UI tree, VNC) → `delete()`. Reservations cost $1.91/hour per Mac; the starter credit pays for them.
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# 1. Reserve one Mac Mini for 24 hours
+reservation = client.reserve(hours=24)
+
+# 2. Launch a macOS sandbox on the reserved Mac
+with client.create(reservation_id=reservation.id) as mac:
+    # 3. Drive the macOS sandbox
+    mac.exec("open -a Safari")
+    mac.keyboard.type("hello from use.computer")
+    mac.mouse.click(500, 500)
+    png = mac.screenshot.take_full_screen()
+    print("VNC URL:", mac.vnc_url)
+```
+
+Each reserved Mac Mini supports up to 2 parallel macOS VMs. Check `Computer().platforms(reservation_id=...)["macos"]["capacity"]` for the selected reservation's `max` and `used` counts.
+
+Sandboxes default to `ephemeral=True`, deleting automatically after the idle timeout (roughly 2 minutes without activity). Use `ephemeral=False` when a sandbox should persist until manual deletion, or call `sandbox.start_keepalive(interval=30)` during long model-think periods.
+
+## Runtime Snapshots
+
+macOS snapshots let you seed a VM once, snapshot it, then create new sandboxes from that snapshot version. macOS snapshots preserve disk state, so installed apps, accounts, and seeded files are available immediately:
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# Configure the macOS desktop by hand over VNC, then snapshot it.
+with client.create(type="macos") as mac:
+    print("Set up the macOS desktop here:", mac.vnc_url)
+    input("Press Enter once the desktop is ready to snapshot...")
+    snapshot = mac.snapshot("chrome-seeded-macos")
+
+# New sandboxes boot from that saved disk state, no setup needed.
+with client.create(type="macos", snapshot=snapshot.version) as seeded:
+    print("Seeded sandbox ready:", seeded.vnc_url)
+```
+
+Use `client.snapshots()` to list saved snapshot versions.
+
+## Examples
+
+| File | What it shows |
+| --- | --- |
+| [`examples/_1_hello_macos.py`](../examples/python/_1_hello_macos.py) | reserve → create → exec → keyboard → screenshot |
+| [`examples/_2_recording.py`](../examples/python/_2_recording.py) | start / stop / download a screen recording |
+| [`examples/_3_file_transfer.py`](../examples/python/_3_file_transfer.py) | upload bytes, download a file back |
+| [`examples/_4_keepalive.py`](../examples/python/_4_keepalive.py) | heartbeat for ephemeral sessions idle > 2 min |
+| [`examples/_5_snapshots.py`](../examples/python/_5_snapshots.py) | snapshot seeded macOS state |
+
+## HTTP API
+
+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.46/README.md

@@ -0,0 +1,78 @@
+# use-computer Python SDK
+
+use.computer gives you macOS sandboxes: VMs on dedicated Apple M4 Mac minis that you reserve for 24 hours or more, up to 2 VMs at a time per Mac.
+
+```bash
+pip install use-computer
+export USE_COMPUTER_API_KEY=uc_live_...
+```
+
+Optional agent integrations are installed explicitly:
+
+```bash
+pip install "use-computer[agents]"        # computer-use agents and provider SDKs
+```
+
+Base installs only the SDK client and `httpx`. The `agents` extra installs the agent runtime plus model-provider dependencies (Anthropic, OpenAI, Gemini, LiteLLM).
+
+## Quickstart
+
+Flow: sign up → $100 starter credit → reserve a Mac mini (dashboard, or `client.reserve(hours=24)` in the SDK) → `create()` a macOS sandbox → drive it (mouse, keyboard, screenshot, exec, files, recording, UI tree, VNC) → `delete()`. Reservations cost $1.91/hour per Mac; the starter credit pays for them.
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# 1. Reserve one Mac Mini for 24 hours
+reservation = client.reserve(hours=24)
+
+# 2. Launch a macOS sandbox on the reserved Mac
+with client.create(reservation_id=reservation.id) as mac:
+    # 3. Drive the macOS sandbox
+    mac.exec("open -a Safari")
+    mac.keyboard.type("hello from use.computer")
+    mac.mouse.click(500, 500)
+    png = mac.screenshot.take_full_screen()
+    print("VNC URL:", mac.vnc_url)
+```
+
+Each reserved Mac Mini supports up to 2 parallel macOS VMs. Check `Computer().platforms(reservation_id=...)["macos"]["capacity"]` for the selected reservation's `max` and `used` counts.
+
+Sandboxes default to `ephemeral=True`, deleting automatically after the idle timeout (roughly 2 minutes without activity). Use `ephemeral=False` when a sandbox should persist until manual deletion, or call `sandbox.start_keepalive(interval=30)` during long model-think periods.
+
+## Runtime Snapshots
+
+macOS snapshots let you seed a VM once, snapshot it, then create new sandboxes from that snapshot version. macOS snapshots preserve disk state, so installed apps, accounts, and seeded files are available immediately:
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# Configure the macOS desktop by hand over VNC, then snapshot it.
+with client.create(type="macos") as mac:
+    print("Set up the macOS desktop here:", mac.vnc_url)
+    input("Press Enter once the desktop is ready to snapshot...")
+    snapshot = mac.snapshot("chrome-seeded-macos")
+
+# New sandboxes boot from that saved disk state, no setup needed.
+with client.create(type="macos", snapshot=snapshot.version) as seeded:
+    print("Seeded sandbox ready:", seeded.vnc_url)
+```
+
+Use `client.snapshots()` to list saved snapshot versions.
+
+## Examples
+
+| File | What it shows |
+| --- | --- |
+| [`examples/_1_hello_macos.py`](../examples/python/_1_hello_macos.py) | reserve → create → exec → keyboard → screenshot |
+| [`examples/_2_recording.py`](../examples/python/_2_recording.py) | start / stop / download a screen recording |
+| [`examples/_3_file_transfer.py`](../examples/python/_3_file_transfer.py) | upload bytes, download a file back |
+| [`examples/_4_keepalive.py`](../examples/python/_4_keepalive.py) | heartbeat for ephemeral sessions idle > 2 min |
+| [`examples/_5_snapshots.py`](../examples/python/_5_snapshots.py) | snapshot seeded macOS state |
+
+## HTTP API
+
+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.45 → use_computer-0.0.46}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "use-computer"
-version = "0.0.45"
-description = "Python SDK for use.computer sandboxes across macOS, iOS simulators, Windows, and Ubuntu"
+version = "0.0.46"
+description = "Python SDK for use.computer macOS sandboxes"
 readme = "README.md"
 requires-python = ">=3.10"
 authors = [{ name = "use.computer" }]
 dependencies = ["httpx>=0.27"]
-keywords = ["computer-use", "macos", "ios", "windows", "ubuntu", "automation", "sandbox", "vnc"]
+keywords = ["computer-use", "macos", "automation", "sandbox", "vnc"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
@@ -33,11 +33,7 @@ agents = [
     "tinker>=0.14.0 ; python_full_version >= '3.11'",
     "tinker-cookbook>=0.1.0 ; python_full_version >= '3.11'",
 ]
-harbor = [
-    "harbor>=0.4.0; python_version >= '3.12'",
-    "PyYAML>=6",
-    "tomli>=2",
-]
+
 
 [dependency-groups]
 dev = [

{use_computer-0.0.45 → use_computer-0.0.46}/scripts/smoke_wheel.py

@@ -20,7 +20,7 @@ def has(name):
         return False
 
 assert "site-packages" in (use_computer.__file__ or ""), use_computer.__file__
-for name in ["PIL", "openai", "anthropic", "google.genai", "litellm", "harbor", "yaml", "tomli"]:
+for name in ["PIL", "openai", "anthropic", "google.genai", "litellm"]:
     assert not has(name), name
 """
 
@@ -41,7 +41,7 @@ from use_computer.agents import (
     AnthropicComputerAgent,
     GeminiComputerAgent,
     GenericComputerAgent,
-    IOSComputerAgent,
+
     OpenAIComputerAgent,
 )
 from use_computer.agents.debug import DebugComputerAgent
@@ -105,28 +105,11 @@ for agent_cls, model_name in [
     (OpenAIComputerAgent, "openai/gpt-5.5"),
     (GeminiComputerAgent, "gemini/gemini-2.5-computer-use-preview-10-2025"),
     (GenericComputerAgent, "openai/gpt-4o"),
-    (IOSComputerAgent, "anthropic/claude-sonnet-4-6"),
+
 ]:
     assert agent_cls(model_name=model_name, max_steps=1).max_steps == 1
 """
 
-HARBOR_SMOKE = r"""
-import importlib
-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"]:
-    importlib.import_module(path)
-"""
-
-HARBOR_AGENTS_SMOKE = r"""
-import importlib
-
-for path in ["use_computer.harbor", "use_computer.harbor.agents"]:
-    importlib.import_module(path)
-"""
-
 
 def main() -> None:
     parser = argparse.ArgumentParser()
@@ -141,8 +124,6 @@ def main() -> None:
     _check_metadata(wheel)
     _smoke_install(wheel, None, BASE_SMOKE)
     _smoke_install(wheel, "agents", AGENTS_SMOKE)
-    _smoke_install(wheel, "harbor", HARBOR_SMOKE)
-    _smoke_install(wheel, "harbor,agents", HARBOR_AGENTS_SMOKE)
 
 
 def _check_wheel_contents(wheel: Path) -> None:
@@ -153,10 +134,8 @@ def _check_wheel_contents(wheel: Path) -> None:
         "use_computer/py.typed",
         "use_computer/agents/prompts/anthropic.txt",
         "use_computer/agents/prompts/gemini.txt",
-        "use_computer/agents/prompts/ios.txt",
         "use_computer/agents/prompts/openai.txt",
         "use_computer/agents/prompts/pyautogui.txt",
-        "use_computer/harbor/agents.py",
     }
     missing = sorted(required - names)
     if missing:
@@ -176,7 +155,6 @@ def _check_metadata(wheel: Path) -> None:
 
     required = [
         "Provides-Extra: agents",
-        "Provides-Extra: harbor",
         "Requires-Dist: pillow>=10; extra == 'agents'",
         "Requires-Dist: openai>=1; extra == 'agents'",
         "Requires-Dist: anthropic>=0.86; extra == 'agents'",
@@ -195,26 +173,6 @@ def _check_metadata(wheel: Path) -> None:
     if present:
         raise SystemExit(f"wheel metadata still has provider-specific extras: {present}")
 
-    harbor_lines = [
-        line for line in metadata.splitlines() if line.startswith("Requires-Dist: harbor>=0.4.0;")
-    ]
-    if not any(
-        "python_version >= '3.12'" in line and "extra == 'harbor'" in line for line in harbor_lines
-    ):
-        raise SystemExit("wheel metadata is missing the Python 3.12+ Harbor extra")
-
-    forbidden_harbor_deps = [
-        line
-        for line in metadata.splitlines()
-        if "extra == 'harbor'" in line
-        and any(
-            f"Requires-Dist: {name}" in line
-            for name in ("pillow", "openai", "anthropic", "litellm", "google-genai")
-        )
-    ]
-    if forbidden_harbor_deps:
-        raise SystemExit(f"harbor extra should not install agent deps: {forbidden_harbor_deps}")
-
 
 def _smoke_install(wheel: Path, extra: str | None, code: str) -> None:
     with tempfile.TemporaryDirectory(prefix="use-computer-wheel-") as tmp:

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/__init__.py

@@ -1,11 +1,10 @@
 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.client import AsyncComputer, Computer, Reservation
 from use_computer.core.errors import (
     BillingRequiredError,
     PlatformNotSupportedError,
     ReservationRequiredError,
-    SandboxLimitReachedError,
     UseComputerError,
 )
 from use_computer.core.models import (
@@ -18,78 +17,38 @@ from use_computer.core.models import (
     RecordingInfo,
 )
 from use_computer.core.sandbox import (
-    AsyncIOSSandbox,
     AsyncMacOSSandbox,
     AsyncSandbox,
-    AsyncUbuntuSandbox,
-    AsyncWindowsSandbox,
-    HostRedirect,
-    IOSSandbox,
     MacOSSandbox,
     Sandbox,
     SandboxType,
     Snapshot,
-    UbuntuSandbox,
-    WindowsSandbox,
 )
-from use_computer.ios.input import Button, Key, RemoteButton
-from use_computer.ios.simulators import (
-    SimulatorChoice,
-    SimulatorFamily,
-    family_for_device,
-    is_usable_device_type,
-    required_runtime_os,
-    runtime_os,
-    select_simulator,
-)
-from use_computer.tasks import Task, TasksClient, TaskSummary
 
 __all__ = [
     "Action",
     "AccessibilityTree",
     "ActionResult",
     "ActResult",
-    "AsyncIOSSandbox",
-    "AsyncMacOSSandbox",
     "AsyncComputer",
+    "AsyncMacOSSandbox",
     "AsyncOSWorldClient",
     "AsyncSandbox",
-    "AsyncUbuntuSandbox",
-    "AsyncWindowsSandbox",
     "BillingRequiredError",
-    "Button",
     "Computer",
     "CursorPosition",
     "DisplayInfo",
     "ExecResult",
-    "HostRedirect",
-    "IOSSandbox",
-    "Key",
     "MacOSSandbox",
     "OSWorldClient",
     "PlatformNotSupportedError",
     "RecordingInfo",
     "Reservation",
     "ReservationRequiredError",
-    "RemoteButton",
-    "RunStatus",
     "Sandbox",
-    "SandboxLimitReachedError",
     "SandboxType",
     "Snapshot",
-    "SimulatorChoice",
-    "SimulatorFamily",
-    "Task",
-    "TaskSummary",
-    "TasksClient",
     "UseComputerError",
-    "UbuntuSandbox",
-    "WindowsSandbox",
-    "family_for_device",
-    "is_usable_device_type",
     "parse_pyautogui",
     "parse_xdotool",
-    "required_runtime_os",
-    "runtime_os",
-    "select_simulator",
 ]

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/agents/__init__.py

@@ -22,8 +22,6 @@ _LAZY_EXPORTS = {
     "GeminiCUAAgent": ("use_computer.agents.providers.gemini", "GeminiCUAAgent"),
     "GenericComputerAgent": ("use_computer.agents.providers.generic", "GenericComputerAgent"),
     "GenericCUAAgent": ("use_computer.agents.providers.generic", "GenericCUAAgent"),
-    "IOSAgent": ("use_computer.agents.ios.agent", "IOSAgent"),
-    "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"),

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/agents/base/agent.py

@@ -255,7 +255,7 @@ class BaseCUAAgent(RecordingMixin, FinalStateMixin, ArtifactCaptureMixin):
         )
 
     async def _save_focused_app(self, sandbox: AsyncSandbox) -> None:
-        shortcut = "command+s" if self.desktop.platform is Platform.MACOS else "ctrl+s"
+        shortcut = "command+s"
         computer = cast(ComputerSandbox, sandbox)
         await computer.keyboard.hotkey(shortcut)
         await asyncio.sleep(1)

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/agents/base/desktop.py

@@ -87,34 +87,9 @@ _KEY_ALIASES = {
     "PAGEDOWN": "pagedown",
 }
 
-# Windows: the modifier is the Windows key, not Cmd.
-_WINDOWS_KEY_ALIASES = {
-    **_KEY_ALIASES,
-    "Command": "win",
-    "command": "win",
-    "COMMAND": "win",
-    "Cmd": "win",
-    "cmd": "win",
-    "CMD": "win",
-    "super": "win",
-    "SUPER": "win",
-    "meta": "win",
-    "META": "win",
-    "Super_L": "win",
-    "Meta_L": "win",
-    "Win": "win",
-    "win": "win",
-    "WIN": "win",
-    "Windows": "win",
-    "windows": "win",
-    "WINDOWS": "win",
-}
-
 
 class OpenAIComputerEnvironment(str, Enum):
     MAC = "mac"
-    WINDOWS = "windows"
-    UBUNTU = "ubuntu"
 
 
 @dataclass(frozen=True)
@@ -136,31 +111,6 @@ _DESKTOP_PROFILES = {
         os_type="macOS",
         openai_environment=OpenAIComputerEnvironment.MAC,
     ),
-    Platform.WINDOWS: DesktopProfile(
-        platform=Platform.WINDOWS,
-        os_type="Windows",
-        notes=(
-            "Windows notes:\n"
-            "- Use Ctrl (not Cmd) for shortcuts: Ctrl+C/V/X copy/paste/cut, "
-            "Ctrl+S save, Ctrl+Z undo.\n"
-            "- Open apps via Start (Windows key, app name, Enter) or by "
-            "double-clicking a file."
-        ),
-        key_aliases=_WINDOWS_KEY_ALIASES,
-        openai_environment=OpenAIComputerEnvironment.WINDOWS,
-    ),
-    Platform.UBUNTU: DesktopProfile(
-        platform=Platform.UBUNTU,
-        os_type="Ubuntu",
-        notes=(
-            "Ubuntu notes:\n"
-            "- Use Ctrl for shortcuts: Ctrl+C/V/X copy/paste/cut, Ctrl+S save, Ctrl+Z undo.\n"
-            "- Open apps via Activities, the app launcher, or the file manager.\n"
-            "- The home directory is /home/user."
-        ),
-        key_aliases=_WINDOWS_KEY_ALIASES,
-        openai_environment=OpenAIComputerEnvironment.UBUNTU,
-    ),
 }
 
 
@@ -172,8 +122,6 @@ def desktop_profile(
     openai_environment: OpenAIComputerEnvironment | str | None = None,
 ) -> DesktopProfile:
     parsed = Platform.parse(platform)
-    if parsed is Platform.IOS:
-        raise ValueError("iOS uses IOSAgent, not desktop CUA agents")
     base = _DESKTOP_PROFILES[parsed]
     environment = (
         OpenAIComputerEnvironment(openai_environment)

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/agents/base/recordings.py

@@ -13,34 +13,22 @@ 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(
@@ -172,82 +160,3 @@ class RecordingMixin:
         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.46/use_computer/agents/base/sandbox.py

@@ -0,0 +1,7 @@
+"""Sandbox type aliases shared by computer agents."""
+
+from __future__ import annotations
+
+from use_computer.core.sandbox import AsyncMacOSSandbox
+
+ComputerSandbox = AsyncMacOSSandbox

{use_computer-0.0.45 → use_computer-0.0.46}/use_computer/agents/base/screenshots.py

@@ -15,7 +15,7 @@ def screenshot_cap_for_model(model: str) -> int:
     if "claude" in m or "anthropic/" in m:
         return 1568  # Other Anthropic models cap at 1568px
     if "kimi" in m or "fireworks" in m:
-        # Kimi: y-coord accuracy degrades at >1024 (probed on tall iOS shots)
+        # Kimi: y-coord accuracy degrades at >1024
         return 896
         # TODO: probe Qwen 3.6 Plus separately — it inherits Kimi's cap for now
     return 1280  # OpenAI/Gemini fallback