fix(connectors,runs): an approved action runs as judged however its input was re-encoded, and one that can't be confirmed is reported as unknown (archie #1985, #1990)

This commit is contained in:
sam committed 2026-11-16 04:08:15 +11:00
1 parent 0238f247e5
commit 3a700cddfa
4 files changed
+120 -6

No files matched your search

+8 -1
View File
@@ -182,6 +182,13 @@ func (m *Module) Answer(ctx context.Context, id uuid.UUID, by, via string, appro
return requestOf(row, judgement.Decision{}), nil
}
// Settle answers a request on one of the channels that carries it, which is
// what a Telegram tap calls. It reports only whether the answer was taken.
func (m *Module) Settle(ctx context.Context, id uuid.UUID, by, via string, approved bool) error {
_, err := m.Answer(ctx, id, by, via, approved)
return err
}
// Expire settles a request whose deadline passed, so the trail shows why it
// never ran.
func (m *Module) Expire(ctx context.Context, id uuid.UUID) error {
@@ -315,7 +322,7 @@ func answerText(a Answer) string {
if a.Approved {
verb = "Approved"
}
return fmt.Sprintf("%s by %s on the %s.", verb, a.By, a.Via)
return fmt.Sprintf("%s by %s in the %s.", verb, a.By, a.Via)
}
// Summary is what a person is shown about the action they are asked to allow:
+17 -2
View File
@@ -255,6 +255,7 @@ func (c *Connector) Invoke(ctx context.Context, inv Invocation) (string, error)
if !a.effect.ReadOnly && !a.idempotent {
return "", fmt.Errorf("connector %q: action %q: %w", c.name, inv.Action, ErrNotIdempotent)
}
inv.Input = Canonical(inv.Input)
digest := Digest(inv.Action, inv.Input)
resp, err := c.client.Invoke(ctx, &pb.InvokeRequest{
Action: inv.Action, Input: inv.Input, IdempotencyKey: inv.IdempotencyKey, Digest: digest,
@@ -266,7 +267,7 @@ func (c *Connector) Invoke(ctx context.Context, inv Invocation) (string, error)
return "", fmt.Errorf("connector %q: action %q: %w", c.name, inv.Action, ErrDigestMismatch)
}
if resp.GetOutcomeUnknown() {
return "", fmt.Errorf("connector %q: action %q: %w", c.name, inv.Action, ErrOutcomeUnknown)
return "", fmt.Errorf("connector %q: action %q: %w: %s", c.name, inv.Action, ErrOutcomeUnknown, resp.GetOutput())
}
return string(resp.GetOutput()), nil
}
@@ -305,10 +306,24 @@ func Digest(action string, input jsontext.Value) string {
h := sha256.New()
h.Write([]byte(action))
h.Write([]byte{0})
h.Write(input)
h.Write(Canonical(input))
return hex.EncodeToString(h.Sum(nil))
}
// Canonical is the form an input is hashed and sent in. Two spellings of the
// same JSON are the same action, so the bytes mustn't depend on spacing or key
// order: an input that has been through a step record or a decision body comes
// back spelled differently, and an action must still run as the one judged.
// RFC 8785's form keeps a number's exact digits, so two large ids stay two
// actions.
func Canonical(input jsontext.Value) jsontext.Value {
out := slices.Clone(input)
if err := out.Canonicalize(jsontext.CanonicalizeRawInts(false)); err != nil {
return input
}
return out
}
func effectFrom(e *pb.Effect) Effect {
return Effect{ReadOnly: e.GetReadOnly(), Reversibility: Reversibility(e.GetReversibility()), Summary: e.GetSummary()}
}
+75
View File
@@ -0,0 +1,75 @@
package connectors
import (
"encoding/json/jsontext"
json "encoding/json/v2"
"testing"
)
// TestDigestIgnoresHowJSONIsSpelled guards the rule that makes an approval
// mean one action: an input that has been through a step record or a decision
// body comes back re-encoded, and the digest over it must match the digest of
// what the agent wrote. A digest that changed would refuse a judged action as
// altered, so an approved action would never run.
func TestDigestIgnoresHowJSONIsSpelled(t *testing.T) {
tests := []struct {
name string
a jsontext.Value
b jsontext.Value
same bool
}{
{
name: "spacing doesn't change the action",
a: jsontext.Value(`{"clean_dir": "/tmp", "host": "web-1"}`),
b: jsontext.Value(`{"clean_dir":"/tmp","host":"web-1"}`),
same: true,
},
{
name: "key order doesn't change the action",
a: jsontext.Value(`{"host":"web-1","clean_dir":"/tmp"}`),
b: jsontext.Value(`{"clean_dir":"/tmp","host":"web-1"}`),
same: true,
},
{
name: "two large ids are two actions",
a: jsontext.Value(`{"id":9007199254740993}`),
b: jsontext.Value(`{"id":9007199254740992}`),
same: false,
},
{
name: "a different value is a different action",
a: jsontext.Value(`{"host":"web-1","clean_dir":"/tmp"}`),
b: jsontext.Value(`{"host":"web-1","clean_dir":"/var/tmp"}`),
same: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := Digest("clean", tt.a) == Digest("clean", tt.b)
if got != tt.same {
t.Fatalf("same digest = %v, want %v", got, tt.same)
}
})
}
}
// TestDigestSurvivesAStepRecord is the same rule through the encoding a run
// actually puts an input through: a value marshalled into a step and read back.
func TestDigestSurvivesAStepRecord(t *testing.T) {
judged := jsontext.Value(`{"host": "web-1", "older_than_hours": "24"}`)
recorded, err := json.Marshal(struct {
Input jsontext.Value `json:"input"`
}{Input: judged})
if err != nil {
t.Fatalf("encode: %v", err)
}
var back struct {
Input jsontext.Value `json:"input"`
}
if err := json.Unmarshal(recorded, &back); err != nil {
t.Fatalf("decode: %v", err)
}
if Digest("clean", back.Input) != Digest("clean", judged) {
t.Fatalf("digest changed through a step record: %s vs %s", back.Input, judged)
}
}
+20 -3
View File
@@ -141,6 +141,9 @@ type approvalOutcome struct {
By string `json:"by,omitzero"`
Result string `json:"result,omitzero"`
Error string `json:"error,omitzero"`
// Unknown is an action that was started but can't be confirmed: it may
// have taken effect, and it is never started again.
Unknown bool `json:"unknown,omitzero"`
}
// settleProposals puts every action judgement held to a person, one at a time,
@@ -198,9 +201,19 @@ func settleOne(rc *Context, judge Judge, ask Approver, d judgement.Decision, dea
// has recorded it, so the investigation still reports.
run, runErr := runApproved(rc, judge, d, answer)
out.State, out.Result, out.Error = approvals.StateApproved, run, errText(runErr)
out.Unknown = errors.Is(runErr, ErrOutcomeUnknown)
return out, nil
}
// unknownOutcome records a connector's unconfirmed action as a step whose
// outcome is unknown, so a resumed run reports it and never runs it again.
func unknownOutcome(err error) error {
if errors.Is(err, connectors.ErrOutcomeUnknown) {
return fmt.Errorf("%w: %w", ErrOutcomeUnknown, err)
}
return err
}
// errText is a failed action's reason, or nothing when it ran.
func errText(err error) string {
if err == nil {
@@ -248,11 +261,13 @@ func runApproved(rc *Context, judge Judge, d judgement.Decision, answer approval
case fresh.Level == judgement.Never:
return "", fmt.Errorf("refused after approval: %s", fresh.Reason)
case fresh.Level.Runs():
return judge.Execute(ctx, fresh, d.Action.Input, key)
out, err := judge.Execute(ctx, fresh, d.Action.Input, key)
return out, unknownOutcome(err)
case fresh.Level > d.Level:
return "", fmt.Errorf("judgement got worse after approval: now %s", fresh.Level)
}
return judge.ExecuteApproved(ctx, d, answer.Approval(d), d.Action.Input, key)
out, err := judge.ExecuteApproved(ctx, d, answer.Approval(d), d.Action.Input, key)
return out, unknownOutcome(err)
})
}
@@ -298,8 +313,10 @@ func outcomeLines(outcomes []approvalOutcome) string {
for _, o := range outcomes {
line := fmt.Sprintf("- %s on %s: %s", o.Action, o.Target, o.State)
switch {
case o.Unknown:
line += ", it was started but its outcome is unknown: " + o.Error
case o.Error != "":
line += ", " + o.Error
line += ", it did not run: " + o.Error
case o.Result != "":
line += ", it ran: " + o.Result
case o.State == approvals.StateApproved: