Run Claude Code

# pip install boxlite
# export CLAUDE_CODE_OAUTH_TOKEN="<YOUR_CLAUDE_OAUTH_TOKEN>"  # replace with your real token
import asyncio
import os
import boxlite

async def main() -> None:
    # Explicit check to surface a helpful hint (SkillBox also validates internally and raises ValueError if missing)
    if not os.environ.get("CLAUDE_CODE_OAUTH_TOKEN"):
        raise SystemExit("Please export CLAUDE_CODE_OAUTH_TOKEN=<your token> first")

    try:
        # SkillBox is an async context manager; token defaults to reading CLAUDE_CODE_OAUTH_TOKEN
        async with boxlite.SkillBox() as box:
            print(f"Box ID: {box.id}")
            # The first call() lazily installs the Claude CLI, bash, git, python (takes a while)
            answer = await box.call("What is 2 + 2? Just give the number.")
            print("Claude:", answer)
    except ValueError as e:
        # For example, a missing OAuth token
        print("Configuration error:", e)
    except RuntimeError as e:
        # For example, no virtualization, image pull failure
        print("Runtime error:", e)

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

// npm install @boxlite-ai/boxlite
// export CLAUDE_CODE_OAUTH_TOKEN="<YOUR_CLAUDE_OAUTH_TOKEN>"  // replace with your real token
import { SkillBox } from "@boxlite-ai/boxlite";

async function main(): Promise<void> {
  const token = process.env.CLAUDE_CODE_OAUTH_TOKEN;
  if (!token) {
    console.error("Please export CLAUDE_CODE_OAUTH_TOKEN=<your token> first");
    process.exit(1);
  }

  // SkillBox supports await using (asyncDispose); cleans up automatically when leaving scope
  const box = new SkillBox({ oauthToken: token });
  try {
    await box.start();
    // The first call() installs the Claude CLI and dependencies inside the box
    const answer = await box.call("What is 2 + 2? Just give the number.");
    console.log("Claude:", answer);
  } catch (err) {
    // Missing token / no virtualization / image pull failure, etc.
    console.error("Run failed:", err instanceof Error ? err.message : err);
  } finally {
    await box.stop();
  }
}

main();

async with boxlite.SkillBox() as box:
    await box.call("My name is Alice and I work with Python and Rust.")
    # Same session; Claude remembers the prior context
    print(await box.call("What do you know about me? Be brief."))

async with boxlite.SkillBox() as box:
    await box.wait_until_ready()           # Wait for the desktop to come up
    # Open the address below to watch the agent operate the desktop in real time
    print(f"Desktop: https://localhost:{box.gui_https_port}")
    print(await box.call("Open a text editor and write hello.txt"))

import asyncio

from boxlite import SimpleBox

BASE_URL = "<ANTHROPIC_BASE_URL>"   # e.g. https://api.anthropic.com, or your own gateway
API_KEY = "<YOUR_API_KEY>"          # an API key for that endpoint, not an OAuth token
MODEL = "<MODEL_NAME>"              # a model the endpoint serves


async def run(box, *cmd, env=None, user=None, timeout=None):
    result = await box.exec(*cmd, env=env, user=user, timeout=timeout)
    # exec does not raise on a non-zero exit — check it yourself
    if result.exit_code != 0:
        raise RuntimeError(f"`{' '.join(cmd)}` failed (exit={result.exit_code}): {result.stderr}")
    return result


async def main() -> None:
    try:
        # disk_size_gb=20 leaves room for the global npm install
        async with SimpleBox(image="node:20-slim", memory_mib=2048, disk_size_gb=20) as box:
            await run(box, "npm", "install", "-g", "@anthropic-ai/claude-code", timeout=600.0)
            version = await run(box, "claude", "--version")
            print("installed:", version.stdout.strip())

            # The CLI will not bypass permissions as root — create a user for it
            await run(box, "sh", "-c",
                      "useradd -m -s /bin/bash agent && mkdir -p /home/agent/work && "
                      "chown -R agent:agent /home/agent")

            cli_env = {
                "ANTHROPIC_BASE_URL": BASE_URL,
                "ANTHROPIC_AUTH_TOKEN": API_KEY,  # used by most compatible gateways
                "ANTHROPIC_API_KEY": API_KEY,     # used by the official API
                "ANTHROPIC_MODEL": MODEL,
                "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "HOME": "/home/agent",
            }

            # < /dev/null closes stdin so the CLI does not wait for piped input
            answer = await run(
                box, "sh", "-c",
                "cd /home/agent/work && claude -p "
                "\"Create a file hello.txt containing the line 'hello from box', "
                "then explain in one sentence what you did.\" "
                f"--permission-mode bypassPermissions --model {MODEL} < /dev/null",
                env=cli_env, user="agent", timeout=300.0,
            )
            print(answer.stdout)

            # Confirm the agent really wrote the file inside the box
            check = await run(box, "sh", "-c", "cat /home/agent/work/hello.txt")
            print(check.stdout)
    except RuntimeError as exc:
        print(f"runtime error: {exc}")


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

# pip install boxlite
# export CLAUDE_CODE_OAUTH_TOKEN="<YOUR_CLAUDE_OAUTH_TOKEN>"  # replace with your real token
import asyncio
import os
import boxlite

OAUTH_TOKEN = os.environ.get("CLAUDE_CODE_OAUTH_TOKEN", "")

async def main() -> None:
    if not OAUTH_TOKEN:
        raise SystemExit("Please export CLAUDE_CODE_OAUTH_TOKEN=<your token> first")

    # SimpleBox: use a plain image and inject the token as an environment variable.
    # Constructor env is a list of (key, value) tuples — exec's env is a dict.
    box = boxlite.SimpleBox(
        image="node:20-alpine",
        memory_mib=2048,
        name="claude-box",
        auto_remove=False,  # Persist to avoid reinstalling each time
        env=[("CLAUDE_CODE_OAUTH_TOKEN", OAUTH_TOKEN)],
    )
    try:
        async with box:
            # 1) Install the Claude Code CLI (a non-zero exit code does not raise; check exit_code yourself)
            install = await box.exec(
                "npm", "install", "-g", "@anthropic-ai/claude-code",
                timeout=600.0,  # SimpleBox.exec timeout parameter is named timeout (float, seconds)
            )
            if install.exit_code != 0:
                raise RuntimeError(f"Failed to install Claude CLI: {install.stderr}")

            # 2) Verify the installation
            version = await box.exec("claude", "--version")
            print("Installed:", version.stdout.strip())

            # 3) Single-shot prompt (--print makes claude exit after running and print the result directly)
            ask = await box.exec(
                "claude", "--print", "--dangerously-skip-permissions",
                "What is the capital of France? One word.",
                timeout=120.0,
            )
            if ask.exit_code != 0:
                raise RuntimeError(f"Claude execution failed: {ask.stderr}")
            print("Claude:", ask.stdout.strip())
    except RuntimeError as e:
        # Image pull failure / no virtualization / missing command all surface as a standard RuntimeError
        print("Runtime error:", e)

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

# Low-level handle path: the native Box returned by runtime.create(...) (note: exec uses list-form args/env)
import asyncio, json
import boxlite
from boxlite import BoxOptions

async def chat_once(box, stdin, stdout, content, session_id="default"):
    msg = {
        "type": "user",
        "message": {"role": "user", "content": content},
        "session_id": session_id,
        "parent_tool_use_id": None,
    }
    await stdin.send_input((json.dumps(msg) + "\n").encode())

    buffer, responses, new_session = "", [], session_id
    try:
        while True:
            chunk = await asyncio.wait_for(stdout.__anext__(), timeout=120)
            buffer += chunk.decode("utf-8", "replace") if isinstance(chunk, bytes) else chunk
            while "\n" in buffer:
                line, buffer = buffer.split("\n", 1)
                line = line.strip()
                if not line:
                    continue
                parsed = json.loads(line)
                responses.append(parsed)
                if parsed.get("session_id"):
                    new_session = parsed["session_id"]
                if parsed.get("type") == "result":
                    raise StopAsyncIteration
    except (asyncio.TimeoutError, StopAsyncIteration):
        pass

    result = next((r for r in responses if r.get("type") == "result"), None)
    return (result.get("result", "") if result else ""), new_session
# Usage shown above: runtime = boxlite.Boxlite.default(); box = await runtime.create(BoxOptions(...));
#           execution = await box.exec("claude", [..stream-json flags..], [("CLAUDE_CODE_OAUTH_TOKEN", token)])