runtime

type AgentResult struct {
	Name       string                // Logical name
	WorkloadID WorkloadID            // Runtime ID
	Uses       []config.ToolSelector // MCP servers this agent depends on
}

type BuildOptions struct {
	SourceType string            // "git" or "local"
	URL        string            // Git URL
	Ref        string            // Git ref/branch
	Path       string            // Local path
	Dockerfile string            // Dockerfile path within context
	Tag        string            // Image tag
	BuildArgs  map[string]string // Build arguments
	NoCache    bool              // Force rebuild
	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 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 MCPServerResult struct {
	Name       string     // Logical name
	WorkloadID WorkloadID // Runtime ID (empty for external/local/SSH/OpenAPI)
	Endpoint   string     // How to reach it (URL or host:port)
	HostPort   int        // Host port if applicable

	// 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

	// 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
}

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
}

type RuntimeType string

type UpOptions struct {
	NoCache     bool // Force rebuild of source-based images
	BasePort    int  // Base port for host port allocation (default: 9000)
	GatewayPort int  // Port for MCP gateway (for agent MCP_ENDPOINT injection)
}

type UpResult struct {
	MCPServers []MCPServerResult
	Agents     []AgentResult
}

type WorkloadConfig struct {
	// 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")

	// 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 {
	// 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