Sandbox

import { Sandbox } from "@superserve/sdk"

from superserve import Sandbox
# Async variant with awaitable methods:
from superserve import AsyncSandbox

const sandbox = await Sandbox.create({
  name: "data-analyzer",
  timeoutSeconds: 3600,
  metadata: { env: "prod" },
  envVars: { OPENAI_API_KEY: "sk-..." },
  network: {
    // deny everything except OpenAI and the sandbox's DNS resolvers
    allowOut: ["api.openai.com", "1.1.1.1/32", "8.8.8.8/32"],
    denyOut: ["0.0.0.0/0"],
  },
  previewAccess: "private",
})

from superserve import Sandbox, NetworkConfig

sandbox = Sandbox.create(
    name="data-analyzer",
    timeout_seconds=3600,
    metadata={"env": "prod"},
    env_vars={"OPENAI_API_KEY": "sk-..."},
    network=NetworkConfig(
        # deny everything except OpenAI and the sandbox's DNS resolvers
        allow_out=["api.openai.com", "1.1.1.1/32", "8.8.8.8/32"],
        deny_out=["0.0.0.0/0"],
    ),
    preview_access="private",
)

const sandbox = await Sandbox.connect("7a3f2b8c-1234-...")

sandbox = Sandbox.connect("7a3f2b8c-1234-...")

const all = await Sandbox.list()
const prod = await Sandbox.list({ metadata: { env: "prod" } })
const running = await Sandbox.list({ status: "active" })
const page = await Sandbox.list({ limit: 100, offset: 100 })

all_boxes = Sandbox.list()
prod = Sandbox.list(metadata={"env": "prod"})
running = Sandbox.list(status="active")
page = Sandbox.list(limit=100, offset=100)

await Sandbox.killById("7a3f2b8c-1234-...")

Sandbox.kill_by_id("7a3f2b8c-1234-...")

await Sandbox.updateById("7a3f2b8c-1234-...", { autoDeleteSeconds: 3600 })

Sandbox.update_by_id("7a3f2b8c-1234-...", auto_delete_seconds=3600)

const info = await sandbox.getInfo()
console.log(info.status)  // e.g. "active" — see SandboxStatus

info = sandbox.get_info()
print(info.status.value)  # e.g. "active" — see SandboxStatus

await sandbox.pause()
// or, to return only once the sandbox is paused:
// await sandbox.pause({ wait: true })

sandbox.pause()
# or, to return only once the sandbox is paused:
# sandbox.pause(wait=True)

await sandbox.resume()

sandbox.resume()

await sandbox.kill()

sandbox.kill()

await sandbox.update({
  metadata: { env: "staging" },
  network: { allowOut: ["api.openai.com"] },
})

// Auto-delete: a number arms the window, null disarms it.
await sandbox.update({ autoDeleteSeconds: 3600 })
await sandbox.update({ autoDeleteSeconds: null })

// Auto-pause timeout: same set/clear contract.
await sandbox.update({ timeoutSeconds: 900 })
await sandbox.update({ timeoutSeconds: null })

await sandbox.update({ previewAccess: "private" })

sandbox.update(
    metadata={"env": "staging"},
    network=NetworkConfig(allow_out=["api.openai.com"]),
)

# Auto-delete: a number arms the window, None disarms it.
sandbox.update(auto_delete_seconds=3600)
sandbox.update(auto_delete_seconds=None)

# Auto-pause timeout: same set/clear contract.
sandbox.update(timeout_seconds=900)
sandbox.update(timeout_seconds=None)

sandbox.update(preview_access="private")

await sandbox.attachSecret("ANTHROPIC_API_KEY", "anthropic-prod")

sandbox.attach_secret("ANTHROPIC_API_KEY", "anthropic-prod")

await sandbox.detachSecret("ANTHROPIC_API_KEY")

sandbox.detach_secret("ANTHROPIC_API_KEY")

const page = await sandbox.getNetworkLog({ verdict: "blocked", limit: 100 })
for (const e of page.events) console.log(e.kind, e.host, e.verdict ?? e.status)

page = sandbox.get_network_log(verdict="blocked", limit=100)
for e in page.events:
    print(e.kind, e.host, e.verdict or e.status)

type SandboxStatus =
  | "starting"
  | "active"
  | "pausing"
  | "paused"
  | "resuming"
  | "failed"
  | "deleted"

from enum import Enum

class SandboxStatus(str, Enum):
    STARTING = "starting"
    ACTIVE = "active"
    PAUSING = "pausing"
    PAUSED = "paused"
    RESUMING = "resuming"
    FAILED = "failed"
    DELETED = "deleted"

interface SandboxInfo {
  id: string
  name: string
  status: SandboxStatus
  vcpuCount: number
  memoryMib: number
  createdAt: Date
  timeoutSeconds?: number
  autoDeleteSeconds?: number
  autoDeleteAt?: Date // present only while paused with autoDeleteSeconds set
  network?: NetworkConfig
  metadata: Record<string, string>
  previewAccess: "legacy_public" | "public" | "private"
}

from datetime import datetime
from pydantic import BaseModel

class SandboxInfo(BaseModel):
    id: str
    name: str
    status: SandboxStatus
    vcpu_count: int
    memory_mib: int
    created_at: datetime
    timeout_seconds: int | None = None
    auto_delete_seconds: int | None = None
    # Set only while paused with auto_delete_seconds configured.
    auto_delete_at: datetime | None = None
    network: NetworkConfig | None = None
    metadata: dict[str, str]
    preview_access: PreviewAccess

interface NetworkConfig {
  allowOut?: string[]  // IPs, CIDRs, or domain patterns (a bare IP reads back as /32)
  denyOut?: string[]   // IPs and CIDRs only - use "0.0.0.0/0" to deny all
}

from pydantic import BaseModel

class NetworkConfig(BaseModel):
    allow_out: list[str] | None = None  # IPs, CIDRs, or domain patterns (a bare IP reads back as /32)
    deny_out: list[str] | None = None   # IPs and CIDRs only - use "0.0.0.0/0" to deny all