solari-desktop 0.1.1__tar.gz

solari_desktop-0.1.1/.gitignore

@@ -0,0 +1,71 @@
+# build artifacts
+dist/
+**/dist/
+**/node_modules/
+**/target/
+*.log
+
+# VM images / snapshots / kernels — large binaries, never committed
+*.img
+*.ext4
+*.qcow2
+*.raw
+*.snapshot
+/snapshots/build/
+/guest/rootfs/build/
+/guest/kernel/build/
+vmlinux
+bzImage
+
+# terraform state
+*.tfstate
+*.tfstate.*
+.terraform/
+*.tfvars.local
+
+# secrets / env
+.env
+.env.*
+*.pem
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+
+# NOTE: tests/sdk/ts-request-fixtures.json is deliberately NOT ignored.
+#
+# It was, and that quietly disabled two gates at once:
+#
+#  1. ci.yml's "Committed fixture must match what the SDK emits today" step runs
+#     `git diff --exit-code tests/sdk/ts-request-fixtures.json`. On an ignored,
+#     never-tracked file that command can only ever succeed — it had never once
+#     been able to fail.
+#  2. The Go/Rust/C++/Python contract suites now assert against that fixture from
+#     inside their OWN CI jobs, none of which run the TypeScript half. If the file
+#     is not committed, it is simply absent there.
+#
+# It is generated, but it is generated from the REFERENCE SDK and checked in as
+# the baseline the other four bindings are held to — regenerating it and diffing
+# is exactly how a wire change is made to announce itself.
+
+# Built guest-agent binaries (produced by go build / build-rootfs staging)
+guest/agent/agent
+guest/rootfs/guest-agent
+
+# build-rootfs.sh template staging + generated Dockerfile (regenerated each run)
+guest/rootfs/guest-agent.service
+guest/rootfs/template.packages
+guest/rootfs/template-files/
+guest/rootfs/.Dockerfile.gen
+guest/rootfs/out/
+
+# local test artifacts
+staging-desktop.png
+desktop.png
+infra/terraform/snapshots-volumes/.build/
+
+# deploy-e2e scratch state: holds a presigned REPO_URL with live STS creds
+# (ASIA... + X-Amz-Security-Token). Never commit. Also stale PHASE_* here makes
+# a bare re-run skip bake+verify and exit 0 with zero assertions.
+infra/.deploy-e2e/

solari_desktop-0.1.1/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: solari-desktop
+Version: 0.1.1
+Summary: Python SDK for Solari Desktop — managed, hardware-isolated Linux desktops with a computer-use action API.
+Project-URL: Homepage, https://getsolari.com
+Author: Solari
+License: MIT
+Keywords: automation,computer-use,desktop,solari,vnc
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Requires-Dist: websockets>=11.0
+Description-Content-Type: text/markdown
+
+# solari-desktop (Python)
+
+Python SDK for **Solari Desktop** — create managed, hardware-isolated Linux
+desktops that boot in well under a second, embed the live VNC stream, and drive
+them with a **computer-use** action API (exec, fs, mouse/keyboard, screenshot,
+clipboard, processes).
+
+This is a faithful port of the TypeScript `@solarisdk/sdk` package; the
+class, method, and field names match it one-for-one (snake_case where TS uses
+camelCase for method/parameter names; wire/response field names are kept as-is).
+
+```
+SDK ──HTTPS──▶ Gateway  (create / get / destroy sessions)
+SDK ──WSS────▶ Gateway  (control channel: computer-use JSON-RPC)
+            ──WSS────▶  (stream channel: RFB/VNC bytes, embed in a viewer)
+```
+
+## Install
+
+```sh
+pip install solari-desktop
+```
+
+Depends only on [`httpx`](https://www.python-httpx.org/) (HTTP) and
+[`websockets`](https://websockets.readthedocs.io/) (control channel). Requires
+Python 3.9+.
+
+## Usage
+
+The primary API is **async** (matching the asyncio WebSocket control channel):
+
+```python
+import asyncio
+from solari_desktop import DesktopClient
+
+
+async def main() -> None:
+    async with DesktopClient(
+        api_key="...",
+        base_url="https://api.getsolari.com",
+    ) as client:
+        # Create a session (assigned from the warm pool — typically sub-second).
+        desktop = await client.create(
+            template="default",
+            resolution="1280x720",
+            timeout_ms=1_800_000,   # rolling idle window: auto-pause after 30 min idle
+        )
+
+        # Embed this URL in a VNC viewer to watch the live desktop.
+        print(desktop.streamUrl)
+
+        # Open the control channel, then drive the desktop.
+        await desktop.connect()
+
+        shot = await desktop.screenshot(format="png")          # bytes
+        out = await desktop.exec("ls", args=["-la", "/home"])
+        print(out.exitCode, out.stdout)
+
+        await desktop.mouse.click(640, 360, humanize=True)
+        await desktop.keyboard.press(["ctrl", "c"])
+        await desktop.fs.write("/tmp/note.txt", "hello")
+        text = await desktop.fs.read_text("/tmp/note.txt")
+
+        # Public preview URL for an in-guest port (requires PREVIEW_DOMAIN).
+        preview = await desktop.preview_url(3000)   # {"url": ..., "token"?: ...}
+        print(preview["url"])
+
+        # Pause (snapshot RAM+disk, free the slot) and resume later.
+        await desktop.pause()
+        await desktop.resume()
+
+        await desktop.close()
+        await client.destroy(desktop.sessionId)
+
+
+asyncio.run(main())
+```
+
+A thin synchronous wrapper, `SyncDesktopClient`, is available for the
+session-lifecycle calls (`create`, `get`, `destroy`, `attach`) when you are not
+running an event loop. The returned `Desktop` handle remains async.
+
+## Client API (`DesktopClient`)
+
+| Method | Description |
+|---|---|
+| `DesktopClient(api_key=, base_url=, http=None, call_timeout_ms=None)` | Construct a client. |
+| `await create(template="default", ttl_seconds=None, timeout_ms=None, resolution=None, metadata=None, record=None, lifecycle=None)` → `Desktop` | `POST /desktops`. `timeout_ms` sets a rolling idle window; `lifecycle` controls idle behaviour (default auto-pause). |
+| `await get(session_id)` | `GET /desktops/:id` → `GetDesktopResponse(sessionId, status, expiresAt)`. |
+| `await destroy(session_id)` | `DELETE /desktops/:id` → `DeleteDesktopResponse(ok=True)` (idempotent). |
+| `attach(session)` → `Desktop` | Re-create a handle from a saved `CreateDesktopResponse`. |
+| `await aclose()` | Close the owned HTTP client. Also usable as an async context manager. |
+
+Gateway errors are mapped to typed errors: `AuthError` (401), `PlanError`
+(402), `ConcurrencyLimitError` (429), `NoCapacityError` (503), and a generic
+`GatewayError` otherwise — all subclasses of `SolariError`.
+
+## Desktop handle (`Desktop`)
+
+Properties: `sessionId`, `streamUrl`, `controlUrl`, `expiresAt`, `connected`.
+
+`await connect()` opens the control WebSocket; `await close()` tears it down.
+Each action sends a `{ id, method, params }` JSON-RPC frame and awaits the
+matching `{ id, ok, result }` reply, correlated by `id`, with a per-call
+timeout (`TimeoutError`). A failed RPC raises `ActionError`.
+
+### Computer-use actions
+
+| Surface | Methods |
+|---|---|
+| `await desktop.exec(cmd, args=None, cwd=None, timeout_ms=None)` | → `ExecResult(exitCode, stdout, stderr)` |
+| `desktop.fs` | `read(path)→bytes`, `read_text(path)→str`, `write(path, data, mode=None)`, `list(path)→list[FsEntry]` |
+| `desktop.mouse` | `move(x,y,humanize=)`, `click(x,y,button=,humanize=)`, `down/up(x,y,button=)`, `scroll(x,y,...)` |
+| `desktop.keyboard` | `type(text)`, `press(keys)`, `down(keys)`, `up(keys)` |
+| `await desktop.screenshot(format="png", quality=None)` | → `bytes` |
+| `desktop.display` | `set(w, h)` |
+| `desktop.clipboard` | `get()→str`, `set(text)` |
+| `desktop.process` | `list()→list[ProcessInfo]`, `kill(pid)` |
+| `await desktop.health()` | → `HealthResult(ready, display, vnc)` |
+
+### Lifecycle & preview
+
+Since the 2026-07 desktop/sandbox VM consolidation, a desktop is backed by the
+same unified session record as a sandbox, so the handle carries the full
+lifecycle surface (routed to `/sandboxes/:id/*`):
+
+| Method | Description |
+|---|---|
+| `await desktop.pause()` / `await desktop.resume()` | Pause (snapshot RAM+disk, free the slot) / resume (re-acquires a slot; may raise `ConcurrencyLimitError` if the org is at cap). |
+| `await desktop.set_timeout(timeout_ms)` | Extend the rolling idle keep-alive → `{ expiresAt }`. |
+| `await desktop.metrics()` / `await desktop.snapshot(name=None)` / `await desktop.revert(id)` | Metrics + in-place snapshot/restore. |
+| `await desktop.preview_url(port)` | Public preview URL `{ url, token? }` for an in-guest port. |
+
+See `examples/quickstart.py` for an end-to-end script.
+
+## Deviations from the TypeScript SDK
+
+- **Async-first.** The TS SDK is promise-based; this SDK exposes the same
+  surface as `async def` coroutines, plus `SyncDesktopClient` for the
+  lifecycle calls. The TS SDK does not split sync/async, so no async/sync split
+  is exposed beyond that convenience wrapper.
+- **Naming.** Method and parameter names are snake_case (`read_text`,
+  `ttl_seconds`, `call_timeout_ms`); constructor args are keyword-only. Wire
+  and response field names (`sessionId`, `exitCode`, `streamUrl`, …) are kept
+  verbatim so dataclass attributes match the JSON.
+- **Bytes vs `Uint8Array`.** `fs.read`/`screenshot` return `bytes`;
+  `fs.write` accepts `bytes | str`.
+- **HTTP/WS deps.** Uses `httpx` and `websockets` instead of `fetch`/`ws`.
+```

solari_desktop-0.1.1/README.md

@@ -0,0 +1,149 @@
+# solari-desktop (Python)
+
+Python SDK for **Solari Desktop** — create managed, hardware-isolated Linux
+desktops that boot in well under a second, embed the live VNC stream, and drive
+them with a **computer-use** action API (exec, fs, mouse/keyboard, screenshot,
+clipboard, processes).
+
+This is a faithful port of the TypeScript `@solarisdk/sdk` package; the
+class, method, and field names match it one-for-one (snake_case where TS uses
+camelCase for method/parameter names; wire/response field names are kept as-is).
+
+```
+SDK ──HTTPS──▶ Gateway  (create / get / destroy sessions)
+SDK ──WSS────▶ Gateway  (control channel: computer-use JSON-RPC)
+            ──WSS────▶  (stream channel: RFB/VNC bytes, embed in a viewer)
+```
+
+## Install
+
+```sh
+pip install solari-desktop
+```
+
+Depends only on [`httpx`](https://www.python-httpx.org/) (HTTP) and
+[`websockets`](https://websockets.readthedocs.io/) (control channel). Requires
+Python 3.9+.
+
+## Usage
+
+The primary API is **async** (matching the asyncio WebSocket control channel):
+
+```python
+import asyncio
+from solari_desktop import DesktopClient
+
+
+async def main() -> None:
+    async with DesktopClient(
+        api_key="...",
+        base_url="https://api.getsolari.com",
+    ) as client:
+        # Create a session (assigned from the warm pool — typically sub-second).
+        desktop = await client.create(
+            template="default",
+            resolution="1280x720",
+            timeout_ms=1_800_000,   # rolling idle window: auto-pause after 30 min idle
+        )
+
+        # Embed this URL in a VNC viewer to watch the live desktop.
+        print(desktop.streamUrl)
+
+        # Open the control channel, then drive the desktop.
+        await desktop.connect()
+
+        shot = await desktop.screenshot(format="png")          # bytes
+        out = await desktop.exec("ls", args=["-la", "/home"])
+        print(out.exitCode, out.stdout)
+
+        await desktop.mouse.click(640, 360, humanize=True)
+        await desktop.keyboard.press(["ctrl", "c"])
+        await desktop.fs.write("/tmp/note.txt", "hello")
+        text = await desktop.fs.read_text("/tmp/note.txt")
+
+        # Public preview URL for an in-guest port (requires PREVIEW_DOMAIN).
+        preview = await desktop.preview_url(3000)   # {"url": ..., "token"?: ...}
+        print(preview["url"])
+
+        # Pause (snapshot RAM+disk, free the slot) and resume later.
+        await desktop.pause()
+        await desktop.resume()
+
+        await desktop.close()
+        await client.destroy(desktop.sessionId)
+
+
+asyncio.run(main())
+```
+
+A thin synchronous wrapper, `SyncDesktopClient`, is available for the
+session-lifecycle calls (`create`, `get`, `destroy`, `attach`) when you are not
+running an event loop. The returned `Desktop` handle remains async.
+
+## Client API (`DesktopClient`)
+
+| Method | Description |
+|---|---|
+| `DesktopClient(api_key=, base_url=, http=None, call_timeout_ms=None)` | Construct a client. |
+| `await create(template="default", ttl_seconds=None, timeout_ms=None, resolution=None, metadata=None, record=None, lifecycle=None)` → `Desktop` | `POST /desktops`. `timeout_ms` sets a rolling idle window; `lifecycle` controls idle behaviour (default auto-pause). |
+| `await get(session_id)` | `GET /desktops/:id` → `GetDesktopResponse(sessionId, status, expiresAt)`. |
+| `await destroy(session_id)` | `DELETE /desktops/:id` → `DeleteDesktopResponse(ok=True)` (idempotent). |
+| `attach(session)` → `Desktop` | Re-create a handle from a saved `CreateDesktopResponse`. |
+| `await aclose()` | Close the owned HTTP client. Also usable as an async context manager. |
+
+Gateway errors are mapped to typed errors: `AuthError` (401), `PlanError`
+(402), `ConcurrencyLimitError` (429), `NoCapacityError` (503), and a generic
+`GatewayError` otherwise — all subclasses of `SolariError`.
+
+## Desktop handle (`Desktop`)
+
+Properties: `sessionId`, `streamUrl`, `controlUrl`, `expiresAt`, `connected`.
+
+`await connect()` opens the control WebSocket; `await close()` tears it down.
+Each action sends a `{ id, method, params }` JSON-RPC frame and awaits the
+matching `{ id, ok, result }` reply, correlated by `id`, with a per-call
+timeout (`TimeoutError`). A failed RPC raises `ActionError`.
+
+### Computer-use actions
+
+| Surface | Methods |
+|---|---|
+| `await desktop.exec(cmd, args=None, cwd=None, timeout_ms=None)` | → `ExecResult(exitCode, stdout, stderr)` |
+| `desktop.fs` | `read(path)→bytes`, `read_text(path)→str`, `write(path, data, mode=None)`, `list(path)→list[FsEntry]` |
+| `desktop.mouse` | `move(x,y,humanize=)`, `click(x,y,button=,humanize=)`, `down/up(x,y,button=)`, `scroll(x,y,...)` |
+| `desktop.keyboard` | `type(text)`, `press(keys)`, `down(keys)`, `up(keys)` |
+| `await desktop.screenshot(format="png", quality=None)` | → `bytes` |
+| `desktop.display` | `set(w, h)` |
+| `desktop.clipboard` | `get()→str`, `set(text)` |
+| `desktop.process` | `list()→list[ProcessInfo]`, `kill(pid)` |
+| `await desktop.health()` | → `HealthResult(ready, display, vnc)` |
+
+### Lifecycle & preview
+
+Since the 2026-07 desktop/sandbox VM consolidation, a desktop is backed by the
+same unified session record as a sandbox, so the handle carries the full
+lifecycle surface (routed to `/sandboxes/:id/*`):
+
+| Method | Description |
+|---|---|
+| `await desktop.pause()` / `await desktop.resume()` | Pause (snapshot RAM+disk, free the slot) / resume (re-acquires a slot; may raise `ConcurrencyLimitError` if the org is at cap). |
+| `await desktop.set_timeout(timeout_ms)` | Extend the rolling idle keep-alive → `{ expiresAt }`. |
+| `await desktop.metrics()` / `await desktop.snapshot(name=None)` / `await desktop.revert(id)` | Metrics + in-place snapshot/restore. |
+| `await desktop.preview_url(port)` | Public preview URL `{ url, token? }` for an in-guest port. |
+
+See `examples/quickstart.py` for an end-to-end script.
+
+## Deviations from the TypeScript SDK
+
+- **Async-first.** The TS SDK is promise-based; this SDK exposes the same
+  surface as `async def` coroutines, plus `SyncDesktopClient` for the
+  lifecycle calls. The TS SDK does not split sync/async, so no async/sync split
+  is exposed beyond that convenience wrapper.
+- **Naming.** Method and parameter names are snake_case (`read_text`,
+  `ttl_seconds`, `call_timeout_ms`); constructor args are keyword-only. Wire
+  and response field names (`sessionId`, `exitCode`, `streamUrl`, …) are kept
+  verbatim so dataclass attributes match the JSON.
+- **Bytes vs `Uint8Array`.** `fs.read`/`screenshot` return `bytes`;
+  `fs.write` accepts `bytes | str`.
+- **HTTP/WS deps.** Uses `httpx` and `websockets` instead of `fetch`/`ws`.
+```

solari_desktop-0.1.1/examples/quickstart.py

@@ -0,0 +1,65 @@
+"""Quickstart: create a desktop, screenshot it, run a command, print the
+stream URL you can embed to watch the live session.
+
+    python examples/quickstart.py
+
+Requires SOLARI_API_KEY (and optionally SOLARI_BASE_URL) in the env.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+from solari_desktop import DesktopClient
+
+
+async def main() -> None:
+    api_key = os.environ.get("SOLARI_API_KEY")
+    if not api_key:
+        raise SystemExit("set SOLARI_API_KEY")
+
+    async with DesktopClient(
+        api_key=api_key,
+        base_url=os.environ.get("SOLARI_BASE_URL", "https://api.getsolari.com"),
+    ) as client:
+        # 1. Create a desktop (warm-pool assign -> ~sub-second).
+        desktop = await client.create(
+            template="default",
+            resolution="1280x720",
+            ttl_seconds=3600,
+        )
+
+        print("session:", desktop.sessionId)
+        print("stream this URL to watch the desktop:", desktop.streamUrl)
+
+        # 2. Open the control channel for computer-use actions.
+        await desktop.connect()
+
+        # 3. Wait until the desktop is fully ready, then act on it.
+        health = await desktop.health()
+        print("ready:", health.ready, "vnc:", health.vnc)
+
+        # 4. Take a screenshot and save it locally.
+        png = await desktop.screenshot(format="png")
+        with open("desktop.png", "wb") as fh:
+            fh.write(png)
+        print(f"saved screenshot ({len(png)} bytes) to desktop.png")
+
+        # 5. Run a command in the guest.
+        result = await desktop.exec("echo", args=["hello from the guest"])
+        print("exec exitCode:", result.exitCode)
+        print("exec stdout:", result.stdout.strip())
+
+        # 6. Drive input.
+        await desktop.mouse.move(640, 360, humanize=True)
+        await desktop.keyboard.type("hello world")
+
+        # 7. Tear down.
+        await desktop.close()
+        await client.destroy(desktop.sessionId)
+        print("destroyed session")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

solari_desktop-0.1.1/examples/sandbox_quickstart.py

@@ -0,0 +1,63 @@
+"""Sandbox quickstart (Python): the unified ``SolariClient`` drives a headless
+sandbox — run commands, run rich code, watch files, snapshot/fork, get a public
+preview URL — then boots a recorded GUI desktop.
+
+    SOLARI_API_KEY=... python3 examples/sandbox_quickstart.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+from solari_desktop import SolariClient
+
+
+async def main() -> None:
+    api_key = os.environ.get("SOLARI_API_KEY")
+    if not api_key:
+        raise SystemExit("set SOLARI_API_KEY")
+
+    pt = SolariClient(
+        api_key=api_key,
+        base_url=os.environ.get("SOLARI_BASE_URL", "https://api.getsolari.com"),
+    )
+
+    # --- headless sandbox ---------------------------------------------------
+    sbx = await pt.sandboxes.create(template="base", metadata={"demo": "1"})
+    await sbx.connect()
+
+    res = await sbx.commands.run("bash", env={"GREETING": "hi"}, on_stdout=lambda d: print(d, end=""))
+    print("exit:", res.exitCode)
+
+    proc = await sbx.commands.start("cat")
+    proc.on_data(lambda stream, data: print(f"[{stream}] {data}", end=""))
+    await proc.stdin("echo me\n")
+    await proc.kill()
+
+    code = await sbx.run_code("import sys; print(sys.version)", language="python")
+    print("code results:", len(code.results), "error:", code.error)
+
+    await sbx.files.write("/tmp/hello.txt", "world")
+    stop = await sbx.files.watch("/tmp", lambda ev: print("fs event:", ev.type, ev.path))
+    print("search hits:", len(await sbx.files.search("/tmp", "world")))
+    await stop()
+
+    snap_id = await sbx.snapshot("after-setup")
+    fork = await pt.sandboxes.create(template="base", from_snapshot=snap_id)
+    await fork.kill()
+    await sbx.kill()
+
+    # --- GUI desktop (recorded) --------------------------------------------
+    d = await pt.desktops.create(template="office", record=True)
+    await d.connect()
+    await d.mouse.double_click(100, 100)
+    await d.keyboard.hotkey("ctrl", "s")
+    print("desktop stream:", (await d.stream.start())["streamUrl"])
+    await d.close()
+    await pt.desktops.destroy(d.sessionId)
+    await pt.aclose()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

solari_desktop-0.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "solari-desktop"
+version = "0.1.1"
+description = "Python SDK for Solari Desktop — managed, hardware-isolated Linux desktops with a computer-use action API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Solari" }]
+keywords = ["solari", "desktop", "computer-use", "vnc", "automation"]
+dependencies = [
+    "httpx>=0.24",
+    "websockets>=11.0",
+]
+
+[project.urls]
+Homepage = "https://getsolari.com"
+
+[tool.hatch.build.targets.wheel]
+packages = ["solari_desktop"]
+
+[tool.ruff]
+line-length = 100

solari_desktop-0.1.1/solari_desktop/__init__.py

@@ -0,0 +1,145 @@
+"""solari_desktop — Python SDK for Solari Desktop.
+
+Mirrors the public surface of the TypeScript ``@solarisdk/sdk`` package
+(``sdk/src/index.ts``): the :class:`DesktopClient` entry point, the
+:class:`Desktop` session handle and its computer-use action API, and the typed
+error hierarchy.
+"""
+
+from __future__ import annotations
+
+from .client import DesktopClient, SyncDesktopClient
+from .desktop import Desktop, DesktopConfig, ExecStreamHandler
+from .handle import SessionConfig, SessionHandle, SessionHooks
+from .image import CompiledImage, Image, LocalCopy
+from .solari import SolariClient, SyncSolariClient
+from .sandbox import Sandbox
+from .sandbox_client import SandboxClient, SyncSandboxClient
+from .template_client import SyncTemplateClient, TemplateClient
+from .volume_client import SyncVolumeClient, VolumeClient
+from .errors import (
+    ActionError,
+    AuthError,
+    ConcurrencyLimitError,
+    ConnectionError,
+    GatewayError,
+    NoCapacityError,
+    SolariError,
+    PlanError,
+    TimeoutError,
+)
+from .types import (
+    CodeLanguage,
+    CodeResultItem,
+    CommandResult,
+    CreateDesktopResponse,
+    CreateSandboxResponse,
+    DeleteDesktopResponse,
+    DesktopLifecycleResponse,
+    DesktopStatus,
+    ExecResult,
+    ExecStreamChunk,
+    FsEntry,
+    FsSearchMatch,
+    FsStat,
+    FsWatchEvent,
+    GatewayErrorBody,
+    GitBranch,
+    GitCommit,
+    GitStatus,
+    GetDesktopResponse,
+    HealthResult,
+    KeyAction,
+    MetricsResult,
+    MouseAction,
+    MouseButton,
+    PackageManager,
+    PkgInstallResult,
+    PortInfo,
+    ProcessInfo,
+    RpcErrorBody,
+    RpcResponse,
+    RunCodeResult,
+    SandboxKind,
+    SandboxState,
+    SandboxView,
+    ScreenshotFormat,
+    SnapshotView,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # unified
+    "SolariClient",
+    "SyncSolariClient",
+    # image builder
+    "Image",
+    "CompiledImage",
+    "LocalCopy",
+    # client
+    "DesktopClient",
+    "SyncDesktopClient",
+    "SandboxClient",
+    "SyncSandboxClient",
+    "TemplateClient",
+    "SyncTemplateClient",
+    "VolumeClient",
+    "SyncVolumeClient",
+    # handles
+    "Desktop",
+    "DesktopConfig",
+    "ExecStreamHandler",
+    "Sandbox",
+    "SessionHandle",
+    "SessionConfig",
+    "SessionHooks",
+    # errors
+    "ActionError",
+    "AuthError",
+    "ConcurrencyLimitError",
+    "ConnectionError",
+    "GatewayError",
+    "NoCapacityError",
+    "SolariError",
+    "PlanError",
+    "TimeoutError",
+    # types
+    "CreateDesktopResponse",
+    "CreateSandboxResponse",
+    "DeleteDesktopResponse",
+    "DesktopLifecycleResponse",
+    "DesktopStatus",
+    "ExecResult",
+    "ExecStreamChunk",
+    "FsEntry",
+    "FsStat",
+    "GatewayErrorBody",
+    "GetDesktopResponse",
+    "HealthResult",
+    "KeyAction",
+    "MouseAction",
+    "MouseButton",
+    "PackageManager",
+    "PkgInstallResult",
+    "PortInfo",
+    "ProcessInfo",
+    "RpcErrorBody",
+    "RpcResponse",
+    "ScreenshotFormat",
+    # v2 types
+    "CodeLanguage",
+    "CodeResultItem",
+    "CommandResult",
+    "FsSearchMatch",
+    "FsWatchEvent",
+    "GitBranch",
+    "GitCommit",
+    "GitStatus",
+    "MetricsResult",
+    "RunCodeResult",
+    "SandboxKind",
+    "SandboxState",
+    "SandboxView",
+    "SnapshotView",
+]