gvisor

type CgroupV2Entry struct {
	File  string // e.g., "cpu.max"
	Value string // e.g., "200000 100000"
}

type ContainerOptions struct {
	// Command is the command and arguments to execute.
	Command []string

	// WorkDir is the working directory inside the container.
	// Must be an absolute path within the rootfs.
	WorkDir string

	// Env is the environment variables for the process.
	// If nil, a minimal default environment is used.
	Env map[string]string

	// RootFS is the host path to use as the container's root filesystem.
	// Typically a ZFS dataset mountpoint.
	RootFS string

	// Resources specifies CPU, memory, PID, and timeout limits.
	Resources ResourceSpec

	// Network controls the container's network access.
	// Default: NetworkNone (no network).
	Network NetworkMode

	// Stdin provides input to the container's stdin.
	// If nil, stdin is /dev/null.
	Stdin io.Reader

	// StdoutWriter receives stdout chunks while the command is running.
	// Optional; captured output is still returned in ContainerResult.Stdout.
	StdoutWriter io.Writer

	// StderrWriter receives stderr chunks while the command is running.
	// Optional; captured output is still returned in ContainerResult.Stderr.
	StderrWriter io.Writer

	// User specifies the UID:GID to run the process as inside the container.
	// Default: 0:0 (root).
	User *UserSpec

	// ReadOnlyRootFS makes the root filesystem read-only.
	ReadOnlyRootFS bool

	// ExtraMounts adds additional bind mounts or tmpfs mounts.
	ExtraMounts []Mount
}

type ContainerResult struct {
	ContainerID     string
	ExitCode        int
	Stdout          []byte
	Stderr          []byte
	StdoutTruncated bool
	StderrTruncated bool
	Duration        time.Duration
	BootDuration    time.Duration
	Status          ContainerStatus
	OOMKilled       bool
	PeakMemoryBytes int64
}

type ContainerStatus string

type GVisorManager interface {
	// Run executes a command in a gVisor container with the given resource limits.
	// Returns ContainerResult on successful execution (even if the command
	// exits non-zero). Returns error only for infrastructure failures.
	Run(ctx context.Context, opts ContainerOptions) (*ContainerResult, error)

	// CleanupStale finds and removes any containers that are no longer tracked
	// by the manager (e.g., from a previous crash). Safe to call periodically.
	CleanupStale(ctx context.Context) (int, error)

	// ActiveContainers returns the number of currently running containers.
	ActiveContainers() int

	// Close shuts down the manager. Idempotent and safe for concurrent callers.
	// Marks manager closed immediately; subsequent Run() returns ErrManagerClosed.
	Close() error
}

type Manager struct {
	// contains filtered or unexported fields
}

type ManagerConfig struct {
	RunscPath               string
	BundleBaseDir           string
	RunscRoot               string
	Platform                string
	MaxConcurrentContainers int
	DefaultNetwork          NetworkMode
	DefaultResources        ResourceSpec
	Logger                  *slog.Logger
	EnableMetrics           bool
}

type Mount struct {
	Source      string
	Destination string
	Type        string
	ReadOnly    bool
	Options     []string
}

type NetworkMode string

type ResourceSpec struct {
	// CPUs is the number of CPU cores to allocate.
	// 0 means no limit (use all available CPUs).
	CPUs float64

	// MemoryMB is the memory limit in megabytes.
	// 0 means no limit.
	MemoryMB int

	// MaxPIDs is the maximum number of processes.
	// 0 means default (1024).
	MaxPIDs int

	// Timeout is the maximum wall-clock execution time.
	// Enforced via context deadline. 0 means no timeout.
	Timeout time.Duration

	// MaxOutputBytes limits stdout and stderr capture size.
	// 0 means default (10 MB).
	MaxOutputBytes int64
}

type UserSpec struct {
	UID uint32
	GID uint32
}