@automattic/vip 4.1.5 → 4.1.6

package/cmd/vip-next/commands/devenv_logs.go

@@ -1,29 +0,0 @@
-package commands
-
-import (
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/devenv"
-)
-
-func newDevEnvLogsCmd() *cobra.Command {
-	var follow bool
-	var service string
-	c := &cobra.Command{
-		Use:           "logs",
-		Short:         "Show logs for a local environment",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			return devenv.Logs(cmd.Context(), slug, devenv.LogOptions{Follow: follow, Service: service})
-		},
-	}
-	addSlugFlag(c)
-	c.Flags().BoolVarP(&follow, "follow", "f", false, "Continually output logs as they are generated.")
-	c.Flags().StringVar(&service, "service", "", "Restrict to a single service.")
-	return c
-}

package/cmd/vip-next/commands/devenv_resolve.go

@@ -1,118 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/appctx"
-	"github.com/Automattic/vip/internal/devenv"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-	"github.com/Automattic/vip/internal/nodeflags"
-)
-
-// ResolveSlug determines which EXISTING environment a command targets, matching
-// the Node getEnvironmentName resolution order (dev-environment-cli.ts:146-192):
-//  1. --slug, if set (lowercased by Node's processSlug —
-//     dev-environment-cli.ts:979 — which every dev-env bin registers as the
-//     option's parse function).
-//  2. An @app.env alias: REJECTED with Node's message. allowAppEnv is set by
-//     `dev-env create` alone (vip-dev-env-create.js:95); every other dev-env
-//     command refuses it rather than guessing a local environment — this is a
-//     guard on destructive commands, so it must fire before anything else.
-//  3. The slug from a discovered .wpvip/vip-dev-env.yml, announced with Node's
-//     "Using environment X from Y" line.
-//  4. The sole environment, when exactly one exists.
-//  5. Interactive: prompt to select from the existing environments.
-//  6. Otherwise: a clear "specify --slug" error (wrapping ErrNonInteractive).
-//
-// Steps 5 and 6 are vip-next's replacement for Node's "More than one
-// environment found" error / DEFAULT_SLUG fallback.
-func ResolveSlug(cmd *cobra.Command) (string, error) {
-	if s, _ := cmd.Flags().GetString("slug"); s != "" {
-		slug := nodeflags.ProcessSlug(s)
-		devEnvTrackingResolved(cmd, slug)
-		return slug, nil
-	}
-	if err := rejectAppEnvAlias(cmd); err != nil {
-		return "", err
-	}
-	return ResolveLocalSlug(cmd)
-}
-
-// ResolveLocalSlug is ResolveSlug without the @app.env guard, for the one
-// dev-env leaf where an alias is meaningful: `dev-env sync sql` uses @app.env
-// to name the PLATFORM environment it exports from, and resolves the LOCAL
-// target separately. Node models this by destructuring app/env out of the
-// options before calling getEnvironmentName (vip-dev-env-sync-sql.js:98).
-func ResolveLocalSlug(cmd *cobra.Command) (string, error) {
-	if s, _ := cmd.Flags().GetString("slug"); s != "" {
-		slug := nodeflags.ProcessSlug(s)
-		devEnvTrackingResolved(cmd, slug)
-		return slug, nil
-	}
-	slug, err := configFileSlug(cmd)
-	if err != nil || slug != "" {
-		if err == nil {
-			devEnvTrackingResolved(cmd, slug)
-		}
-		return slug, err
-	}
-	names := instancedata.AllNames()
-	switch len(names) {
-	case 0:
-		return "", errors.New("no dev environments found; create one with `vip dev-env create`")
-	case 1:
-		devEnvTrackingResolved(cmd, names[0])
-		return names[0], nil
-	}
-	if appctx.IsInteractive(cmd) {
-		slug, err := appctx.Select(cmd, "Which environment?", names)
-		if err == nil {
-			devEnvTrackingResolved(cmd, slug)
-		}
-		return slug, err
-	}
-	return "", fmt.Errorf("multiple environments found; specify --slug: %w", appctx.ErrNonInteractive)
-}
-
-// rejectAppEnvAlias ports getEnvironmentName's @app.env guard. `--app`/`--env`
-// are root persistent flags that the alias PersistentPreRunE fills in from an
-// `@app.env` token, so this covers both spellings — as it does in Node, where
-// command.js:570 populates options.app from the parsed alias.
-func rejectAppEnvAlias(cmd *cobra.Command) error {
-	app, _ := cmd.Flags().GetString("app")
-	if app == "" {
-		return nil
-	}
-	name := app
-	if env, _ := cmd.Flags().GetString("env"); env != "" {
-		name += "-" + env
-	}
-	return fmt.Errorf("This command does not support @app.env notation. Use '--slug=%s' to target the local environment.", name)
-}
-
-// configFileSlug returns the slug from a discovered dev-env configuration file
-// (walking up from the working directory), or "" when there is none. A file
-// that exists but cannot be parsed is a hard error: Node exits there, and
-// falling through would let `destroy` target a DIFFERENT environment than the
-// repo is configured for.
-//
-// Node's slug is used verbatim here — unlike --slug it is not passed through
-// processSlug, so it is not lowercased.
-func configFileSlug(cmd *cobra.Command) (string, error) {
-	cfg, err := devenv.LoadConfigFile()
-	if err != nil {
-		return "", err
-	}
-	if cfg == nil || cfg.Slug == "" {
-		return "", nil
-	}
-	// Node suppresses the announcement only where the caller passes its
-	// `quiet` option — `dev-env import sql --quiet` (vip-dev-env-import-sql.js:65).
-	if quiet, _ := cmd.Flags().GetBool("quiet"); !quiet {
-		fmt.Fprintf(cmd.OutOrStdout(), "Using environment %s from %s\n\n", cfg.Slug, cfg.Path)
-	}
-	return cfg.Slug, nil
-}

package/cmd/vip-next/commands/devenv_resolve_test.go

@@ -1,221 +0,0 @@
-package commands
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/appctx"
-)
-
-// newSlugCmd builds a cobra command with a --slug flag + --non-interactive,
-// mirroring what the real dev-env leaves register.
-func newSlugCmd(slug string) *cobra.Command {
-	c := &cobra.Command{Use: "x"}
-	c.Flags().String("slug", "", "")
-	c.Flags().Bool("non-interactive", false, "")
-	// --app/--env live on the root command in production; the alias
-	// PersistentPreRunE sets them from an @app.env token.
-	c.Flags().String("app", "", "")
-	c.Flags().String("env", "", "")
-	if slug != "" {
-		_ = c.Flags().Set("slug", slug)
-	}
-	return c
-}
-
-func mkEnv(t *testing.T, base, slug string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Join(base, "vip", "dev-environment", slug), 0o755); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestResolveSlugFlagWins(t *testing.T) {
-	got, err := ResolveSlug(newSlugCmd("chosen"))
-	if err != nil || got != "chosen" {
-		t.Fatalf("ResolveSlug = %q, %v; want chosen", got, err)
-	}
-}
-
-func TestResolveSlugSoleEnv(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "only-one")
-	got, err := ResolveSlug(newSlugCmd(""))
-	if err != nil || got != "only-one" {
-		t.Fatalf("ResolveSlug = %q, %v; want only-one", got, err)
-	}
-}
-
-func TestResolveSlugNoneIsError(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	_, err := ResolveSlug(newSlugCmd(""))
-	if err == nil {
-		t.Fatal("expected error when no environments exist")
-	}
-}
-
-// writeDevEnvConfig drops a .wpvip/vip-dev-env.yml in dir.
-func writeDevEnvConfig(t *testing.T, dir, slug string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Join(dir, ".wpvip"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	body := "configuration-version: 1\nslug: " + slug + "\n"
-	if err := os.WriteFile(filepath.Join(dir, ".wpvip", "vip-dev-env.yml"), []byte(body), 0o600); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Register 2.21. In a configured repo every dev-env command must target the
-// configured environment, NOT whichever environment happens to be on disk.
-// Before this fix `dev-env destroy` in a repo configured for "configured-site"
-// destroyed the unrelated environment "some-other-env".
-func TestResolveSlugUsesConfigurationFile(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "some-other-env")
-	repo := t.TempDir()
-	writeDevEnvConfig(t, repo, "configured-site")
-	t.Chdir(repo)
-
-	got, err := ResolveSlug(newSlugCmd(""))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != "configured-site" {
-		t.Fatalf("ResolveSlug = %q, want configured-site (from .wpvip/vip-dev-env.yml)", got)
-	}
-}
-
-// Node prints `Using environment <slug> from <path>` when the configuration
-// file decides the target (dev-environment-cli.ts:170-176).
-func TestResolveSlugPrintsUsingEnvironment(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	repo := t.TempDir()
-	writeDevEnvConfig(t, repo, "configured-site")
-	t.Chdir(repo)
-
-	c := newSlugCmd("")
-	var out bytes.Buffer
-	c.SetOut(&out)
-	if _, err := ResolveSlug(c); err != nil {
-		t.Fatal(err)
-	}
-	want := "Using environment configured-site from " + filepath.Join(repo, ".wpvip", "vip-dev-env.yml")
-	if !strings.Contains(out.String(), want) {
-		t.Errorf("output = %q, want it to contain %q", out.String(), want)
-	}
-}
-
-// --slug beats the configuration file (Node checks options.slug first).
-func TestResolveSlugFlagBeatsConfigurationFile(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	repo := t.TempDir()
-	writeDevEnvConfig(t, repo, "configured-site")
-	t.Chdir(repo)
-
-	got, err := ResolveSlug(newSlugCmd("explicit"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != "explicit" {
-		t.Fatalf("ResolveSlug = %q, want explicit", got)
-	}
-}
-
-// A broken configuration file must be fatal, not silently ignored — otherwise
-// `destroy` falls through to some other environment.
-func TestResolveSlugBrokenConfigurationFileIsFatal(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "some-other-env")
-	repo := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(repo, ".wpvip"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(repo, ".wpvip", "vip-dev-env.yml"), []byte("slug: x\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	t.Chdir(repo)
-
-	if _, err := ResolveSlug(newSlugCmd("")); err == nil {
-		t.Fatal("a malformed configuration file must fail, not fall through to another environment")
-	}
-}
-
-// Node rejects @app.env on every dev-env command except create
-// (getEnvironmentName: allowAppEnv is only set by vip-dev-env-create.js:95).
-// The message tells the user the --slug form to use instead.
-func TestResolveSlugRejectsAppEnvAlias(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "only-one")
-	c := newSlugCmd("")
-	_ = c.Flags().Set("app", "example-app")
-	_ = c.Flags().Set("env", "develop")
-
-	_, err := ResolveSlug(c)
-	if err == nil {
-		t.Fatal("@app.env must be rejected on a dev-env command")
-	}
-	const want = "This command does not support @app.env notation. Use '--slug=example-app-develop' to target the local environment."
-	if err.Error() != want {
-		t.Errorf("error = %q, want %q", err.Error(), want)
-	}
-}
-
-// Node builds the suggested slug from app + "-" + env, and omits the suffix
-// when there is no env part.
-func TestResolveSlugRejectsAppAliasWithoutEnv(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "only-one")
-	c := newSlugCmd("")
-	_ = c.Flags().Set("app", "example-app")
-
-	_, err := ResolveSlug(c)
-	if err == nil || !strings.Contains(err.Error(), "--slug=example-app'") {
-		t.Fatalf("error = %v, want the bare app name in the suggested --slug", err)
-	}
-}
-
-// `dev-env sync sql` is the one dev-env leaf where @app.env is meaningful: it
-// names the PLATFORM environment to export from, while the local target comes
-// from --slug/the configuration file. Node strips app/env before calling
-// getEnvironmentName (`const { app, env, ... } = opt` in
-// vip-dev-env-sync-sql.js), so the guard must not fire there.
-func TestResolveLocalSlugIgnoresAppEnvForSync(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	mkEnv(t, base, "only-one")
-	c := newSlugCmd("")
-	_ = c.Flags().Set("app", "example-app")
-	_ = c.Flags().Set("env", "develop")
-
-	got, err := ResolveLocalSlug(c)
-	if err != nil {
-		t.Fatalf("sync sql must accept @app.env: %v", err)
-	}
-	if got != "only-one" {
-		t.Fatalf("ResolveLocalSlug = %q, want only-one", got)
-	}
-}
-
-func TestResolveSlugAmbiguousNonInteractive(t *testing.T) {
-	base := t.TempDir()
-	t.Setenv("XDG_DATA_HOME", base)
-	t.Setenv("VIP_NON_INTERACTIVE", "1")
-	mkEnv(t, base, "a")
-	mkEnv(t, base, "b")
-	_, err := ResolveSlug(newSlugCmd(""))
-	if !errors.Is(err, appctx.ErrNonInteractive) {
-		t.Fatalf("want ErrNonInteractive, got %v", err)
-	}
-}

package/cmd/vip-next/commands/devenv_sync.go

@@ -1,256 +0,0 @@
-package commands
-
-import (
-	"compress/gzip"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/appctx"
-	"github.com/Automattic/vip/internal/devenv"
-	"github.com/Automattic/vip/internal/devenv/compose"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-	"github.com/Automattic/vip/internal/gql"
-	"github.com/Automattic/vip/internal/sqlexport"
-	"github.com/Automattic/vip/internal/tui"
-)
-
-func newDevEnvSyncCmd() *cobra.Command {
-	sync := &cobra.Command{Use: "sync", Short: "Sync a VIP Platform environment into a local environment"}
-	sync.AddCommand(newDevEnvSyncSQLCmd())
-	return sync
-}
-
-func newDevEnvSyncSQLCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:           "sql",
-		Short:         "Sync the database of a VIP Platform environment to a local environment",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-	}
-	addSlugFlag(c)
-	c.Flags().StringArrayP("table", "t", nil, "Table to include in a partial sync (repeatable, or comma-separated).")
-	c.Flags().StringArray("site-id", nil, "Network site id to include in a partial sync (repeatable, or comma-separated).")
-	c.Flags().StringP("wpcli-command", "w", "", "Custom WP-CLI command that retrieves the data for a partial export.")
-	c.Flags().StringP("config-file", "c", "", "Local configuration file specifying the data to sync.")
-	c.Flags().StringArrayP("search-replace", "r", nil, "Map a source URL or domain to a routable local target; repeatable (source,target).")
-	c.Flags().BoolP("force", "f", false, "Skip validations (e.g. the running-environment check).")
-
-	addAppEnvFlags(c)
-	cfg := GetConfig()
-	return appctx.Build(c,
-		appctx.WithAppContext(cfg.AppCtxConfig),
-		appctx.WithEnvContext(),
-	).WithRun(runDevEnvSyncSQL)
-}
-
-func runDevEnvSyncSQL(cmd *cobra.Command, _ []string) error {
-	ae := appctx.FromContext(cmd.Context())
-	if ae == nil {
-		return errors.New("appctx not set; this is a wiring bug")
-	}
-	cfg := GetConfig()
-	// ResolveLocalSlug, not ResolveSlug: here @app.env names the PLATFORM
-	// environment to export from, so it must not be rejected as a local target.
-	slug, err := ResolveLocalSlug(cmd)
-	if err != nil {
-		return err
-	}
-	out := cmd.OutOrStdout()
-
-	tables, _ := cmd.Flags().GetStringArray("table")
-	siteIDs, _ := cmd.Flags().GetStringArray("site-id")
-	wpcliCommand, _ := cmd.Flags().GetString("wpcli-command")
-	configFile, _ := cmd.Flags().GetString("config-file")
-	overrides, _ := cmd.Flags().GetStringArray("search-replace")
-	liveCopy, err := sqlexport.ParseLiveCopyCLIOptions(configFile, tables, siteIDs, wpcliCommand)
-	if err != nil {
-		return err
-	}
-
-	domain := compose.DefaultDomain
-	if d, derr := instancedata.Read(slug); derr == nil && d.Domain != "" {
-		domain = d.Domain
-	}
-
-	appID := ae.App.ID
-	envID := ae.Env.ID
-
-	// exportTo runs the M7 platform export to a temporary .gz next to dest, then
-	// gunzips it to dest (the plain SQL file the sync orchestration consumes).
-	// Mirrors Node generateExport + unzipFile (dev-env-sync-sql.ts:184,418).
-	exportTo := func(ctx context.Context, dest string) error {
-		pt := tui.NewProgressTracker(sqlexport.Steps())
-		renderer := startImportProgressRenderer(cmd, pt)
-		defer renderer.stop(cmd, false)
-
-		gzPath := dest + ".gz"
-		// Ignore the saved-path return: the export lands in a temp file the
-		// user never sees, and printing "File saved to" here would interleave
-		// with the still-running progress renderer (the duplicated-line bug).
-		_, rerr := sqlexport.Run(gql.WithAllowGQLErrors(ctx), pt, sqlexport.Options{
-			OutputFile:     gzPath,
-			LiveCopy:       liveCopy,
-			Interval:       exportPollInterval(),
-			AppID:          appID,
-			AppName:        ae.App.Name,
-			EnvUniqueLabel: ae.Env.UniqueLabel,
-		}, buildExportDeps(cmd, appID, envID, out), out)
-		renderer.stop(cmd, true)
-		if rerr != nil {
-			return rerr
-		}
-
-		fmt.Fprintf(out, "Extracting the exported file %s...\n", gzPath)
-		if uerr := gunzipFile(gzPath, dest); uerr != nil {
-			return fmt.Errorf("Error extracting the SQL export: %s", uerr.Error())
-		}
-		fmt.Fprintf(out, "%s Extracted to %s\n", color.GreenString("✓"), dest)
-		return nil
-	}
-
-	baseHost := slug + "." + domain
-	deps := devenv.SyncDeps{
-		ExportTo: exportTo,
-		FetchSites: func(ctx context.Context) ([]devenv.SyncSite, string) {
-			return fetchDevEnvSyncSites(ctx, cfg.GQLClient, appID, envID, func(line string) {
-				fmt.Fprintln(out, line)
-			})
-		},
-		ResolveDraft: func(draft devenv.PlanDraft) ([]string, error) {
-			return resolveSyncMappings(cmd, draft, baseHost)
-		},
-		ImportFile: func(ctx context.Context, slug, file string, pairs []string) error {
-			// Node runImport: inPlace + skipValidate + quiet (dev-env-sync-sql.ts:333).
-			// The same DevEnvImportSQLCommand.run() Node uses here, so sync also
-			// gets the post-import steps (cache flush / reindex / vipgo admin
-			// user / data cleanup) — without them a synced env locks the user
-			// out of their own local wp-admin.
-			return devenv.ImportSQL(ctx, slug, file, devenv.ImportOptions{
-				SearchReplace: pairs,
-				InPlace:       true,
-				SkipValidate:  true,
-				Quiet:         true,
-				// Node's sync search-replaces the export itself and passes no
-				// searchReplace to the import, so it never reaches the
-				// irreversible-rewrite prompt. Go routes the pairs through
-				// ImportSQL, so pre-confirm the way Node's batchMode does —
-				// the file is a temp export, not anything the user named.
-				BatchMode: true,
-				Out:       out,
-			})
-		},
-		RepairDomains: devenv.RepairBlogDomains,
-		RefreshHosts:  devenv.RefreshManagedHosts,
-		Log: func(msg string) {
-			fmt.Fprintln(out, msg)
-		},
-	}
-	return devenv.SyncSQL(cmd.Context(), devenv.SyncOptions{
-		Slug:        slug,
-		Domain:      domain,
-		IsMultisite: ae.Env.IsMultisite,
-		Overrides:   overrides,
-	}, deps)
-}
-
-type syncMappingInput func(*cobra.Command, string, string) (string, error)
-
-func suggestedSyncTarget(source, baseHost string, index int) string {
-	host := source
-	if slash := strings.IndexByte(host, '/'); slash >= 0 {
-		host = host[:slash]
-	}
-	if colon := strings.LastIndexByte(host, ':'); colon >= 0 {
-		host = host[:colon]
-	}
-	var label strings.Builder
-	lastHyphen := false
-	for _, char := range strings.ToLower(host) {
-		if char >= 'a' && char <= 'z' || char >= '0' && char <= '9' {
-			label.WriteRune(char)
-			lastHyphen = false
-			continue
-		}
-		if !lastHyphen {
-			label.WriteByte('-')
-			lastHyphen = true
-		}
-	}
-	readable := strings.Trim(label.String(), "-")
-	if readable == "" {
-		readable = "site"
-	}
-	suffix := fmt.Sprintf("-r%d", index+1)
-	if limit := 63 - len(suffix); len(readable) > limit {
-		readable = strings.TrimRight(readable[:limit], "-")
-	}
-	return readable + suffix + "." + baseHost
-}
-
-func resolveSyncMappingsCore(
-	cmd *cobra.Command,
-	draft devenv.PlanDraft,
-	baseHost string,
-	interactive bool,
-	input syncMappingInput,
-) ([]string, error) {
-	if len(draft.Unresolved) == 0 {
-		return nil, nil
-	}
-	if !interactive {
-		var message strings.Builder
-		message.WriteString("Multisite URL mappings remain unresolved; no SQL was imported. Re-run with these recovery flags (edit targets if needed):\n")
-		for index, mapping := range draft.Unresolved {
-			target := suggestedSyncTarget(mapping.Source, baseHost, index)
-			fmt.Fprintf(&message, "- %s\n  -r \"%s,%s\"\n", mapping.Source, mapping.Source, target)
-		}
-		return nil, errors.New(strings.TrimRight(message.String(), "\n"))
-	}
-	if input == nil {
-		return nil, errors.New("interactive sync mapping input is not configured")
-	}
-	pairs := make([]string, 0, len(draft.Unresolved))
-	for index, mapping := range draft.Unresolved {
-		fallback := suggestedSyncTarget(mapping.Source, baseHost, index)
-		target, err := input(cmd, fmt.Sprintf("Local target for %s", mapping.Source), fallback)
-		if err != nil || strings.TrimSpace(target) == "" {
-			return nil, devenv.ErrSyncCancelled
-		}
-		pairs = append(pairs, mapping.Source+","+strings.TrimSpace(target))
-	}
-	return pairs, nil
-}
-
-func resolveSyncMappings(cmd *cobra.Command, draft devenv.PlanDraft, baseHost string) ([]string, error) {
-	return resolveSyncMappingsCore(cmd, draft, baseHost, appctx.IsInteractive(cmd), appctx.Input)
-}
-
-// gunzipFile decompresses a gzip file at src into dest.
-func gunzipFile(src, dest string) error {
-	in, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer in.Close()
-	gz, err := gzip.NewReader(in)
-	if err != nil {
-		return err
-	}
-	defer gz.Close()
-	outFile, err := os.Create(dest)
-	if err != nil {
-		return err
-	}
-	defer outFile.Close()
-	if _, err := io.Copy(outFile, gz); err != nil { // #nosec G110 -- trusted platform export
-		return err
-	}
-	return nil
-}