Files
pipelines/internal/server/verification_fixture.go
T
alan 2cdb9a9e93 Stabilize guarded model delivery
Add validated OpenCode-only delivery capabilities, canonical linked-worktree access checks, isolated candidate verification, and guarded main settlement.

Wire the bounded reconnect-foreground controlled HTTP fixture through ordinary server construction so target verification obtains server-controlled provenance and rejects unknown or incompatible fixture evidence.

Checked packaged templates and packaged authoring skill references; no updates are needed because this draft-only infrastructure activates no definition. Recorded the stale reference and activation guidance in docs/notes/delivery-stabilization.md for the docs fold.
2026-10-18 14:50:18 +01:00

136 lines
5.5 KiB
Go

package server
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/stage"
)
const (
verificationFixtureID = "reconnect-foreground"
verificationFixtureResponseLimit int64 = 64 << 10
verificationFixtureTimeout = 10 * time.Second
)
// VerificationFixture is a server-owned, explicitly registered probe. Its
// endpoint and expected provenance come from server configuration, never a
// stage definition or result.
type VerificationFixture struct {
ID, Endpoint, Backend, Revision, Capability, State string
}
// VerificationFixturesFromEnvironment returns the single supported fixture
// registration when its endpoint is explicitly configured. There is no default
// endpoint: an unconfigured server fails target-aware verification closed.
func VerificationFixturesFromEnvironment(getenv func(string) string) []VerificationFixture {
if getenv == nil {
getenv = os.Getenv
}
endpoint := strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_URL"))
if endpoint == "" {
return nil
}
return []VerificationFixture{{
ID: verificationFixtureID,
Endpoint: endpoint,
Backend: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_BACKEND")),
Revision: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_REVISION")),
Capability: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_CAPABILITY")),
State: strings.TrimSpace(getenv("PIPELINES_VERIFICATION_RECONNECT_FOREGROUND_STATE")),
}}
}
type verificationFixtureRegistry struct {
fixtures map[string]VerificationFixture
err error
}
func newVerificationFixtureRegistry(fixtures []VerificationFixture) *verificationFixtureRegistry {
r := &verificationFixtureRegistry{fixtures: make(map[string]VerificationFixture, len(fixtures))}
for _, fixture := range fixtures {
if err := validVerificationFixture(fixture); err != nil {
r.err = err
return r
}
if _, exists := r.fixtures[fixture.ID]; exists {
r.err = fmt.Errorf("duplicate verification fixture %q", fixture.ID)
return r
}
r.fixtures[fixture.ID] = fixture
}
return r
}
func validVerificationFixture(fixture VerificationFixture) error {
if fixture.ID != verificationFixtureID {
return fmt.Errorf("unsupported verification fixture %q", fixture.ID)
}
for _, value := range []string{fixture.Endpoint, fixture.Backend, fixture.Revision, fixture.Capability, fixture.State} {
if value == "" || len(value) > 256 {
return fmt.Errorf("verification fixture %q has incomplete configuration", fixture.ID)
}
}
u, err := url.Parse(fixture.Endpoint)
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
return fmt.Errorf("verification fixture %q has invalid endpoint", fixture.ID)
}
return nil
}
func (r *verificationFixtureRegistry) verify(ctx context.Context, target stage.VerificationTarget) (stage.VerificationEvidence, error) {
if r.err != nil {
return stage.VerificationEvidence{}, r.err
}
fixture, exists := r.fixtures[target.Fixture]
if !exists {
return stage.VerificationEvidence{}, fmt.Errorf("unknown verification fixture %q", target.Fixture)
}
if fixture.Backend != target.Backend || fixture.Revision != target.Revision || fixture.Capability != target.Capability {
return stage.VerificationEvidence{}, fmt.Errorf("verification target does not match registered fixture %q", target.Fixture)
}
probeCtx, cancel := context.WithTimeout(ctx, verificationFixtureTimeout)
defer cancel()
req, err := http.NewRequestWithContext(probeCtx, http.MethodGet, fixture.Endpoint, nil)
if err != nil {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q request: %w", fixture.ID, err)
}
client := &http.Client{Timeout: verificationFixtureTimeout, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
response, err := client.Do(req)
if err != nil {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q probe: %w", fixture.ID, err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q probe returned %s", fixture.ID, response.Status)
}
var observed struct {
Backend string `json:"backend"`
Revision string `json:"revision"`
Capability string `json:"capability"`
Fixture string `json:"fixture"`
State string `json:"state"`
}
body, err := io.ReadAll(io.LimitReader(response.Body, verificationFixtureResponseLimit+1))
if err != nil {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response: %w", fixture.ID, err)
}
if int64(len(body)) > verificationFixtureResponseLimit {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response exceeds %d bytes", fixture.ID, verificationFixtureResponseLimit)
}
if err := json.Unmarshal(body, &observed); err != nil {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q response: %w", fixture.ID, err)
}
if observed.Backend != fixture.Backend || observed.Revision != fixture.Revision || observed.Capability != fixture.Capability || observed.Fixture != fixture.ID || observed.State != fixture.State {
return stage.VerificationEvidence{}, fmt.Errorf("verification fixture %q returned incompatible backend, revision, capability, fixture, or state", fixture.ID)
}
return stage.VerificationEvidence{Backend: observed.Backend, Revision: observed.Revision, Capability: observed.Capability, Fixture: observed.Fixture}, nil
}