executions

type ChunkPayload struct {
	ExecutionID string
	Index       uint64
}

type Client struct {
	StatusEndpoint   goa.Endpoint
	ListEndpoint     goa.Endpoint
	GetEndpoint      goa.Endpoint
	StartEndpoint    goa.Endpoint
	ManifestEndpoint goa.Endpoint
	ChunkEndpoint    goa.Endpoint
}

type Endpoints struct {
	Status   goa.Endpoint
	List     goa.Endpoint
	Get      goa.Endpoint
	Start    goa.Endpoint
	Manifest goa.Endpoint
	Chunk    goa.Endpoint
}

type ExecutionCommand struct {
	// Execution identifier
	ExecutionID string
	// Recording identifier
	RecordingID   string
	Namespace     string
	WorkspaceName string
	WorkspaceUID  *string
	// RFC3339 timestamp
	AdmissionTime *string
	// Storage mode: ephemeral|external|bundled
	Mode *string
	// none|durable
	Durability *string
	// Final command outcome
	Outcome string
	// Final lifecycle state
	State string
	// Guest process exit code when known
	ExitCode *int
	// Standard output, truncated to the pilot output bound
	Stdout []byte
	// Standard error, truncated to the pilot output bound
	Stderr []byte
	// Output was truncated at the 16 KiB bound
	Truncated *bool
	// Guest-measured duration in milliseconds
	DurationMs *uint64
	// Runner denial or transport-loss note
	Denial *string
}

type ExecutionRecord struct {
	// Execution identifier
	ExecutionID string
	// Actor identifier
	ActorID *string
	// command|script|shell
	Operation           string
	Namespace           string
	WorkspaceName       string
	WorkspaceUID        *string
	WorkspaceGeneration *int64
	GrantVersion        *string
	OsIdentity          *string
	Elevated            *bool
	RecordingID         string
	// Storage mode: ephemeral|external|bundled
	Mode string
	// none|durable
	Durability string
	Admitted   bool
	// RFC3339 timestamp
	AdmissionTime string
	DenyReason    *string
	// lifecycle state
	State *string
	// RFC3339 timestamp
	StartTime *string
	// RFC3339 timestamp
	EndTime       *string
	ExitCode      *int
	Termination   *string
	RecordingLost *bool
}

type ExecutionRecordingChunk struct {
	// Chunk index starting at 0
	Index uint64
	// Base64-encoded plaintext recording data
	Data []byte
}

type ExecutionRecordingManifest struct {
	RecordingID    string
	Chunks         uint64
	PlaintextBytes int64
	Verified       bool
}

type ExecutionScriptPayload struct {
	// Script content
	Body string
	// Optional filename hint (e.g. run.sh, script.ps1)
	Name *string
	// Optional working directory for the script
	Cwd *string
}

type ExecutionStatus struct {
	// Whether VM execution is enabled by policy
	Enabled bool
	// Whether elevated execution is allowed by policy
	AllowElevated bool
	// Storage mode: disabled|ephemeral|external|bundled
	StorageMode string
	// Metadata and recordings are durable (not ephemeral)
	Durable bool
	// Store is Ready and can admit work
	StorageAvailable bool
	// Opt-in management issuer prerequisites and initial bootstrap sync are ready;
	// not a guest execution capability
	IssuerReady bool
}

type Forbidden string

type GetPayload struct {
	// Execution identifier
	ExecutionID string
}

type Invalid string

type ListPayload struct {
	// Filter by namespace
	Namespace *string
	// Filter by workspace name
	WorkspaceName *string
	// Filter by actor
	ActorID *string
	// RFC3339 lower bound
	Since *string
	// Max results
	Limit int
}

type ManifestPayload struct {
	ExecutionID string
}

type NotFound string

type Service interface {
	// Get execution management status (policy + storage readiness)
	Status(context.Context) (res *ExecutionStatus, err error)
	// List execution records visible to the actor
	List(context.Context, *ListPayload) (res []*ExecutionRecord, err error)
	// Get an execution record and its last known outcome
	Get(context.Context, *GetPayload) (res *ExecutionRecord, err error)
	// Execute one bounded root (Linux) or SYSTEM (Windows) command or script in an
	// eligible running agent-equipped VM and return its recorded outcome
	// synchronously
	Start(context.Context, *StartPayload) (res *ExecutionCommand, err error)
	// Verify recording integrity and audit protected playback access
	Manifest(context.Context, *ManifestPayload) (res *ExecutionRecordingManifest, err error)
	// Read a verified recording chunk with fresh scoped recording-read permission
	Chunk(context.Context, *ChunkPayload) (res *ExecutionRecordingChunk, err error)
}

type StartPayload struct {
	// Workspace namespace
	Namespace string
	// Workspace name
	WorkspaceName string
	// Absolute path or name of the program to run
	Executable *string
	// Arguments passed to the executable verbatim
	Args []string
	// Optional working directory for the new process
	Cwd *string
	// Guest execution deadline in seconds
	DeadlineSeconds int
	// Script to execute (mutually exclusive with executable/args)
	Script *ExecutionScriptPayload
}

type Unauthorized string

type Unavailable string