use-computer 0.0.18__tar.gz → 0.0.19__tar.gz

{use_computer-0.0.18 → use_computer-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: use-computer
-Version: 0.0.18
+Version: 0.0.19
 Summary: Python SDK for the use.computer macOS and iOS Computer Use API
 Project-URL: Homepage, https://use.computer
 Project-URL: Documentation, https://api.use.computer/docs

use_computer-0.0.19/examples/_7_hello_windows.py

@@ -0,0 +1,11 @@
+from use_computer import Computer
+
+# Beta: Windows sandboxes. No SSH — exec runs in-guest via PowerShell/cmd.
+with Computer().create(type="windows") as win:
+    win.run("Start-Process notepad")  # PowerShell by default
+    win.keyboard.type("hello from use.computer")
+    print(win.run("$env:COMPUTERNAME", shell="powershell").stdout)
+
+    png = win.screenshot.take_full_screen()
+    open("hello_windows.png", "wb").write(png)
+    print(f"saved hello_windows.png ({len(png)} bytes)")

{use_computer-0.0.18 → use_computer-0.0.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "use-computer"
-version = "0.0.18"
+version = "0.0.19"
 description = "Python SDK for the use.computer macOS and iOS Computer Use API"
 readme = "README.md"
 requires-python = ">=3.10"

{use_computer-0.0.18 → use_computer-0.0.19}/use_computer/__init__.py

@@ -15,10 +15,12 @@ from use_computer.sandbox import (
     AsyncIOSSandbox,
     AsyncMacOSSandbox,
     AsyncSandbox,
+    AsyncWindowsSandbox,
     IOSSandbox,
     MacOSSandbox,
     Sandbox,
     SandboxType,
+    WindowsSandbox,
 )
 from use_computer.simulators import (
     SimulatorChoice,
@@ -40,6 +42,7 @@ __all__ = [
     "AsyncMacOSSandbox",
     "AsyncComputer",
     "AsyncSandbox",
+    "AsyncWindowsSandbox",
     "Button",
     "Computer",
     "CursorPosition",
@@ -60,6 +63,7 @@ __all__ = [
     "TaskSummary",
     "TasksClient",
     "UseComputerError",
+    "WindowsSandbox",
     "family_for_device",
     "is_usable_device_type",
     "parse_pyautogui",

{use_computer-0.0.18 → use_computer-0.0.19}/use_computer/client.py

@@ -14,17 +14,19 @@ from use_computer.sandbox import (
     AsyncIOSSandbox,
     AsyncMacOSSandbox,
     AsyncSandbox,
+    AsyncWindowsSandbox,
     IOSSandbox,
     MacOSSandbox,
     Sandbox,
     SandboxType,
+    WindowsSandbox,
 )
 from use_computer.simulators import SimulatorFamily, select_simulator
 from use_computer.tasks import TasksClient
 
 DEFAULT_BASE_URL = "https://api.use.computer"
 
-SandboxTypeInput = SandboxType | Literal["macos", "ios"]
+SandboxTypeInput = SandboxType | Literal["macos", "ios", "windows"]
 
 
 def _resolve_api_key(api_key: str | None) -> str | None:
@@ -128,6 +130,14 @@ class Computer:
         runtime: str = ...,
     ) -> IOSSandbox: ...
 
+    @overload
+    def create(
+        self,
+        *,
+        type: Literal["windows", SandboxType.WINDOWS],
+        host: str = ...,
+    ) -> WindowsSandbox: ...
+
     def create(
         self,
         *,
@@ -136,7 +146,7 @@ class Computer:
         family: SimulatorFamily | str | None = None,
         device_type: str = "",
         runtime: str = "",
-    ) -> MacOSSandbox | IOSSandbox:
+    ) -> MacOSSandbox | IOSSandbox | WindowsSandbox:
         """Create a new sandbox.
 
         Args:
@@ -167,6 +177,13 @@ class Computer:
 
         if sandbox_type == SandboxType.IOS:
             return IOSSandbox(sandbox_id=sid, http=self._http)
+        if sandbox_type == SandboxType.WINDOWS:
+            return WindowsSandbox(
+                sandbox_id=sid,
+                http=self._http,
+                vnc_url=f"{self._base_url}{data.get('vnc_url', '')}",
+                host=data.get("host", ""),
+            )
         return MacOSSandbox(
             sandbox_id=sid,
             http=self._http,
@@ -184,6 +201,13 @@ class Computer:
         sb_type = SandboxType(data.get("type", "macos"))
         if sb_type == SandboxType.IOS:
             return IOSSandbox(sandbox_id=data["sandbox_id"], http=self._http)
+        if sb_type == SandboxType.WINDOWS:
+            return WindowsSandbox(
+                sandbox_id=data["sandbox_id"],
+                http=self._http,
+                vnc_url=f"{self._base_url}{data.get('vnc_url', '')}",
+                host=data.get("host", ""),
+            )
         return MacOSSandbox(
             sandbox_id=data["sandbox_id"],
             http=self._http,
@@ -292,6 +316,14 @@ class AsyncComputer:
         runtime: str = ...,
     ) -> AsyncIOSSandbox: ...
 
+    @overload
+    async def create(
+        self,
+        *,
+        type: Literal["windows", SandboxType.WINDOWS],
+        host: str = ...,
+    ) -> AsyncWindowsSandbox: ...
+
     async def create(
         self,
         *,
@@ -300,7 +332,7 @@ class AsyncComputer:
         family: SimulatorFamily | str | None = None,
         device_type: str = "",
         runtime: str = "",
-    ) -> AsyncMacOSSandbox | AsyncIOSSandbox:
+    ) -> AsyncMacOSSandbox | AsyncIOSSandbox | AsyncWindowsSandbox:
         """Create a new sandbox.
 
         Args:
@@ -331,6 +363,13 @@ class AsyncComputer:
 
         if sandbox_type == SandboxType.IOS:
             return AsyncIOSSandbox(sandbox_id=sid, http=self._http)
+        if sandbox_type == SandboxType.WINDOWS:
+            return AsyncWindowsSandbox(
+                sandbox_id=sid,
+                http=self._http,
+                vnc_url=f"{self._base_url}{data.get('vnc_url', '')}",
+                host=data.get("host", ""),
+            )
         return AsyncMacOSSandbox(
             sandbox_id=sid,
             http=self._http,
@@ -348,6 +387,13 @@ class AsyncComputer:
         sb_type = SandboxType(data.get("type", "macos"))
         if sb_type == SandboxType.IOS:
             return AsyncIOSSandbox(sandbox_id=data["sandbox_id"], http=self._http)
+        if sb_type == SandboxType.WINDOWS:
+            return AsyncWindowsSandbox(
+                sandbox_id=data["sandbox_id"],
+                http=self._http,
+                vnc_url=f"{self._base_url}{data.get('vnc_url', '')}",
+                host=data.get("host", ""),
+            )
         return AsyncMacOSSandbox(
             sandbox_id=data["sandbox_id"],
             http=self._http,

{use_computer-0.0.18 → use_computer-0.0.19}/use_computer/errors.py

@@ -18,7 +18,13 @@ class PlatformNotSupportedError(UseComputerError):
          "hint": "use POST /tap"}
     """
 
-    def __init__(self, action: str, sandbox_type: str, hint: str, response: httpx.Response):
+    def __init__(
+        self,
+        action: str,
+        sandbox_type: str,
+        hint: str,
+        response: httpx.Response | None = None,
+    ):
         self.action = action
         self.sandbox_type = sandbox_type
         self.hint = hint

{use_computer-0.0.18 → use_computer-0.0.19}/use_computer/recording.py

@@ -26,7 +26,9 @@ class Recording:
     def list_all(self) -> list[RecordingInfo]:
         resp = self._http.get(f"{self._prefix}/recordings")
         resp.raise_for_status()
-        return [RecordingInfo.from_dict(r) for r in resp.json()]
+        data = resp.json()
+        items = data.get("recordings", []) if isinstance(data, dict) else data
+        return [RecordingInfo.from_dict(r) for r in items]
 
     def get(self, recording_id: str) -> RecordingInfo:
         resp = self._http.get(f"{self._prefix}/recordings/{recording_id}")
@@ -67,7 +69,9 @@ class AsyncRecording:
     async def list_all(self) -> list[RecordingInfo]:
         resp = await self._http.get(f"{self._prefix}/recordings")
         resp.raise_for_status()
-        return [RecordingInfo.from_dict(r) for r in resp.json()]
+        data = resp.json()
+        items = data.get("recordings", []) if isinstance(data, dict) else data
+        return [RecordingInfo.from_dict(r) for r in items]
 
     async def get(self, recording_id: str) -> RecordingInfo:
         resp = await self._http.get(f"{self._prefix}/recordings/{recording_id}")

{use_computer-0.0.18 → use_computer-0.0.19}/use_computer/sandbox.py

@@ -11,6 +11,7 @@ import httpx
 
 from use_computer.accessibility import Accessibility, AsyncAccessibility
 from use_computer.display import AsyncDisplay, Display
+from use_computer.errors import PlatformNotSupportedError
 from use_computer.ios.apps import Apps, AsyncApps
 from use_computer.ios.environment import AsyncEnvironment, Environment
 from use_computer.ios.input import AsyncInput, Input
@@ -19,11 +20,13 @@ from use_computer.macos.mouse import AsyncMouse, Mouse
 from use_computer.models import ActResult, ExecResult
 from use_computer.recording import AsyncRecording, Recording
 from use_computer.screenshot import AsyncScreenshot, Screenshot
+from use_computer.windows.shell import AsyncShell, Shell, ShellKind
 
 
 class SandboxType(str, Enum):
     MACOS = "macos"
     IOS = "ios"
+    WINDOWS = "windows"
 
 
 # ---------------------------------------------------------------------------
@@ -252,6 +255,75 @@ class IOSSandbox(Sandbox):
         self.environment = Environment(http, self._prefix)
 
 
+class _NoAxeAccessibility:
+    """Mixin: Windows has no macOS axe-schema tree — `.accessibility` raises, use `.ui_tree()`."""
+
+    @property
+    def accessibility(self):
+        raise PlatformNotSupportedError(
+            action="accessibility (macOS axe schema)",
+            sandbox_type="windows",
+            hint="use .ui_tree() for the native Windows UIAutomation tree",
+        )
+
+    @accessibility.setter
+    def accessibility(self, _value):
+        pass  # discard the base's axe helper — Windows exposes .ui_tree() instead
+
+
+class WindowsSandbox(_NoAxeAccessibility, Sandbox):
+    """Windows VM sandbox (Beta) — mouse, keyboard, PowerShell/cmd exec, VNC.
+
+    Beta. Differs from macOS: no SSH (exec runs through the in-guest agent via
+    `shell`), and `ui_tree()` returns the native Windows UIAutomation tree. The
+    macOS axe-schema `.accessibility` raises PlatformNotSupportedError here.
+    """
+
+    def __init__(
+        self,
+        sandbox_id: str,
+        http: httpx.Client,
+        *,
+        vnc_url: str = "",
+        host: str = "",
+    ):
+        super().__init__(sandbox_id, SandboxType.WINDOWS, http, vnc_url=vnc_url)
+        self.host = host
+        # Mouse/keyboard hit the same gateway command path as macOS.
+        self.mouse = Mouse(http, self._prefix)
+        self.keyboard = Keyboard(http, self._prefix)
+        self.shell = Shell(http, self._prefix)
+
+    def act(
+        self,
+        action: dict,
+        screenshot_after: bool = True,
+        screenshot_delay_ms: int = 100,
+    ) -> ActResult:
+        resp = self._http.post(
+            f"{self._prefix}/act",
+            json={
+                "action": action,
+                "screenshot_after": screenshot_after,
+                "screenshot_delay_ms": screenshot_delay_ms,
+            },
+        )
+        resp.raise_for_status()
+        if screenshot_after and resp.headers.get("content-type", "").startswith("image/"):
+            return ActResult(screenshot=resp.content)
+        return ActResult(data=resp.json())
+
+    def run(self, command: str, shell: ShellKind = "powershell", timeout: int = 300) -> ExecResult:
+        """Shorthand for self.shell.run()."""
+        return self.shell.run(command, shell, timeout)
+
+    def ui_tree(self, max_depth: int = 12) -> dict:
+        """Native Windows UIAutomation tree (raw, not normalized to the axe schema)."""
+        resp = self._http.get(f"{self._prefix}/display/windows", params={"max_depth": max_depth})
+        resp.raise_for_status()
+        return resp.json()
+
+
 # ---------------------------------------------------------------------------
 # Async
 # ---------------------------------------------------------------------------
@@ -420,3 +492,54 @@ class AsyncIOSSandbox(AsyncSandbox):
         self.input = AsyncInput(http, self._prefix)
         self.apps = AsyncApps(http, self._prefix)
         self.environment = AsyncEnvironment(http, self._prefix)
+
+
+class AsyncWindowsSandbox(_NoAxeAccessibility, AsyncSandbox):
+    """Async Windows VM sandbox — see WindowsSandbox."""
+
+    def __init__(
+        self,
+        sandbox_id: str,
+        http: httpx.AsyncClient,
+        *,
+        vnc_url: str = "",
+        host: str = "",
+    ):
+        super().__init__(sandbox_id, SandboxType.WINDOWS, http, vnc_url=vnc_url)
+        self.host = host
+        self.mouse = AsyncMouse(http, self._prefix)
+        self.keyboard = AsyncKeyboard(http, self._prefix)
+        self.shell = AsyncShell(http, self._prefix)
+
+    async def act(
+        self,
+        action: dict,
+        screenshot_after: bool = True,
+        screenshot_delay_ms: int = 100,
+    ) -> ActResult:
+        resp = await self._http.post(
+            f"{self._prefix}/act",
+            json={
+                "action": action,
+                "screenshot_after": screenshot_after,
+                "screenshot_delay_ms": screenshot_delay_ms,
+            },
+        )
+        resp.raise_for_status()
+        if screenshot_after and resp.headers.get("content-type", "").startswith("image/"):
+            return ActResult(screenshot=resp.content)
+        return ActResult(data=resp.json())
+
+    async def run(
+        self, command: str, shell: ShellKind = "powershell", timeout: int = 300
+    ) -> ExecResult:
+        """Shorthand for self.shell.run()."""
+        return await self.shell.run(command, shell, timeout)
+
+    async def ui_tree(self, max_depth: int = 12) -> dict:
+        """Native Windows UIAutomation tree (raw, not normalized to the axe schema)."""
+        resp = await self._http.get(
+            f"{self._prefix}/display/windows", params={"max_depth": max_depth}
+        )
+        resp.raise_for_status()
+        return resp.json()

use_computer-0.0.19/use_computer/windows/__init__.py

@@ -0,0 +1,3 @@
+from use_computer.windows.shell import AsyncShell, Shell
+
+__all__ = ["AsyncShell", "Shell"]

use_computer-0.0.19/use_computer/windows/shell.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import httpx
+
+from use_computer.models import ExecResult
+
+ShellKind = Literal["powershell", "cmd"]
+
+
+class Shell:
+    """Run commands inside a Windows sandbox via the in-guest agent (no SSH)."""
+
+    def __init__(self, http: httpx.Client, prefix: str):
+        self._http = http
+        self._prefix = prefix
+
+    def run(self, command: str, shell: ShellKind = "powershell", timeout: int = 300) -> ExecResult:
+        resp = self._http.post(
+            f"{self._prefix}/exec",
+            json={"command": command, "shell": shell},
+            timeout=timeout,
+        )
+        resp.raise_for_status()
+        return ExecResult.from_dict(resp.json())
+
+    def powershell(self, command: str, timeout: int = 300) -> ExecResult:
+        return self.run(command, "powershell", timeout)
+
+    def cmd(self, command: str, timeout: int = 300) -> ExecResult:
+        return self.run(command, "cmd", timeout)
+
+
+class AsyncShell:
+    """Async variant of Shell."""
+
+    def __init__(self, http: httpx.AsyncClient, prefix: str):
+        self._http = http
+        self._prefix = prefix
+
+    async def run(
+        self, command: str, shell: ShellKind = "powershell", timeout: int = 300
+    ) -> ExecResult:
+        resp = await self._http.post(
+            f"{self._prefix}/exec",
+            json={"command": command, "shell": shell},
+            timeout=timeout,
+        )
+        resp.raise_for_status()
+        return ExecResult.from_dict(resp.json())
+
+    async def powershell(self, command: str, timeout: int = 300) -> ExecResult:
+        return await self.run(command, "powershell", timeout)
+
+    async def cmd(self, command: str, timeout: int = 300) -> ExecResult:
+        return await self.run(command, "cmd", timeout)