Box types

import asyncio
from boxlite import SimpleBox, BoxliteError

async def main() -> None:
    try:
        # at least one of image and rootfs_path must be provided, otherwise construction raises ValueError
        async with SimpleBox(image="alpine:latest") as box:
            # the exec timeout parameter is timeout (float, seconds); env is a dict
            result = await box.exec("echo", "hi", env={"FOO": "bar"}, timeout=30.0)
            # a non-zero exit code does not raise; check exit_code yourself
            if result.exit_code != 0:
                print(f"command failed ({result.exit_code}): {result.stderr}")
            else:
                print(result.stdout.strip())  # -> hi
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from boxlite import CodeBox, BoxliteError

async def main() -> None:
    try:
        async with CodeBox() as cb:
            await cb.install_package("requests")  # pip install requests
            out = await cb.run("import requests; print(requests.__version__)")
            print(out.strip())
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())

# pip install boxlite playwright
import asyncio
from boxlite import BrowserBox, BrowserBoxOptions, BoxliteError

async def main() -> None:
    try:
        # the browser type is passed via BrowserBoxOptions (BrowserBox's first positional argument is options)
        async with BrowserBox(BrowserBoxOptions(browser="chromium")) as bb:
            # Playwright Server mode (port defaults to 3000, supports all browser types)
            endpoint = await bb.playwright_endpoint(timeout=60)
            print(f"Playwright endpoint: {endpoint}")

            # connect into the in-sandbox browser using the host's playwright
            from playwright.async_api import async_playwright
            async with async_playwright() as p:
                browser = await p.chromium.connect(endpoint)
                page = await browser.new_page()
                await page.goto("https://example.com")
                print(await page.title())  # -> Example Domain
                await browser.close()
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from boxlite import ComputerBox, BoxliteError

async def main() -> None:
    try:
        async with ComputerBox() as cb:
            await cb.wait_until_ready(timeout=60)   # wait for the desktop to be ready
            print(f"screen resolution: {await cb.get_screen_size()}")

            await cb.mouse_move(400, 300)
            await cb.left_click()
            await cb.type("hello desktop")

            shot = await cb.screenshot()             # returns a dict (contains screenshot data)
            print(f"screenshot fields: {list(shot.keys())}")
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from boxlite import InteractiveBox, BoxliteError

async def main() -> None:
    try:
        # image is required; when tty=None, sys.stdin.isatty() is auto-detected
        async with InteractiveBox(image="alpine:latest") as box:
            # once entered you are inside the sandbox shell; type commands to see live output, type exit to leave
            await box.wait()
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import os
from boxlite import SkillBox, BoxliteError

async def main() -> None:
    # an OAuth token must be provided: via constructor argument or the CLAUDE_CODE_OAUTH_TOKEN environment variable, otherwise entry raises ValueError
    token = os.environ.get("CLAUDE_CODE_OAUTH_TOKEN", "<YOUR_CLAUDE_OAUTH_TOKEN>")  # TODO: replace with your token
    try:
        async with SkillBox(skills=["anthropics/skills"], oauth_token=token) as box:
            await box.wait_until_ready(timeout=60)
            # open https://localhost:<gui_https_port> in a browser to watch live
            answer = await box.call("What skills do you have?")
            print(answer)
    except ValueError as exc:
        print(f"configuration missing: {exc}")        # e.g. no OAuth token provided
    except RuntimeError as exc:
        print(f"startup failed: {exc}")
    except BoxliteError as exc:
        print(f"BoxLite error: {exc}")

if __name__ == "__main__":
    asyncio.run(main())