Files
archie/proto/state/v1/state.proto
T
sam d6f526ce4f feat(state): carry channel lifecycle from the Messaging Service to the dashboard
archie-core-8cda.6.8's carrier. The service now records channel lifecycle and has
nowhere to put it: /api/channels answered with nothing because
webui.Server.Channels had no production source, and reload answered 501 for the
same reason. This adds the surface the register decided on, following the split
archie-core-ymut established for config snapshots -- a pair of administrative RPCs
whose writer is one process and whose reader is the UI -- and wires both ends.

Wire and store: PutChannelStatus / ListChannelStatus, with ChannelStatus carrying
id, name, state, detail, configured, reload_supported and observed_at. The store
holds one row per channel and replaces the reported set, so a channel the reporter
no longer mentions is deleted rather than left standing as a stale "running"; an
empty report clears the table, because hosting no channels is a fact worth
reporting. A row without an id is refused: it could never be replaced or removed
by a later report.

Writer: the service publishes on every lifecycle transition through a coalescing
signal -- a burst of transitions is one write, since a reader only wants the latest
state of every channel -- plus a start-up report and a final report after shutdown,
so a stopped service leaves the store honest. A failed write is logged and retried
on the next signal; the dashboard losing channel state is worth a warning and never
worth failing a channel start over.

Reader: webui.Server.Channels becomes a source rather than a concrete manager, and
webui.RemoteChannelStatus reads the store the way RemoteConfigView reads the config
snapshot. A store it cannot reach reports nothing rather than a stale "running",
and a state the reader does not recognise is carried through rather than dropped.

The contract's own index gains the group in the same change that adds the RPCs --
a surface the grouped table does not list is one nobody finds -- and the count moves
to 51. The register records why the surface is the State Store rather than a
resource kind, and why reload gets its own surface rather than a field here: reading
status must not be able to retrigger an action, a transient request is not
distinguishable from state once anything polls it, and it would invert the
writer/reader relationship the precedent establishes.

Verified: task check exit 0. New coverage: the store's replace-the-set semantics
and its refusal of an id-less row, the reader's mapping including an unknown state,
and the publisher's start-up, transition and final reports.
2026-09-22 08:04:44 +10:00

678 lines
24 KiB
Protocol Buffer

syntax = "proto3";
package state.v1;
import "google/protobuf/timestamp.proto";
// StateStore is the single gRPC service fronting archie.db (one store, one
// file). 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 stays
// producer-owned in internal/store. Both are served by the same service and
// the same *store.Store implementation; the proto bypasses the Go
// interfacebloat cap (max 8), like gateway.v1.ChatService does.
service StateStoreService {
// 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);
// 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);
rpc Requeue(RequeueRequest) returns (RequeueResponse);
rpc RecoverStale(RecoverStaleRequest) returns (RecoverStaleResponse);
// Archive / Retry
rpc ArchiveTask(ArchiveTaskRequest) returns (ArchiveTaskResponse);
rpc RetryTask(RetryTaskRequest) returns (RetryTaskResponse);
// 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);
// ListCaptures is superseded by StreamCaptures (kept, unmodified, so an
// in-flight rolling deploy's old client/server pairing keeps working --
// buf breaking forbids removing or reshaping an existing RPC). Every
// in-repo caller uses StreamCaptures.
rpc ListCaptures(ListCapturesRequest) returns (ListCapturesResponse) {
option deprecated = true;
}
// 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);
// 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);
// 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);
// ListUndispatchedCaptures is superseded by StreamUndispatchedCaptures; see
// ListCaptures above.
rpc ListUndispatchedCaptures(ListUndispatchedCapturesRequest) returns (ListUndispatchedCapturesResponse) {
option deprecated = true;
}
rpc StreamUndispatchedCaptures(StreamUndispatchedCapturesRequest) returns (stream StreamUndispatchedCapturesResponse);
// BindingTaskCreator
rpc EnqueueBindingTask(EnqueueBindingTaskRequest) returns (EnqueueBindingTaskResponse);
}
// Task mirrors internal/domain/workflow.Task.
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; }
// 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;
string stage = 10;
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;
int64 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;
}
// 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;
}
// CapturedEvent mirrors internal/store.CapturedEvent.
message CapturedEvent {
int64 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;
}
// 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 {
int64 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;
}
// BindingMatcher mirrors internal/domain/binding.Matcher.
message BindingMatcher {
string source = 1;
}
// Binding mirrors internal/domain/binding.Binding.
message Binding {
int64 id = 1;
string name = 2;
BindingMatcher matcher = 3;
int64 mapping_id = 4;
string workflow = 5;
string owner = 6;
string repo = 7;
int64 version = 8;
string status = 9;
string secret = 10;
google.protobuf.Timestamp created_at = 11;
google.protobuf.Timestamp updated_at = 12;
}
// WorkflowStat mirrors internal/store.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;
}
// StageStat mirrors internal/store.StageStat.
message StageStat {
string workflow = 1;
string stage = 2;
int64 runs = 3;
int64 avg_ms = 4;
int64 errors = 5;
}
// DayTokens mirrors internal/store.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 UpdateRequest { Task task = 1; }
message UpdateResponse {}
message RequeueRequest {
int64 task_id = 1;
string from_status = 2;
string workflow = 3;
}
message RequeueResponse {}
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 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 {
int64 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 { int64 id = 1; }
message ListCapturesRequest { int64 limit = 1; }
message ListCapturesResponse { repeated CapturedEvent captures = 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 { int64 id = 1; }
message GetMappingRequest { int64 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 { int64 id = 1; }
message DeleteMappingResponse {}
message InsertBindingRequest { Binding binding = 1; }
message InsertBindingResponse { int64 id = 1; }
message GetBindingRequest { int64 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 { int64 id = 1; }
message DeleteBindingResponse {}
message ApproveBindingRequest { int64 id = 1; }
message ApproveBindingResponse {}
message ArmedBindingsForSourceRequest { string source = 1; }
message ArmedBindingsForSourceResponse { repeated Binding bindings = 1; }
message RecordDispatchRequest {
int64 binding_id = 1;
int64 binding_version = 2;
int64 capture_id = 3;
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 ListUndispatchedCapturesRequest {
repeated string sources = 1;
int64 limit = 2;
}
message ListUndispatchedCapturesResponse { repeated CapturedEvent captures = 1; }
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;
int64 binding_id = 7;
int64 binding_version = 8;
}
message EnqueueBindingTaskResponse { Task task = 1; }