runnerwire

type ActionResult struct {
	ID         uuid.UUID `json:"id"`
	Outcome    string    `json:"outcome"`
	ObservedAt time.Time `json:"observed_at"`
	Reason     string    `json:"reason,omitempty"` // why a refused action was refused
}

type AgentExit struct {
	Generation uuid.UUID `json:"generation"`
	ExecID     string    `json:"exec_id"`
	Ref        string    `json:"ref"`
	Code       int       `json:"code"`
	ObservedAt time.Time `json:"observed_at"`
}

type AgentStatusArgs struct {
	Ref         string `json:"ref"`
	AgentExecID string `json:"agent_exec_id"`
}

type AttachArgs struct {
	Ref     string               `json:"ref"`
	Options runner.AttachOptions `json:"options"`
}

type Auth struct {
	RunnerID string  `json:"runner_id"`
	Version  int     `json:"version"`
	Sig      []byte  `json:"sig"`
	Resume   *Resume `json:"resume,omitempty"`
}

type AuthOK struct {
	SessionID    string        `json:"session_id"`
	Resumed      bool          `json:"resumed"`
	PingInterval time.Duration `json:"ping_interval"`
	// LastSeq is the org's received cursor; the runner replays after it.
	LastSeq uint64 `json:"last_seq"`
}

type Call struct {
	Method string          `json:"method"`
	Args   json.RawMessage `json:"args,omitempty"`
}

type CallHandler func(ctx context.Context, id uint32, method string, args json.RawMessage) (any, error)

type CallOption func(*pendingCall)

type Caps struct {
	Support substrate.ClassSupport `json:"support"`
	placement.Capacity
	AllowedRoots []string `json:"allowed_roots,omitempty"`
	Version      string   `json:"version"`
	// MachineName is the host's own name (os.Hostname), stored as the runner's machine_name.
	MachineName string `json:"machine_name,omitempty"`
}

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

type ClientConfig struct {
	OrgURL, RunnerID string
	PrivateKey       ed25519.PrivateKey
	HTTPClient       *http.Client
	Dial             func(context.Context) (Conn, error)
	Hooks            RunnerHooks
}

type Code string

type Conn interface {
	ReadFrame(ctx context.Context) (Frame, error)
	WriteFrame(ctx context.Context, f Frame) error
	Close() error
}

type CreateSandboxArgs struct {
	Spec runner.SandboxSpec `json:"spec"`
	// ExecOutput says the org wants the agent's output: the runner opens an
	// `output` stream named by the run id (the writer itself cannot cross the wire).
	ExecOutput bool `json:"exec_output,omitempty"`
}

type CreateSandboxResult struct {
	Sandbox runner.Sandbox `json:"sandbox"`
}

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

type CurrentActivity struct {
	RunID uuid.UUID `json:"run_id"`
}

type DeliverResidentArgs struct {
	RunID    uuid.UUID `json:"run_id"`
	GrantID  uuid.UUID `json:"grant_id"`
	Kind     string    `json:"kind"`
	Value    string    `json:"value"`
	NotAfter time.Time `json:"not_after"`
	// Sandbox lets the runner place the value in SecretEnv or ManagedFiles;
	// false keeps it in the runner's own proxy configuration only.
	Sandbox bool `json:"sandbox,omitempty"`
}

type EraseResidentArgs struct {
	RunID uuid.UUID `json:"run_id"`
}

type Error struct {
	Code    Code   `json:"code"`
	Message string `json:"message"`
}

type Event struct {
	Kind  string          `json:"kind"`
	Call  uint32          `json:"call,omitempty"`
	RunID *uuid.UUID      `json:"run_id,omitempty"`
	Data  json.RawMessage `json:"data,omitempty"`
}

type ExecArgs struct {
	ExecutionGeneration uuid.UUID `json:"execution_generation"`
	Ref                 string    `json:"ref"`
	Argv                []string  `json:"argv"`
}

type ExecResult struct {
	ExecID string `json:"exec_id"`
}

type ExecStreamArgs struct {
	Ref  string          `json:"ref"`
	Spec runner.ExecSpec `json:"spec"`
}

type ExecStreamResult struct {
	Exec   uint32 `json:"exec"`
	Stderr uint32 `json:"stderr,omitempty"`
}

type ExecWaitArgs struct {
	Stream uint32 `json:"stream"`
}

type ExecutionResult struct {
	Containment     *types.RunnerMutationFailure `json:"containment,omitempty"`
	MutationFailure *types.RunnerMutationFailure `json:"mutation_failure,omitempty"`
	Generation      uuid.UUID                    `json:"generation"`
	Operation       string                       `json:"operation"`
	ExecID          string                       `json:"exec_id"`
	Attempted       bool                         `json:"attempted"`
}

type ExecutionResultArgs struct {
	Ref        string    `json:"ref"`
	Generation uuid.UUID `json:"generation"`
}

type Frame struct {
	Type    Type
	Flags   uint8
	Stream  uint32
	Seq     uint64
	Payload []byte
}

type Hello struct {
	Versions     []int     `json:"versions"`
	Nonce        []byte    `json:"nonce"`
	ServerTime   time.Time `json:"server_time"`
	OrgURLSHA256 string    `json:"org_url_sha256"`
}

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

type Lease struct {
	ExecutionGeneration uuid.UUID `json:"execution_generation"`
	RunID               uuid.UUID `json:"run_id"`
	TokenRenewedAt      time.Time `json:"token_renewed_at"`
	EndsAt              time.Time `json:"ends_at"`
}

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

type Open struct {
	Kind   string `json:"kind"`
	Target string `json:"target,omitempty"`
	Offset int64  `json:"offset,omitempty"`
	// Call, when non-zero, names the in-flight CALL this stream was opened for;
	// the REPLY names the stream and the caller claims it with Peer.TakeStream.
	Call uint32 `json:"call,omitempty"`
}

type OutputAckArgs struct {
	RunID  uuid.UUID `json:"run_id"`
	Offset int64     `json:"offset"`
}

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

type PeerConfig struct {
	Org bool
	// OnCall serves incoming calls; nil refuses every call.
	OnCall CallHandler
	// OnEvent receives EVENT frames (org side), in order, on the read loop.
	OnEvent func(Event)
	// OnOpen accepts an incoming byte stream that belongs to no call; an error
	// refuses it. It must not block.
	OnOpen func(s *Stream, o Open) error
	// OnControl receives the session-level frames the peer does not act on
	// itself: PENDING, STATE, READY, LEASE, GOAWAY, REVOKED and CURRENT_ACTIVITY.
	OnControl func(Frame)
	// Checked handlers replace their unchecked counterpart when set. A failed
	// durable ingest must not advance the received/ACK cursor.
	OnEventChecked   func(Event) error
	OnControlChecked func(Frame) error
	// Replay and LastReceived carry a session's sequencing across a reconnect:
	// the buffer the previous connection used (frames still un-ACKed) and the
	// last sequenced frame received from the peer. Zero values start a fresh
	// session at sequence 1.
	Replay       *ReplayBuffer
	LastReceived uint64
	// NextID and AbandonedCalls retain the call-id space after a link drop.
	// Callers fail offline; their late, replayed replies are still legitimate.
	NextID         uint32
	AbandonedCalls []uint32
}

type PendingAction struct {
	Retirement *types.RunnerRetirement      `json:"retirement,omitempty"`
	Quarantine *types.RunnerQuarantine      `json:"quarantine,omitempty"`
	Recovery   *types.RunnerMutationFailure `json:"recovery,omitempty"`
	ID         uuid.UUID                    `json:"id"`
	Kind       types.RunnerActionKind       `json:"kind"`
	RunID      uuid.UUID                    `json:"run_id"`
	Ref        string                       `json:"ref"`
}

type Reason struct {
	Reason string `json:"reason"`
}

type RecoverResult struct {
	Stream        uint32 `json:"stream,omitempty"`
	Unrecoverable bool   `json:"unrecoverable,omitempty"`
}

type RefArgs struct {
	ExecutionGeneration uuid.UUID `json:"execution_generation,omitempty"`
	Ref                 string    `json:"ref"`
}

type ReplaceProxyArgs struct {
	Ref     string `json:"ref"`
	CfgJSON []byte `json:"cfg_json"`
}

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

type Reply struct {
	Result json.RawMessage `json:"result,omitempty"`
	Error  *Error          `json:"error,omitempty"`
}

type ResetError struct{ Code uint32 }

type ResidentErase struct {
	GrantID uuid.UUID `json:"grant_id"`
	Outcome string    `json:"outcome"`
}

type ResizeArgs struct {
	Stream uint32 `json:"stream"`
	Cols   uint16 `json:"cols"`
	Rows   uint16 `json:"rows"`
}

type Resume struct {
	SessionID string `json:"session_id"`
	LastSeq   uint64 `json:"last_seq"`
}

type RunState struct {
	SpoolReceipt    *types.RunnerSpoolReceipt    `json:"spool_receipt,omitempty"`
	Retirement      *types.RunnerRetirement      `json:"retirement,omitempty"`
	Containment     *types.RunnerMutationFailure `json:"containment,omitempty"`
	ContainmentOnly bool                         `json:"containment_only,omitempty"`
	MutationFailure *types.RunnerMutationFailure `json:"mutation_failure,omitempty"`
	Execution       *ExecutionResult             `json:"execution,omitempty"`
	RunID           uuid.UUID                    `json:"run_id"`
	// Ref and Generation are the runner's own identity for the run, asserted
	// evidence only. The org uses them solely to contain a run it has no row
	// for; they never bind or authorize anything for a known run.
	Ref            string     `json:"ref,omitempty"`
	Generation     uuid.UUID  `json:"generation"`
	SandboxPresent bool       `json:"sandbox_present"`
	AgentState     string     `json:"agent_state,omitempty"`
	ExitCode       *int       `json:"exit_code,omitempty"`
	ProxyStoppedAt *time.Time `json:"proxy_stopped_at,omitempty"`
	SpoolDepth     int        `json:"spool_depth"`
	SpoolDrops     int        `json:"spool_drops"`
	ResidentGrants []string   `json:"resident_grants,omitempty"`
}

type RunnerHooks struct {
	Call func(context.Context, *Peer, uint32, string, json.RawMessage) (any, error)
	Open func(*Peer, *Stream, Open) error
	// Clock anchors org time to the local monotonic HELLO receipt instant.
	// It runs after binding validation and before any lease or execution hook.
	Clock func(Hello, time.Time) error
	// Pending applies actions oldest first and durably records each result.
	// It sends action_result through peer only after recording that result.
	Pending func(context.Context, *Peer, []PendingAction) error
	// StatePages emits one fresh inventory as bounded ordered pages through
	// send, ending with Final. Each page is a separate STATE frame.
	StatePages func(ctx context.Context, send func(StatePage) error) error
	// Replay sends the durable spool, completing before READY is sent.
	Replay func(context.Context, *Peer) error
	// BeforeReady establishes local execution admission before the org can
	// send work. On resume it runs before the peer read loop starts, so it
	// must not wait for replies or emit byte streams.
	BeforeReady func(context.Context, *Peer, bool) error
	Lease       func(context.Context, Lease) error
	Revoked     func(context.Context) error
	Offline     func(context.Context)
	Online      func(*Peer, bool)
	// StreamOffline releases per-connection PTY/exec resources, not sandboxes.
	StreamOffline func(*Peer)
}

type StateInventory struct {
	ID       uuid.UUID
	Last     uuid.UUID
	Complete bool
}

type StatePage struct {
	InventoryID uuid.UUID  `json:"inventory_id"`
	After       uuid.UUID  `json:"after"`
	Runs        []RunState `json:"runs"`
	Final       bool       `json:"final"`
}

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

type StreamResult struct {
	Stream uint32 `json:"stream"`
}

type SweepArgs struct {
	MinAge time.Duration `json:"min_age"`
	Remove []uuid.UUID   `json:"remove,omitempty"`
}

type SweepResult struct {
	Candidates []uuid.UUID `json:"candidates,omitempty"`
	Removed    int         `json:"removed"`
}

type Type uint8

type WaitResult struct {
	ExitCode int `json:"exit_code"`
}

type Waiting struct {
	Detail string `json:"detail"`
}

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