@automattic/vip 4.1.4 → 4.1.6

package/internal/devenv/devenv.go

@@ -1,434 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Automattic/vip/internal/debuglog"
-	"github.com/Automattic/vip/internal/version"
-
-	"github.com/Automattic/vip/internal/devenv/compose"
-	"github.com/Automattic/vip/internal/devenv/devlog"
-	"github.com/Automattic/vip/internal/devenv/dockercli"
-	"github.com/Automattic/vip/internal/devenv/hostops"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-	"github.com/Automattic/vip/internal/devenv/lifecycle"
-	"github.com/Automattic/vip/internal/devenv/paths"
-	"github.com/Automattic/vip/internal/devenv/proxy"
-	"github.com/Automattic/vip/internal/httpproxy"
-)
-
-// newRunner builds the production docker runner. DockerSocket() is called once
-// (intentional DOCKER_HOST side effect — Plan 1 parity). When ctx carries a
-// session logger (set by the cobra layer for create/start), the runner tees its
-// docker output into that per-env log.
-func newRunner(ctx context.Context) (*dockercli.Runner, error) {
-	socket, err := dockercli.DockerSocket()
-	if err != nil {
-		debuglog.Printf(ctx, debugNamespace, "Docker endpoint resolution failed")
-		return nil, err
-	}
-	// DOCKER_HOST may contain credentials; only report whether it was resolved.
-	debuglog.Printf(ctx, debugNamespace, "Docker endpoint resolved: explicit=%t", socket != "")
-	return &dockercli.Runner{Log: devlog.FromContext(ctx)}, nil
-}
-
-func goos() string { return runtime.GOOS }
-
-// logBanner assembles the diagnostic banner written to the head of a fresh
-// per-invocation log (ports writeLogBanner, dev-environment-lando.ts).
-func logBanner(ctx context.Context, r *dockercli.Runner) devlog.Banner {
-	return devlog.Banner{
-		Command: strings.Join(os.Args, " "),
-		OS:      fmt.Sprintf("%s %s", runtime.GOOS, runtime.GOARCH),
-		CLI:     version.Version,
-		Runtime: "go",
-		Docker:  r.Versions(ctx),
-		RAMGB:   "unknown",
-		CPUs:    strconv.Itoa(runtime.NumCPU()),
-	}
-}
-
-// StartOptions tunes a start.
-type StartOptions struct {
-	// SkipRebuild only starts services that are not already running (omits the
-	// compose --force-recreate), matching Node `start --skip-rebuild`.
-	SkipRebuild bool
-	// Lando, when non-nil and Detected, adopts a pre-existing Lando environment
-	// for this slug before starting: its old containers/proxy are removed and its
-	// data volume reused. Set by the cobra layer after PlanLandoMigration + a
-	// confirmation prompt.
-	Lando *lifecycle.MigrationPlan
-}
-
-// Create writes a new env and (when c.Start) starts it.
-func Create(ctx context.Context, c CreateConfig) error {
-	debuglog.Printf(ctx, debugNamespace, "Will create an environment %q: start=%t", c.Slug, c.Start)
-	if err := writeNewEnv(c); err != nil {
-		return err
-	}
-	if c.Start {
-		return Start(ctx, c.Slug, StartOptions{})
-	}
-	return nil
-}
-
-// Start materializes + starts an existing env (detecting migration on first run).
-func Start(ctx context.Context, slug string, opts StartOptions) error {
-	debuglog.Printf(ctx, debugNamespace, "Will start an environment %q: skipRebuild=%t", slug, opts.SkipRebuild)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	return startStack(ctx, r, realDeps(r), slug, opts)
-}
-
-// PlanLandoMigration detects a pre-existing Lando footprint for slug so the cobra
-// layer can prompt before an irreversible adoption. It builds a runner and
-// delegates to lifecycle.DetectLandoMigration.
-func PlanLandoMigration(ctx context.Context, slug string) (lifecycle.MigrationPlan, error) {
-	r, err := newRunner(ctx)
-	if err != nil {
-		return lifecycle.MigrationPlan{}, err
-	}
-	return lifecycle.DetectLandoMigration(ctx, dockerAdapter{r: r}, slug)
-}
-
-// Rebuild downs (keeping volumes) + orphan-guards, then re-runs the start stack.
-func Rebuild(ctx context.Context, slug string) error {
-	debuglog.Printf(ctx, debugNamespace, "Will rebuild an environment %q", slug)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	deps := realDeps(r)
-	if err := lifecycle.Rebuild(ctx, deps.Docker, deps.Proxy, slug); err != nil {
-		return err
-	}
-	return startStack(ctx, r, deps, slug, StartOptions{})
-}
-
-// startStack reads instance-data, runs one-time migration detection, materializes
-// the compose files, pull-gates images, and runs lifecycle.Start. Shared by Start
-// and Rebuild.
-func startStack(ctx context.Context, r *dockercli.Runner, deps lifecycle.Deps, slug string, opts StartOptions) error {
-	debuglog.Printf(ctx, debugNamespace, "Will try to get instance data for environment %q", slug)
-	// Write the diagnostic banner to the head of a fresh per-invocation log
-	// (Node parity: writeLogBanner). No-op if the file already has content.
-	if r.Log != nil {
-		_ = r.Log.WriteBanner(logBanner(ctx, r))
-	}
-	d, err := instancedata.Read(slug)
-	if err != nil {
-		return err
-	}
-	view := compose.NewView(d, compose.Options{
-		Domain:              d.Domain,
-		Migrate:             len(d.ExternalVolumes) > 0,
-		ExternalVolumeNames: d.ExternalVolumes,
-	})
-	if _, err := Materialize(slug, view); err != nil {
-		return err
-	}
-	debuglog.Printf(ctx, debugNamespace, "Environment %q configuration materialized", slug)
-	// One-time Lando adoption: after materialize (so `compose down` finds the
-	// project's compose file) and before Start (so the Go proxy/containers come up
-	// clean on the reused data volume).
-	if opts.Lando != nil && opts.Lando.Detected {
-		if err := lifecycle.AdoptLando(ctx, deps, slug, *opts.Lando); err != nil {
-			return err
-		}
-		d.MigratedFromLando = time.Now().UTC().Format(time.RFC3339)
-		if err := instancedata.Write(slug, d); err != nil {
-			return err
-		}
-	}
-	reachable := registryReachable()
-	pull := lifecycle.ShouldPull(time.Now(), d.PullAfter, reachable)
-	debuglog.Printf(ctx, debugNamespace, "Registry ghcr.io resolvable=%t; environment %q pull=%t", reachable, slug, pull)
-	if pull {
-		if err := r.Compose(ctx, slug, "pull"); err != nil {
-			return err
-		}
-		now := time.Now().Unix()
-		d.PullAfter = &now
-		_ = instancedata.Write(slug, d) // best-effort: pull succeeded; a stale timestamp only re-pulls next time
-	}
-	_, err = lifecycle.Start(ctx, deps, lifecycle.StartParams{
-		Project:      slug,
-		View:         view,
-		CertSANs:     compose.CertSANs(view),
-		HostsAdd:     envHosts(view, nil),
-		InitServices: initServices(view),
-		SetupSteps:   adoptSetupSteps(compose.SetupSteps(view), opts.Lando != nil && opts.Lando.Detected),
-		Pull:         pull,
-		SkipRebuild:  opts.SkipRebuild,
-		GOOS:         goos(),
-	})
-	return err
-}
-
-// Stop stops an env's containers.
-func Stop(ctx context.Context, slug string) error {
-	debuglog.Printf(ctx, debugNamespace, "Will stop an environment %q", slug)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	return lifecycle.Stop(ctx, dockerAdapter{r: r}, slug)
-}
-
-// StopAll stops every on-disk environment (Node `dev-env stop --all`).
-func StopAll(ctx context.Context) error {
-	debuglog.Printf(ctx, debugNamespace, "Will stop all environments")
-	return stopEachEnv(instancedata.AllNames(), func(slug string) error {
-		return Stop(ctx, slug)
-	})
-}
-
-// stopEachEnv / purgeEachEnv apply an operation to every environment, CONTINUING
-// past a failure and reporting all of them at the end. Node wraps each iteration
-// of `stop --all` (vip-dev-env-stop.js:72-100) and `purge`
-// (vip-dev-env-purge.js:85-98) in its own try/catch: it prints the error, sets
-// process.exitCode = 1 and moves on. Returning on the first error instead left
-// the remaining environments running / half-purged.
-func stopEachEnv(names []string, stop func(string) error) error {
-	return eachEnv(names, stop)
-}
-
-func purgeEachEnv(names []string, destroy func(string) error) error {
-	return eachEnv(names, destroy)
-}
-
-// purgeEnvStep is the per-environment body of Purge, split out from the Docker
-// plumbing so its error handling is unit-testable.
-//
-// The removal error is PROPAGATED. Node does the removal inside
-// destroyEnvironment with a bare `fs.promises.rm(instancePath, {recursive:
-// true})` — no `force: true` (dev-environment-core.ts:381-382) — so a failure
-// rejects and the purge bin sets `process.exitCode = 1`
-// (vip-dev-env-purge.js:92-97). Dropping it left an environment on disk (still
-// listed by `dev-env list`, still counted by instancedata.AllNames()) while
-// purge exited 0. The single-environment Destroy path always propagated it.
-func purgeEnvStep(destroy, removeFiles func(string) error, soft bool) func(string) error {
-	return func(slug string) error {
-		if err := destroy(slug); err != nil {
-			return err
-		}
-		if soft {
-			// A soft purge keeps the env's config files so it can be recreated.
-			return nil
-		}
-		return removeFiles(slug)
-	}
-}
-
-func eachEnv(names []string, fn func(string) error) error {
-	var errs []error
-	for _, name := range names {
-		if err := fn(name); err != nil {
-			errs = append(errs, fmt.Errorf("%s: %w", name, err))
-		}
-	}
-	return errors.Join(errs...)
-}
-
-// Destroy tears down an env's containers/volumes. When soft is true the env's
-// config files (and its /etc/hosts entry) are KEPT so it can be recreated (Node
-// `--soft`); otherwise the env dir is removed and /etc/hosts is recomputed for
-// the remaining envs.
-func Destroy(ctx context.Context, slug string, soft bool) error {
-	debuglog.Printf(ctx, debugNamespace, "Will destroy an environment %q: preserveFiles=%t", slug, soft)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	deps := realDeps(r)
-
-	hadCustom := false
-	if d, err := instancedata.Read(slug); err == nil {
-		hadCustom = len(envHosts(compose.NewView(d, compose.Options{Domain: d.Domain}), nil)) > 0
-	}
-
-	// A soft destroy leaves the env on disk, so it still counts as remaining
-	// (keeps the shared proxy alive for a later restart).
-	remaining := len(instancedata.AllNames())
-	if !soft {
-		remaining--
-	}
-	if err := lifecycle.Destroy(ctx, deps.Docker, deps.Proxy, slug, remaining); err != nil {
-		return err
-	}
-	if soft {
-		return nil
-	}
-	if err := removeEnvFiles(slug); err != nil {
-		return err
-	}
-	// Recompute the managed /etc/hosts block for the remaining envs — only when
-	// the file was or will be affected, to avoid a needless sudo prompt.
-	remain := remainingHosts()
-	if hadCustom || len(remain) > 0 {
-		plan := hostops.PrivilegedPlan{GOOS: goos()}
-		if len(remain) > 0 {
-			plan.HostsAdd = remain
-		} else {
-			plan.HostsRemove = true
-		}
-		return deps.Elevator.Apply(plan)
-	}
-	return nil
-}
-
-// Purge destroys every env, cleans up the shared proxy, and clears the managed
-// /etc/hosts block (only when some env had custom-domain entries — avoids a
-// needless sudo prompt).
-func Purge(ctx context.Context, soft bool) error {
-	debuglog.Printf(ctx, debugNamespace, "Will purge all environments: preserveFiles=%t", soft)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	deps := realDeps(r)
-	hadCustom := len(remainingHosts()) > 0
-	// Pass remaining=1 so lifecycle.Destroy never runs its per-env proxy cleanup
-	// (which fires only at remaining==0). Purge owns a single Proxy.Cleanup below,
-	// after every env is torn down.
-	//
-	// A failing environment must NOT abort the purge (Node continues and exits
-	// 1); the shared proxy + hosts cleanup below still has to run, otherwise one
-	// wedged environment leaves the machine half-purged.
-	destroyErr := purgeEachEnv(instancedata.AllNames(), purgeEnvStep(
-		func(slug string) error { return lifecycle.Destroy(ctx, deps.Docker, deps.Proxy, slug, 1) },
-		removeEnvFiles,
-		soft,
-	))
-	if err := deps.Proxy.Cleanup(ctx); err != nil {
-		return errors.Join(destroyErr, err)
-	}
-	// A soft purge keeps every env's config files + /etc/hosts entries.
-	if !soft && hadCustom {
-		return errors.Join(destroyErr, deps.Elevator.Apply(hostops.PrivilegedPlan{GOOS: goos(), HostsRemove: true}))
-	}
-	return destroyErr
-}
-
-// Info returns a human-readable summary of an env (URL from bound ports + status).
-func Info(ctx context.Context, slug string) (string, error) {
-	debuglog.Printf(ctx, debugNamespace, "Will get info for an environment %q", slug)
-	r, err := newRunner(ctx)
-	if err != nil {
-		return "", err
-	}
-	d, err := instancedata.Read(slug)
-	if err != nil {
-		return "", err
-	}
-	view := compose.NewView(d, compose.Options{Domain: d.Domain})
-	ports, _ := proxy.LoadPorts(proxy.PortsStatePath())
-	states, _ := dockerAdapter{r: r}.ComposePS(ctx, slug)
-	return renderEnvInfo(slug, view, ports, states), nil
-}
-
-// InfoAll returns the Info summary for every on-disk environment, separated by
-// a blank line (Node `dev-env info --all`).
-func InfoAll(ctx context.Context) (string, error) {
-	names := instancedata.AllNames()
-	debuglog.Printf(ctx, debugNamespace, "Will print info for all environments. Names found: %q", names)
-	if len(names) == 0 {
-		return "No local environments found.\n", nil
-	}
-	var b strings.Builder
-	for i, name := range names {
-		if s, err := Info(ctx, name); err != nil {
-			fmt.Fprintf(&b, "Environment: %s\n  error: %v\n", name, err)
-		} else {
-			b.WriteString(s)
-		}
-		if i < len(names)-1 {
-			b.WriteString("\n")
-		}
-	}
-	return b.String(), nil
-}
-
-// registryProbeURL is the registry the reachability check HEADs. A var so the
-// proxy-policy test can point it at a local server.
-var registryProbeURL = "https://ghcr.io/"
-
-// registryReachable does a quick HEAD to ghcr.io to gate image pulls.
-//
-// ghcr.io is off-box, so it follows vip-next's proxy policy rather than
-// http.DefaultTransport's: a developer behind the VIP SOCKS proxy has no other
-// route out, and one who declined VIP_USE_SYSTEM_PROXY must not have the probe
-// silently pushed through an ambient HTTPS_PROXY. See internal/httpproxy.
-func registryReachable() bool {
-	c := httpproxy.ClientWithTimeout(3 * time.Second)
-	resp, err := c.Head(registryProbeURL)
-	if err != nil {
-		return false
-	}
-	_ = resp.Body.Close()
-	return true
-}
-
-// viewForData builds the default render View for an env's instance data.
-func viewForData(d *instancedata.InstanceData) compose.View {
-	return compose.NewView(d, compose.Options{Domain: d.Domain})
-}
-
-// envHosts returns the hostnames an env needs in the managed hosts block: the
-// front-end host plus the pma/mailpit hosts for enabled services, then any
-// already-discovered multisite subsite hosts. Applies to ALL envs now (the
-// managed block is the offline supplement; online the public wildcard covers it).
-func envHosts(v compose.View, subsiteHosts []string) []string {
-	hosts := []string{v.SiteSlug + "." + v.Domain}
-	if v.PHPMyAdmin {
-		hosts = append(hosts, v.SiteSlug+"-pma."+v.Domain)
-	}
-	if v.Mailpit {
-		hosts = append(hosts, v.SiteSlug+"-mailpit."+v.Domain)
-	}
-	hosts = append(hosts, subsiteHosts...)
-	return hosts
-}
-
-// remainingHosts is the union of fixed hosts across every env still on disk
-// (used to recompute the hosts block after a destroy). Subsite hosts are not
-// re-discovered here; they refresh on each env's next start.
-func remainingHosts() []string {
-	var all []string
-	for _, name := range instancedata.AllNames() {
-		d, err := instancedata.Read(name)
-		if err != nil {
-			continue
-		}
-		view := compose.NewView(d, compose.Options{Domain: d.Domain})
-		all = append(all, envHosts(view, nil)...)
-	}
-	return all
-}
-
-// initServices lists the one-shot init services to wait for. Names are verified
-// against compose/project.go: wordpress init = "wordpress", mu-plugins = "vip-mu-plugins",
-// app-code = "demo-app-code".
-func initServices(v compose.View) []string {
-	svcs := []string{"wordpress"}
-	if !v.MuPluginsLocal {
-		svcs = append(svcs, "vip-mu-plugins")
-	}
-	if !v.AppCodeLocal {
-		svcs = append(svcs, "demo-app-code")
-	}
-	return svcs
-}
-
-func removeEnvFiles(slug string) error {
-	return os.RemoveAll(paths.EnvironmentPath(slug))
-}

package/internal/devenv/devenv_test.go

@@ -1,77 +0,0 @@
-package devenv
-
-import (
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/compose"
-)
-
-// TestEnvHostsDefaultDomainIncluded verifies that default-domain envs (vipdev.site)
-// DO get a managed hosts block entry now — previously default-domain envs were
-// excluded and relied solely on the public *.vipdev.site wildcard (which resolves
-// to 127.0.0.1 online). The managed block is the OFFLINE supplement, so every env
-// needs it regardless of domain.
-func TestEnvHostsDefaultDomainIncluded(t *testing.T) {
-	got := envHosts(compose.View{SiteSlug: "example", Domain: compose.DefaultDomain}, nil)
-	if len(got) == 0 {
-		t.Fatalf("expected at least one hosts entry for default domain %q, got none", compose.DefaultDomain)
-	}
-	if got[0] != "example."+compose.DefaultDomain {
-		t.Fatalf("first entry = %q, want %q", got[0], "example."+compose.DefaultDomain)
-	}
-}
-
-func TestEnvHostsCustomDomain(t *testing.T) {
-	v := compose.View{SiteSlug: "example", Domain: "mysite.test", PHPMyAdmin: true, Mailpit: true}
-	got := envHosts(v, nil)
-	want := map[string]bool{
-		"example.mysite.test":         true,
-		"example-pma.mysite.test":     true,
-		"example-mailpit.mysite.test": true,
-	}
-	if len(got) != len(want) {
-		t.Fatalf("got %v", got)
-	}
-	for _, h := range got {
-		if !want[h] {
-			t.Fatalf("unexpected host %q in %v", h, got)
-		}
-	}
-}
-
-func TestEnvHostsForDefaultDomain(t *testing.T) {
-	v := compose.View{SiteSlug: "demo", Domain: "vipdev.site", PHPMyAdmin: true, Mailpit: true}
-	got := envHosts(v, nil)
-	want := map[string]bool{
-		"demo.vipdev.site":         true,
-		"demo-pma.vipdev.site":     true,
-		"demo-mailpit.vipdev.site": true,
-	}
-	if len(got) != len(want) {
-		t.Fatalf("envHosts = %v, want keys %v", got, want)
-	}
-	for _, h := range got {
-		if !want[h] {
-			t.Fatalf("unexpected host %q in %v", h, got)
-		}
-	}
-}
-
-func TestEnvHostsOmitsDisabledServices(t *testing.T) {
-	v := compose.View{SiteSlug: "demo", Domain: "vipdev.site"} // no pma/mailpit
-	got := envHosts(v, nil)
-	if len(got) != 1 || got[0] != "demo.vipdev.site" {
-		t.Fatalf("envHosts = %v, want only demo.vipdev.site", got)
-	}
-}
-
-func TestInitServicesImageVsLocal(t *testing.T) {
-	full := initServices(compose.View{}) // image mode for both
-	if len(full) < 1 {
-		t.Fatal("expected at least the wordpress init service")
-	}
-	local := initServices(compose.View{MuPluginsLocal: true, AppCodeLocal: true})
-	if len(local) != 1 {
-		t.Fatalf("local mu-plugins+app-code should leave only the wordpress init service, got %v", local)
-	}
-}

package/internal/devenv/devexec.go

@@ -1,140 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/Automattic/vip/internal/debuglog"
-	"github.com/Automattic/vip/internal/devenv/devlog"
-	"github.com/Automattic/vip/internal/devenv/devterm"
-	"github.com/Automattic/vip/internal/devenv/dockercli"
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-// phpService is where wp-cli + WordPress live (verified against compose/services.go).
-const phpService = "php"
-
-// shellUserMap mirrors the Node dev-env shell userMap (vip-dev-env-shell.js).
-var shellUserMap = map[string]string{
-	"nginx": "www-data", "php": "www-data", "database": "mysql",
-	"memcached": "memcache", "elasticsearch": "elasticsearch",
-	"phpmyadmin": "www-data", "mailpit": "root", "photon": "root",
-}
-
-// shellUser resolves the container user for a shell: root when forced, else the
-// service's mapped user, else www-data.
-func shellUser(service string, root bool) string {
-	if root {
-		return "root"
-	}
-	if u, ok := shellUserMap[service]; ok {
-		return u
-	}
-	return "www-data"
-}
-
-// execOpts returns the leading `exec` token(s). When noTTY is set (stdin is not
-// a terminal) it appends -T to disable docker compose's default pseudo-TTY
-// allocation, which would otherwise fail with "the input device is not a TTY"
-// on piped stdin.
-func execOpts(noTTY bool) []string {
-	if noTTY {
-		return []string{"exec", "-T"}
-	}
-	return []string{"exec"}
-}
-
-// execArgv builds `docker compose -p <slug> exec [-T] php wp --allow-root <wpArgs...>`.
-// --allow-root is required because the php container runs as root, so wp-cli
-// would otherwise refuse with "YIKES! running as root".
-func execArgv(r *dockercli.Runner, slug string, wpArgs []string, noTTY bool) []string {
-	args := append(execOpts(noTTY), phpService, "wp", "--allow-root")
-	args = append(args, wpArgs...)
-	return r.ComposeArgv(slug, args...)
-}
-
-// defaultShellCmd is the command run when `dev-env shell` is given no explicit
-// command. It mirrors Node's landoShell (vip-dev-env-shell.js ->
-// dev-environment-lando.ts): prefer bash so the container's interactive profile
-// (the VIP banner, colored prompt, and aliases) loads, falling back to sh for
-// service containers (e.g. database) that ship no bash. The -i flag is passed
-// only when interactive, matching Node's stdin.isTTY check (-i vs no flag).
-func defaultShellCmd(interactive bool) []string {
-	flag := ""
-	if interactive {
-		flag = " -i"
-	}
-	script := fmt.Sprintf("if [ -x /bin/bash ]; then /bin/bash%s; else /bin/sh%s; fi; exit 0", flag, flag)
-	return []string{"/bin/sh", "-c", script}
-}
-
-// shellArgv builds `docker compose -p <slug> exec [-T] -u <user> <service> [cmd...|default-shell]`.
-func shellArgv(r *dockercli.Runner, slug, service string, root bool, cmd []string, noTTY bool) []string {
-	args := append(execOpts(noTTY), "-u", shellUser(service, root), service)
-	if len(cmd) > 0 {
-		args = append(args, cmd...)
-	} else {
-		args = append(args, defaultShellCmd(!noTTY)...)
-	}
-	return r.ComposeArgv(slug, args...)
-}
-
-// Exec runs a WP-CLI command against an env. With a terminal on stdin it runs
-// interactively through the raw-mode PTY; with piped stdin (e.g. redirecting
-// output to a file) it runs through plain pipes. Either way output tees into
-// the unified log.
-func Exec(ctx context.Context, slug string, wpArgs []string) error {
-	debuglog.Printf(ctx, debugNamespace, "Will exec a WP command in environment %q: arguments=%d", slug, len(wpArgs))
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	l, err := devlog.Open(slug)
-	if err != nil {
-		return err
-	}
-	defer l.Close()
-	interactive := devterm.Interactive()
-	argv := execArgv(r, slug, wpArgs, !interactive)
-	return runTermOrPipe(ctx, l, paths.EnvironmentPath(slug), argv, interactive)
-}
-
-// Shell opens an interactive shell (or runs cmd) in a service container. Like
-// Exec it falls back to plain pipes when stdin is not a terminal.
-func Shell(ctx context.Context, slug, service string, root bool, cmd []string) error {
-	debuglog.Printf(ctx, debugNamespace, "Will open shell in environment %q: service=%q root=%t arguments=%d", slug, service, root, len(cmd))
-	r, err := newRunner(ctx)
-	if err != nil {
-		return err
-	}
-	l, err := devlog.Open(slug)
-	if err != nil {
-		return err
-	}
-	defer l.Close()
-	interactive := devterm.Interactive()
-	argv := shellArgv(r, slug, service, root, cmd, !interactive)
-	return runTermOrPipe(ctx, l, paths.EnvironmentPath(slug), argv, interactive)
-}
-
-// runTermOrPipe dispatches a built compose-exec argv to either the raw-mode PTY
-// runner (interactive) or the plain-pipe runner (non-interactive). The pipe
-// path opens a separate log writer per stream, as devlog.Writer requires (its
-// per-writer line buffer is single-goroutine; the underlying file is
-// serialized), so the subprocess's stdout and stderr each tee into the log.
-func runTermOrPipe(ctx context.Context, l *devlog.Logger, dir string, argv []string, interactive bool) error {
-	if interactive {
-		w := l.Writer()
-		defer w.Close()
-		return devterm.Run(ctx, dir, argv, w)
-	}
-	outLog := l.Writer()
-	defer outLog.Close()
-	errLog := l.Writer()
-	defer errLog.Close()
-	return devterm.RunPiped(ctx, dir, argv,
-		io.MultiWriter(os.Stdout, outLog),
-		io.MultiWriter(os.Stderr, errLog))
-}