Template

import { Template } from "@superserve/sdk"

from superserve import Template
# Step types for the `steps` array:
from superserve import RunStep, EnvStep, EnvStepValue, WorkdirStep, UserStep, UserStepValue

const template = await Template.create({
  name: "my-python-env",
  vcpu: 2,
  memoryMib: 2048,
  diskMib: 4096,
  from: "python:3.11",
  steps: [
    { run: "pip install numpy pandas" },
    { env: { key: "DEBUG", value: "1" } },
    { workdir: "/app" },
    { user: { name: "appuser", sudo: true } },
  ],
  startCmd: "python server.py",
  readyCmd: "curl -f http://localhost:8080/health",
})

from superserve import Template, RunStep, EnvStep, EnvStepValue, WorkdirStep, UserStep, UserStepValue

template = Template.create(
    name="my-python-env",
    vcpu=2,
    memory_mib=2048,
    disk_mib=4096,
    from_="python:3.11",
    steps=[
        RunStep(run="pip install numpy pandas"),
        EnvStep(env=EnvStepValue(key="DEBUG", value="1")),
        WorkdirStep(workdir="/app"),
        UserStep(user=UserStepValue(name="appuser", sudo=True)),
    ],
    start_cmd="python server.py",
    ready_cmd="curl -f http://localhost:8080/health",
)

const template = await Template.connect("7a3f2b8c-1234-...")

template = Template.connect("7a3f2b8c-1234-...")

const all = await Template.list()
const mine = await Template.list({ namePrefix: "my-" })

all_templates = Template.list()
mine = Template.list(name_prefix="my-")

await Template.deleteById("7a3f2b8c-1234-...")

Template.delete_by_id("7a3f2b8c-1234-...")

const info = await template.getInfo()
console.log(info.status)  // "pending" | "building" | "ready" | "failed"

info = template.get_info()
print(info.status.value)  # "pending" | "building" | "ready" | "failed"

const info = await template.waitUntilReady({
  onLog: (event) => {
    if (event.stream === "system") return
    process.stdout.write(event.text)
  },
})

def print_log(ev):
    if ev.stream.value != "system":
        print(ev.text, end="")

info = template.wait_until_ready(on_log=print_log)

await template.streamBuildLogs({
  onEvent: (ev) => {
    console.log(`[${ev.stream}] ${ev.text}`)
  },
  // buildId defaults to template.latestBuildId
})

def on_event(ev):
    print(f"[{ev.stream.value}] {ev.text}")

template.stream_build_logs(on_event=on_event)
# build_id defaults to template.latest_build_id

const build = await template.rebuild()
console.log(build.id, build.status)

build = template.rebuild()
print(build.id, build.status.value)

const builds = await template.listBuilds({ limit: 10 })

builds = template.list_builds(limit=10)

const build = await template.getBuild("build-uuid")

build = template.get_build("build-uuid")

await template.cancelBuild(build.id)

template.cancel_build(build.id)

await template.delete()

template.delete()

type TemplateStatus = "pending" | "building" | "ready" | "failed"

from enum import Enum

class TemplateStatus(str, Enum):
    PENDING = "pending"
    BUILDING = "building"
    READY = "ready"
    FAILED = "failed"

type TemplateBuildStatus =
  | "pending"
  | "building"
  | "snapshotting"
  | "ready"
  | "failed"
  | "cancelled"

from enum import Enum

class TemplateBuildStatus(str, Enum):
    PENDING = "pending"
    BUILDING = "building"
    SNAPSHOTTING = "snapshotting"
    READY = "ready"
    FAILED = "failed"
    CANCELLED = "cancelled"

interface TemplateInfo {
  id: string
  name: string
  teamId: string
  status: TemplateStatus
  vcpu: number
  memoryMib: number
  diskMib: number
  sizeBytes?: number
  errorMessage?: string
  createdAt: Date
  builtAt?: Date
  latestBuildId?: string
}

from datetime import datetime
from pydantic import BaseModel

class TemplateInfo(BaseModel):
    id: str
    name: str
    team_id: str
    status: TemplateStatus
    vcpu: int
    memory_mib: int
    disk_mib: int
    size_bytes: int | None = None
    error_message: str | None = None
    created_at: datetime
    built_at: datetime | None = None
    latest_build_id: str | None = None

interface TemplateBuildInfo {
  id: string
  templateId: string
  status: TemplateBuildStatus
  buildSpecHash: string
  errorMessage?: string
  startedAt?: Date
  finalizedAt?: Date
  createdAt: Date
}

from datetime import datetime
from pydantic import BaseModel

class TemplateBuildInfo(BaseModel):
    id: str
    template_id: str
    status: TemplateBuildStatus
    build_spec_hash: str
    error_message: str | None = None
    started_at: datetime | None = None
    finalized_at: datetime | None = None
    created_at: datetime

interface BuildLogEvent {
  timestamp: Date
  stream: "stdout" | "stderr" | "system"
  text: string
  finished?: boolean
  status?: "ready" | "failed" | "cancelled"
}

from datetime import datetime
from pydantic import BaseModel

class BuildLogEvent(BaseModel):
    timestamp: datetime
    stream: BuildLogStream        # "stdout" | "stderr" | "system"
    text: str
    finished: bool | None = None
    status: str | None = None     # "ready" | "failed" | "cancelled"

type BuildStep =
  | { run: string }
  | { env: { key: string; value: string } }
  | { workdir: string }
  | { user: { name: string; sudo?: boolean } }

from pydantic import BaseModel

class RunStep(BaseModel):
    run: str

class EnvStepValue(BaseModel):
    key: str
    value: str

class EnvStep(BaseModel):
    env: EnvStepValue

class WorkdirStep(BaseModel):
    workdir: str

class UserStepValue(BaseModel):
    name: str
    sudo: bool = False

class UserStep(BaseModel):
    user: UserStepValue

BuildStep = RunStep | EnvStep | WorkdirStep | UserStep

class BuildError extends SandboxError {
  readonly code: string        // e.g. "image_pull_failed" | "step_failed" | ...
  readonly message: string     // human-readable detail (prefix stripped)
  readonly buildId: string
  readonly templateId: string
}

class BuildError(SandboxError):
    code: str             # e.g. "image_pull_failed" | "step_failed" | ...
    # `str(err)` returns the human-readable detail (prefix stripped)
    build_id: str
    template_id: str