TypeScript and JavaScript SDK

npm install @boatdev/sdk

import { BoatApi, Configuration, waitUntilReady, waitForPrompt } from "@boatdev/sdk";

const sandbox = new BoatApi(new Configuration({
  basePath: process.env.BOAT_BASE_URL ?? "https://boat.dev/api/v1",
  accessToken: process.env.BOAT_API_KEY ?? (() => {
    throw new Error("Set BOAT_API_KEY from the Boat dashboard API keys tab.");
  })(),
}));

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022", "DOM"],
    "types": ["node"],
    "strict": true
  }
}

import { BoatApi, Configuration } from "@boatdev/sdk";

const sandbox = new BoatApi(new Configuration({
  basePath: process.env.BOAT_BASE_URL ?? "https://boat.dev/api/v1",
  accessToken: process.env.BOAT_API_KEY ?? (() => {
    throw new Error("Set BOAT_API_KEY from the Boat dashboard API keys tab.");
  })(),
}));

async function main() {
  let sandboxId: string | undefined;

  try {
    const created = await sandbox.create({ ttlSeconds: 1800 });
    sandboxId = created.sandbox.id;

    await sandbox.update({
      sandboxId,
      name: "sdk-demo",
    });

    await waitUntilReady(sandbox, sandboxId);

    const queued = await sandbox.prompt({
      sandboxId,
      provider: "codex",
      prompt: "Inspect the repository and summarize the test command.",
    });

    const run = await waitForPrompt(sandbox, sandboxId, queued.promptId);
    console.log(run.status);

    const events = await sandbox.events({ sandboxId, limit: 50, type: "prompt,response" });
    console.log(events.events);
  } finally {
    if (sandboxId) await sandbox.stop({ sandboxId });
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

const created = await sandbox.create({ type: "large", ttlSeconds: 3600 });

const info = await sandbox.get({ sandboxId: created.sandbox.id });
console.log(info.sandbox.type, info.sandbox.vcpu, info.sandbox.memoryGB);

const created = await sandbox.create({
  ttlSeconds: 3600,
  env: { DATABASE_URL: "postgres://user:pass@host:5432/app", FEATURE_FLAG: "1" },
});

const created = await sandbox.create({ ttlSeconds: 1800, noEnv: true });

await sandbox.resume({
  sandboxId,
  noEnv: true,
});

const forked = await sandbox.fork({
  sandboxId,
  noEnv: true,
});

const { BoatApi, Configuration } = require("@boatdev/sdk");

const sandbox = new BoatApi(new Configuration({
  basePath: process.env.BOAT_BASE_URL || "https://boat.dev/api/v1",
  accessToken: process.env.BOAT_API_KEY,
}));

const latest = await sandbox.getLatestSandboxSnapshot({ sandboxId });
const tree = await sandbox.getSnapshotTree({ snapshotId: latest.snapshot.id });
const blob = await sandbox.getSnapshotFile({ snapshotId: latest.snapshot.id, path: "projects/app/.env" });

import { waitUntilReady, waitUntilIdle, waitForDesktop, waitForPrompt, waitForPromptDone, streamEvents, streamPrompt, stopAndRemove, readText, writeText, execCommand } from "@boatdev/sdk";

await waitUntilReady(sandbox, sandboxId);
const queued = await sandbox.prompt({ sandboxId, provider: "codex", prompt: "Run tests" });
// fast mode instead: { sandboxId, provider: "codex", model: "gpt-6.1-sol", fast: true, prompt: "Run tests" }
await waitForPrompt(sandbox, sandboxId, queued.promptId);
const publicVnc = await waitForDesktop(sandbox, sandboxId, { publicAccess: true });
await writeText(sandbox, sandboxId, "notes/result.txt", "done\n");
const result = await execCommand(sandbox, sandboxId, "cat notes/result.txt");
await stopAndRemove(sandbox, sandboxId);                      // stop, keep the snapshots
await stopAndRemove(sandbox, sandboxId, { delete: true });    // delete the sandbox and its snapshots

import { BoatApi, Configuration, streamPrompt } from "@boatdev/sdk";

const sandbox = new BoatApi(new Configuration({
  basePath: "https://boat.dev/api/v1",
  accessToken: process.env.BOAT_API_KEY!,
}));

const stream = streamPrompt(sandbox, sandboxId, {
  provider: "codex",
  prompt: "Run pwd and ls, then summarize the result.",
});

for await (const event of stream) {
  if (event.type !== "response") continue;
  const data = event.data;
  if (data.tools?.length) console.log("tools", data.tools);
  if (data.content) process.stdout.write(data.content);
  if (data.isStreaming) process.stdout.write("\n[partial]\n");
}

import { ResponseError } from "@boatdev/sdk";

try {
  await sandbox.get({ sandboxId: "bx_missing" });
} catch (error) {
  if (error instanceof ResponseError) {
    console.error(error.response.status);
    console.error(await error.response.json());
  }
}