sambox

type AgentBundle struct {
	Version string        `yaml:"version"`
	Agent   AgentIdentity `yaml:"agent"`
	Egress  BundleEgress  `yaml:"egress"`

	// Ingress is what this agent is permitted to serve, not what it is
	// currently serving. The agent says when it is ready, and on which port,
	// through the gateway's ingress endpoint; the platform decides only which
	// names it may claim.
	Ingress []BundleIngress `yaml:"ingress"`
	// contains filtered or unexported fields
}

type AgentDialer struct {
	// Router classifies destinations. Required.
	Router *Router

	// SidecarSocket is the Unix socket of the sam-node this sandbox is attached
	// to. sam-box is the node's only consumer here: an agent never reaches the
	// socket, only the curated surface built on top of it (entrypoint.go).
	SidecarSocket string

	// AgentID is the principal this boundary serves, asserted to the node on
	// every request (api.HeaderSamAgent). Empty means the sandbox is
	// unidentified, and mesh policy sees only the node it came through.
	AgentID string

	// Ingress serves what the agent is permitted to advertise. Nil means the
	// agent may serve nothing, which is the case for a sandbox that only calls
	// out.
	Ingress *IngressManager

	// DialContext opens external destinations. Nil uses a plain net.Dialer;
	// tests and future egress interception replace it.
	DialContext func(ctx context.Context, network, address string) (net.Conn, error)
}

type AgentIdentity struct {
	// ID is the canonical mesh identifier, without the "agent:" prefix.
	ID string `yaml:"id"`

	// ExternalID is the platform's own identifier, kept verbatim: the
	// translation into ID is not always reversible, and an auditor needs the
	// value the platform actually issued. When credentials are verified, it is
	// also the subject the credential has to attest.
	ExternalID string `yaml:"external_id"`

	// Credential is the path to the credential the platform issued this
	// workload, such as a projected Kubernetes service-account token. It backs
	// the claim the rest of this file makes; see credential.go.
	Credential string `yaml:"credential"`
}

type BundleEgress struct {
	Allow []string `yaml:"allow"`
}

type BundleIngress struct {
	Name string `yaml:"name"`
	Type string `yaml:"type"`
}

type CA struct {
	CertBytes   []byte
	Certificate *x509.Certificate
	PrivateKey  *rsa.PrivateKey
}

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

type Credentials struct {
	Username string
	Password string
}

type Destination struct {
	Name   string
	Port   uint16
	IsName bool
}

type Dialer interface {
	DialDestination(ctx context.Context, creds *Credentials, dst Destination) (net.Conn, error)
}

type DialerFunc func(ctx context.Context, creds *Credentials, dst Destination) (net.Conn, error)

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

type Gateway struct {
	CA              *CA
	CertCache       *CertCache
	SecretStore     map[string]SecretConfig
	Transport       http.RoundTripper
	InterceptorsDir string
	// contains filtered or unexported fields
}

type IngressManager struct {
	// SidecarSocket is the node's API socket, where registrations are made.
	SidecarSocket string

	// Allowed is what the bundle permits this agent to serve. Empty means the
	// agent may serve nothing.
	Allowed []BundleIngress

	// AgentSocket is the sandbox's reverse channel: a Unix socket nano-init
	// listens on from inside the sandbox. It is how an isolated agent is
	// reached at all, because every sandbox has a network namespace of its own
	// and the gateway's 127.0.0.1 is therefore not the agent's. A pathname
	// socket crosses that boundary for the same reason the egress one does: it
	// is a filesystem object, and network namespaces do not apply to it.
	//
	// Empty means the agent shares this process's network namespace and can be
	// dialled directly, which is true of no sandboxed profile.
	AgentSocket string

	// AgentAddr resolves where the agent listens inside its sandbox. Setting it
	// overrides both of the above, which is how tests point the forwarder at a
	// server of their own.
	AgentAddr func(port int) string
	// contains filtered or unexported fields
}

type Route struct {
	Kind RouteKind

	// ServiceURI is the canonical mesh identity for RouteMeshService, e.g.
	// "inference://openrouter". It is the same string policy is written
	// against, so a routing decision and an authorization decision can never
	// disagree about what was asked for.
	ServiceURI string

	Destination Destination
}

type RouteKind int

type Router struct {
	// Egress is the allowlist for destinations outside the mesh. Nil denies
	// every external destination.
	Egress *EgressPolicy
}

type SOCKS5Server struct {
	// Dialer is required.
	Dialer Dialer

	// Authenticate, when set, makes RFC 1929 username/password the only
	// acceptable method: a client that offers no credentials is rejected rather
	// than silently downgraded to an anonymous flow.
	Authenticate func(Credentials) error
}

type SecretConfig struct {
	Kind       SecretKind `yaml:"kind" json:"kind"`
	HeaderName string     `yaml:"header_name" json:"header_name"`
	Value      string     `yaml:"value" json:"value"`
}

type SecretKind string

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