Browsers, shells and files for AI agents. In one isolated session.

import { chromium } from "playwright";

const API = "https://api.staging.boxline.dev/v1";
const headers = {
  "x-api-key": process.env.BOXLINE_API_KEY!,
  "content-type": "application/json",
};

// 1. Create a session with a browser
const session = await fetch(`${API}/sessions`, {
  method: "POST",
  headers,
  body: JSON.stringify({ browser: true, timeout: 300 }),
}).then((r) => r.json());

// 2. Connect Playwright over CDP
const browser = await chromium.connectOverCDP(session.connectUrl);
const context = browser.contexts()[0];
const page = context.pages()[0] ?? (await context.newPage());

await page.goto("https://example.com");
console.log(await page.title());

// 3. Release it: billing stops at the second you do
await browser.close();
await fetch(`${API}/sessions/${session.id}/release`, { method: "POST", headers });

import { readFile } from "node:fs/promises";
import { Boxline } from "@boxline/sdk";
import { chromium } from "playwright";

const client = new Boxline(); // reads BOXLINE_API_KEY and BOXLINE_API_URL
const session = await client.sessions.create({
  browser: true,
  shell: true,
});

try {
  // Browser: export a report. Downloads land in /workspace/downloads.
  const browser = await chromium.connectOverCDP(session.connectUrl!);
  const page = browser.contexts()[0].pages()[0];
  await page.goto("https://example.com/reports");
  await page.getByRole("link", { name: "Export CSV" }).click();
  const csv = await session.files.waitFor("downloads/*.csv");

  // Files: put a script next to the download.
  await session.files.write("summarise.py", await readFile("summarise.py"));

  // Shell: run it with Python, on the same machine.
  const result = await session.exec(`python3 summarise.py ${csv.path}`);
  console.log(result.stdout);
} finally {
  await session.release();
}

{
  "mcpServers": {
    "boxline": {
      "command": "npx",
      "args": ["-y", "@boxline/mcp"],
      "env": {
        "BOXLINE_API_KEY": "your-api-key",
        "BOXLINE_API_URL": "https://api.staging.boxline.dev"
      }
    }
  }
}

import Anthropic from "@anthropic-ai/sdk";
import { Boxline } from "@boxline/sdk";

const anthropic = new Anthropic();
const client = new Boxline();
const session = await client.sessions.create({
  browser: false,
  shell: true,
});

const messages: Anthropic.Beta.BetaMessageParam[] = [
  { role: "user", content: "Use Python to list the 10 largest files under /usr/lib." },
];

try {
  while (true) {
    const res = await anthropic.beta.messages.create({
      model: "claude-opus-5",
      max_tokens: 16000,
      betas: ["server-side-fallback-2026-07-01"],
      fallbacks: "default",
      tools: [{ type: "bash_20250124", name: "bash" }],
      messages,
    });
    if (res.stop_reason === "refusal") break;
    if (res.stop_reason === "pause_turn") {
      messages.push({ role: "assistant", content: res.content });
      continue;
    }
    const calls = res.content.filter(
      (b): b is Anthropic.Beta.BetaToolUseBlock => b.type === "tool_use",
    );
    if (calls.length === 0) break;
    messages.push({ role: "assistant", content: res.content });

    // Each bash call runs in the session's persistent shell
    const results: Anthropic.Beta.BetaToolResultBlockParam[] = [];
    for (const call of calls) {
      const input = call.input as { command?: string; restart?: boolean };
      if (input.restart) {
        await session.shell.restart();
        results.push({ type: "tool_result", tool_use_id: call.id, content: "Shell restarted." });
        continue;
      }
      const run = await session.exec(input.command ?? "", { timeoutMs: 120_000 });
      results.push({
        type: "tool_result",
        tool_use_id: call.id,
        content: run.stdout + run.stderr || "(no output)",
        is_error: run.exitCode !== 0,
      });
    }
    messages.push({ role: "user", content: results });
  }
} finally {
  await session.release();
}