refactor(lint): extract more helpers to clear nestif/gocyclo findings
- toolset.go: extract requireApproval out of toolExecute (nestif) - gateway.go: extract handleDeny/handleVersion/handleUpdateCheck/ handleRestartAdapter out of dispatchLocal (gocyclo 26 -> under 20) - cronstore/store.go: extract applyPatch/applyScheduleChange out of Update (nestif, gocognit) Behavior-preserving.
This commit is contained in:
1 parent
0d119e58d8
commit
33da682887
3 files changed
+139
-98
No files matched your search
@@ -244,41 +244,8 @@ func toolExecute(entry tools.ToolEntry, opts ToolSetOptions) func(context.Contex
|
||||
}
|
||||
}
|
||||
if entry.Classification.IsApprovalRequired() {
|
||||
if opts.Approval == nil {
|
||||
return "", fmt.Errorf("tool %s requires approval but no approver is configured", entry.Name)
|
||||
}
|
||||
approveCtx, cancel := context.WithTimeout(ctx, tools.ToolApprovalTimeout)
|
||||
defer cancel()
|
||||
desc := entry.Description
|
||||
if entry.BuildApprovalDescription != nil {
|
||||
desc = entry.BuildApprovalDescription(args)
|
||||
}
|
||||
decision, err := opts.Approval.RequestApproval(approveCtx, entry.Name, desc)
|
||||
if err != nil {
|
||||
// Distinguish a tool-level timeout (our own deadline)
|
||||
// from a turn-level cancellation (/stop). A turn
|
||||
// cancellation must propagate as a context error; a
|
||||
// tool timeout must surface as a plain error so the
|
||||
// model can report it instead of the turn aborting.
|
||||
if (errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled)) && ctx.Err() == nil {
|
||||
return "", fmt.Errorf("tool %s: approval timed out after %v", entry.Name, tools.ToolApprovalTimeout)
|
||||
}
|
||||
return "", fmt.Errorf("tool %s: approval: %w", entry.Name, err)
|
||||
}
|
||||
switch decision {
|
||||
case tools.ApprovalApproved, tools.ApprovalPermanentlyApproved:
|
||||
// Fall through to execution. PermanentlyApproved is
|
||||
// handled by the adapter caching the decision; the
|
||||
// dispatch layer treats both the same.
|
||||
case tools.ApprovalDenied:
|
||||
return "", fmt.Errorf("tool %s: %w", entry.Name, tools.ErrApprovalDenied)
|
||||
default:
|
||||
// Fail closed: an unrecognised decision value from
|
||||
// a faulty or future Approver must not execute the
|
||||
// tool. ApprovalDecision is an exported int type,
|
||||
// so a value returned with nil error is a defect
|
||||
// in the approver, not a grant.
|
||||
return "", fmt.Errorf("tool %s: approval returned unexpected decision %v", entry.Name, decision)
|
||||
if err := requireApproval(ctx, entry, opts, args); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
out, err := entry.Handler(ctx, args)
|
||||
@@ -294,3 +261,43 @@ func toolExecute(entry tools.ToolEntry, opts ToolSetOptions) func(context.Contex
|
||||
return payload, nil
|
||||
}
|
||||
}
|
||||
|
||||
// requireApproval blocks until entry's approval is granted, returning an
|
||||
// error if it is denied, times out, or the approver misbehaves.
|
||||
func requireApproval(ctx context.Context, entry tools.ToolEntry, opts ToolSetOptions, args map[string]any) error {
|
||||
if opts.Approval == nil {
|
||||
return fmt.Errorf("tool %s requires approval but no approver is configured", entry.Name)
|
||||
}
|
||||
approveCtx, cancel := context.WithTimeout(ctx, tools.ToolApprovalTimeout)
|
||||
defer cancel()
|
||||
desc := entry.Description
|
||||
if entry.BuildApprovalDescription != nil {
|
||||
desc = entry.BuildApprovalDescription(args)
|
||||
}
|
||||
decision, err := opts.Approval.RequestApproval(approveCtx, entry.Name, desc)
|
||||
if err != nil {
|
||||
// Distinguish a tool-level timeout (our own deadline) from a
|
||||
// turn-level cancellation (/stop). A turn cancellation must
|
||||
// propagate as a context error; a tool timeout must surface as
|
||||
// a plain error so the model can report it instead of the turn
|
||||
// aborting.
|
||||
if (errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled)) && ctx.Err() == nil {
|
||||
return fmt.Errorf("tool %s: approval timed out after %v", entry.Name, tools.ToolApprovalTimeout)
|
||||
}
|
||||
return fmt.Errorf("tool %s: approval: %w", entry.Name, err)
|
||||
}
|
||||
switch decision {
|
||||
case tools.ApprovalApproved, tools.ApprovalPermanentlyApproved:
|
||||
// PermanentlyApproved is handled by the adapter caching the
|
||||
// decision; the dispatch layer treats both the same.
|
||||
return nil
|
||||
case tools.ApprovalDenied:
|
||||
return fmt.Errorf("tool %s: %w", entry.Name, tools.ErrApprovalDenied)
|
||||
default:
|
||||
// Fail closed: an unrecognised decision value from a faulty or
|
||||
// future Approver must not execute the tool. ApprovalDecision is
|
||||
// an exported int type, so a value returned with nil error is a
|
||||
// defect in the approver, not a grant.
|
||||
return fmt.Errorf("tool %s: approval returned unexpected decision %v", entry.Name, decision)
|
||||
}
|
||||
}
|
||||
+52
-31
@@ -345,18 +345,8 @@ func (r *Router) dispatchLocal(ctx context.Context, msg Message, text, cmd strin
|
||||
reply, err := r.handleApproveCommand(ctx, rest)
|
||||
return reply, true, err
|
||||
case "/deny":
|
||||
if r.Dangerous == nil {
|
||||
return "Dangerous approvals are not configured.", true, nil
|
||||
}
|
||||
fields := strings.Fields(rest)
|
||||
if len(fields) != 1 {
|
||||
return "Usage: /deny <action-id>", true, nil
|
||||
}
|
||||
result, err := r.Dangerous.Decide(ctx, fields[0], "deny")
|
||||
if err != nil {
|
||||
return fmt.Sprintf("Cannot deny action: %v", err), true, nil
|
||||
}
|
||||
return result, true, nil
|
||||
reply, err := r.handleDeny(ctx, rest)
|
||||
return reply, true, err
|
||||
case "/cancel":
|
||||
reply, err := r.handleCancel(ctx, rest)
|
||||
return reply, true, err
|
||||
@@ -384,31 +374,62 @@ func (r *Router) dispatchLocal(ctx context.Context, msg Message, text, cmd strin
|
||||
case "/help":
|
||||
return r.helpText(), true, nil
|
||||
case "/version":
|
||||
if r.Version == "" {
|
||||
return "Version information is not configured.", true, nil
|
||||
}
|
||||
return r.Version, true, nil
|
||||
return r.handleVersion(), true, nil
|
||||
case "/update":
|
||||
if r.Updates == nil {
|
||||
return "Updates are not configured.", true, nil
|
||||
}
|
||||
snapshot, err := r.Updates.Check(ctx, 0)
|
||||
if err != nil {
|
||||
return fmt.Sprintf("Could not check for updates: %v", err), true, nil
|
||||
}
|
||||
return releaseupdate.FormatSnapshot(snapshot), true, nil
|
||||
return r.handleUpdateCheck(ctx), true, nil
|
||||
case "/restart":
|
||||
if r.Restart == nil {
|
||||
return "Chat adapter restart is not configured.", true, nil
|
||||
}
|
||||
if err := r.Restart(ctx); err != nil {
|
||||
return fmt.Sprintf("Could not restart the chat adapter: %v", err), true, nil
|
||||
}
|
||||
return "Chat adapter reload requested.", true, nil
|
||||
return r.handleRestartAdapter(ctx), true, nil
|
||||
}
|
||||
return r.dispatchSessionCommand(ctx, msg, cmd, rest)
|
||||
}
|
||||
|
||||
// handleDeny denies a pending dangerous action by ID.
|
||||
func (r *Router) handleDeny(ctx context.Context, rest string) (string, error) {
|
||||
if r.Dangerous == nil {
|
||||
return "Dangerous approvals are not configured.", nil
|
||||
}
|
||||
fields := strings.Fields(rest)
|
||||
if len(fields) != 1 {
|
||||
return "Usage: /deny <action-id>", nil
|
||||
}
|
||||
result, err := r.Dangerous.Decide(ctx, fields[0], "deny")
|
||||
if err != nil {
|
||||
return fmt.Sprintf("Cannot deny action: %v", err), nil
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// handleVersion reports the configured build version.
|
||||
func (r *Router) handleVersion() string {
|
||||
if r.Version == "" {
|
||||
return "Version information is not configured."
|
||||
}
|
||||
return r.Version
|
||||
}
|
||||
|
||||
// handleUpdateCheck reports the latest available update snapshot.
|
||||
func (r *Router) handleUpdateCheck(ctx context.Context) string {
|
||||
if r.Updates == nil {
|
||||
return "Updates are not configured."
|
||||
}
|
||||
snapshot, err := r.Updates.Check(ctx, 0)
|
||||
if err != nil {
|
||||
return fmt.Sprintf("Could not check for updates: %v", err)
|
||||
}
|
||||
return releaseupdate.FormatSnapshot(snapshot)
|
||||
}
|
||||
|
||||
// handleRestartAdapter reloads the chat adapter.
|
||||
func (r *Router) handleRestartAdapter(ctx context.Context) string {
|
||||
if r.Restart == nil {
|
||||
return "Chat adapter restart is not configured."
|
||||
}
|
||||
if err := r.Restart(ctx); err != nil {
|
||||
return fmt.Sprintf("Could not restart the chat adapter: %v", err)
|
||||
}
|
||||
return "Chat adapter reload requested."
|
||||
}
|
||||
|
||||
// dispatchSessionCommand handles the session-lifecycle command group
|
||||
// (/new, /topic, /retry, /undo, /title, /branch, /compress and their
|
||||
// aliases). Split out from dispatchLocal to keep cyclomatic complexity
|
||||
|
||||
@@ -334,38 +334,8 @@ func (s *Store) Update(ctx context.Context, id string, patch Patch) error {
|
||||
if s.buf[i].ID != id {
|
||||
continue
|
||||
}
|
||||
if patch.Pool != nil {
|
||||
s.buf[i].Pool = *patch.Pool
|
||||
}
|
||||
if patch.Detail != nil {
|
||||
s.buf[i].Detail = *patch.Detail
|
||||
}
|
||||
if patch.Schedule != nil {
|
||||
s.buf[i].Schedule = patch.Schedule.resolve()
|
||||
// Schedule change: NextRun is stale. Recompute from
|
||||
// the last run if there is one, else as a first run
|
||||
// from now. Keeping it strictly future-of-now would
|
||||
// re-fire a job the operator just shortened.
|
||||
now := time.Now().UTC()
|
||||
if s.buf[i].LastRun != nil {
|
||||
next, err := s.buf[i].Schedule.nextRun(*s.buf[i].LastRun)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.buf[i].NextRun = next.UTC()
|
||||
} else {
|
||||
next, err := s.buf[i].Schedule.firstRun(now)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.buf[i].NextRun = next.UTC()
|
||||
}
|
||||
}
|
||||
if patch.Target != nil {
|
||||
s.buf[i].Target = *patch.Target
|
||||
}
|
||||
if patch.Payload != nil {
|
||||
s.buf[i].Payload = *patch.Payload
|
||||
if err := applyPatch(&s.buf[i], patch); err != nil {
|
||||
return err
|
||||
}
|
||||
s.buf[i].Updated = time.Now().UTC()
|
||||
return s.writeLocked()
|
||||
@@ -374,6 +344,49 @@ func (s *Store) Update(ctx context.Context, id string, patch Patch) error {
|
||||
})
|
||||
}
|
||||
|
||||
// applyPatch overwrites record's non-nil Patch fields in place, recomputing
|
||||
// NextRun when Schedule changes.
|
||||
func applyPatch(record *JobSpec, patch Patch) error {
|
||||
if patch.Pool != nil {
|
||||
record.Pool = *patch.Pool
|
||||
}
|
||||
if patch.Detail != nil {
|
||||
record.Detail = *patch.Detail
|
||||
}
|
||||
if patch.Schedule != nil {
|
||||
if err := applyScheduleChange(record, patch.Schedule); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if patch.Target != nil {
|
||||
record.Target = *patch.Target
|
||||
}
|
||||
if patch.Payload != nil {
|
||||
record.Payload = *patch.Payload
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// applyScheduleChange sets record's Schedule and recomputes NextRun, which
|
||||
// is stale once Schedule changes. Recomputed from the last run if there is
|
||||
// one, else as a first run from now — keeping it strictly future-of-now
|
||||
// would re-fire a job the operator just shortened.
|
||||
func applyScheduleChange(record *JobSpec, schedule *Schedule) error {
|
||||
record.Schedule = schedule.resolve()
|
||||
var next time.Time
|
||||
var err error
|
||||
if record.LastRun != nil {
|
||||
next, err = record.Schedule.nextRun(*record.LastRun)
|
||||
} else {
|
||||
next, err = record.Schedule.firstRun(time.Now().UTC())
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
record.NextRun = next.UTC()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Delete removes the job by id. Idempotent: deleting a missing id
|
||||
// returns nil rather than ErrJobNotFound, so a CLI retry after a
|
||||
// partial failure cannot stall the operator.
|
||||
|
||||
Reference in new issue
Block a user