@automattic/vip 4.1.5 → 4.1.6

package/internal/devenv/instancedata/instancedata.go

@@ -1,239 +0,0 @@
-// Package instancedata reads and writes a dev environment's
-// instance_data.json. Ports the data layer of dev-environment-core.ts
-// (readEnvironmentData / writeEnvironmentData / getAllEnvironmentNames /
-// doesEnvironmentExist). Unknown keys are preserved losslessly so files
-// written by older/newer CLIs survive a round-trip (spec §10).
-package instancedata
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-// ComponentConfig mirrors types.ts ComponentConfig.
-type ComponentConfig struct {
-	Mode  string `json:"mode"`
-	Dir   string `json:"dir,omitempty"`
-	Image string `json:"image,omitempty"`
-	Tag   string `json:"tag,omitempty"`
-}
-
-// WordPressConfig mirrors types.ts WordPressConfig.
-type WordPressConfig struct {
-	Mode         string `json:"mode"`
-	Tag          string `json:"tag"`
-	Ref          string `json:"ref,omitempty"`
-	DoNotUpgrade bool   `json:"doNotUpgrade,omitempty"`
-}
-
-// InstanceData mirrors types.ts InstanceData. multisite and elasticsearch
-// are JS union types (bool|string), kept as json.RawMessage to round-trip
-// faithfully; typed accessors are added in a later plan when consumers
-// need them. Extra holds every key not modeled above, preserved verbatim.
-type InstanceData struct {
-	SiteSlug string `json:"siteSlug"`
-	WPTitle  string `json:"wpTitle"`
-	// Multisite is a JS union (bool|string). NOTE for environment-creation
-	// code (Plan 4): a nil value serializes as `"multisite": null`, which
-	// differs from the Node CLI (it always writes `false` or a string).
-	// Creators MUST set this explicitly (e.g. json.RawMessage("false")) to
-	// match Node output; reads round-trip whatever was on disk.
-	Multisite           json.RawMessage `json:"multisite"`
-	WordPress           WordPressConfig `json:"wordpress"`
-	MuPlugins           ComponentConfig `json:"muPlugins"`
-	AppCode             ComponentConfig `json:"appCode"`
-	MediaRedirectDomain string          `json:"mediaRedirectDomain"`
-	PHPMyAdmin          bool            `json:"phpmyadmin"`
-	Xdebug              bool            `json:"xdebug"`
-	XdebugConfig        string          `json:"xdebugConfig,omitempty"`
-	MariaDB             string          `json:"mariadb,omitempty"`
-	PHP                 string          `json:"php"`
-	Elasticsearch       json.RawMessage `json:"elasticsearch,omitempty"`
-	Mailpit             bool            `json:"mailpit"`
-	Photon              bool            `json:"photon"`
-	Cron                bool            `json:"cron"`
-	PullAfter           *int64          `json:"pullAfter,omitempty"`
-	AutologinKey        string          `json:"autologinKey,omitempty"`
-	AdminPassword       string          `json:"adminPassword,omitempty"`
-	Version             string          `json:"version,omitempty"`
-	Overrides           string          `json:"overrides,omitempty"`
-	// MigratedFromLando is an RFC3339 timestamp stamped the first time this env
-	// was adopted from a pre-existing Lando environment (Go-only; surfaced in
-	// `dev-env info`). Empty means never adopted.
-	MigratedFromLando string `json:"migratedFromLando,omitempty"`
-	// Domain is the per-env domain. New envs pin it explicitly at create
-	// (compose.DefaultDomain, "vipdev.site", unless `create --domain` overrides);
-	// an empty value marks a pre-switch/legacy env and is backfilled to
-	// LegacyDomain ("vipdev.lndo.site") on read. Consumed by compose.Options.Domain.
-	Domain string `json:"domain,omitempty"`
-	// ExternalVolumes maps a logical volume name to an existing (Lando) volume
-	// name; non-empty marks the env as migrated (Plan 4 §D). Declared external
-	// in the rendered compose so a destroy never deletes the original data.
-	ExternalVolumes map[string]string `json:"externalVolumes,omitempty"`
-	// EnvVars holds per-env user variables (Plan 5 `dev-env envvar`). Node
-	// stores these in the env's .env file; the Go port keeps them here in
-	// instance_data.json because Materialize owns/overwrites .env on every
-	// Start/Rebuild. They are injected into the php service environment on
-	// materialize (compose.View.EnvVars).
-	EnvVars map[string]string `json:"envVars,omitempty"`
-
-	// Extra carries unmodeled keys verbatim for lossless round-trip.
-	Extra map[string]json.RawMessage `json:"-"`
-}
-
-// LegacyDomain is the domain used by envs created before the vipdev.site switch
-// (and Lando-migrated envs). An env whose stored Domain is empty predates the
-// switch, so it is backfilled to this value on read — keeping its DB siteurl
-// (which references *.vipdev.lndo.site) valid. New envs pin compose.DefaultDomain
-// explicitly at create time, so they are never empty and never backfilled.
-const LegacyDomain = "vipdev.lndo.site"
-
-// knownKeys is the set of JSON keys modeled by InstanceData's fields.
-var knownKeys = map[string]bool{
-	"siteSlug": true, "wpTitle": true, "multisite": true, "wordpress": true,
-	"muPlugins": true, "appCode": true, "mediaRedirectDomain": true,
-	"phpmyadmin": true, "xdebug": true, "xdebugConfig": true, "mariadb": true,
-	"php": true, "elasticsearch": true, "mailpit": true, "photon": true,
-	"cron": true, "pullAfter": true, "autologinKey": true, "adminPassword": true,
-	"version": true, "overrides": true,
-	"domain": true, "externalVolumes": true, "envVars": true,
-	"migratedFromLando": true,
-}
-
-func parse(b []byte) (*InstanceData, error) {
-	d := &InstanceData{}
-	if err := json.Unmarshal(b, d); err != nil {
-		return nil, err
-	}
-
-	var all map[string]json.RawMessage
-	if err := json.Unmarshal(b, &all); err != nil {
-		return nil, err
-	}
-	d.Extra = map[string]json.RawMessage{}
-	for k, v := range all {
-		if !knownKeys[k] {
-			d.Extra[k] = v
-		}
-	}
-
-	applyBackcompat(d)
-	return d, nil
-}
-
-// serialize merges modeled fields over the preserved unknown keys and
-// emits 2-space-indented JSON (matching Node's JSON.stringify(data, null, 2)
-// indentation; key ordering may differ, which is acceptable per spec §10).
-func serialize(d *InstanceData) ([]byte, error) {
-	knownBytes, err := json.Marshal(d)
-	if err != nil {
-		return nil, err
-	}
-	var known map[string]json.RawMessage
-	if err := json.Unmarshal(knownBytes, &known); err != nil {
-		return nil, err
-	}
-
-	merged := make(map[string]json.RawMessage, len(d.Extra)+len(known))
-	for k, v := range d.Extra {
-		merged[k] = v
-	}
-	for k, v := range known {
-		merged[k] = v
-	}
-	return json.MarshalIndent(merged, "", "  ")
-}
-
-// applyBackcompat ports the BACKWARDS COMPATIBILITY section of
-// readEnvironmentData (dev-environment-core.ts:558-575).
-func applyBackcompat(d *InstanceData) {
-	// enterpriseSearchEnabled / elasticsearchEnabled -> elasticsearch
-	for _, legacy := range []string{"enterpriseSearchEnabled", "elasticsearchEnabled"} {
-		if v, ok := d.Extra[legacy]; ok && isTruthyJSON(v) {
-			d.Elasticsearch = json.RawMessage("true")
-		}
-	}
-	// clientCode -> appCode
-	if v, ok := d.Extra["clientCode"]; ok {
-		var cc ComponentConfig
-		if err := json.Unmarshal(v, &cc); err == nil {
-			d.AppCode = cc
-		}
-	}
-	// Envs created before the vipdev.site switch stored no domain; pin them to the
-	// legacy domain so they keep resolving to their original *.vipdev.lndo.site host.
-	if d.Domain == "" {
-		d.Domain = LegacyDomain
-	}
-}
-
-func isTruthyJSON(v json.RawMessage) bool {
-	var b bool
-	if err := json.Unmarshal(v, &b); err == nil {
-		return b
-	}
-	var s string
-	if err := json.Unmarshal(v, &s); err == nil {
-		return s != ""
-	}
-	return false
-}
-
-const instanceDataFileName = "instance_data.json"
-
-// Read loads and migrates an environment's instance data. Error messages
-// mirror readEnvironmentData (dev-environment-core.ts:529-578).
-func Read(slug string) (*InstanceData, error) {
-	target := filepath.Join(paths.EnvironmentPath(slug), instanceDataFileName)
-	b, err := os.ReadFile(target)
-	if err != nil {
-		return nil, fmt.Errorf("There was an error reading file %q: %s.", target, err)
-	}
-	d, err := parse(b)
-	if err != nil {
-		return nil, fmt.Errorf("There was an error parsing file %q: %s. You may need to recreate the environment.", target, err)
-	}
-	return d, nil
-}
-
-// Write serializes instance data to disk, creating the env directory if
-// needed. Ports writeEnvironmentData (2-space indent).
-func Write(slug string, d *InstanceData) error {
-	dir := paths.EnvironmentPath(slug)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return err
-	}
-	out, err := serialize(d)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(filepath.Join(dir, instanceDataFileName), out, 0o644)
-}
-
-// Exists reports whether an environment's instance_data.json is a file.
-// Ports doesEnvironmentExist (dev-environment-core.ts:518-527).
-func Exists(slug string) bool {
-	info, err := os.Stat(filepath.Join(paths.EnvironmentPath(slug), instanceDataFileName))
-	return err == nil && info.Mode().IsRegular()
-}
-
-// AllNames lists environment directory names under the dev-env base dir.
-// Ports getAllEnvironmentNames (dev-environment-core.ts:705-723): only
-// directories count; a missing base dir yields an empty slice.
-func AllNames() []string {
-	entries, err := os.ReadDir(paths.DevEnvBase())
-	if err != nil {
-		return nil
-	}
-	var names []string
-	for _, e := range entries {
-		if e.IsDir() {
-			names = append(names, e.Name())
-		}
-	}
-	return names
-}

package/internal/devenv/instancedata/instancedata_test.go

@@ -1,281 +0,0 @@
-package instancedata
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-func TestMigratedFromLandoRoundTrips(t *testing.T) {
-	in := []byte(`{"siteSlug":"foo","wpTitle":"Foo","multisite":false,"php":"8.2","migratedFromLando":"2026-07-10T00:00:00Z"}`)
-	d, err := parse(in)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if d.MigratedFromLando != "2026-07-10T00:00:00Z" {
-		t.Fatalf("want marker parsed, got %q", d.MigratedFromLando)
-	}
-	out, err := serialize(d)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(out), `"migratedFromLando": "2026-07-10T00:00:00Z"`) {
-		t.Fatalf("marker not serialized: %s", out)
-	}
-}
-
-func TestWriteThenReadRoundTrips(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-
-	in := &InstanceData{
-		SiteSlug:  "rt",
-		WPTitle:   "Round Trip",
-		Multisite: json.RawMessage("false"),
-		WordPress: WordPressConfig{Mode: "image", Tag: "trunk"},
-		MuPlugins: ComponentConfig{Mode: "image"},
-		AppCode:   ComponentConfig{Mode: "local", Dir: "/srv/rt"},
-		PHP:       "php:8.2",
-		Extra:     map[string]json.RawMessage{"keepMe": json.RawMessage(`"yes"`)},
-	}
-	if err := Write("rt", in); err != nil {
-		t.Fatalf("Write: %v", err)
-	}
-	if !Exists("rt") {
-		t.Fatalf("Exists(rt) = false after Write")
-	}
-
-	out, err := Read("rt")
-	if err != nil {
-		t.Fatalf("Read: %v", err)
-	}
-	if out.SiteSlug != "rt" || out.WPTitle != "Round Trip" {
-		t.Fatalf("round-trip mismatch: %+v", out)
-	}
-	if string(out.Extra["keepMe"]) != `"yes"` {
-		t.Fatalf("Extra not preserved: %q", out.Extra["keepMe"])
-	}
-}
-
-func TestReadMissingFileReturnsError(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	_, err := Read("nope")
-	if err == nil {
-		t.Fatal("expected error reading missing env")
-	}
-}
-
-func TestExistsFalseForMissing(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if Exists("ghost") {
-		t.Fatal("Exists(ghost) = true for missing env")
-	}
-}
-
-func TestParseSerializePreservesUnknownKeys(t *testing.T) {
-	raw, err := os.ReadFile(filepath.Join("testdata", "unknown_keys.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	d, err := parse(raw)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if d.SiteSlug != "example" || d.WPTitle != "Example Dev" {
-		t.Fatalf("known fields not parsed: %+v", d)
-	}
-	if !d.PHPMyAdmin {
-		t.Fatalf("phpmyadmin should be true")
-	}
-	if _, ok := d.Extra["futureKeyWeDoNotModel"]; !ok {
-		t.Fatalf("unknown key futureKeyWeDoNotModel not captured in Extra")
-	}
-
-	out, err := serialize(d)
-	if err != nil {
-		t.Fatalf("serialize: %v", err)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(out, &got); err != nil {
-		t.Fatalf("re-parse: %v", err)
-	}
-	if _, ok := got["futureKeyWeDoNotModel"]; !ok {
-		t.Fatalf("unknown key lost on serialize")
-	}
-	if got["anotherUnknown"] != "keep-me" {
-		t.Fatalf("unknown scalar lost: %v", got["anotherUnknown"])
-	}
-	if got["siteSlug"] != "example" {
-		t.Fatalf("known key lost: %v", got["siteSlug"])
-	}
-}
-
-func TestParseAppliesBackcompatMigrations(t *testing.T) {
-	raw, err := os.ReadFile(filepath.Join("testdata", "legacy_keys.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	d, err := parse(raw)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-
-	if string(d.Elasticsearch) != "true" {
-		t.Fatalf("enterpriseSearchEnabled should migrate to elasticsearch=true, got %q", d.Elasticsearch)
-	}
-	if d.AppCode.Mode != "local" || d.AppCode.Dir != "/srv/legacy" {
-		t.Fatalf("clientCode should migrate to appCode, got %+v", d.AppCode)
-	}
-}
-
-// TestParseMigratesElasticsearchEnabledAlias covers the second legacy
-// elasticsearch alias (elasticsearchEnabled), which the fixture-based test
-// above does not exercise. applyBackcompat treats both enterpriseSearchEnabled
-// and elasticsearchEnabled as inputs (dev-environment-core.ts:565-568).
-func TestParseMigratesElasticsearchEnabledAlias(t *testing.T) {
-	in := []byte(`{
-		"siteSlug": "es",
-		"wpTitle": "ES",
-		"multisite": false,
-		"wordpress": { "mode": "image", "tag": "trunk" },
-		"muPlugins": { "mode": "image" },
-		"appCode": { "mode": "image" },
-		"mediaRedirectDomain": "",
-		"phpmyadmin": false,
-		"xdebug": false,
-		"php": "php:8.2",
-		"mailpit": false,
-		"photon": false,
-		"cron": false,
-		"elasticsearchEnabled": true
-	}`)
-	d, err := parse(in)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if string(d.Elasticsearch) != "true" {
-		t.Fatalf("elasticsearchEnabled should migrate to elasticsearch=true, got %q", d.Elasticsearch)
-	}
-}
-
-// TestKnownKeysMatchStructTags machine-verifies the invariant that every
-// modeled struct json tag is listed in knownKeys (and vice versa). If a
-// field is added to InstanceData but not to knownKeys, parse() would put
-// its key into Extra AND serialize() would also write it from the struct,
-// double-writing the key — silent corruption. This test catches that drift.
-func TestKnownKeysMatchStructTags(t *testing.T) {
-	rt := reflect.TypeOf(InstanceData{})
-
-	tagNames := map[string]bool{}
-	for i := 0; i < rt.NumField(); i++ {
-		tag := rt.Field(i).Tag.Get("json")
-		if tag == "" || tag == "-" {
-			continue
-		}
-		name := strings.Split(tag, ",")[0]
-		if name == "" {
-			continue
-		}
-		tagNames[name] = true
-		if !knownKeys[name] {
-			t.Errorf("struct field %s has json key %q missing from knownKeys (would be double-written on round-trip)", rt.Field(i).Name, name)
-		}
-	}
-
-	for k := range knownKeys {
-		if !tagNames[k] {
-			t.Errorf("knownKeys has %q with no corresponding struct json tag", k)
-		}
-	}
-}
-
-func TestDomainAndExternalVolumesRoundTrip(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	in := &InstanceData{
-		SiteSlug:        "example",
-		Multisite:       json.RawMessage("false"),
-		Domain:          "mysite.test",
-		ExternalVolumes: map[string]string{"database_data": "landoproj_database_data"},
-	}
-	if err := Write("example", in); err != nil {
-		t.Fatal(err)
-	}
-	got, err := Read("example")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got.Domain != "mysite.test" {
-		t.Fatalf("domain lost: %q", got.Domain)
-	}
-	if got.ExternalVolumes["database_data"] != "landoproj_database_data" {
-		t.Fatalf("external volumes lost: %+v", got.ExternalVolumes)
-	}
-}
-
-func TestEnvVarsRoundTrip(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	d := &InstanceData{
-		SiteSlug:  "evs",
-		Multisite: json.RawMessage("false"),
-		EnvVars:   map[string]string{"MY_VAR": "hello", "OTHER": "x"},
-	}
-	if err := Write("evs", d); err != nil {
-		t.Fatal(err)
-	}
-	got, err := Read("evs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got.EnvVars["MY_VAR"] != "hello" || got.EnvVars["OTHER"] != "x" {
-		t.Fatalf("EnvVars did not round-trip: %+v", got.EnvVars)
-	}
-}
-
-func TestEmptyDomainBackfilledToLegacy(t *testing.T) {
-	d := &InstanceData{} // Domain == ""
-	applyBackcompat(d)
-	if d.Domain != LegacyDomain {
-		t.Fatalf("empty Domain = %q, want LegacyDomain %q", d.Domain, LegacyDomain)
-	}
-	d2 := &InstanceData{Domain: "vipdev.site"}
-	applyBackcompat(d2)
-	if d2.Domain != "vipdev.site" {
-		t.Fatalf("non-empty Domain must be left alone, got %q", d2.Domain)
-	}
-}
-
-func TestAllNamesListsEnvironmentDirectories(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-
-	// No base dir yet -> empty, no error.
-	if names := AllNames(); len(names) != 0 {
-		t.Fatalf("expected no envs, got %v", names)
-	}
-
-	for _, slug := range []string{"alpha", "beta"} {
-		if err := Write(slug, &InstanceData{SiteSlug: slug, Multisite: json.RawMessage("false")}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	// A stray file (not a directory) must be ignored.
-	if err := os.WriteFile(filepath.Join(paths.DevEnvBase(), "stray.txt"), []byte("x"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	got := AllNames()
-	want := map[string]bool{"alpha": true, "beta": true}
-	if len(got) != 2 {
-		t.Fatalf("AllNames() = %v, want alpha+beta only", got)
-	}
-	for _, n := range got {
-		if !want[n] {
-			t.Fatalf("unexpected env name %q in %v", n, got)
-		}
-	}
-}

package/internal/devenv/instancedata/testdata/legacy_keys.json

@@ -1,16 +0,0 @@
-{
-  "siteSlug": "legacy",
-  "wpTitle": "Legacy",
-  "multisite": false,
-  "wordpress": { "mode": "image", "tag": "trunk" },
-  "muPlugins": { "mode": "image" },
-  "mediaRedirectDomain": "",
-  "phpmyadmin": false,
-  "xdebug": false,
-  "php": "php:8.2",
-  "mailpit": false,
-  "photon": false,
-  "cron": false,
-  "enterpriseSearchEnabled": true,
-  "clientCode": { "mode": "local", "dir": "/srv/legacy" }
-}

package/internal/devenv/instancedata/testdata/unknown_keys.json

@@ -1,19 +0,0 @@
-{
-  "siteSlug": "example",
-  "wpTitle": "Example Dev",
-  "multisite": false,
-  "wordpress": { "mode": "image", "tag": "trunk" },
-  "muPlugins": { "mode": "image" },
-  "appCode": { "mode": "local", "dir": "/srv/example" },
-  "mediaRedirectDomain": "",
-  "phpmyadmin": true,
-  "xdebug": false,
-  "php": "ghcr.io/automattic/vip-container-images/php-fpm:8.2",
-  "mailpit": false,
-  "photon": false,
-  "cron": false,
-  "pullAfter": 1700000000000,
-  "adminPassword": "s3cret",
-  "futureKeyWeDoNotModel": { "nested": [1, 2, 3] },
-  "anotherUnknown": "keep-me"
-}

package/internal/devenv/lifecycle/adopt.go

@@ -1,24 +0,0 @@
-package lifecycle
-
-import (
-	"context"
-	"fmt"
-)
-
-// AdoptLando hands a pre-existing Lando environment to the Go engine. It removes
-// Lando's old containers + the per-project network via `compose down
-// --remove-orphans` (NO -v, so named data volumes are kept) and, when Lando owned
-// the shared proxy, force-removes it so proxy.Ensure rebuilds the correct image.
-// The natural same-name volume reuse (compose's `<slug>_database_data` equals the
-// Lando volume) then preserves the data on the following start.
-func AdoptLando(ctx context.Context, deps Deps, slug string, plan MigrationPlan) error {
-	if err := deps.Docker.Compose(ctx, slug, "down", "--remove-orphans"); err != nil {
-		return fmt.Errorf("removing old Lando containers for %q: %w", slug, err)
-	}
-	if plan.LandoProxy {
-		if err := deps.Proxy.ForceRemove(ctx); err != nil {
-			return fmt.Errorf("removing Lando proxy: %w", err)
-		}
-	}
-	return nil
-}

package/internal/devenv/lifecycle/adopt_test.go

@@ -1,43 +0,0 @@
-package lifecycle
-
-import (
-	"context"
-	"strings"
-	"testing"
-)
-
-func TestAdoptLandoRemovesContainersKeepsVolumes(t *testing.T) {
-	d := &fakeDocker{}
-	events := []string{}
-	deps := Deps{Docker: d, Proxy: recProxy{events: &events}}
-	err := AdoptLando(context.Background(), deps, "example", MigrationPlan{Detected: true, LandoProxy: false})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(d.calls) != 1 {
-		t.Fatalf("want exactly one compose call, got %v", d.calls)
-	}
-	got := strings.Join(d.calls[0], " ")
-	if !strings.Contains(got, "down --remove-orphans") {
-		t.Fatalf("want `down --remove-orphans`, got %q", got)
-	}
-	if strings.Contains(got, "--volumes") || strings.Contains(got, " -v") {
-		t.Fatalf("adoption must NOT delete volumes, got %q", got)
-	}
-	if strings.Contains(strings.Join(events, ","), "proxy.ForceRemove") {
-		t.Fatal("proxy must not be force-removed when LandoProxy=false")
-	}
-}
-
-func TestAdoptLandoRemovesProxyWhenLandoOwned(t *testing.T) {
-	d := &fakeDocker{}
-	events := []string{}
-	deps := Deps{Docker: d, Proxy: recProxy{events: &events}}
-	err := AdoptLando(context.Background(), deps, "example", MigrationPlan{Detected: true, LandoProxy: true})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(strings.Join(events, ","), "proxy.ForceRemove") {
-		t.Fatalf("expected proxy.ForceRemove, events=%v", events)
-	}
-}

package/internal/devenv/lifecycle/health.go

@@ -1,28 +0,0 @@
-package lifecycle
-
-import (
-	"fmt"
-
-	"github.com/Automattic/vip/internal/devenv/proxy"
-)
-
-// SiteURL builds the front-end HTTPS URL, including the bound https port only
-// when it is not the default 443 (the place Lando drifts: printed URL vs bound
-// port).
-func SiteURL(slug, domain string, ports proxy.Ports) string {
-	host := slug + "." + domain
-	if ports.HTTPS == 443 {
-		return "https://" + host + "/"
-	}
-	return fmt.Sprintf("https://%s:%d/", host, ports.HTTPS)
-}
-
-// Healthy probes the site URL and reports whether it returned a non-5xx, non-0
-// status (the env is up and routing). Network errors are returned.
-func Healthy(p Prober, slug, domain string, ports proxy.Ports) (bool, error) {
-	code, err := p.Probe(SiteURL(slug, domain, ports))
-	if err != nil {
-		return false, err
-	}
-	return code >= 200 && code < 500, nil
-}

package/internal/devenv/lifecycle/health_test.go

@@ -1,34 +0,0 @@
-package lifecycle
-
-import (
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/proxy"
-)
-
-func TestSiteURLUsesBoundHTTPSPort(t *testing.T) {
-	if got := SiteURL("example", "vipdev.lndo.site", proxy.Ports{HTTP: 80, HTTPS: 443}); got != "https://example.vipdev.lndo.site/" {
-		t.Fatalf("443 should be portless: %q", got)
-	}
-	if got := SiteURL("example", "vipdev.lndo.site", proxy.Ports{HTTP: 8000, HTTPS: 4444}); got != "https://example.vipdev.lndo.site:4444/" {
-		t.Fatalf("fallback port must appear: %q", got)
-	}
-}
-
-type fakeProber struct {
-	codes map[string]int
-}
-
-func (f *fakeProber) Probe(url string) (int, error) { return f.codes[url], nil }
-
-func TestHealthProbesSiteURL(t *testing.T) {
-	url := "https://example.vipdev.lndo.site/"
-	p := &fakeProber{codes: map[string]int{url: 200}}
-	ok, err := Healthy(p, "example", "vipdev.lndo.site", proxy.Ports{HTTP: 80, HTTPS: 443})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !ok {
-		t.Fatal("expected healthy when site returns 200")
-	}
-}