@shortlink-org/portolan 0.1.0 → 0.2.1

package/plugins/extract-watermill/extract_test.go

@@ -1,234 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/shortlink-org/portolan/catalog"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-func write(t *testing.T, root, name, contents string) {
-	t.Helper()
-	path := filepath.Join(root, name)
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func extracted(t *testing.T, root string) (catalog.Catalog, plugin.Response) {
-	t.Helper()
-	resp, err := extract(plugin.Input{Root: root, Commit: "abc", GeneratedAt: "2026-01-01T00:00:00Z"}, Options{Context: "sales", Service: "mailer"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var out catalog.Catalog
-	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &out); err != nil {
-		t.Fatal(err)
-	}
-	return out, resp
-}
-
-func TestExtractsConfiguredHandlerAndHelperPublications(t *testing.T) {
-	root := t.TempDir()
-	write(t, root, "go.mod", "module example.com/mailer\n")
-	write(t, root, "config/config.go", `package config
-type Bus struct {
-  Input string `+"`envconfig:\"MAIL_INPUT_TOPIC\" default:\"mail.input\"`"+`
-  Output string `+"`envconfig:\"MAIL_OUTPUT_TOPIC\" default:\"mail.output\"`"+`
-  Errors string `+"`envconfig:\"MAIL_ERROR_TOPIC\" default:\"mail.error\"`"+`
-}
-`)
-	write(t, root, "api/messages.go", `package api
-type Input struct {
-  ID string `+"`json:\"id\"`"+`
-  Valid bool `+"`json:\"valid\"`"+`
-}
-type Output struct { Accepted bool `+"`json:\"accepted\"`"+` }
-type Failure struct { Reason string `+"`json:\"reason\"`"+` }
-`)
-	write(t, root, "app/router.go", `package app
-import (
-  "encoding/json"
-  "github.com/ThreeDotsLabs/watermill"
-  "github.com/ThreeDotsLabs/watermill/message"
-  "example.com/mailer/api"
-  "example.com/mailer/config"
-)
-const ConsumerGroup = "mail-workers"
-func NewSubscriber(config.Bus, string) (message.Subscriber, error) { return nil, nil }
-func publishFailure(pub message.Publisher, topic string) error {
-  value := api.Failure{Reason: "bad"}
-  payload, _ := json.Marshal(value)
-  msg := message.NewMessage(watermill.NewUUID(), payload)
-  return pub.Publish(topic, msg)
-}
-func Register(r *message.Router, cfg config.Bus, pub message.Publisher) {
-  sub, _ := NewSubscriber(cfg, ConsumerGroup)
-  handlerName := "mail_router"
-  r.AddHandler(handlerName, cfg.Input, sub, "", nil, func(msg *message.Message) ([]*message.Message, error) {
-    var input api.Input
-    _ = json.Unmarshal(msg.Payload, &input)
-    if !input.Valid {
-      _ = publishFailure(pub, cfg.Errors)
-      return nil, nil
-    }
-    value := api.Output{Accepted: true}
-    payload, _ := json.Marshal(value)
-    out := message.NewMessage(watermill.NewUUID(), payload)
-    _ = pub.Publish(cfg.Output, out)
-    return nil, nil
-  })
-}
-`)
-
-	out, _ := extracted(t, root)
-	service := out.Contexts[0].Services[0]
-	if len(service.Channels) != 3 {
-		t.Fatalf("channels = %+v", service.Channels)
-	}
-	byAddress := map[string]catalog.Channel{}
-	for _, channel := range service.Channels {
-		byAddress[channel.Address] = channel
-	}
-	if got := byAddress["mail.input"].Messages[0]; got.Direction != catalog.ChannelReceive || got.Name != "Input" || !strings.Contains(got.Doc, "id string") {
-		t.Fatalf("input = %+v", got)
-	}
-	if got := byAddress["mail.output"].Messages[0]; got.Direction != catalog.ChannelSend || got.Name != "Output" {
-		t.Fatalf("output = %+v", got)
-	}
-	if got := byAddress["mail.error"].Messages[0]; got.Name != "Failure" || !strings.Contains(got.Doc, "reason string") {
-		t.Fatalf("error = %+v", got)
-	}
-	if !strings.Contains(byAddress["mail.input"].Doc, "MAIL_INPUT_TOPIC") {
-		t.Fatalf("channel doc = %q", byAddress["mail.input"].Doc)
-	}
-	if len(out.Flows) != 1 {
-		t.Fatalf("flows = %+v", out.Flows)
-	}
-	flow := out.Flows[0]
-	if len(flow.Steps) != 2 || !strings.Contains(flow.Steps[0].(*catalog.Step).Note, "mail-workers") {
-		t.Fatalf("flow = %+v", flow)
-	}
-	branches := flow.Steps[1].(*catalog.Alt).Branches
-	if len(branches) != 2 || branches[0].Title != "!input.Valid" || branches[1].Title != "not (!input.Valid)" || !branches[0].Terminal {
-		t.Fatalf("branches = %+v", branches)
-	}
-	receive := flow.Steps[0].(*catalog.Step).Handoff
-	errorSend := branches[0].Steps[0].(*catalog.Step).Handoff
-	successSend := branches[1].Steps[0].(*catalog.Step).Handoff
-	if receive == nil || receive.Direction != "receive" || receive.Transport != "watermill" || receive.Channel != "mail.input" {
-		t.Fatalf("receive handoff = %+v", receive)
-	}
-	if errorSend == nil || errorSend.Direction != "send" || errorSend.Channel != "mail.error" || successSend == nil || successSend.Channel != "mail.output" {
-		t.Fatalf("publish handoffs = error %+v, success %+v", errorSend, successSend)
-	}
-}
-
-func TestExtractsNamedNoPublisherHandler(t *testing.T) {
-	root := t.TempDir()
-	write(t, root, "go.mod", "module example.com/consumer\n")
-	write(t, root, "consumer.go", `package consumer
-import (
-  "encoding/json"
-  "github.com/ThreeDotsLabs/watermill/message"
-)
-type Notice struct { Code string `+"`json:\"code\"`"+` }
-func consume(msg *message.Message) error {
-  var notice Notice
-  return json.Unmarshal(msg.Payload, &notice)
-}
-func Register(r *message.Router, sub message.Subscriber) {
-  r.AddNoPublisherHandler("notice_handler", "notice.input", sub, consume)
-}
-`)
-
-	out, _ := extracted(t, root)
-	service := out.Contexts[0].Services[0]
-	if len(service.Channels) != 1 || service.Channels[0].Messages[0].Name != "Notice" {
-		t.Fatalf("channels = %+v", service.Channels)
-	}
-	if len(out.Flows) != 1 || len(out.Flows[0].Steps) != 1 {
-		t.Fatalf("flows = %+v", out.Flows)
-	}
-	if got := out.Flows[0].Steps[0].(*catalog.Step).ContinuesAt; got != "consume" {
-		t.Fatalf("handler continuation = %q", got)
-	}
-	if got := out.Flows[0].Steps[0].(*catalog.Step).Handoff; got == nil || got.Kind != "message" || got.Channel != "notice.input" || got.Direction != "receive" {
-		t.Fatalf("handler handoff = %+v", got)
-	}
-}
-
-func TestExtractsGenericCQRSProcessors(t *testing.T) {
-	root := t.TempDir()
-	write(t, root, "go.mod", "module example.com/cqrsapp\n")
-	write(t, root, "cqrs.go", `package cqrsapp
-import (
-  "context"
-  "github.com/ThreeDotsLabs/watermill/components/cqrs"
-  "github.com/ThreeDotsLabs/watermill/message"
-)
-type OrderPlaced struct { OrderID string `+"`json:\"order_id\"`"+` }
-type BookOrder struct { CustomerID string `+"`json:\"customer_id\"`"+` }
-func Register(router *message.Router) {
-  events, _ := cqrs.NewEventProcessorWithConfig(router, cqrs.EventProcessorConfig{
-    GenerateSubscribeTopic: func(cqrs.EventProcessorGenerateSubscribeTopicParams) (string, error) { return "domain.events", nil },
-  })
-  project := cqrs.NewEventHandler("project_order", func(ctx context.Context, event *OrderPlaced) error { return nil })
-  _ = events.AddHandlers(project)
-
-  commands, _ := cqrs.NewCommandProcessorWithConfig(router, cqrs.CommandProcessorConfig{
-    GenerateSubscribeTopic: func(params cqrs.CommandProcessorGenerateSubscribeTopicParams) (string, error) { return params.CommandName, nil },
-  })
-  book := cqrs.NewCommandHandler("book_order", func(ctx context.Context, command *BookOrder) error { return nil })
-  _, _ = commands.AddHandler(book)
-}
-`)
-
-	out, _ := extracted(t, root)
-	service := out.Contexts[0].Services[0]
-	if len(service.Channels) != 2 {
-		t.Fatalf("channels = %+v", service.Channels)
-	}
-	byAddress := map[string]catalog.Channel{}
-	for _, channel := range service.Channels {
-		byAddress[channel.Address] = channel
-	}
-	if got := byAddress["domain.events"].Messages[0]; got.Name != "OrderPlaced" || got.Direction != catalog.ChannelReceive {
-		t.Fatalf("event = %+v", got)
-	}
-	if got := byAddress["BookOrder"].Messages[0]; got.Name != "BookOrder" || got.Direction != catalog.ChannelReceive {
-		t.Fatalf("command = %+v", got)
-	}
-	if len(out.Flows) != 2 {
-		t.Fatalf("flows = %+v", out.Flows)
-	}
-}
-
-func TestBranchesRequireSourceBackedConditions(t *testing.T) {
-	unstructured := []publication{
-		{topic: topic{address: "one"}, payload: "One"},
-		{topic: topic{address: "two"}, payload: "Two"},
-	}
-	if structuredBranches(unstructured) {
-		t.Fatal("two publications without control-flow evidence became an alt")
-	}
-
-	structured := []publication{
-		{topic: topic{address: "errors"}, conditions: []string{"ready", "err != nil"}},
-		{topic: topic{address: "success"}, conditions: []string{"ready", "not (err != nil)"}},
-	}
-	if !structuredBranches(structured) {
-		t.Fatal("complementary source paths did not become an alt")
-	}
-	got := branchConditions(structured)
-	if got[0] != "err != nil" || got[1] != "not (err != nil)" {
-		t.Fatalf("branch conditions = %v", got)
-	}
-}

package/plugins/extract-watermill/main.go

@@ -1,41 +0,0 @@
-// Package main is portolan-extract-watermill: Watermill router declarations
-// and publications in a Go repository in, channels and source-backed flows out.
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/shortlink-org/portolan/internal/goscan"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-type Options struct {
-	Context string `json:"context"`
-	Service string `json:"service"`
-	Out     string `json:"out,omitempty"`
-}
-
-func main() {
-	if err := run(os.Stdin, os.Stdout); err != nil {
-		fmt.Fprintln(os.Stderr, "portolan-extract-watermill:", err)
-		os.Exit(1)
-	}
-}
-
-func run(stdin io.Reader, stdout io.Writer) error {
-	return plugin.Serve(stdin, stdout, descriptor(), func(req plugin.Request, opts Options) (plugin.Response, error) {
-		if req.Input.Root == "" {
-			return plugin.Response{}, fmt.Errorf("no input root: an extractor has nothing to read")
-		}
-		if opts.Context == "" {
-			opts.Context = goscan.Slug(filepath.Base(req.Input.Root))
-		}
-		if opts.Service == "" {
-			opts.Service = goscan.Slug(filepath.Base(req.Input.Root))
-		}
-		return extract(req.Input, opts)
-	})
-}

package/plugins/extract-wsdl/describe.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	_ "embed"
-
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-//go:embed options.schema.json
-var optionsSchema []byte
-
-func descriptor() plugin.Descriptor {
-	return plugin.Descriptor{
-		Name:    "extract-wsdl",
-		Summary: "Reads WSDL services, SOAP bindings, operations, messages, faults, and local XSD shapes.",
-		Phases:  []string{plugin.PhaseExtract},
-		Options: optionsSchema,
-	}
-}

package/plugins/extract-wsdl/describe_test.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/shortlink-org/portolan/plugin/schematest"
-)
-
-func TestOptionsSchemaMatchesStruct(t *testing.T) {
-	schematest.Check(t, optionsSchema, Options{})
-}

package/plugins/extract-wsdl/extract.go

@@ -1,148 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-	"github.com/shortlink-org/portolan/internal/wsdl"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-func extract(in plugin.Input, opts Options) (plugin.Response, error) {
-	if opts.Mode != "" && opts.Mode != "service" && opts.Mode != "external" {
-		return plugin.Response{}, fmt.Errorf("mode %q is not service or external", opts.Mode)
-	}
-	if opts.External != "" && strings.Contains(opts.External, ".") {
-		return plugin.Response{}, fmt.Errorf("external %q has a dot in its id", opts.External)
-	}
-	var result wsdl.Result
-	var err error
-	if opts.Spec != "" {
-		result, err = wsdl.Read(in.Root, opts.Spec)
-	} else {
-		result, err = wsdl.Discover(in.Root)
-	}
-	if err != nil {
-		return plugin.Response{}, err
-	}
-	b := &plugin.Builder{}
-	for _, warning := range result.Warnings {
-		b.Warn(in.Root, warning)
-	}
-	fragment := catalog.Catalog{
-		GeneratedAt: in.GeneratedAt, Commit: in.Commit,
-		Contexts: []catalog.BoundedContext{}, Defs: map[string]catalog.TypeDef{},
-		Flows: []catalog.Flow{}, Adrs: []catalog.Adr{}, Externals: []catalog.External{},
-	}
-	apiIDs := wsdl.APIIDs(result.Contracts)
-	if opts.Mode == "external" || opts.External != "" {
-		fragment.Externals = externalContracts(result.Contracts, apiIDs, opts)
-	} else {
-		var provides []catalog.RpcService
-		for _, contract := range result.Contracts {
-			api := apiOf(contract, apiIDs, opts, len(result.Contracts))
-			provides = append(provides, servicesOf(contract, api)...)
-		}
-		sort.Slice(provides, func(i, j int) bool { return provides[i].ID < provides[j].ID })
-		fragment.Contexts = []catalog.BoundedContext{{
-			ID: opts.Context, Slug: opts.Context,
-			Services: []catalog.Service{{
-				ID: opts.Context + "." + opts.Service, Slug: opts.Service,
-				Provides: provides, Consumes: []catalog.RpcCall{}, Aggregates: []catalog.Aggregate{},
-			}},
-		}}
-	}
-	if len(result.Contracts) == 0 {
-		b.Warn(in.Root, "no WSDL service or port type was found")
-	}
-	encoded, err := json.MarshalIndent(fragment, "", "  ")
-	if err != nil {
-		return plugin.Response{}, err
-	}
-	b.File(firstNonEmpty(opts.Out, "wsdl.json"), string(encoded)+"\n")
-	return b.Response(), nil
-}
-
-func externalContracts(contracts []wsdl.Contract, apiIDs map[string]string, opts Options) []catalog.External {
-	byID := map[string]*catalog.External{}
-	for _, contract := range contracts {
-		api := apiOf(contract, apiIDs, opts, len(contracts))
-		id := firstNonEmpty(opts.External, opts.Externals[api], wsdl.ExternalID(contract))
-		external := byID[id]
-		if external == nil {
-			external = &catalog.External{
-				ID: id, Slug: id,
-				Name:    firstNonEmpty(opts.ExternalName, contract.Name),
-				Summary: firstNonEmpty(opts.ExternalSummary, contract.Summary),
-				URL:     opts.ExternalURL, Provides: []catalog.RpcService{},
-			}
-			byID[id] = external
-		}
-		if external.URL == "" {
-			for _, iface := range contract.Interfaces {
-				if iface.Endpoint != "" {
-					external.URL = iface.Endpoint
-					break
-				}
-			}
-		}
-		external.Provides = append(external.Provides, servicesOf(contract, api)...)
-	}
-	var out []catalog.External
-	for _, external := range byID {
-		sort.Slice(external.Provides, func(i, j int) bool { return external.Provides[i].ID < external.Provides[j].ID })
-		out = append(out, *external)
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
-	return out
-}
-
-func apiOf(contract wsdl.Contract, apiIDs map[string]string, opts Options, count int) string {
-	if opts.API != "" && count == 1 {
-		return opts.API
-	}
-	return apiIDs[wsdl.ContractKey(contract)]
-}
-
-func servicesOf(contract wsdl.Contract, api string) []catalog.RpcService {
-	var out []catalog.RpcService
-	for _, iface := range contract.Interfaces {
-		methods := make([]catalog.RpcMethod, 0, len(iface.Operations))
-		for _, operation := range iface.Operations {
-			methods = append(methods, catalog.RpcMethod{
-				Name: operation.Name, Doc: operation.Doc,
-				Request: operation.Request, Response: operation.Response,
-				SOAP: &catalog.SoapRoute{
-					Action: operation.Action, Version: iface.Version, Style: iface.Style,
-					Endpoint: iface.Endpoint, Binding: iface.Binding,
-					Faults: append([]string(nil), operation.Faults...), Headers: append([]string(nil), operation.Headers...),
-				},
-			})
-		}
-		messages := make([]catalog.RpcMessage, 0, len(iface.Messages))
-		for _, message := range iface.Messages {
-			fields := make([]catalog.Field, 0, len(message.Fields))
-			for _, field := range message.Fields {
-				fields = append(fields, catalog.Field{Name: field.Name, Type: field.Type, Doc: field.Doc})
-			}
-			messages = append(messages, catalog.RpcMessage{Name: message.Name, Fields: fields})
-		}
-		out = append(out, catalog.RpcService{
-			ID: wsdl.InterfaceID(api, iface), Source: contract.Source,
-			Methods: methods, Messages: messages,
-		})
-	}
-	return out
-}
-
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		if strings.TrimSpace(value) != "" {
-			return strings.TrimSpace(value)
-		}
-	}
-	return ""
-}

package/plugins/extract-wsdl/extract_test.go

@@ -1,45 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/shortlink-org/portolan/catalog"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-func TestWSDLBecomesStructuredExternalAPI(t *testing.T) {
-	root := t.TempDir()
-	spec := `<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="urn:payments" name="Payments" targetNamespace="urn:payments">
-  <types><xsd:schema targetNamespace="urn:payments"><xsd:element name="Pay"><xsd:complexType><xsd:sequence><xsd:element name="amount" type="xsd:decimal"/></xsd:sequence></xsd:complexType></xsd:element></xsd:schema></types>
-  <message name="PayRequest"><part name="body" element="tns:Pay"/></message>
-  <message name="PayResponse"><part name="id" type="xsd:string"/></message>
-  <portType name="PaymentsPortType"><operation name="Pay"><input message="tns:PayRequest"/><output message="tns:PayResponse"/></operation></portType>
-  <binding name="PaymentsBinding" type="tns:PaymentsPortType"><soap:binding style="document"/><operation name="Pay"><soap:operation soapAction="urn:pay"/></operation></binding>
-  <service name="PaymentsService"><port name="PaymentsPort" binding="tns:PaymentsBinding"><soap:address location="https://pay.example/soap"/></port></service>
-</definitions>`
-	if err := os.WriteFile(filepath.Join(root, "payments.wsdl"), []byte(spec), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	resp, err := extract(plugin.Input{Root: root, Commit: "abc", GeneratedAt: "2026-01-01T00:00:00Z"}, Options{Mode: "external", Spec: "payments.wsdl"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var got catalog.Catalog
-	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
-		t.Fatal(err)
-	}
-	if len(got.Externals) != 1 || got.Externals[0].ID != "payments" || got.Externals[0].URL != "https://pay.example/soap" {
-		t.Fatalf("externals = %+v", got.Externals)
-	}
-	provided := got.Externals[0].Provides[0]
-	if provided.ID != "paymentsservice.soap.PaymentsPort" || provided.Source != "payments.wsdl" || len(provided.Messages) != 2 {
-		t.Fatalf("provided = %+v", provided)
-	}
-	method := provided.Methods[0]
-	if method.Request != "PayRequest" || method.Response != "PayResponse" || method.SOAP == nil || method.SOAP.Action != "urn:pay" || method.SOAP.Version != "1.1" {
-		t.Fatalf("method = %+v", method)
-	}
-}

package/plugins/extract-wsdl/main.go

@@ -1,53 +0,0 @@
-// Package main is portolan-extract-wsdl: WSDL contracts and their local XSD
-// graph in, structured SOAP interfaces in the catalog out.
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/shortlink-org/portolan/internal/wsdl"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-type Options struct {
-	Context string `json:"context"`
-	Service string `json:"service"`
-	Spec    string `json:"spec,omitempty"`
-	API     string `json:"api,omitempty"`
-
-	// Mode is service for a contract implemented by this component, external
-	// for copies used to call systems outside the estate.
-	Mode      string            `json:"mode,omitempty"`
-	External  string            `json:"external,omitempty"`
-	Externals map[string]string `json:"externals,omitempty"`
-
-	ExternalName    string `json:"externalName,omitempty"`
-	ExternalSummary string `json:"externalSummary,omitempty"`
-	ExternalURL     string `json:"externalUrl,omitempty"`
-	Out             string `json:"out,omitempty"`
-}
-
-func main() {
-	if err := run(os.Stdin, os.Stdout); err != nil {
-		fmt.Fprintln(os.Stderr, "portolan-extract-wsdl:", err)
-		os.Exit(1)
-	}
-}
-
-func run(stdin io.Reader, stdout io.Writer) error {
-	return plugin.Serve(stdin, stdout, descriptor(), func(req plugin.Request, opts Options) (plugin.Response, error) {
-		if req.Input.Root == "" {
-			return plugin.Response{}, fmt.Errorf("no input root: an extractor has nothing to read")
-		}
-		if opts.Context == "" {
-			opts.Context = wsdl.Slug(filepath.Base(req.Input.Root))
-		}
-		if opts.Service == "" {
-			opts.Service = wsdl.Slug(filepath.Base(req.Input.Root))
-		}
-		return extract(req.Input, opts)
-	})
-}

package/plugins/fetch-bsr/auth.go

@@ -1,114 +0,0 @@
-package main
-
-// The only file that reads the environment.
-//
-// The plugin protocol says a plugin has "no ambient state to read, no
-// environment". That is about FACTS: nothing about the estate may come from
-// anywhere but the request, or a fragment stops being reproducible from the
-// tree it describes.
-//
-// A credential is not a fact about the estate. It is how the transport is
-// allowed to open a socket, the same way a git credential is - it changes
-// whether the fetch succeeds, never what the fetch says. Isolating it in one
-// file that nothing else calls is what keeps that claim checkable.
-//
-// It is also why this plugin can never be wasm. It needs a socket and a
-// secret, and `process` exists for exactly that trade.
-
-import (
-	"bufio"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// TokenEnv is where `buf registry login` is usually mirrored in CI.
-const TokenEnv = "BUF_TOKEN"
-
-// token finds a credential for a registry, or returns none.
-//
-// None is a normal outcome, not a failure: public modules download
-// anonymously, and an estate whose schemas are public never needs a token.
-func token(registry string) string {
-	if t := strings.TrimSpace(os.Getenv(TokenEnv)); t != "" {
-		return t
-	}
-
-	return netrcToken(registry)
-}
-
-// netrcToken reads the password `buf registry login` wrote.
-func netrcToken(registry string) string {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return ""
-	}
-
-	for _, name := range []string{".netrc", "_netrc"} {
-		if t := readNetrc(filepath.Join(home, name), registry); t != "" {
-			return t
-		}
-	}
-
-	return ""
-}
-
-// readNetrc walks a netrc for the machine asked about.
-//
-// Deliberately small: netrc is a stream of words, and the only entry that
-// matters here is the password belonging to one machine.
-func readNetrc(path, machine string) string {
-	file, err := os.Open(path)
-	if err != nil {
-		return ""
-	}
-	defer file.Close()
-
-	words := bufio.NewScanner(file)
-	words.Split(bufio.ScanWords)
-
-	current := ""
-	for words.Scan() {
-		switch words.Text() {
-		case "machine":
-			if !words.Scan() {
-				return ""
-			}
-			current = words.Text()
-		case "default":
-			current = machine
-		case "password":
-			if !words.Scan() {
-				return ""
-			}
-			if current == machine {
-				return words.Text()
-			}
-		case "login", "account":
-			// Read past the value so it cannot be mistaken for a keyword.
-			words.Scan()
-		}
-	}
-
-	return ""
-}
-
-// OfflineEnv turns the fetch off. Explicit, rather than inferred from a socket
-// timeout: CI sets it in one line, and a build that would otherwise depend on
-// the registry being up cannot silently start doing so again.
-const OfflineEnv = "PORTOLAN_OFFLINE"
-
-func offline() bool {
-	if strings.TrimSpace(os.Getenv(OfflineEnv)) != "" {
-		return true
-	}
-
-	// CI verifies what was committed. It never needs to reach the registry, and
-	// a fork's pull request has no secret to reach it with.
-	switch strings.ToLower(strings.TrimSpace(os.Getenv("CI"))) {
-	case "", "0", "false":
-		return false
-	default:
-		return true
-	}
-}