Recover the OAuth storage slice from f6079e9d and the missing workflow persistence error handling from f07c314e, adapted to the current step contract. Require encryption for OAuth token storage and verify RPC round trips and task-grant denial.
1115 lines
41 KiB
Protocol Buffer
1115 lines
41 KiB
Protocol Buffer
syntax = "proto3";
|
|
|
|
package state.v1;
|
|
|
|
import "google/protobuf/timestamp.proto";
|
|
|
|
// StateStore is the single gRPC service fronting archie's PostgreSQL database.
|
|
// See docs/prds/state-store-contract.md for the ownership split: the
|
|
// workflow-domain Store view (Update/Transition/InsertEvent) is consumer-owned
|
|
// in internal/domain/workflow, while the rest of this surface is
|
|
// producer-owned in internal/domain/storecontract. Both are served by the same
|
|
// service over internal/infrastructure/postgres; the proto bypasses the Go
|
|
// interfacebloat cap (max 8), like gateway.v1.ChatService does.
|
|
service StateStoreService {
|
|
// Installed Archie packages. Administrative until org-scoped principals land.
|
|
rpc InstallPackage(InstallPackageRequest) returns (InstallPackageResponse);
|
|
rpc GetInstalledPackage(GetInstalledPackageRequest) returns (GetInstalledPackageResponse);
|
|
rpc ListInstalledPackages(ListInstalledPackagesRequest) returns (ListInstalledPackagesResponse);
|
|
rpc RemoveInstalledPackage(RemoveInstalledPackageRequest) returns (RemoveInstalledPackageResponse);
|
|
// Administrative task credential lifecycle. Worker credentials cannot call these.
|
|
rpc RegisterTaskGrant(RegisterTaskGrantRequest) returns (RegisterTaskGrantResponse);
|
|
rpc RevokeTaskGrant(RevokeTaskGrantRequest) returns (RevokeTaskGrantResponse);
|
|
// Identity domain. Task-scoped grants cannot call these administrative RPCs.
|
|
rpc ListIdentities(ListIdentitiesRequest) returns (ListIdentitiesResponse);
|
|
rpc GetIdentity(GetIdentityRequest) returns (GetIdentityResponse);
|
|
rpc CreateIdentity(CreateIdentityRequest) returns (CreateIdentityResponse);
|
|
rpc RenameIdentity(RenameIdentityRequest) returns (RenameIdentityResponse);
|
|
rpc SuspendIdentity(SuspendIdentityRequest) returns (SuspendIdentityResponse);
|
|
rpc ReactivateIdentity(ReactivateIdentityRequest) returns (ReactivateIdentityResponse);
|
|
rpc RetireIdentity(RetireIdentityRequest) returns (RetireIdentityResponse);
|
|
// Subject bindings. A verified provider subject is resolved to the identity it
|
|
// is bound to; the authenticating process calls these rather than owning the
|
|
// identity store.
|
|
rpc ResolveIdentitySubject(ResolveIdentitySubjectRequest) returns (ResolveIdentitySubjectResponse);
|
|
rpc BindIdentitySubject(BindIdentitySubjectRequest) returns (BindIdentitySubjectResponse);
|
|
// Lifecycle
|
|
rpc EnqueueIssue(EnqueueIssueRequest) returns (EnqueueIssueResponse);
|
|
rpc EnqueueChatTask(EnqueueChatTaskRequest) returns (EnqueueChatTaskResponse);
|
|
rpc ClaimNext(ClaimNextRequest) returns (ClaimNextResponse);
|
|
rpc ClaimByIssue(ClaimByIssueRequest) returns (ClaimByIssueResponse);
|
|
rpc Transition(TransitionRequest) returns (TransitionResponse);
|
|
rpc Update(UpdateRequest) returns (UpdateResponse);
|
|
// Step executions (docs/prds/execution-tree-state-machine.md). The run
|
|
// credential authorises both on its own execution only.
|
|
rpc StartStep(StartStepRequest) returns (StartStepResponse);
|
|
rpc FinishStep(FinishStepRequest) returns (FinishStepResponse);
|
|
// Cancellation. Deliberately administrative (deny-by-default for a
|
|
// task-scoped grant): a cancel is a dashboard, API and dispatch action
|
|
// decided by the Authorizer, not a worker call.
|
|
rpc CancelExecution(CancelExecutionRequest) returns (CancelExecutionResponse);
|
|
// ListSteps is a dashboard/API/dispatch action (Authorizer: read on the
|
|
// run), not task-scoped-grant callable like StartStep/FinishStep.
|
|
rpc ListSteps(ListStepsRequest) returns (ListStepsResponse);
|
|
// Harness OAuth secrets (docs/prds/external-agent-harness.md,
|
|
// Credentials). Administrative: the setup terminal (an `update` action on
|
|
// the secret, Authorizer-gated) and the egress proxy's token-endpoint
|
|
// interception (acting as the daemon, not a worker) are the only callers.
|
|
rpc GetHarnessSecret(GetHarnessSecretRequest) returns (GetHarnessSecretResponse);
|
|
rpc PutHarnessSecret(PutHarnessSecretRequest) returns (PutHarnessSecretResponse);
|
|
rpc Requeue(RequeueRequest) returns (RequeueResponse);
|
|
rpc ParkTask(ParkTaskRequest) returns (ParkTaskResponse);
|
|
rpc RecoverStale(RecoverStaleRequest) returns (RecoverStaleResponse);
|
|
|
|
// Archive / Retry
|
|
rpc ArchiveTask(ArchiveTaskRequest) returns (ArchiveTaskResponse);
|
|
rpc RetryTask(RetryTaskRequest) returns (RetryTaskResponse);
|
|
rpc BeginRemediation(BeginRemediationRequest) returns (BeginRemediationResponse);
|
|
rpc UpdateReviewPayload(UpdateReviewPayloadRequest) returns (UpdateReviewPayloadResponse);
|
|
rpc SetReviewCursors(SetReviewCursorsRequest) returns (SetReviewCursorsResponse);
|
|
|
|
// Queries
|
|
rpc TaskByIssue(TaskByIssueRequest) returns (TaskByIssueResponse);
|
|
rpc OpenTaskByPR(OpenTaskByPRRequest) returns (OpenTaskByPRResponse);
|
|
rpc TaskByID(TaskByIDRequest) returns (TaskByIDResponse);
|
|
rpc OpenPRs(OpenPRsRequest) returns (OpenPRsResponse);
|
|
rpc ClearTerminalTasks(ClearTerminalTasksRequest) returns (ClearTerminalTasksResponse);
|
|
rpc Tasks(TasksRequest) returns (TasksResponse);
|
|
rpc StatusCounts(StatusCountsRequest) returns (StatusCountsResponse);
|
|
|
|
// Events
|
|
rpc InsertEvent(InsertEventRequest) returns (InsertEventResponse);
|
|
rpc EventsSince(EventsSinceRequest) returns (EventsSinceResponse);
|
|
rpc TaskEvents(TaskEventsRequest) returns (TaskEventsResponse);
|
|
rpc WorkflowStats(WorkflowStatsRequest) returns (WorkflowStatsResponse);
|
|
rpc StageStats(StageStatsRequest) returns (StageStatsResponse);
|
|
rpc TokensByDay(TokensByDayRequest) returns (TokensByDayResponse);
|
|
|
|
// Configuration snapshot: the running configuration as the dashboard
|
|
// renders it, published by the owner of configuration for the process that
|
|
// displays it. PutConfigSnapshot is administrative; GetConfigSnapshot is
|
|
// the UI's read (docs/architecture/migration-decisions.md, "Dashboard
|
|
// configuration page").
|
|
rpc PutConfigSnapshot(PutConfigSnapshotRequest) returns (PutConfigSnapshotResponse);
|
|
rpc GetConfigSnapshot(GetConfigSnapshotRequest) returns (GetConfigSnapshotResponse);
|
|
|
|
// Channel status is what the process HOSTING the channels observes about them:
|
|
// one row per channel, written by the Messaging Service and read by the UI
|
|
// process. Administrative like the config snapshot, and for the same reason --
|
|
// a task-scoped grant reaches neither, so authorizesTaskScopedCall admits only
|
|
// the administrative token. It is runtime state rather than a settings
|
|
// document, which is why it is not a ControlPlaneService resource kind.
|
|
rpc PutChannelStatus(PutChannelStatusRequest) returns (PutChannelStatusResponse);
|
|
rpc ListChannelStatus(ListChannelStatusRequest) returns (ListChannelStatusResponse);
|
|
|
|
// Apply status: which version of a control-plane resource each process is
|
|
// running, and why it could not. Every process that applies a resource
|
|
// publishes; the UI process reads (docs/prds/control-plane-apply-status.md).
|
|
// Both are administrative.
|
|
rpc PutApplyStatus(PutApplyStatusRequest) returns (PutApplyStatusResponse);
|
|
rpc ListApplyStatus(ListApplyStatusRequest) returns (ListApplyStatusResponse);
|
|
|
|
// Task log: one task attempt's persisted log. Task log files live in the
|
|
// state directory this process owns, so the dashboard reads them over this
|
|
// contract rather than opening them itself
|
|
// (docs/prds/ui-service-boundary.md).
|
|
rpc ReadTaskLog(ReadTaskLogRequest) returns (ReadTaskLogResponse);
|
|
// StreamTaskLogContent returns one attempt's log verbatim, one chunk per
|
|
// message, for a download. A log file is unbounded input (it rotates at
|
|
// DefaultMaxSizeMB), so a unary response would exceed gRPC's 4MiB message
|
|
// cap on a real log -- the same reason ListCaptures was superseded by
|
|
// StreamCaptures.
|
|
rpc StreamTaskLogContent(StreamTaskLogContentRequest) returns (stream StreamTaskLogContentResponse);
|
|
|
|
// Capture
|
|
rpc InsertCapture(InsertCaptureRequest) returns (InsertCaptureResponse);
|
|
// StreamCaptures returns one capture per message: a batch of large capture
|
|
// bodies can exceed gRPC's 4MiB unary message cap
|
|
// (docs/prds/state-store-contract.md).
|
|
rpc StreamCaptures(StreamCapturesRequest) returns (stream StreamCapturesResponse);
|
|
|
|
// Mapping
|
|
rpc InsertMapping(InsertMappingRequest) returns (InsertMappingResponse);
|
|
rpc GetMapping(GetMappingRequest) returns (GetMappingResponse);
|
|
rpc ListMappings(ListMappingsRequest) returns (ListMappingsResponse);
|
|
rpc UpdateMapping(UpdateMappingRequest) returns (UpdateMappingResponse);
|
|
rpc DeleteMapping(DeleteMappingRequest) returns (DeleteMappingResponse);
|
|
// RecordMappingMatch counts one event a mapping resolved; the same
|
|
// (mapping, capture) twice counts once.
|
|
rpc RecordMappingMatch(RecordMappingMatchRequest) returns (RecordMappingMatchResponse);
|
|
|
|
// EventType (docs/prds/event-automation.md, "Event types"). Insert and
|
|
// Update refuse an overlapping or malformed type.
|
|
rpc InsertEventType(InsertEventTypeRequest) returns (InsertEventTypeResponse);
|
|
rpc UpdateEventType(UpdateEventTypeRequest) returns (UpdateEventTypeResponse);
|
|
rpc DeleteEventType(DeleteEventTypeRequest) returns (DeleteEventTypeResponse);
|
|
rpc ListEventTypes(ListEventTypesRequest) returns (ListEventTypesResponse);
|
|
|
|
// Binding
|
|
rpc InsertBinding(InsertBindingRequest) returns (InsertBindingResponse);
|
|
rpc GetBinding(GetBindingRequest) returns (GetBindingResponse);
|
|
rpc ListBindings(ListBindingsRequest) returns (ListBindingsResponse);
|
|
rpc UpdateBinding(UpdateBindingRequest) returns (UpdateBindingResponse);
|
|
rpc DeleteBinding(DeleteBindingRequest) returns (DeleteBindingResponse);
|
|
rpc ApproveBinding(ApproveBindingRequest) returns (ApproveBindingResponse);
|
|
|
|
// Source (event-automation.md "Sources"): the capture endpoint and its
|
|
// signing setting. Secrets travel in plaintext; the store encrypts at rest.
|
|
rpc InsertSource(InsertSourceRequest) returns (InsertSourceResponse);
|
|
rpc GetSource(GetSourceRequest) returns (GetSourceResponse);
|
|
rpc ListSources(ListSourcesRequest) returns (ListSourcesResponse);
|
|
rpc SetSourceSigning(SetSourceSigningRequest) returns (SetSourceSigningResponse);
|
|
rpc SetSourceSecret(SetSourceSecretRequest) returns (SetSourceSecretResponse);
|
|
|
|
// Dispatch
|
|
rpc ArmedBindingsForSource(ArmedBindingsForSourceRequest) returns (ArmedBindingsForSourceResponse);
|
|
rpc RecordDispatch(RecordDispatchRequest) returns (RecordDispatchResponse);
|
|
// Playbook dispatch ledger (eda-playbook-engine.md gap 2): one durable
|
|
// at-most-once record per (playbook, version, event, action) for the
|
|
// side-effecting positions. Administrative, like RecordDispatch: a
|
|
// task-scoped grant cannot reach either (see TaskGrants).
|
|
rpc RecordPlaybookDispatch(RecordPlaybookDispatchRequest) returns (RecordPlaybookDispatchResponse);
|
|
rpc DeletePlaybookDispatches(DeletePlaybookDispatchesRequest) returns (DeletePlaybookDispatchesResponse);
|
|
rpc StreamUndispatchedCaptures(StreamUndispatchedCapturesRequest) returns (stream StreamUndispatchedCapturesResponse);
|
|
|
|
// BindingTaskCreator
|
|
rpc EnqueueBindingTask(EnqueueBindingTaskRequest) returns (EnqueueBindingTaskResponse);
|
|
|
|
// WorkflowCaller: a workflow.call step starts its callee and, with
|
|
// wait:true, reads it back while waiting. Both are the one sanctioned
|
|
// widening of a task-scoped grant -- the callee is the caller's child
|
|
// (docs/prds/workflow-calls.md). CallStatus re-checks the parent-child
|
|
// relation server-side, so the grant only names the caller.
|
|
rpc EnqueueCallTask(EnqueueCallTaskRequest) returns (EnqueueCallTaskResponse);
|
|
rpc WorkflowCallStatus(WorkflowCallStatusRequest) returns (WorkflowCallStatusResponse);
|
|
|
|
// Access: the stored policy chain and its denial records
|
|
// (docs/prds/orgs-and-access.md). ListPolicies is the engine's snapshot;
|
|
// the writes are administrative. RecordDenial is the dashboard's and
|
|
// dispatch's write path; ListDenials is the operator surface.
|
|
// The principal assembly the Authorizer evaluates: an identity, the org
|
|
// it serves, and its memberships (internal/domain/access).
|
|
rpc GetPrincipal(GetPrincipalRequest) returns (GetPrincipalResponse);
|
|
rpc ListPolicies(ListPoliciesRequest) returns (ListPoliciesResponse);
|
|
rpc PutPolicy(PutPolicyRequest) returns (PutPolicyResponse);
|
|
rpc DeletePolicy(DeletePolicyRequest) returns (DeletePolicyResponse);
|
|
rpc EnsureShippedOrgPolicies(EnsureShippedOrgPoliciesRequest) returns (EnsureShippedOrgPoliciesResponse);
|
|
rpc RecordDenial(RecordDenialRequest) returns (RecordDenialResponse);
|
|
rpc ListDenials(ListDenialsRequest) returns (ListDenialsResponse);
|
|
}
|
|
|
|
message RegisterTaskGrantRequest {
|
|
int64 task_id = 1;
|
|
string token = 2;
|
|
int64 lifetime_seconds = 3;
|
|
}
|
|
message RegisterTaskGrantResponse {}
|
|
message RevokeTaskGrantRequest {
|
|
string token = 1;
|
|
}
|
|
message RevokeTaskGrantResponse {}
|
|
|
|
message Identity {
|
|
string id = 1;
|
|
string kind = 2;
|
|
string display_name = 3;
|
|
string lifecycle = 4;
|
|
int64 version = 5;
|
|
google.protobuf.Timestamp created_at = 6;
|
|
google.protobuf.Timestamp updated_at = 7;
|
|
}
|
|
message IdentityAudit {
|
|
string actor_id = 1;
|
|
string source = 2;
|
|
string request_id = 3;
|
|
}
|
|
message ListIdentitiesRequest {}
|
|
message ListIdentitiesResponse { repeated Identity identities = 1; }
|
|
message GetIdentityRequest { string id = 1; }
|
|
message GetIdentityResponse { Identity identity = 1; }
|
|
message CreateIdentityRequest {
|
|
string id = 1;
|
|
string kind = 2;
|
|
string display_name = 3;
|
|
IdentityAudit audit = 4;
|
|
}
|
|
message RenameIdentityRequest {
|
|
string id = 1;
|
|
int64 expected_version = 2;
|
|
string display_name = 3;
|
|
IdentityAudit audit = 4;
|
|
}
|
|
message SuspendIdentityRequest { string id = 1; int64 expected_version = 2; IdentityAudit audit = 3; }
|
|
message ReactivateIdentityRequest { string id = 1; int64 expected_version = 2; IdentityAudit audit = 3; }
|
|
message RetireIdentityRequest { string id = 1; int64 expected_version = 2; IdentityAudit audit = 3; }
|
|
message CreateIdentityResponse { Identity identity = 1; }
|
|
message RenameIdentityResponse { Identity identity = 1; }
|
|
message SuspendIdentityResponse { Identity identity = 1; }
|
|
message ReactivateIdentityResponse { Identity identity = 1; }
|
|
message RetireIdentityResponse { Identity identity = 1; }
|
|
message ResolveIdentitySubjectRequest {
|
|
string issuer = 1;
|
|
string subject = 2;
|
|
}
|
|
message ResolveIdentitySubjectResponse { Identity identity = 1; }
|
|
message BindIdentitySubjectRequest {
|
|
string id = 1;
|
|
string issuer = 2;
|
|
string subject = 3;
|
|
IdentityAudit audit = 4;
|
|
}
|
|
message BindIdentitySubjectResponse { Identity identity = 1; }
|
|
|
|
// Task mirrors internal/domain/workflow.Task.
|
|
message Task {
|
|
int64 id = 1;
|
|
string owner = 2;
|
|
string repo = 3;
|
|
int64 issue_number = 4;
|
|
string title = 5;
|
|
string body = 6;
|
|
string labels = 7;
|
|
string status = 8;
|
|
string workflow = 9;
|
|
// Retired: the per-task "current stage" column was overwritten as
|
|
// workflow.Run advanced and carried no history. step_executions is the
|
|
// durable per-step record now (docs/prds/execution-tree-state-machine.md);
|
|
// ListSteps is its read.
|
|
string stage = 10 [deprecated = true];
|
|
string branch = 11;
|
|
string plan = 12;
|
|
string notes = 13;
|
|
int64 pr_number = 14;
|
|
int64 tokens_used = 15;
|
|
int64 iterations = 16;
|
|
int64 attempt = 17;
|
|
string park_reason = 18;
|
|
int64 retry_count = 19;
|
|
int64 watch_comment_id = 20;
|
|
string source = 21;
|
|
string identity = 22;
|
|
string binding_id = 23;
|
|
int64 binding_version = 24;
|
|
google.protobuf.Timestamp created_at = 25;
|
|
google.protobuf.Timestamp updated_at = 26;
|
|
// review_payload is the JSON-encoded review unit the remediate workflow's
|
|
// current run must address (docs/prds/pr-review-remediation.md decision 4).
|
|
string review_payload = 27;
|
|
// The workflow pin: the exact definition version this run started with.
|
|
// It has to cross the wire for the daemon's digest guard to hold, because
|
|
// a retry reads the task back over this contract before deciding whether
|
|
// to reuse the pinned YAML (docs/prds/runtime-control-plane.md:95).
|
|
int64 workflow_definition_version = 28;
|
|
string workflow_definition_digest = 29;
|
|
string workflow_definition_yaml = 30;
|
|
// review_cursor is the poll backstop's high-water mark over forge review
|
|
// IDs for this task. It is separate from watch_comment_id (the review-
|
|
// comment cursor) because the two forge sequences are independent; one
|
|
// combined cursor would silently skip reviews once a larger comment ID
|
|
// landed (docs/prds/pr-review-remediation.md decision 2).
|
|
int64 review_cursor = 31;
|
|
// park_class is the producer-recorded answer to "what kind of
|
|
// intervention does this park need?" (taskstate.ParkClass:
|
|
// needs_human, transient, terminal). Store-side normalization makes
|
|
// empty and unknown values needs_human, so the class is advisory on
|
|
// the wire and authoritative only as recorded at the park site.
|
|
string park_class = 32;
|
|
// remediation_rounds counts review-triggered remediation rounds
|
|
// separately from retry_count, so an operator's manual retries no
|
|
// longer draw down the review-remediation budget (and vice versa).
|
|
int32 remediation_rounds = 33;
|
|
// inputs_json is the JSON object of workflow inputs a binding dispatch
|
|
// resolved (task.EncodeInputs); empty for a task no binding started.
|
|
string inputs_json = 34;
|
|
// org is the org the task belongs to, derived store-side from the task's
|
|
// identity when the row is written; a task of a single-operator install
|
|
// belongs to the default org (docs/prds/orgs-and-access.md).
|
|
string org = 35;
|
|
// The workflow.call linkage (docs/prds/workflow-calls.md): the task whose
|
|
// workflow.call step started this one (0 on a root run) and how many
|
|
// call hops this row is from that root. Columns default, so an older
|
|
// writer reads as a depth-0 root run.
|
|
int64 call_parent_task_id = 36;
|
|
int32 call_depth = 37;
|
|
}
|
|
|
|
// Event mirrors internal/events.Event. Data is carried as a JSON object
|
|
// string (matching the store's own on-disk representation) rather than
|
|
// google.protobuf.Struct, to stay a direct mirror of the existing column.
|
|
message Event {
|
|
int64 id = 1;
|
|
google.protobuf.Timestamp at = 2;
|
|
string kind = 3;
|
|
int64 task_id = 4;
|
|
string repo = 5;
|
|
int64 issue = 6;
|
|
string workflow = 7;
|
|
string stage = 8;
|
|
// attempt is the run this event belongs to. Zero means UNATTRIBUTED, not a
|
|
// first attempt: rows written before the field existed, and the deliberately
|
|
// task-agnostic producers, all carry zero. A reader must report those as
|
|
// unattributable rather than presenting them as one run.
|
|
int64 attempt = 11;
|
|
string detail = 9;
|
|
string data_json = 10;
|
|
// Attribution. actor_id is the identity that performed the action and
|
|
// actor_kind its kind, so a reader can tell an agent's action from a person's
|
|
// without resolving the identity. principal_id is the identity whose authority
|
|
// the action used, which is a different fact when an agent acts under a
|
|
// person's standing approval; empty means unattributed. All three must cross
|
|
// this boundary: a record whose attribution survives only in `detail` is not
|
|
// queryable, which is the attribution this design exists to replace.
|
|
string actor_id = 12;
|
|
string actor_kind = 13;
|
|
string principal_id = 14;
|
|
}
|
|
|
|
// CapturedEvent mirrors storecontract.CapturedEvent.
|
|
message CapturedEvent {
|
|
string id = 1;
|
|
google.protobuf.Timestamp received_at = 2;
|
|
string source = 3;
|
|
string remote_addr = 4;
|
|
string content_type = 5;
|
|
string headers = 6;
|
|
string body = 7;
|
|
bool authenticated = 8;
|
|
// event_type is the ID of the event type the capture was identified as on
|
|
// arrival; empty is unidentified.
|
|
string event_type = 9;
|
|
// unsigned marks an event taken on an approved unsigned source.
|
|
bool unsigned = 10;
|
|
}
|
|
|
|
// EventTypeHeaderCondition mirrors internal/domain/eventtype.HeaderCondition.
|
|
message EventTypeHeaderCondition {
|
|
string name = 1;
|
|
string value = 2;
|
|
}
|
|
|
|
// EventTypePayloadCondition mirrors internal/domain/eventtype.PayloadCondition.
|
|
message EventTypePayloadCondition {
|
|
string path = 1;
|
|
string op = 2;
|
|
string value = 3;
|
|
}
|
|
|
|
// EventType mirrors internal/domain/eventtype.EventType. header_conditions and
|
|
// payload_conditions are its rule; schema maps each payload path to its type.
|
|
message EventType {
|
|
string id = 1;
|
|
string source = 2;
|
|
string name = 3;
|
|
repeated EventTypeHeaderCondition header_conditions = 4;
|
|
repeated EventTypePayloadCondition payload_conditions = 5;
|
|
map<string, string> schema = 6;
|
|
google.protobuf.Timestamp created_at = 7;
|
|
google.protobuf.Timestamp updated_at = 8;
|
|
}
|
|
|
|
// MappingField mirrors internal/domain/mapping.Field.
|
|
message MappingField {
|
|
string name = 1;
|
|
string path = 2;
|
|
string type = 3;
|
|
bool required = 4;
|
|
}
|
|
|
|
// Mapping mirrors internal/domain/mapping.Mapping.
|
|
message Mapping {
|
|
string id = 1;
|
|
string name = 2;
|
|
string source_hint = 3;
|
|
repeated MappingField fields = 4;
|
|
google.protobuf.Timestamp created_at = 5;
|
|
google.protobuf.Timestamp updated_at = 6;
|
|
string event_type_id = 7;
|
|
// match_count and last_matched_at are read-only: the store counts them.
|
|
int64 match_count = 8;
|
|
google.protobuf.Timestamp last_matched_at = 9;
|
|
}
|
|
|
|
// BindingMatcher mirrors internal/domain/binding.Matcher.
|
|
message BindingMatcher {
|
|
string source = 1;
|
|
}
|
|
|
|
// Binding mirrors internal/domain/binding.Binding.
|
|
message Binding {
|
|
string id = 1;
|
|
string name = 2;
|
|
BindingMatcher matcher = 3;
|
|
string mapping_id = 4;
|
|
string workflow = 5;
|
|
string owner = 6;
|
|
string repo = 7;
|
|
int64 version = 8;
|
|
string status = 9;
|
|
reserved 10;
|
|
reserved "secret";
|
|
google.protobuf.Timestamp created_at = 11;
|
|
google.protobuf.Timestamp updated_at = 12;
|
|
string filter = 13;
|
|
// inputs_json assigns workflow inputs, a JSON object of
|
|
// {"param": name} or {"value": constant} per input.
|
|
string inputs_json = 14;
|
|
// repo_param names the mapped parameter holding "owner/name".
|
|
string repo_param = 15;
|
|
}
|
|
|
|
// Source mirrors internal/domain/source.Source.
|
|
message Source {
|
|
string path = 1;
|
|
string signing = 2;
|
|
string secret = 3;
|
|
google.protobuf.Timestamp created_at = 4;
|
|
google.protobuf.Timestamp updated_at = 5;
|
|
}
|
|
|
|
// WorkflowStat mirrors storecontract.WorkflowStat.
|
|
message WorkflowStat {
|
|
string workflow = 1;
|
|
int64 runs = 2;
|
|
int64 merged = 3;
|
|
int64 pr_open = 4;
|
|
int64 parked = 5;
|
|
int64 avg_tokens = 6;
|
|
double avg_steps = 7;
|
|
int64 total_tokens = 8;
|
|
int64 completed = 9;
|
|
}
|
|
|
|
// StageStat mirrors storecontract.StageStat.
|
|
message StageStat {
|
|
string workflow = 1;
|
|
string stage = 2;
|
|
int64 runs = 3;
|
|
int64 avg_ms = 4;
|
|
int64 errors = 5;
|
|
}
|
|
|
|
// DayTokens mirrors storecontract.DayTokens.
|
|
message DayTokens {
|
|
string day = 1;
|
|
int64 tokens = 2;
|
|
}
|
|
|
|
message EnqueueIssueRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
int64 number = 3;
|
|
string title = 4;
|
|
string body = 5;
|
|
string labels = 6;
|
|
string identity = 7;
|
|
}
|
|
message EnqueueIssueResponse { bool inserted = 1; }
|
|
|
|
message EnqueueChatTaskRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
string title = 3;
|
|
string body = 4;
|
|
string workflow = 5;
|
|
string identity = 6;
|
|
}
|
|
message EnqueueChatTaskResponse { Task task = 1; }
|
|
|
|
message ClaimNextRequest {}
|
|
message ClaimNextResponse {
|
|
Task task = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message ClaimByIssueRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
int64 number = 3;
|
|
}
|
|
message ClaimByIssueResponse {
|
|
Task task = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message TransitionRequest {
|
|
int64 task_id = 1;
|
|
string from = 2;
|
|
string to = 3;
|
|
string detail = 4;
|
|
}
|
|
message TransitionResponse {}
|
|
|
|
message StartStepRequest {
|
|
// execution_id is the WorkflowExecution (the tasks row) the step belongs
|
|
// to, and the task ID the run credential is scoped to.
|
|
int64 execution_id = 1;
|
|
int64 attempt = 2;
|
|
// parent_id is 0 when the step is a stage; otherwise it names the enclosing
|
|
// StepExecution, from which the store derives depth.
|
|
int64 parent_id = 3;
|
|
// kind is stage, agent or call.
|
|
string kind = 4;
|
|
string name = 5;
|
|
// called_execution_id names the WorkflowExecution a `call` step started;
|
|
// the store verifies it is this execution's own callee.
|
|
int64 called_execution_id = 6;
|
|
}
|
|
message StartStepResponse {
|
|
int64 step_id = 1;
|
|
// event is the transition's stage_start row, already persisted; the caller
|
|
// publishes it to its bus after the write commits (the daemon's event sink
|
|
// skips already-persisted rows by their assigned ID).
|
|
Event event = 2;
|
|
}
|
|
|
|
message FinishStepRequest {
|
|
// execution_id names the run the step belongs to. The grant check verifies
|
|
// it against the credential, and the store verifies the step really is that
|
|
// execution's, so a caller cannot move another run's step by naming it.
|
|
int64 execution_id = 1;
|
|
int64 step_id = 2;
|
|
string from = 3;
|
|
string to = 4;
|
|
string detail = 5;
|
|
int64 tokens_used = 6;
|
|
}
|
|
message FinishStepResponse {
|
|
// event is the transition's stage_finish row, already persisted.
|
|
Event event = 1;
|
|
}
|
|
|
|
message CancelExecutionRequest {
|
|
int64 task_id = 1;
|
|
// reason records why the run was stopped, in the execution's park reason
|
|
// when the cancel lands there, and on every step event it writes.
|
|
string reason = 2;
|
|
// to is the execution's destination: the transition table routes it, and
|
|
// the operator actions name parked or closed_wont_do.
|
|
string to = 3;
|
|
}
|
|
message CancelExecutionResponse {
|
|
// cancelled_step_ids are the StepExecutions the transaction cancelled.
|
|
repeated int64 cancelled_step_ids = 1;
|
|
}
|
|
|
|
// StepExecution mirrors internal/domain/workflow/task.StepExecution.
|
|
message StepExecution {
|
|
int64 id = 1;
|
|
int64 execution_id = 2;
|
|
int64 attempt = 3;
|
|
// parent_id is 0 for a stage at the tree's root.
|
|
int64 parent_id = 4;
|
|
int32 depth = 5;
|
|
string kind = 6;
|
|
string name = 7;
|
|
string status = 8;
|
|
string detail = 9;
|
|
int64 tokens_used = 10;
|
|
google.protobuf.Timestamp started_at = 11;
|
|
google.protobuf.Timestamp finished_at = 12;
|
|
}
|
|
|
|
message ListStepsRequest {
|
|
int64 execution_id = 1;
|
|
// attempt selects one attempt's steps; 0 lists every attempt of the
|
|
// execution, oldest first -- the dashboard's run-detail rail renders every
|
|
// attempt from a single call rather than one per attempt.
|
|
int64 attempt = 2;
|
|
}
|
|
message ListStepsResponse { repeated StepExecution steps = 1; }
|
|
|
|
// HarnessSecret mirrors internal/domain/harnesssecret.Secret -- one org's
|
|
// captured OAuth token set for a credential binding's service
|
|
// (docs/prds/external-agent-harness.md, Credentials).
|
|
message HarnessSecret {
|
|
string org = 1;
|
|
string service = 2;
|
|
string access_token = 3;
|
|
string refresh_token = 4;
|
|
string token_type = 5;
|
|
google.protobuf.Timestamp expires_at = 6;
|
|
google.protobuf.Timestamp updated_at = 7;
|
|
}
|
|
|
|
message GetHarnessSecretRequest {
|
|
string org = 1;
|
|
string service = 2;
|
|
}
|
|
message GetHarnessSecretResponse { HarnessSecret secret = 1; }
|
|
|
|
message PutHarnessSecretRequest { HarnessSecret secret = 1; }
|
|
message PutHarnessSecretResponse {}
|
|
|
|
message UpdateRequest { Task task = 1; }
|
|
message UpdateResponse {}
|
|
|
|
message RequeueRequest {
|
|
int64 task_id = 1;
|
|
string from_status = 2;
|
|
string workflow = 3;
|
|
}
|
|
message RequeueResponse {}
|
|
|
|
message ParkTaskRequest {
|
|
int64 task_id = 1;
|
|
string from = 2;
|
|
string detail = 3;
|
|
string class = 4;
|
|
}
|
|
message ParkTaskResponse {}
|
|
|
|
message RecoverStaleRequest {}
|
|
message RecoverStaleResponse { int64 count = 1; }
|
|
|
|
message ArchiveTaskRequest {
|
|
int64 task_id = 1;
|
|
string from_status = 2;
|
|
Event audit = 3;
|
|
}
|
|
message ArchiveTaskResponse { int64 event_id = 1; }
|
|
|
|
message RetryTaskRequest {
|
|
int64 task_id = 1;
|
|
string from_status = 2;
|
|
string workflow = 3;
|
|
}
|
|
message RetryTaskResponse {}
|
|
|
|
message BeginRemediationRequest {
|
|
int64 task_id = 1;
|
|
string payload = 2;
|
|
}
|
|
message BeginRemediationResponse {}
|
|
|
|
message UpdateReviewPayloadRequest {
|
|
int64 task_id = 1;
|
|
string payload = 2;
|
|
}
|
|
message UpdateReviewPayloadResponse {}
|
|
|
|
message SetReviewCursorsRequest {
|
|
int64 task_id = 1;
|
|
int64 review_cursor = 2;
|
|
int64 comment_cursor = 3;
|
|
}
|
|
message SetReviewCursorsResponse {}
|
|
|
|
message TaskByIssueRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
int64 number = 3;
|
|
}
|
|
message TaskByIssueResponse {
|
|
Task task = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message OpenTaskByPRRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
int64 number = 3;
|
|
}
|
|
message OpenTaskByPRResponse {
|
|
Task task = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message TaskByIDRequest { int64 task_id = 1; }
|
|
message TaskByIDResponse {
|
|
Task task = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message OpenPRsRequest {}
|
|
message OpenPRsResponse { repeated Task tasks = 1; }
|
|
|
|
message ClearTerminalTasksRequest {}
|
|
message ClearTerminalTasksResponse { int64 count = 1; }
|
|
|
|
message TasksRequest { int64 limit = 1; }
|
|
message TasksResponse { repeated Task tasks = 1; }
|
|
|
|
message StatusCountsRequest {}
|
|
message StatusCountsResponse { map<string, int64> counts = 1; }
|
|
|
|
message InsertEventRequest { Event event = 1; }
|
|
message InsertEventResponse { int64 id = 1; }
|
|
|
|
message EventsSinceRequest {
|
|
// since_id is the opaque resume cursor returned by the previous page (the SSE
|
|
// id: field, echoed back as Last-Event-ID). Empty means "from the
|
|
// beginning". The field keeps its name and number so the wire name stays
|
|
// put; only its type widened, from the SQLite rowid to the fixed-width
|
|
// "<at>|<row id>" cursor.
|
|
string since_id = 1;
|
|
int64 limit = 2;
|
|
}
|
|
message EventsSinceResponse { repeated Event events = 1; }
|
|
|
|
message TaskEventsRequest { int64 task_id = 1; }
|
|
message TaskEventsResponse { repeated Event events = 1; }
|
|
|
|
message WorkflowStatsRequest {}
|
|
message WorkflowStatsResponse { repeated WorkflowStat stats = 1; }
|
|
|
|
message StageStatsRequest {}
|
|
message StageStatsResponse { repeated StageStat stats = 1; }
|
|
|
|
message TokensByDayRequest { int64 days = 1; }
|
|
message TokensByDayResponse { repeated DayTokens tokens = 1; }
|
|
|
|
// ConfigSnapshot carries the dashboard's configuration projection. document
|
|
// is opaque to the store: its shape belongs to the producer and the page that
|
|
// reads it, and schema names that shape so a reader can refuse one it does
|
|
// not understand. It is secret-free at the producer -- the projection carries
|
|
// an API key's environment variable name and whether it resolved, never a
|
|
// value.
|
|
message ConfigSnapshot {
|
|
string schema = 1;
|
|
bytes document = 2;
|
|
google.protobuf.Timestamp published_at = 3;
|
|
}
|
|
message PutConfigSnapshotRequest { ConfigSnapshot snapshot = 1; }
|
|
message PutConfigSnapshotResponse {}
|
|
message GetConfigSnapshotRequest {}
|
|
message GetConfigSnapshotResponse {
|
|
ConfigSnapshot snapshot = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
// ChannelStatus is one channel's runtime state, as the process hosting it
|
|
// observes it. ReloadSupported is a capability declaration, not a request: the
|
|
// service reports it, so a reader may offer a reload action -- but asking for one
|
|
// travels on its own surface, because a transient request and a durable state do
|
|
// not share a lifetime.
|
|
message ChannelStatus {
|
|
string id = 1;
|
|
string name = 2;
|
|
string state = 3;
|
|
string detail = 4;
|
|
bool configured = 5;
|
|
bool reload_supported = 6;
|
|
google.protobuf.Timestamp observed_at = 7;
|
|
}
|
|
message PutChannelStatusRequest { repeated ChannelStatus channels = 1; }
|
|
message PutChannelStatusResponse {}
|
|
message ListChannelStatusRequest {}
|
|
message ListChannelStatusResponse { repeated ChannelStatus channels = 1; }
|
|
|
|
// ApplyStatus is one process's report about one control-plane resource kind.
|
|
// applied_version is the version that process is running; error is set when it
|
|
// could not apply what the store returned, and leaves applied_version at the
|
|
// last version it did apply. reported_at is re-stamped on an interval, so a
|
|
// record older than the staleness window belongs to a process that has stopped
|
|
// running (docs/prds/control-plane-apply-status.md).
|
|
message ApplyStatus {
|
|
string process = 1;
|
|
string kind = 2;
|
|
int64 applied_version = 3;
|
|
string error = 4;
|
|
google.protobuf.Timestamp reported_at = 5;
|
|
}
|
|
message PutApplyStatusRequest { ApplyStatus status = 1; }
|
|
message PutApplyStatusResponse {}
|
|
message ListApplyStatusRequest {}
|
|
message ListApplyStatusResponse { repeated ApplyStatus statuses = 1; }
|
|
|
|
// TaskLogEntry mirrors internal/logging.Entry: one decoded log line. fields
|
|
// carries every remaining key as a JSON object string, the same way Event
|
|
// carries its data, so structured context survives the hop without this
|
|
// contract having to know what a call site attached.
|
|
message TaskLogEntry {
|
|
int64 id = 1;
|
|
google.protobuf.Timestamp time = 2;
|
|
string level = 3;
|
|
string msg = 4;
|
|
string fields_json = 5;
|
|
}
|
|
|
|
// ReadTaskLog returns a page of one task attempt's decoded log. attempt is the
|
|
// attempt the caller resolved (the dashboard sends the task's current attempt
|
|
// when the request omitted one). levels, component, contains, since and until
|
|
// carry the whole query the logging package's Tail accepts -- the wire mirrors
|
|
// that query rather than a subset of it, so a filter cannot silently stop
|
|
// working by crossing the boundary. limit is caller-capped
|
|
// (docs/prds/state-store-contract.md §8: the log cap is 2000).
|
|
message ReadTaskLogRequest {
|
|
int64 task_id = 1;
|
|
int64 attempt = 2;
|
|
int64 limit = 3;
|
|
repeated string levels = 4;
|
|
string component = 5;
|
|
string contains = 6;
|
|
google.protobuf.Timestamp since = 7;
|
|
google.protobuf.Timestamp until = 8;
|
|
// stage filters on an entry's own "stage" field. Only entries a stage
|
|
// tagged carry one -- agent and tool output is logged without a stage, so a
|
|
// stage filter narrows the file rather than covering it. Empty means any.
|
|
string stage = 9;
|
|
}
|
|
// found=false is not an error: the task has no log file for that attempt.
|
|
// That is a different condition from a process that cannot read logs at all
|
|
// (codes.Unavailable), and the dashboard reports them differently.
|
|
message ReadTaskLogResponse {
|
|
repeated TaskLogEntry entries = 1;
|
|
bool truncated = 2;
|
|
int64 attempt = 3;
|
|
bool found = 4;
|
|
repeated string components = 5;
|
|
// file is the path read, so the page can name where the log came from. It
|
|
// is the state directory's own layout, reported to an already-authenticated
|
|
// operator; no caller is expected to open it.
|
|
string file = 6;
|
|
}
|
|
|
|
// StreamTaskLogContent returns one attempt's log verbatim, for a download. The
|
|
// bytes are the file's own JSONL, not a re-encoding of it: this contract
|
|
// transports the log, it does not restate the format. found=false, with no
|
|
// chunks, means the attempt has no log file -- not an error.
|
|
message StreamTaskLogContentRequest {
|
|
int64 task_id = 1;
|
|
int64 attempt = 2;
|
|
}
|
|
message StreamTaskLogContentResponse {
|
|
bytes chunk = 1;
|
|
int64 attempt = 2;
|
|
bool found = 3;
|
|
}
|
|
|
|
message InsertCaptureRequest {
|
|
CapturedEvent capture = 1;
|
|
int64 retention_seconds = 2;
|
|
int64 max_events = 3;
|
|
}
|
|
message InsertCaptureResponse { string id = 1; }
|
|
|
|
message StreamCapturesRequest { int64 limit = 1; }
|
|
// Streamed one capture per message; see StreamCaptures above.
|
|
message StreamCapturesResponse { CapturedEvent capture = 1; }
|
|
|
|
message InsertMappingRequest { Mapping mapping = 1; }
|
|
message InsertMappingResponse { string id = 1; }
|
|
|
|
message GetMappingRequest { string id = 1; }
|
|
message GetMappingResponse {
|
|
Mapping mapping = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message ListMappingsRequest {}
|
|
message ListMappingsResponse { repeated Mapping mappings = 1; }
|
|
|
|
message UpdateMappingRequest { Mapping mapping = 1; }
|
|
message UpdateMappingResponse {}
|
|
|
|
message DeleteMappingRequest { string id = 1; }
|
|
message DeleteMappingResponse {}
|
|
|
|
message RecordMappingMatchRequest {
|
|
string mapping_id = 1;
|
|
string capture_id = 2;
|
|
}
|
|
message RecordMappingMatchResponse {}
|
|
|
|
message InsertEventTypeRequest { EventType event_type = 1; }
|
|
message InsertEventTypeResponse { string id = 1; }
|
|
|
|
message UpdateEventTypeRequest { EventType event_type = 1; }
|
|
message UpdateEventTypeResponse {}
|
|
|
|
message DeleteEventTypeRequest { string id = 1; }
|
|
message DeleteEventTypeResponse {}
|
|
|
|
message ListEventTypesRequest {}
|
|
message ListEventTypesResponse { repeated EventType event_types = 1; }
|
|
|
|
message InsertBindingRequest { Binding binding = 1; }
|
|
message InsertBindingResponse { string id = 1; }
|
|
|
|
message GetBindingRequest { string id = 1; }
|
|
message GetBindingResponse {
|
|
Binding binding = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message ListBindingsRequest {}
|
|
message ListBindingsResponse { repeated Binding bindings = 1; }
|
|
|
|
message UpdateBindingRequest { Binding binding = 1; }
|
|
message UpdateBindingResponse {}
|
|
|
|
message DeleteBindingRequest { string id = 1; }
|
|
message DeleteBindingResponse {}
|
|
|
|
message ApproveBindingRequest { string id = 1; }
|
|
message ApproveBindingResponse {}
|
|
|
|
message InsertSourceRequest { Source source = 1; }
|
|
message InsertSourceResponse {}
|
|
|
|
message GetSourceRequest { string path = 1; }
|
|
message GetSourceResponse {
|
|
Source source = 1;
|
|
bool found = 2;
|
|
}
|
|
|
|
message ListSourcesRequest {}
|
|
message ListSourcesResponse { repeated Source sources = 1; }
|
|
|
|
message SetSourceSigningRequest {
|
|
string path = 1;
|
|
string from = 2;
|
|
string to = 3;
|
|
}
|
|
message SetSourceSigningResponse {}
|
|
|
|
message SetSourceSecretRequest {
|
|
string path = 1;
|
|
string secret = 2;
|
|
}
|
|
message SetSourceSecretResponse {}
|
|
|
|
message ArmedBindingsForSourceRequest { string source = 1; }
|
|
message ArmedBindingsForSourceResponse { repeated Binding bindings = 1; }
|
|
|
|
message RecordDispatchRequest {
|
|
string binding_id = 1;
|
|
int64 binding_version = 2;
|
|
string capture_id = 3;
|
|
// task_id addresses the tasks table.
|
|
int64 task_id = 4;
|
|
}
|
|
message RecordDispatchResponse {}
|
|
|
|
message RecordPlaybookDispatchRequest {
|
|
string playbook_id = 1;
|
|
string playbook_version = 2;
|
|
string event_id = 3;
|
|
string action_id = 4;
|
|
}
|
|
message RecordPlaybookDispatchResponse {}
|
|
|
|
message DeletePlaybookDispatchesRequest { string playbook_id = 1; }
|
|
message DeletePlaybookDispatchesResponse {}
|
|
|
|
message StreamUndispatchedCapturesRequest {
|
|
repeated string sources = 1;
|
|
int64 limit = 2;
|
|
}
|
|
// Streamed one capture per message; see StreamUndispatchedCaptures above.
|
|
message StreamUndispatchedCapturesResponse { CapturedEvent capture = 1; }
|
|
|
|
message EnqueueBindingTaskRequest {
|
|
string owner = 1;
|
|
string repo = 2;
|
|
string title = 3;
|
|
string body = 4;
|
|
string workflow = 5;
|
|
string identity = 6;
|
|
string binding_id = 7;
|
|
int64 binding_version = 8;
|
|
string inputs_json = 9;
|
|
}
|
|
message EnqueueBindingTaskResponse { Task task = 1; }
|
|
|
|
// workflow.call: the caller's grant names the caller; the store derives the
|
|
// rest from the caller's row (docs/prds/workflow-calls.md).
|
|
message EnqueueCallTaskRequest {
|
|
int64 caller_task_id = 1;
|
|
string workflow = 2;
|
|
string inputs_json = 3;
|
|
}
|
|
message EnqueueCallTaskResponse {
|
|
Task task = 1;
|
|
bool accepted = 2;
|
|
}
|
|
|
|
message WorkflowCallStatusRequest {
|
|
int64 caller_task_id = 1;
|
|
int64 call_task_id = 2;
|
|
}
|
|
message WorkflowCallStatusResponse {
|
|
// status is the callee's task status and detail its latest transition
|
|
// detail (empty before the callee first moves).
|
|
string status = 1;
|
|
string detail = 2;
|
|
}
|
|
|
|
message InstalledPackage {
|
|
string org_id = 1;
|
|
string name = 2;
|
|
string reference = 3;
|
|
string digest = 4;
|
|
bytes descriptor_json = 5;
|
|
bytes layer = 6;
|
|
string update_policy = 7;
|
|
}
|
|
message InstallPackageRequest {
|
|
string org_id = 1;
|
|
string name = 2;
|
|
string reference = 3;
|
|
string digest = 4;
|
|
}
|
|
message InstallPackageResponse { InstalledPackage package = 1; }
|
|
message GetInstalledPackageRequest { string org_id = 1; string name = 2; }
|
|
message GetInstalledPackageResponse { InstalledPackage package = 1; }
|
|
message ListInstalledPackagesRequest { string org_id = 1; }
|
|
message ListInstalledPackagesResponse { repeated InstalledPackage packages = 1; }
|
|
message RemoveInstalledPackageRequest { string org_id = 1; string name = 2; }
|
|
message RemoveInstalledPackageResponse {}
|
|
|
|
// Task mirrors internal/domain/workflow.Task.
|
|
|
|
message GetPrincipalRequest { string identity_id = 1; }
|
|
// PrincipalMembership mirrors org.Membership: an identity's role in an org,
|
|
// or in one workspace of it.
|
|
message PrincipalMembership {
|
|
string org_id = 1;
|
|
string workspace_id = 2;
|
|
string role = 3;
|
|
}
|
|
message AccessPrincipal {
|
|
string identity_id = 1;
|
|
string org_id = 2;
|
|
repeated PrincipalMembership memberships = 3;
|
|
}
|
|
message GetPrincipalResponse { AccessPrincipal principal = 1; }
|
|
|
|
// AccessPolicy mirrors internal/domain/access.Policy: one Cedar policy
|
|
// document and the level-scope tuple that places it in the chain.
|
|
message AccessPolicy {
|
|
string policy_id = 1;
|
|
string level = 2;
|
|
string org_id = 3;
|
|
string workspace_id = 4;
|
|
string object_kind = 5;
|
|
string object_id = 6;
|
|
string text = 7;
|
|
}
|
|
message ListPoliciesRequest {}
|
|
message ListPoliciesResponse { repeated AccessPolicy policies = 1; }
|
|
message PutPolicyRequest { AccessPolicy policy = 1; }
|
|
message PutPolicyResponse { int64 version = 1; }
|
|
message DeletePolicyRequest { AccessPolicy policy = 1; }
|
|
message DeletePolicyResponse {}
|
|
message EnsureShippedOrgPoliciesRequest { string org_id = 1; }
|
|
message EnsureShippedOrgPoliciesResponse {}
|
|
// AccessDenial mirrors internal/domain/access.Denial: one refusal with the
|
|
// level that decided it and the deciding policies. The store coalesces
|
|
// identical denials within a minute into one row with a count.
|
|
message AccessDenial {
|
|
string org_id = 1;
|
|
string principal = 2;
|
|
string action = 3;
|
|
string resource_kind = 4;
|
|
string resource_id = 5;
|
|
string level = 6;
|
|
repeated string policies = 7;
|
|
int64 count = 8;
|
|
google.protobuf.Timestamp at = 9;
|
|
}
|
|
message RecordDenialRequest { AccessDenial denial = 1; }
|
|
message RecordDenialResponse {}
|
|
message ListDenialsRequest { string org_id = 1; int32 limit = 2; }
|
|
message ListDenialsResponse { repeated AccessDenial denials = 1; }
|