handshake

type HandshakeMsg struct {
	Type          string `json:"type"`
	NodeID        uint32 `json:"node_id"`
	PublicKey     string `json:"public_key"`    // base64 Ed25519 public key
	Justification string `json:"justification"` // why the sender wants to connect
	Signature     string `json:"signature"`     // Ed25519 sig over "handshake:<node_id>:<peer_id>"
	Reason        string `json:"reason"`        // rejection reason
	Timestamp     int64  `json:"timestamp"`
}

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

type PendingHandshake struct {
	NodeID        uint32
	PublicKey     string
	Justification string
	ReceivedAt    time.Time
}

type RegistryClient interface {
	Lookup(nodeID uint32) (map[string]interface{}, error)
	ReportTrust(nodeID, peerID uint32) (map[string]interface{}, error)
	RevokeTrust(nodeID, peerID uint32) (map[string]interface{}, error)
	RequestHandshake(fromNodeID, toNodeID uint32, justification, signatureB64 string) (map[string]interface{}, error)
	RespondHandshake(nodeID, peerID uint32, accept bool, signatureB64 string) (map[string]interface{}, error)
	PollHandshakes(nodeID uint32) (map[string]interface{}, error)
}

type Runtime interface {
	// NodeID returns this daemon's stable node ID. Returns 0 if
	// identity has not been initialized yet.
	NodeID() uint32

	// HasIdentity reports whether the daemon has loaded an Ed25519
	// identity. SendRequest / signing paths early-return when false.
	HasIdentity() bool

	// PublicKey returns the local Ed25519 public key (for inclusion in
	// outbound HandshakeMsg.PublicKey). Returns nil when HasIdentity is
	// false.
	PublicKey() ed25519.PublicKey

	// Sign signs the given payload with the local Ed25519 private key.
	// Returns nil when HasIdentity is false; callers handle that as
	// "no signature attached".
	Sign(msg []byte) []byte

	// IdentityPath returns the configured on-disk identity path; the
	// trust.json store sits in the same directory. Empty when the
	// daemon runs in-memory only (no persistence).
	IdentityPath() string

	// TrustAutoApprove reports whether the daemon was configured to
	// auto-approve all incoming handshake requests (trust-on-first-use
	// stance for friendly fleets).
	TrustAutoApprove() bool

	// IsTrusted consults the trustedagents allowlist. Returns the
	// agent's display name and ok=true on a match. Returns "", false
	// when no checker has been registered (treated as "not trusted").
	IsTrusted(nodeID uint32) (name string, ok bool)

	// PublishEvent emits a topic+payload event onto the daemon's event
	// bus. Non-blocking; events may be dropped under bus pressure.
	PublishEvent(topic string, payload map[string]any)

	// PortListener binds the given well-known port and returns a
	// coreapi.Listener. The handshake plugin uses this for PortHandshake.
	// Closing the returned listener stops the accept loop.
	PortListener(port uint16) (coreapi.Listener, error)

	// DialAndSend establishes a stream to (peerNodeID, port), writes
	// the JSON-encoded message, and closes after a brief grace period
	// to let the data flush.
	DialAndSend(peerNodeID uint32, port uint16, data []byte) error

	// RemoveTunnelPeer tears down the encrypted tunnel for the given
	// peer. Called from RevokeTrust so a revoked peer's tunnel state
	// (session keys, retransmit queues) is purged immediately.
	RemoveTunnelPeer(nodeID uint32)

	// Registry returns the L8 registry-side-channel client used for
	// peer lookups, trust-pair reporting, and relay-based handshake
	// when direct dial fails. Returns nil when the daemon is offline
	// or running without a registry connection — callers must nil-check.
	Registry() RegistryClient
}

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

type TrustRecord struct {
	NodeID     uint32
	PublicKey  string // base64 Ed25519 pubkey
	ApprovedAt time.Time
	Mutual     bool   // true if both sides initiated
	Network    uint16 // non-zero if trust is via network membership
}