Files
archie/internal/infrastructure/gatewayrpc/client.go
T
sam 3902b7ecbc feat(identity): attribute a task action to the identity that acted
The transport could carry an actor and nothing filled it. It does now, so a
dashboard approval is recorded as the person whose credential verified, and an
agent's token is recorded as the agent's action -- for an agent, agent_approved;
for a person, human_approved; and for a caller whose identity archie could not
verify, task_approved, which claims nothing about who did it.

The actor travels the path the action takes: webui reads it from the request
context the middleware resolved, carries it in the gateway request, the daemon
passes it through the in-process adapter, and the NATS request body carries it to
the service that records it. Scope stays separate from actor at every hop, because
scope is which task a caller may touch and the actor is who touched it.

A chat channel's bound identity is an actor too: a bot acting on its own channel's
task is recorded as an agent's action rather than a person's, via ActorFromScope,
whose empty kind is what keeps it out of human_approved. The agent-facing
task_action tool passes that identity and never input["identity"].

The UI process's credential check is now filled by endpoint references rather than
by configuration: -oidc-issuer and -oidc-audience on archie-ui, two URLs the
process already understands the shape of, with the verifier built in Run because
cmd/ parses flags and nothing else. The UI package still never reads config, and a
configured provider that cannot be reached fails boot rather than falling back to
the gate that names nobody.

Evidence for this change, stated as measured: go build ./... and go vet ./... are
clean, and every package this touches passes -- webui, domain/taskactions,
infrastructure/taskactions, infrastructure/gatewayrpc, gateway, app/archieui,
app/archied, domain/messaging, channels/telegram, cmd/archie-ui. task check could
not be run to completion: it fails in cmd/archie-messaging on an untracked
internal/buildinfo package another lane has in flight, which is not this change and
was left untouched. The end-to-end flip is covered in
internal/webui/api_tasks_actor_test.go: a person's credential produces a record
naming that person with human_approved, an agent's produces agent_approved, an
unverified request produces task_approved with no actor, and a request carrying
forged actor fields cannot name one.
2026-09-22 14:52:10 +10:00

138 lines
4.5 KiB
Go

// Package gatewayrpc adapts the Gateway chat contract to gRPC.
package gatewayrpc
import (
"context"
"errors"
"io"
"google.golang.org/grpc"
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/taskactions"
"github.com/samcharles93/archie-core/internal/taskstate"
)
var _ messaging.ChatContract = (*Client)(nil)
// Client implements messaging.ChatContract over the chat service. The proto
// is unchanged by the messaging migration, so history crosses without its
// role and is re-addressed from the owning session on arrival; StoreClient
// serves the SessionStore view over the same RPCs.
type Client struct{ client pb.ChatServiceClient }
func NewClient(conn grpc.ClientConnInterface) *Client {
return &Client{client: pb.NewChatServiceClient(conn)}
}
func (c *Client) Snapshot(ctx context.Context) (messaging.ChatSnapshot, error) {
v, err := c.client.Snapshot(ctx, &pb.SnapshotRequest{})
if err != nil {
return messaging.ChatSnapshot{}, err
}
return snapshotValue(v), nil
}
func (c *Client) GetSession(ctx context.Context, id string) (messaging.SessionContext, bool, error) {
v, err := c.client.GetSession(ctx, &pb.GetSessionRequest{SessionId: id})
if err != nil {
return messaging.SessionContext{}, false, err
}
return sessionValue(v.Session), v.Found, nil
}
func (c *Client) RecentMessages(ctx context.Context, id string, n int) ([]messaging.Message, error) {
v, err := c.client.RecentMessages(ctx, &pb.RecentMessagesRequest{SessionId: id, Limit: int64(n)})
if err != nil {
return nil, err
}
return addressRecords(ctx, c.client, id, v.Messages)
}
func (c *Client) RecentTurns(ctx context.Context, id string, n int) ([]messaging.TurnRecord, error) {
v, err := c.client.RecentTurns(ctx, &pb.RecentTurnsRequest{SessionId: id, Limit: int64(n)})
if err != nil {
return nil, err
}
return mapValues(v.Turns, turnValue), nil
}
func (c *Client) Route(ctx context.Context, in messaging.Inbound) (messaging.ChatReply, error) {
v, err := c.client.Route(ctx, &pb.RouteRequest{Message: inboundProto(in)})
if err != nil {
return messaging.ChatReply{}, err
}
return messaging.ChatReply{Text: v.Text, SessionID: v.SessionId}, nil
}
func (c *Client) Cancel(ctx context.Context, id string) (messaging.ChatCancellation, error) {
v, err := c.client.Cancel(ctx, &pb.CancelRequest{SessionId: id})
if err != nil {
return messaging.ChatCancellation{}, err
}
return messaging.ChatCancellation{Cancelled: v.Cancelled, Dropped: int(v.Dropped)}, nil
}
func (c *Client) SetPersona(ctx context.Context, id, name string) (bool, error) {
v, err := c.client.SetPersona(ctx, &pb.SetPersonaRequest{SessionId: id, Name: name})
if err != nil {
return false, err
}
return v.Found, nil
}
func (c *Client) ApplyTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action) (messaging.TaskActionResult, error) {
v, err := c.client.ApplyTaskAction(ctx, &pb.ApplyTaskActionRequest{Identity: identity, TaskId: taskID, Action: string(action)})
if err != nil {
return messaging.TaskActionResult{}, taskActionError(err)
}
return messaging.TaskActionResult{TaskID: v.TaskId, Action: v.Action, Message: v.Message}, nil
}
func (c *Client) ApplyOperatorTaskAction(ctx context.Context, actor taskactions.Actor, taskID int64, action taskstate.Action) (messaging.TaskActionResult, error) {
v, err := c.client.ApplyOperatorTaskAction(ctx, &pb.ApplyOperatorTaskActionRequest{
TaskId: taskID,
Action: string(action),
ActorId: string(actor.Identity),
ActorKind: string(actor.Kind),
PrincipalId: string(actor.Principal),
})
if err != nil {
return messaging.TaskActionResult{}, taskActionError(err)
}
return messaging.TaskActionResult{TaskID: v.TaskId, Action: v.Action, Message: v.Message}, nil
}
func (c *Client) Stream(ctx context.Context, in messaging.Inbound) (<-chan messaging.ChatEvent, error) {
stream, err := c.client.Stream(ctx, &pb.StreamRequest{Message: inboundProto(in)})
if err != nil {
return nil, err
}
out := make(chan messaging.ChatEvent)
go func() {
defer close(out)
for {
v, err := stream.Recv()
if errors.Is(err, io.EOF) {
return
}
var event messaging.ChatEvent
if err != nil {
event = messaging.ChatEvent{Kind: "error", Text: err.Error()}
} else {
event = eventValue(v)
}
select {
case out <- event:
case <-ctx.Done():
return
}
if err != nil {
return
}
}
}()
return out, nil
}