types

type Config struct {
	// Type is the type of transport to use.
	Type TransportType

	// ProxyPort is the port to use for network transports (host port).
	ProxyPort int

	// TargetPort is the port that the container will expose (container port).
	// This is only applicable to SSE transport.
	TargetPort int

	// TargetHost is the host to forward traffic to.
	// This is only applicable to SSE transport.
	TargetHost string

	// Host is the host to use for network transports.
	Host string

	// Deployer is the container runtime to use.
	// This is used for container operations like creating, starting, and attaching.
	Deployer rt.Deployer

	// Debug indicates whether debug mode is enabled.
	// If debug mode is enabled, containers will not be removed when stopped.
	Debug bool

	// Middlewares is a list of named middleware to apply to the transport.
	// These are applied in order, with the first middleware being the outermost wrapper.
	Middlewares []NamedMiddleware

	// PrometheusHandler is an optional HTTP handler for Prometheus metrics endpoint.
	// If provided, it will be exposed at /metrics on the transport's HTTP server.
	PrometheusHandler http.Handler

	// AuthInfoHandler is an optional HTTP handler for authentication information endpoint.
	// If provided, it will be exposed at /.well-known/oauth-protected-resource on the transport's HTTP server.
	AuthInfoHandler http.Handler

	// TrustProxyHeaders indicates whether to trust X-Forwarded-* headers from reverse proxies
	TrustProxyHeaders bool

	// ProxyMode is the proxy mode for stdio transport ("sse" or "streamable-http")
	ProxyMode ProxyMode
}

type Middleware interface {
	// Handler returns the middleware function used by the proxy.
	Handler() MiddlewareFunction
	// Close cleans up any resources used by the middleware.
	Close() error
}

type MiddlewareConfig struct {
	// Type is a string representing the middleware type.
	Type string `json:"type"`
	// Parameters is a JSON object containing the middleware parameters.
	// It is stored as a raw message to allow flexible parameter types.
	Parameters json.RawMessage `json:"parameters" swaggertype:"object"`
}

type MiddlewareFactory func(config *MiddlewareConfig, runner MiddlewareRunner) error

type MiddlewareFunction func(http.Handler) http.Handler

type MiddlewareRunner interface {
	// AddMiddleware adds a middleware instance to the runner's middleware chain with a name for logging
	AddMiddleware(name string, middleware Middleware)

	// SetAuthInfoHandler sets the authentication info handler (used by auth middleware)
	SetAuthInfoHandler(handler http.Handler)

	// SetPrometheusHandler sets the Prometheus metrics handler (used by telemetry middleware)
	SetPrometheusHandler(handler http.Handler)

	// GetConfig returns a config interface for middleware to access runner configuration
	GetConfig() RunnerConfig
}

type NamedMiddleware struct {
	Name     string
	Function MiddlewareFunction
}

type Proxy interface {
	// Start starts the proxy.
	Start(ctx context.Context) error

	// Stop stops the proxy.
	Stop(ctx context.Context) error

	// GetMessageChannel returns the channel for messages to/from the destination.
	GetMessageChannel() chan jsonrpc2.Message

	// SendMessageToDestination sends a message to the destination.
	SendMessageToDestination(msg jsonrpc2.Message) error

	// ForwardResponseToClients forwards a response from the destination to clients.
	ForwardResponseToClients(ctx context.Context, msg jsonrpc2.Message) error
}

type ProxyMode string

type RunnerConfig interface {
	GetPort() int
}

type Transport interface {
	// Mode returns the transport mode.
	Mode() TransportType

	// ProxyPort returns the port used by the transport.
	ProxyPort() int

	// Start initializes the transport and begins processing messages.
	// The transport is responsible for container operations like attaching to stdin/stdout if needed.
	Start(ctx context.Context) error

	// Stop gracefully shuts down the transport.
	Stop(ctx context.Context) error

	// IsRunning checks if the transport is currently running.
	IsRunning(ctx context.Context) (bool, error)
}

type TransportType string

type TunnelProvider interface {
	ParseConfig(config map[string]any) error
	StartTunnel(ctx context.Context, name string, targetURI string) error
}