Files
archie/internal/agentexec/capture_mcp.go
T
sam 0f6448c048
deploy / plan (push) Failing after 1s
deploy / gate (push) Skipped
deploy / archied-image (push) Skipped
deploy / agent-image (push) Skipped
deploy / dist-zip (push) Skipped
refactor(agentexec): delete unused runner injection seams, ServeCaptureMCP, an unreachable approval branch and orphan fixtures
2026-11-09 01:43:53 +11:00

154 lines
4.9 KiB
Go

package agentexec
import (
"bufio"
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"sync"
"sync/atomic"
"github.com/modelcontextprotocol/go-sdk/mcp"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
)
const mcpConfigPlaceholder = "{{.MCPConfig}}"
// captureRecord is one accepted capture call, as the MCP server appends it
// to the captures file.
type captureRecord struct {
Tool string `json:"tool"`
Args json.RawMessage `json:"args"`
}
// AcceptCapture decides whether one capture call is kept. Both the built-in
// loop and the harness path use it, and the harness path applies it twice:
// in the MCP server, and again when the worker reads the captures back.
func AcceptCapture(spec agentrun.CaptureTool, accepted int, value json.RawMessage) (string, bool) {
if spec.MaxCalls > 0 && accepted >= spec.MaxCalls {
return fmt.Sprintf("%s rejected: maximum call count is %d", spec.Name, spec.MaxCalls), false
}
if !json.Valid(value) {
return spec.Name + " rejected: arguments are not valid JSON", false
}
if rejection, ok := ValidateCaptureArgs(spec, value); !ok {
return rejection, false
}
return spec.Name + " recorded", true
}
func serveHarnessMCP(ctx context.Context, specs []agentrun.CaptureTool, sink io.Writer, t mcp.Transport, server *mcp.Server, central bool) error {
if central {
cleanup, err := addCentralTools(ctx, server, specs)
if err != nil {
return err
}
defer cleanup()
}
var mu sync.Mutex
accepted := map[string]int{}
for _, spec := range specs {
schema := spec.Parameters
if len(schema) == 0 {
schema = json.RawMessage(`{"type":"object"}`)
}
server.AddTool(&mcp.Tool{Name: spec.Name, Description: spec.Description, InputSchema: schema},
func(_ context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
mu.Lock()
defer mu.Unlock()
args := append(json.RawMessage(nil), req.Params.Arguments...)
reply, ok := AcceptCapture(spec, accepted[spec.Name], args)
if ok {
line, err := json.Marshal(captureRecord{Tool: spec.Name, Args: args})
if err != nil {
return nil, err
}
if _, err := sink.Write(append(line, '\n')); err != nil {
return nil, fmt.Errorf("record %s: %w", spec.Name, err)
}
accepted[spec.Name]++
}
return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: reply}}}, nil
})
}
return server.Run(ctx, t)
}
// readCaptures reads a captures file back into a stage's captures. The file
// is writable by the harness user, so nothing in it is trusted: every record
// is checked again, and anything that is not an accepted call of a declared
// tool is dropped.
func readCaptures(path string, specs []agentrun.CaptureTool) (map[string][]json.RawMessage, error) {
raw, err := os.ReadFile(path)
if errors.Is(err, os.ErrNotExist) {
return nil, nil
}
if err != nil {
return nil, err
}
byName := make(map[string]agentrun.CaptureTool, len(specs))
for _, s := range specs {
byName[s.Name] = s
}
captures := map[string][]json.RawMessage{}
scanner := bufio.NewScanner(bytes.NewReader(raw))
scanner.Buffer(make([]byte, 64*1024), 16*1024*1024)
for scanner.Scan() {
var rec captureRecord
if json.Unmarshal(scanner.Bytes(), &rec) != nil {
continue
}
spec, declared := byName[rec.Tool]
if !declared {
continue
}
if _, ok := AcceptCapture(spec, len(captures[rec.Tool]), rec.Args); ok {
captures[rec.Tool] = append(captures[rec.Tool], rec.Args)
}
}
if len(captures) == 0 {
return nil, scanner.Err()
}
return captures, scanner.Err()
}
// ServeCaptureFiles serves the capture tools listed in specPath, appending
// accepted calls to capturesPath. The files are the ones prepareCaptures
// writes, so this package owns their format end to end.
func ServeCaptureFiles(ctx context.Context, specPath, capturesPath string, t mcp.Transport) error {
raw, err := os.ReadFile(specPath)
if err != nil {
return err
}
var spec harnessMCPSpec
if err := json.Unmarshal(raw, &spec); err != nil {
return fmt.Errorf("capture tool spec: %w", err)
}
sink, err := os.OpenFile(capturesPath, os.O_WRONLY|os.O_APPEND, 0)
if err != nil {
return err
}
defer sink.Close()
server := mcp.NewServer(&mcp.Implementation{Name: "archie", Version: "1"}, nil)
var ready atomic.Bool
server.AddReceivingMiddleware(func(next mcp.MethodHandler) mcp.MethodHandler {
return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
result, err := next(ctx, method, req)
if err == nil && (method == "tools/list" || method == "tools/call") && !ready.Load() {
// A call is already recorded by now, so a failed marker must not
// turn it into a tool error; the runner reports the missing marker.
if os.WriteFile(capturesPath+".ready", nil, 0o600) == nil {
ready.Store(true)
}
}
return result, err
}
})
return serveHarnessMCP(ctx, spec.Captures, sink, t, server, spec.CentralTools)
}