Run an AI coding agent

import { Sandbox } from "@brimble/sandbox";

const client = new Sandbox();

async function runAgent({
  repoUrl,
  task,
  anthropicKey,
}: { repoUrl: string; task: string; anthropicKey: string }) {
  const handle = await client.sandboxes.create({
    region: "auto",
    template: "claude-code",
    persistent: true,
    persistentDiskGB: 20,         // room for the checkout + node_modules / venvs
    autoDestroy: true,
    destroyTimeout: "3h",         // generous; agent runs can take a while
    // egress defaults to open — agent needs model API access
  });

  try {
    // Seed the task description on disk
    await handle.putFile("/work/task.md", task);

    // Clone and run the agent. Pass the agent's API key via `env`, never bake
    // a secret into the cmd string.
    const run = await handle.exec({
      cmd: [
        "set -e",
        "mkdir -p /work && cd /work",
        `git clone --depth 1 ${repoUrl} repo`,
        "cd repo",
        "claude --print --dangerously-skip-permissions < /work/task.md > /work/agent.log 2>&1",
      ].join(" && "),
      env: { ANTHROPIC_API_KEY: anthropicKey },
      timeout_seconds: 1800,       // 30 min cap
    });

    if (run.exit_code !== 0) {
      throw new Error(`agent failed (${run.exit_code}): ${run.stderr}`);
    }

    // Collect the resulting diff
    const diff = await handle.exec({
      cmd: "cd /work/repo && git add -A && git diff --staged",
    });

    // Snapshot before we destroy, in case we want to resume / inspect later
    const snap = await handle.snapshots.create({ name: "post-run" });

    return { diff: diff.stdout, snapshotId: snap.id };
  } finally {
    await handle.destroy().catch(() => {});
  }
}

const result = await runAgent({
  repoUrl: "https://github.com/myorg/widgets.git",
  task: "Refactor src/utils to use async/await. Add tests.",
  anthropicKey: process.env.ANTHROPIC_API_KEY!,
});

console.log(result.diff);

import os
from brimble_sandbox import Sandbox

client = Sandbox()

def run_agent(*, repo_url: str, task: str, anthropic_key: str) -> dict:
    sandbox = client.sandboxes.create({
        "region": "auto",
        "template": "claude-code",
        "persistent": True,
        "persistentDiskGB": 20,
        "autoDestroy": True,
        "destroyTimeout": "3h",
    })

    try:
        sandbox.put_file("/work/task.md", task.encode())

        run = sandbox.exec({
            "cmd": " && ".join([
                "set -e",
                "mkdir -p /work && cd /work",
                f"git clone --depth 1 {repo_url} repo",
                "cd repo",
                "claude --print --dangerously-skip-permissions < /work/task.md > /work/agent.log 2>&1",
            ]),
            "env": {"ANTHROPIC_API_KEY": anthropic_key},
            "timeout_seconds": 1800,
        })
        if run["exit_code"] != 0:
            raise RuntimeError(f"agent failed ({run['exit_code']}): {run['stderr']}")

        diff = sandbox.exec({
            "cmd": "cd /work/repo && git add -A && git diff --staged",
        })

        snap = sandbox.snapshots.create({"name": "post-run"})
        return {"diff": diff["stdout"], "snapshot_id": snap["id"]}
    finally:
        try:
            sandbox.destroy()
        except Exception:
            pass

result = run_agent(
    repo_url="https://github.com/myorg/widgets.git",
    task="Refactor src/utils to use async/await. Add tests.",
    anthropic_key=os.environ["ANTHROPIC_API_KEY"],
)
print(result["diff"])

package main

import (
    "context"
    "fmt"
    "os"
    "strings"
    sandbox "github.com/brimblehq/brimble-sdks/sandbox-go"
)

func runAgent(ctx context.Context, client *sandbox.Client, repoURL, task, anthropicKey string) (string, string, error) {
    handle, err := client.Sandboxes.Create(ctx, sandbox.CreateSandboxRequest{
        Region:           "auto",
        Template:         "claude-code",
        Persistent:       true,
        PersistentDiskGB: 20,
        AutoDestroy:      true,
        DestroyTimeout:   "3h",
    })
    if err != nil {
        return "", "", err
    }
    defer handle.Destroy(context.Background())

    if err := handle.PutFile(ctx, "/work/task.md", strings.NewReader(task), int64(len(task))); err != nil {
        return "", "", err
    }

    cmd := strings.Join([]string{
        "set -e",
        "mkdir -p /work && cd /work",
        fmt.Sprintf("git clone --depth 1 %s repo", repoURL),
        "cd repo",
        "claude --print --dangerously-skip-permissions < /work/task.md > /work/agent.log 2>&1",
    }, " && ")

    run, err := handle.Exec(ctx, sandbox.ExecInput{
        Cmd:            cmd,
        Env:            map[string]string{"ANTHROPIC_API_KEY": anthropicKey},
        TimeoutSeconds: 1800,
    })
    if err != nil {
        return "", "", err
    }
    if run.ExitCode != 0 {
        return "", "", fmt.Errorf("agent failed (%d): %s", run.ExitCode, run.Stderr)
    }

    diff, err := handle.Exec(ctx, sandbox.ExecInput{
        Cmd: "cd /work/repo && git add -A && git diff --staged",
    })
    if err != nil {
        return "", "", err
    }

    snap, err := handle.Snapshots.Create(ctx, sandbox.CreateSnapshotInput{Name: "post-run"})
    if err != nil {
        return "", "", err
    }
    return diff.Stdout, snap.ID, nil
}

func main() {
    ctx := context.Background()
    client, _ := sandbox.NewClient(sandbox.ClientConfig{})
    diff, snapID, _ := runAgent(ctx, client,
        "https://github.com/myorg/widgets.git",
        "Refactor src/utils to use async/await. Add tests.",
        os.Getenv("ANTHROPIC_API_KEY"),
    )
    fmt.Println("snapshot:", snapID)
    fmt.Println(diff)
}