Usage

sandbox, err := client.CreateSandbox(ctx, "bonya-dev", bonya.CreateOptions{
	Wait:           bonya.WaitReady,
	IdempotencyKey: "create-job-123",
})

sandbox, err := client.GetSandbox(ctx, "sbx_123")

summaries, err := client.ListSandboxes(ctx, bonya.ListOptions{
	States: []bonya.Status{bonya.StatusRunning, bonya.StatusSuspended},
	Limit:  20,
})
for _, summary := range summaries {
	fmt.Println(summary.ID, summary.LastObservedStatus)
}

byName, err := client.GetSandboxByName(ctx, "web-server")

result, err := sandbox.Delete(ctx)
fmt.Println(result.SandboxID, result.AlreadyDeleted)

sandbox, err := client.CreateSandbox(ctx, "bonya-dev")
if err != nil {
	log.Fatal(err)
}
defer sandbox.Delete(ctx)

resume, err := sandbox.Resume(ctx, bonya.ResumeOptions{IdempotencyKey: "resume-job-123"})
fmt.Println(resume.SandboxID, resume.LifecycleOperationID, resume.AlreadyRunning)

result, err := sandbox.Exec(ctx, []string{"python3", "-c", "import os; print(os.environ['MODE'])"}, bonya.ExecOptions{
	Env:     map[string]string{"MODE": "development"},
	Cwd:     "/workspace",
	Timeout: 10 * time.Second,
})

fmt.Println(result.Stdout(), result.Stderr(), result.ExitCode, result.OK())

func (s *Sandbox) Exec(ctx context.Context, command any, opts ...ExecOptions) (*ExecResult, error)

type ExecOptions struct {
	Env     map[string]string
	Cwd     string
	TTY     bool
	Cols    int
	Rows    int
	Timeout time.Duration
	Check   bool  // calls ExecResult.Check before Exec returns; ignored by ExecStream
	Input   []byte // written to stdin, then half-closed; requires TTY: false; ignored by ExecStream
}

result, err := sandbox.Exec(ctx, []string{"false"}, bonya.ExecOptions{Check: true})
var execErr *bonya.ExecFailedError
if errors.As(err, &execErr) {
	fmt.Println(execErr.Result.ExitCode)
}

session, err := sandbox.ExecStream(ctx, []string{"bash", "-lc", "echo out; echo err >&2"})
if err != nil {
	log.Fatal(err)
}
defer session.Close()

for {
	event, err := session.Next()
	if err != nil {
		log.Fatal(err)
	}
	if event == nil {
		break // stream ended cleanly after Exit
	}
	switch e := event.(type) {
	case bonya.Stdout:
		fmt.Print("stdout: ", string(e.Data))
	case bonya.Stderr:
		fmt.Print("stderr: ", string(e.Data))
	case bonya.Exit:
		fmt.Println("exit:", e.ExitCode)
	}
}

func (s *Sandbox) ExecStream(ctx context.Context, command any, opts ...ExecOptions) (*ExecSession, error)

info, err := sandbox.CreateSession(ctx, "server", []string{"bash"}, bonya.CreateSessionOptions{Cols: 120, Rows: 40})

stream, err := sandbox.AttachSession(ctx, "server")
stream.Write([]byte("npm run dev\n"))
stream.Resize(140, 45)
for {
	event, err := stream.Next()
	if err != nil || event == nil {
		break
	}
}
stream.Detach()

result, err := sandbox.ListSessions(ctx)
for _, info := range result.Sessions {
	fmt.Println(info.Name, info.Status)
}

sandbox.KillSession(ctx, "server")

func (s *Sandbox) CreateSession(ctx context.Context, name string, command []string, opts ...CreateSessionOptions) (SessionInfo, error)

sandbox.WriteFile(ctx, "/workspace/message.txt", []byte("hello\n"))
payload, err := sandbox.ReadFile(ctx, "/workspace/message.txt")

sandbox.UploadFile(ctx, "local-input.bin", "/workspace/input.bin")
sandbox.DownloadFile(ctx, "/workspace/input.bin", "local-output.bin")

entries, err := sandbox.ListFiles(ctx, "/workspace")
info, err := sandbox.StatFile(ctx, "/workspace/message.txt")

sandbox.MkdirFile(ctx, "/workspace/output")
sandbox.MoveFile(ctx, "/workspace/message.txt", "/workspace/output/message.txt")
sandbox.RemoveFile(ctx, "/workspace/output", true) // recursive

preview, err := sandbox.CreatePreview(ctx, 3000, bonya.CreatePreviewOptions{Name: "web"})
fmt.Println(preview.URL) // https://pv-<26 chars>.tv.bonya.ai

previews, err := sandbox.ListPreviews(ctx)
err = sandbox.DeletePreview(ctx, preview.ID)

public, err := sandbox.CreatePreview(ctx, 8080, bonya.CreatePreviewOptions{Auth: bonya.PreviewAuthPublic})

snapshot, err := sandbox.Snapshot(ctx, bonya.SnapshotOptions{IdempotencyKey: "snapshot-job-123"})
fmt.Println(snapshot.ID, snapshot.SourceSandboxID)

snapshot.Delete(ctx)
snapshot.Delete(ctx) // local no-op

run, err := client.RunJob(ctx, bonya.JobSpec{
	NewSandbox: &bonya.JobSandboxSpec{Template: "bonya-dev"},
	Cmd:        []string{"./run-tests.sh"},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(run.Status, run.Result.ExitCode)

runID, alreadyRunning, err := client.StartJob(ctx, bonya.JobSpec{
	ExistingSandboxID: "sbx-123",
	Cmd:               []string{"./long-migration.sh"},
})
// ... later ...
detail, err := client.GetJobRun(ctx, runID)
fmt.Println(detail.Status, detail.Spec, detail.Timeline)

runs, err := client.ListJobRuns(ctx, bonya.ListJobRunsOptions{SandboxID: "sbx-123"})
err = client.CancelJobRun(ctx, runID) // requests cancellation; cleanup still runs

schedule, err := client.CreateJobSchedule(ctx,
	bonya.ScheduleSpec{IntervalSeconds: 3600},
	bonya.JobSpec{
		NewSandbox: &bonya.JobSandboxSpec{Template: "bonya-dev"},
		Cmd:        []string{"./nightly-report.sh"},
	},
)
fmt.Println(schedule.ScheduleID, schedule.NextRunAtUnixNanos)

schedules, err := client.ListJobSchedules(ctx)
schedule, err = client.GetJobSchedule(ctx, scheduleID)

// UpdateJobSchedule replaces the whole schedule -- pass every field you
// want to keep, not just the one you're changing.
schedule, err = client.UpdateJobSchedule(ctx, scheduleID,
	bonya.ScheduleSpec{IntervalSeconds: 7200}, jobSpec)

schedule, err = client.SetJobSchedulePaused(ctx, scheduleID, true, "pausing for maintenance")
err = client.TriggerJobSchedule(ctx, scheduleID) // fires one run now, ignoring timing
err = client.DeleteJobSchedule(ctx, scheduleID)

templates, err := client.ListTemplates(ctx)
for _, template := range templates {
	fmt.Println(template.ID, template.Version, template.IsDefault, template.Metadata.OS)
}

organizations, err := client.ListOrganizations(ctx)
for _, org := range organizations {
	fmt.Println(org.ID, org.Name, org.Personal, org.Role)
}

err = client.SetOrganizationID(organizations[0].ID)

sandbox, err := client.GetSandbox(ctx, "sbx_missing")
var notFound *bonya.SandboxNotFoundError
if errors.As(err, &notFound) {
	fmt.Println("sandbox does not exist or is not visible")
}

client, err := bonya.NewClient(bonya.WithAPIKey("BONYA_API_KEY"))
if err != nil {
	log.Fatal(err)
}
defer client.Close()

sandbox, err := client.CreateSandbox(ctx, "bonya-dev")
if err != nil {
	log.Fatal(err)
}
defer sandbox.Delete(ctx)

session, err := sandbox.ExecStream(ctx, []string{"cat"})
if err != nil {
	log.Fatal(err)
}
defer session.Close()
session.Write([]byte("hello\n"))
session.CloseStdin()

export BONYA_API_KEY=byk_...
cd examples && go run ./quickstart