2cdb9a9e93
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.
136 lines
5.5 KiB
Go
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
|
|
}
|