providers

type ChangelogRunner ¶

type ChangelogRunner struct {
	// Client is the Dagger client used to construct the git/changelog
	// container.
	Client daggerkit.DaggerClient
}

ChangelogRunner generates a Keep a Changelog "Unreleased" summary from git history since the last tag and prepends it into build's CHANGELOG.md, returning the resulting Container. It is Shipwright's live-system replacement for the now-deleted internal/app.ChangelogStepHandler, which shelled out to git on the host and wrote directly to the host filesystem — behavior with no place in a capability contract whose only inputs/outputs are Dagger core types (mirroring providers/go/containerpublisher.go's own "Behavioral judgment calls" note about host filesystem side effects). Every text-processing helper below (classification, section building, prepend) is ported unchanged from that handler; only the git access and file I/O move inside a Dagger container.

build is expected to contain a `.git` history — typically a checkout step's source Directory, not a Builder's compiled-output Directory (the Runner interface's build parameter name, pkg/shipwright/capabilities.go, describes the common case, not a hard requirement: any Directory-producing step can feed a Runner via `${{ steps.<id>.output }}` wiring, and this Runner's own contract is "a Directory with git history in it", whatever step produced it).

func (r *ChangelogRunner) Run(ctx context.Context, build *dagger.Directory) (*dagger.Container, error)

type Ref ¶

type Ref struct {
	Name    string
	Module  string
	Version string
}

Ref identifies one registered provider implementation for a capability (design.md D-I's type sketch, exactly). Module == "" means an in-repo provider — one registered directly by this binary's own provider-registration file (register.go). A non-empty Module names the external module path a manifest's uses.module field references; it is resolved through the identical Register*/Resolve* mechanism as an in-repo provider — there is no separate, more permissive path for "external" providers (workflow-execution spec, "External module: Providers Satisfy The Same Dagger Contract As In-Repo Providers").

Ref is keyed by BOTH Name and Module (never Name alone): a manifest requesting uses.provider: go and a manifest requesting uses.module: go must never resolve to the same registered entry, because they are declaring different trust boundaries (in-repo vs. external) even if they happen to share a literal name.

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry is the typed, per-capability provider table (design.md D-I). Its zero value is not usable — construct with NewRegistry.

func NewRegistry() *Registry

func (r *Registry) RegisterArtifactor(ref Ref, schema WithSchema, f func(Values) shipwright.Artifactor)

func (r *Registry) RegisterBuilder(ref Ref, schema WithSchema, f func(Values) shipwright.Builder)

func (r *Registry) RegisterDeployer(ref Ref, schema WithSchema, f func(Values) shipwright.Deployer)

func (r *Registry) RegisterRunner(ref Ref, schema WithSchema, f func(Values) shipwright.Runner)

func (r *Registry) RegisterRuntimeInspector(ref Ref, schema WithSchema, f func(Values) shipwright.RuntimeInspector)

func (r *Registry) RegisterRuntimeUpgrader(ref Ref, schema WithSchema, f func(Values) shipwright.RuntimeUpgrader)

func (r *Registry) RegisterTester(ref Ref, schema WithSchema, f func(Values) shipwright.Tester)

func (r *Registry) ResolveArtifactor(ref Ref, v Values) (shipwright.Artifactor, error)

func (r *Registry) ResolveBuilder(ref Ref, v Values) (shipwright.Builder, error)

func (r *Registry) ResolveDeployer(ref Ref, v Values) (shipwright.Deployer, error)

func (r *Registry) ResolveRunner(ref Ref, v Values) (shipwright.Runner, error)

func (r *Registry) ResolveRuntimeInspector(ref Ref, v Values) (shipwright.RuntimeInspector, error)

func (r *Registry) ResolveRuntimeUpgrader(ref Ref, v Values) (shipwright.RuntimeUpgrader, error)

func (r *Registry) ResolveTester(ref Ref, v Values) (shipwright.Tester, error)

type UnregisteredProviderError ¶

type UnregisteredProviderError struct {
	Capability string
	Ref        Ref
}

UnregisteredProviderError reports a uses.provider/uses.module reference naming no provider registered at build time for the requested capability (design.md D-I, tasks.md 7.3). This is the exact fail-closed boundary that makes plugin.Open unreachable from provider resolution: there is no fetch/download/cache/dynamic-load fallback here, only this error.

func (e *UnregisteredProviderError) Error() string

type UnsupportedVersionError ¶

type UnsupportedVersionError struct {
	Capability        string
	Name              string
	Module            string
	RequestedVersion  string
	SupportedVersions []string
}

UnsupportedVersionError reports a registered provider Name/Module that exists, but not at the requested Version (tasks.md 7.2). Deliberately a distinct type from UnregisteredProviderError: "you asked for a version we don't ship" is a different failure mode from "you asked for a provider that doesn't exist at all", and a caller/operator needs to be able to tell them apart with errors.As, not string matching.

func (e *UnsupportedVersionError) Error() string

type Values ¶

type Values map[string]interp.Value

Values carries a step's resolved `with` values, keyed by field name, already interpolated into typed interp.Value carriers — never a raw Go string that might hide a secret (interp.Value's own structural guarantee that a secret cannot be represented as a plain string).

type WithSchema ¶

type WithSchema map[string]interp.Kind

WithSchema is a provider's declaration of its accepted `with` field names and their expected interp.Kind (design.md D-I). It is what makes stage 7 checkable and what keeps providers receiving typed Values, never an interpolated shell string (the security skill's `sh -c` rule, and design.md's Threat Matrix row 4, "Provider argument construction").

type WithSchemaMismatchError ¶

type WithSchemaMismatchError struct {
	Capability string
	Field      string
	Want       interp.Kind
	Got        interp.Kind
}

WithSchemaMismatchError reports a `with` field value whose resolved Kind does not match the resolved provider's declared WithSchema entry for that field name (tasks.md 7.5, stage 7's forbidPlaintext and general with-value type mismatch).

This is the check WU5's task 5.3 and WU6's task 6.9 both explicitly deferred here: WU5's interp.Reference.StaticKind() reports ok=false for steps.<id>.output because that Kind is fixed by whichever provider resolves the step, and WU6's graph package could not compare a with-field's kind against anything because no provider schema existed in that package. Both boundaries close HERE, because this is the first point in the pipeline where a provider's declared WithSchema actually exists to compare against.

func (e *WithSchemaMismatchError) Error() string