runtime

type BuildOptions struct {
	Stack       string               // Stack name used in image identity
	ServerName  string               // Logical server name used in image identity
	SourceType  string               // "git" or "local"
	URL         string               // Git URL
	Ref         string               // Git ref/branch
	Path        string               // Local path
	ProjectPath string               // Python project subdirectory below a local root
	Runtime     string               // Generated source runtime
	Package     string               // Public package name
	Python      string               // Python minor version
	Extras      []string             // Python package extras
	With        []string             // Additional Python dependencies
	Packages    []string             // Debian runtime packages
	Dockerfile  string               // Dockerfile path within context
	BuildArgs   map[string]string    // Build arguments
	Command     []string             // Runtime command included in build identity
	Platform    string               // Target OCI platform
	NoCache     bool                 // Force rebuild
	Auth        transport.AuthMethod // Resolved git auth (nil = unauthenticated)
	Logger      *slog.Logger         // Logger for build operations (optional)
}

type BuildResult struct {
	ImageTag string // Image tag
	Cached   bool   // Whether build was cached
}

type Builder interface {
	Build(ctx context.Context, opts BuildOptions) (*BuildResult, error)
}

type ConfigFile = config.ConfigFile

type CredentialResolver func(ref string) (string, error)

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

type DetectOptions struct {
	Explicit string // Value from --runtime flag or GRIDCTL_RUNTIME env var
}

type DockerClientGetter interface {
	Client() dockerclient.DockerClient
}

type LoggerSetter interface {
	SetLogger(logger *slog.Logger)
}

type MCPServerReplica struct {
	ReplicaID  int        // zero-indexed within the server
	WorkloadID WorkloadID // runtime ID for container replicas
	Endpoint   string     // host:port or URL
	HostPort   int        // host port if applicable
}

type MCPServerResult struct {
	Name       string     // Logical name
	Image      string     // Desired image resolved before reconciliation
	WorkloadID WorkloadID // Runtime ID (empty for external/local/SSH/OpenAPI). Mirrors Replicas[0].WorkloadID.
	Endpoint   string     // How to reach it (URL or host:port). Mirrors Replicas[0].Endpoint.
	HostPort   int        // Host port if applicable. Mirrors Replicas[0].HostPort.

	// Replicas carries per-replica runtime handles. Always non-empty after Up()
	// returns: a server with no replicas field (or Replicas=1) gets a single entry
	// whose top-level fields match the mirrored fields above.
	Replicas []MCPServerReplica

	// Server type flags (exactly one should be true for non-container servers)
	External     bool // URL-based external server
	LocalProcess bool // Local stdio process
	SSH          bool // SSH-based remote process
	OpenAPI      bool // OpenAPI-based adapter server
	A2A          bool // Outbound A2A source

	// For non-container servers
	URL             string   // External server URL
	Command         []string // Local process or SSH command
	SSHHost         string
	SSHUser         string
	SSHPort         int
	SSHIdentityFile string

	// For OpenAPI servers
	OpenAPIConfig *config.OpenAPIConfig // OpenAPI configuration for gateway to use
	A2AConfig     *config.A2AConfig
}

type NetworkOptions struct {
	Driver string // Network driver (e.g., "bridge")
	Stack  string // For labeling/cleanup purposes
}

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

type RuntimeInfo struct {
	Type           RuntimeType
	SocketPath     string
	HostAlias      string // "host.docker.internal" or "host.containers.internal"
	Version        string // Runtime version for feature gating
	SELinux        bool   // Whether SELinux is enforcing
	HasNetavark    bool   // Whether netavark is available (rootless inter-container networking)
	HasAardvarkDNS bool   // Whether aardvark-dns is available (inter-container DNS resolution)
}

type RuntimeType string

type UpOptions struct {
	NoCache  bool // Force rebuild of source-based images
	BasePort int  // Base port for host port allocation (default: 9000)
}

type UpResult struct {
	MCPServers []MCPServerResult
}

type WorkloadConfig struct {
	Execution *execution.ExecutionContract
	// Identity
	Name  string       // Logical name (e.g., "postgres", "weather-server")
	Stack string       // Stack this workload belongs to
	Type  WorkloadType // Type of workload

	// Image/artifact
	Image string // Container image or artifact reference

	// Execution
	Command []string          // Override entrypoint/command
	Env     map[string]string // Environment variables

	// Networking
	NetworkName string // Network to join
	ExposedPort int    // Port the workload exposes (0 if none)
	HostPort    int    // Desired host port (0 for auto-assign)

	// Storage
	Volumes []string     // Volume mounts (format: "host:container" or "host:container:mode")
	Configs []ConfigFile // Files copied into the container after create and before start

	// Transport-specific
	Transport string // "http", "stdio", "sse"

	// Labels for identification and filtering
	Labels map[string]string
}

type WorkloadFilter struct {
	Stack  string            // Filter by stack name
	Labels map[string]string // Additional label filters
}

type WorkloadID string

type WorkloadRuntime interface {
	// Start starts a workload and returns its status.
	Start(ctx context.Context, cfg WorkloadConfig) (*WorkloadStatus, error)

	// Stop stops a running workload by its ID.
	Stop(ctx context.Context, id WorkloadID) error

	// Remove removes a stopped workload.
	Remove(ctx context.Context, id WorkloadID) error

	// Status returns the current status of a workload.
	Status(ctx context.Context, id WorkloadID) (*WorkloadStatus, error)

	// Exists checks if a workload exists by name.
	Exists(ctx context.Context, name string) (exists bool, id WorkloadID, err error)

	// List returns all workloads matching the filter.
	List(ctx context.Context, filter WorkloadFilter) ([]WorkloadStatus, error)

	// GetHostPort returns the host port for a workload's exposed port.
	GetHostPort(ctx context.Context, id WorkloadID, exposedPort int) (int, error)

	// EnsureNetwork creates the network if it doesn't exist.
	EnsureNetwork(ctx context.Context, name string, opts NetworkOptions) error

	// ListNetworks returns all managed networks for a stack.
	ListNetworks(ctx context.Context, stack string) ([]string, error)

	// RemoveNetwork removes a network by name.
	RemoveNetwork(ctx context.Context, name string) error

	// EnsureImage ensures the image is available locally.
	EnsureImage(ctx context.Context, imageName string) error

	// Ping checks if the runtime is accessible.
	Ping(ctx context.Context) error

	// Close releases runtime resources.
	Close() error
}

type WorkloadState string

type WorkloadStatus struct {
	Execution *execution.Report `json:"execution,omitempty"`
	// Identity
	ID    WorkloadID   // Runtime-assigned unique identifier
	Name  string       // Logical name from config
	Stack string       // Stack name
	Type  WorkloadType // Type of workload

	// State
	State   WorkloadState // Running, Stopped, Failed, etc.
	Message string        // Human-readable status message (e.g., "Up 5 minutes")

	// Networking
	Endpoint string // How to reach this workload (e.g., "localhost:9000")
	HostPort int    // Actual host port (if port-mapped)

	// Metadata
	Image  string            // Image/artifact that's running
	Labels map[string]string // All labels
}

type WorkloadType string