go get github.com/brimblehq/rexec-go

package main

import (
    "context"
    "fmt"
    "log"

    rexec "github.com/brimblehq/rexec-go"
)

func main() {
    // Create client
    client := rexec.NewClient("https://your-rexec-instance.com", "your-api-token")

    ctx := context.Background()

    // Create a container
    container, err := client.Containers.Create(ctx, &rexec.CreateContainerRequest{
        Image: "ubuntu:24.04",
        Name:  "my-sandbox",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created container: %s\n", container.ID)

    // Connect to terminal
    term, err := client.Terminal.Connect(ctx, container.ID)
    if err != nil {
        log.Fatal(err)
    }
    defer term.Close()

    // Send a command
    term.Write([]byte("echo 'Hello from Rexec!'\n"))

    // Read output
    output, _ := term.Read()
    fmt.Printf("Output: %s\n", output)

    // Clean up
    client.Containers.Delete(ctx, container.ID)
}

client := rexec.NewClient(baseURL, apiToken)

import (
    "net/http"
    "time"
)

client := rexec.NewClient(baseURL, apiToken)
client.SetHTTPClient(&http.Client{
    Timeout: 60 * time.Second,
})

containers, err := client.Containers.List(ctx)
if err != nil {
    log.Fatal(err)
}

for _, c := range containers {
    fmt.Printf("%s: %s\n", c.Name, c.Status)
}

container, err := client.Containers.Get(ctx, containerID)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Container %s is %s\n", container.Name, container.Status)

container, err := client.Containers.Create(ctx, &rexec.CreateContainerRequest{
    Image: "ubuntu:24.04",
    Name:  "my-container",
    Environment: map[string]string{
        "MY_VAR": "value",
        "DEBUG":  "true",
    },
    Labels: map[string]string{
        "project": "demo",
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Created: %s\n", container.ID)

err := client.Containers.Start(ctx, containerID)
if err != nil {
    log.Fatal(err)
}

err := client.Containers.Stop(ctx, containerID)
if err != nil {
    log.Fatal(err)
}

err := client.Containers.Delete(ctx, containerID)
if err != nil {
    log.Fatal(err)
}

files, err := client.Files.List(ctx, containerID, "/home")
if err != nil {
    log.Fatal(err)
}

for _, f := range files {
    icon := "📄"
    if f.IsDir {
        icon = "📁"
    }
    fmt.Printf("%s %s\n", icon, f.Name)
}

data, err := client.Files.Download(ctx, containerID, "/home/file.txt")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("File contents: %s\n", string(data))

err := client.Files.Mkdir(ctx, containerID, "/home/newdir")
if err != nil {
    log.Fatal(err)
}

term, err := client.Terminal.Connect(ctx, containerID)
if err != nil {
    log.Fatal(err)
}
defer term.Close()

err := term.Write([]byte("ls -la\n"))
if err != nil {
    log.Fatal(err)
}

for {
    output, err := term.Read()
    if err != nil {
        break
    }
    fmt.Print(string(output))
}

err := term.Resize(120, 40)
if err != nil {
    log.Fatal(err)
}

func runScript(client *rexec.Client, containerID, script string) error {
    ctx := context.Background()
    
    term, err := client.Terminal.Connect(ctx, containerID)
    if err != nil {
        return err
    }
    defer term.Close()

    // Write script
    term.Write([]byte(script + "\n"))
    
    // Read output
    for {
        output, err := term.Read()
        if err != nil {
            break
        }
        fmt.Print(string(output))
    }
    
    return nil
}

func interactiveSession(client *rexec.Client, containerID string) error {
    ctx := context.Background()
    
    term, err := client.Terminal.Connect(ctx, containerID)
    if err != nil {
        return err
    }
    defer term.Close()

    // Handle terminal resize
    term.Resize(80, 24)

    // Read from stdin and write to terminal
    go func() {
        buf := make([]byte, 1024)
        for {
            n, _ := os.Stdin.Read(buf)
            term.Write(buf[:n])
        }
    }()

    // Read from terminal and write to stdout
    for {
        output, err := term.Read()
        if err != nil {
            break
        }
        os.Stdout.Write(output)
    }
    
    return nil
}

type Container struct {
    ID          string            `json:"id"`
    Name        string            `json:"name"`
    Image       string            `json:"image"`
    Status      string            `json:"status"`
    CreatedAt   time.Time         `json:"created_at"`
    StartedAt   *time.Time        `json:"started_at,omitempty"`
    Labels      map[string]string `json:"labels,omitempty"`
    Environment map[string]string `json:"environment,omitempty"`
}

type FileInfo struct {
    Name    string    `json:"name"`
    Path    string    `json:"path"`
    Size    int64     `json:"size"`
    Mode    string    `json:"mode"`
    ModTime time.Time `json:"mod_time"`
    IsDir   bool      `json:"is_dir"`
}

import "errors"

container, err := client.Containers.Get(ctx, "invalid-id")
if err != nil {
    var apiErr *rexec.APIError
    if errors.As(err, &apiErr) {
        fmt.Printf("API Error %d: %s\n", apiErr.StatusCode, apiErr.Message)
    } else {
        fmt.Printf("Network error: %v\n", err)
    }
}