remote

type CredentialResolver interface {
	ResolvePluginCredential(ctx context.Context, credential string) (string, error)
}

type CredentialResolverFunc func(ctx context.Context, credential string) (string, error)

type Factory struct {
	// Tunnel serves tunnel-mode plugins. Required for plugins with
	// no URL endpoint.
	Tunnel *TunnelServer
	// TrustedLAN reports whether the owner confirmed the plugin's
	// URL as a LAN origin at install (Manager grants carry it).
	TrustedLAN func(pluginID string) bool
	// Credential returns the credential Ether presents to the plugin
	// on URL calls, or "" for none (plain Stremio add-ons).
	Credential func(pluginID string) string
	// Guard guards URL fetches; nil uses a zero safefetch.Guard.
	Guard *safefetch.Guard
	// Locale is the fallback X-Ether-Locale for calls that carry none.
	Locale string
	Logger *slog.Logger
}

type HandlerFunc func(ctx context.Context, req Request) (Response, error)

type Host interface {
	KVGet(ctx context.Context, pluginID, key string) ([]byte, bool, error)
	KVPut(ctx context.Context, pluginID, key string, value []byte) error
	KVDelete(ctx context.Context, pluginID, key string) error
	KVList(ctx context.Context, pluginID, prefix string) ([]string, error)

	CatalogSearch(ctx context.Context, pluginID, query string, limit, offset int) (json.RawMessage, error)
	CatalogGet(ctx context.Context, pluginID, id string) (json.RawMessage, error)

	ViewerGranted(ctx context.Context, pluginID string) (json.RawMessage, error)
	ViewerHistory(ctx context.Context, pluginID string, viewerID int64, limit, offset int) (json.RawMessage, error)
	SetWatchState(ctx context.Context, pluginID string, viewerID int64, titleID string, watched bool) error

	CollectionsUpsert(ctx context.Context, pluginID string, collection json.RawMessage) error

	Settings(ctx context.Context, pluginID string) (map[string]any, error)

	NotifyOwner(ctx context.Context, pluginID, text string) error
	Log(ctx context.Context, pluginID, level, msg string, attrs map[string]any) error
}

type HostAdapter struct {
	HostFor func(pluginID string) plugins.Host
	// SettingsWithSecrets, when set, returns the plugin's settings with its own
	// secrets (Manager.PluginSettings); a remote sidecar cannot call
	// secret.get, so this is how it recovers configuration after a
	// restart or reconnect. Without it only non-secret settings are served.
	SettingsWithSecrets func(ctx context.Context, pluginID string) (map[string]any, error)
}

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

type HostOptions struct {
	Host   Host
	Auth   CredentialResolver
	Logger *slog.Logger
}

type Pairing struct {
	// TunnelURL derives the externally reachable URL from the owner request.
	TunnelURL func(*http.Request) string
	// Exists allows owners to inspect and revoke pairings of disabled plugins.
	Exists func(context.Context, string) bool
	// contains filtered or unexported fields
}

type Request struct {
	Method  string
	Path    string
	Query   map[string][]string
	Headers map[string][]string
	Body    []byte
	// Locale, when set, overrides the client's configured locale for
	// this call.
	Locale string
	// RequestID correlates the call in logs; generated when empty.
	RequestID string
	// Timeout bounds this call. When zero, the context deadline (or
	// the client default) applies. The resulting absolute deadline is
	// sent to the plugin as X-Ether-Deadline.
	Timeout time.Duration
}

type Response struct {
	Status  int
	Headers map[string][]string
	Body    []byte
}

type Runtime interface {
	Call(ctx context.Context, req Request) (Response, error)
	Close() error
}

type StaticCredentials map[string]string

type StreamCall interface {
	CallStream(ctx context.Context, req plugins.Request) (plugins.Response, io.ReadCloser, error)
}

type StreamHandlerFunc func(ctx context.Context, req Request) (*StreamResponse, error)

type StreamResponse struct {
	Status  int
	Headers map[string][]string
	Body    io.ReadCloser
}

type Streamer interface {
	CallStream(ctx context.Context, req Request) (*StreamResponse, error)
}

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

type TunnelClientOptions struct {
	// URL is Ether's tunnel endpoint, ws:// or wss:// (http/https
	// are accepted and rewritten).
	URL string
	// Credential authenticates the connection (sent as
	// X-Ether-Plugin-Credential on the upgrade request).
	Credential string
	// Plugin, when set, declares the plugin id in the hello frame.
	// It must match the credential's plugin or Ether refuses the
	// connection, which catches a sidecar started with the wrong
	// credential early.
	Plugin string
	// Handler serves buffered replies. Required.
	Handler HandlerFunc
	// StreamHandler, when set, gets first refusal on every request
	// (file ranges use it through FileHandler).
	StreamHandler StreamHandlerFunc
	Logger        *slog.Logger
}

type TunnelOptions struct {
	// Auth resolves tunnel credentials to plugin ids. Required: a
	// server without it refuses every connection.
	Auth CredentialResolver
	// Locale is sent to plugins unless a request overrides it.
	Locale string
	// MaxResponseBytes caps buffered replies; zero uses the default.
	MaxResponseBytes int64
	// MaxInFlight bounds concurrent calls per connection
	// (backpressure); zero uses DefaultMaxInFlight.
	MaxInFlight int
	// ChunkBytes is the streamed-body chunk size advertised to
	// sidecars; zero uses DefaultChunkBytes.
	ChunkBytes int
	// PingInterval is the websocket keepalive cadence; zero uses
	// DefaultPingInterval, negative disables server pings.
	PingInterval time.Duration
	// Timeout is the default per-call deadline; zero uses
	// DefaultCallTimeout.
	Timeout time.Duration
	Logger  *slog.Logger
}

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

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

type URLOptions struct {
	// Plain Stremio resources may redirect to public CDNs. Credentials never follow.
	AllowPublicRedirects bool
	// Base is the plugin base URL, usually the manifest URL's
	// directory (for example https://addons.example/usercfg). Request
	// paths are appended to it. A trailing "/manifest.json" is
	// stripped so a manifest URL may be passed directly.
	Base string
	// Credential is sent as X-Ether-Plugin-Credential on every call.
	// Plain Stremio add-ons have none.
	Credential string
	// Plain marks a third-party Stremio add-on: it is sent only standard
	// HTTP headers (no X-Ether-* request id, deadline or locale), as the
	// Stremio app would, and its base keeps its configuration query.
	Plain bool
	// Locale is sent as X-Ether-Locale unless a request overrides it.
	Locale string
	// TrustedOrigin allows this exact origin to resolve to private
	// addresses (owner-confirmed LAN URL mode). It must name the same
	// origin as Base; anything else is refused at construction so a
	// client can never be built trusted for one host and aimed at
	// another.
	TrustedOrigin string
	// Guard guards fetches; nil uses a zero safefetch.Guard. Tests
	// inject one with fake DNS.
	Guard *safefetch.Guard
	// BaseTransport is the transport the guard clones. It must be a
	// *http.Transport (the guard refuses anything else). Nil uses
	// egress.Transport(egress.CapPlugins).
	BaseTransport http.RoundTripper
	// MaxResponseBytes caps buffered replies; zero uses the default,
	// negative means the default too (a cap is always enforced).
	MaxResponseBytes int64
	// MaxStreamBytes caps streamed replies; zero means no cap beyond
	// the caller's context (range-relayed media files are large).
	MaxStreamBytes int64
	// Timeout is the default per-call deadline; zero uses
	// DefaultCallTimeout.
	Timeout time.Duration
	Logger  *slog.Logger
}