runtime

type Capabilities struct {
	CheckpointRestore bool // CRIU support
	GPU               bool // GPU device passthrough
	OOMEvents         bool // Runtime-native OOM events (use cgroup poller as fallback)
	JoinExistingNetNS bool // Can join existing network namespace
	CDI               bool // Container Device Interface support
}

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

type CheckpointOpts struct {
	ImagePath    string       // Path to store checkpoint image
	WorkDir      string       // Working directory for checkpoint files
	LeaveRunning bool         // Leave container running after checkpoint
	AllowOpenTCP bool         // Allow open TCP connections
	SkipInFlight bool         // Skip in-flight TCP connections
	LinkRemap    bool         // Enable link remapping
	OutputWriter OutputWriter // Writer for checkpoint output
}

type Config struct {
	Type          string // "runc" | "gvisor"
	RuncPath      string // Path to runc binary (default: "runc")
	RunscPath     string // Path to runsc binary (default: "runsc")
	RunscPlatform string // "kvm" | "ptrace" (optional)
	RunscRoot     string // Root directory for runsc state (default: "/run/gvisor")
	Debug         bool   // Enable debug mode
}

type DeleteOpts struct {
	Force bool // Force deletion
}

type ErrContainerNotFound struct {
	ContainerID string
}

type ErrRuntimeNotAvailable struct {
	Runtime string
	Reason  string
}

type ErrUnsupportedRuntime struct {
	Runtime string
}

type Event struct {
	Type string // "oom", "exit", "error"
	Err  error
}

type ExecOpts struct {
	OutputWriter OutputWriter
	StdinReader  io.Reader
	Started      chan<- int
}

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

type KillOpts struct {
	All bool // Kill all processes in the container
}

type OOMWatcher interface {
	Watch(onOOM func()) error
	Stop()
}

type OutputWriter interface {
	Write(p []byte) (n int, err error)
}

type RestoreOpts struct {
	ImagePath    string       // Path to checkpoint image
	WorkDir      string       // Working directory for restore files
	BundlePath   string       // Path to container bundle
	OutputWriter OutputWriter // Writer for restore output
	Started      chan<- int   // PID channel
	TCPClose     bool         // Close TCP connections on restore
}

type RunOpts struct {
	OutputWriter  OutputWriter
	Started       chan<- int // PID channel
	DockerEnabled bool       // Enable Docker-in-Docker (gVisor only)
}

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

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

type Runtime interface {
	// Name returns the name of the runtime (e.g., "runc", "gvisor")
	Name() string

	// Capabilities returns what features this runtime supports
	Capabilities() Capabilities

	// Prepare may mutate spec to fit runtime quirks (e.g., seccomp, mounts)
	// Called before writing config.json
	Prepare(ctx context.Context, spec *specs.Spec) error

	// Run starts a container with the given configuration
	Run(ctx context.Context, containerID, bundlePath string, opts *RunOpts) (int, error)

	// Exec executes a command inside a running container
	Exec(ctx context.Context, containerID string, proc specs.Process, opts *ExecOpts) error

	// Kill sends a signal to a container
	Kill(ctx context.Context, containerID string, sig syscall.Signal, opts *KillOpts) error

	// Delete removes a container
	Delete(ctx context.Context, containerID string, opts *DeleteOpts) error

	// State returns the current state of a container
	State(ctx context.Context, containerID string) (State, error)

	// Events returns a channel for receiving container events
	// Optional; use cgroup poller as portable fallback
	Events(ctx context.Context, containerID string) (<-chan Event, error)

	// Checkpoint creates a checkpoint of a running container
	// Returns an error if the runtime doesn't support checkpointing
	Checkpoint(ctx context.Context, containerID string, opts *CheckpointOpts) error

	// Restore restores a container from a checkpoint
	// Returns the exit code and any error
	Restore(ctx context.Context, containerID string, opts *RestoreOpts) (int, error)

	// Close cleans up any resources held by the runtime
	Close() error
}

type State struct {
	ID     string
	Pid    int
	Status string // "running", "stopped", etc.
}