@automattic/vip 4.1.4 → 4.1.6

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

@@ -1,333 +0,0 @@
-package commands
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	jsonv1 "encoding/json"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/appctx"
-	"github.com/Automattic/vip/internal/backup"
-	"github.com/Automattic/vip/internal/gql"
-	"github.com/Automattic/vip/internal/sqlexport"
-	"github.com/Automattic/vip/internal/tui"
-)
-
-// ExportSQLCmd returns `vip export sql`.
-//
-// Node parity: src/bin/vip-export-sql.js + src/commands/export-sql.ts.
-// Full exports ride the latest db_backup (optionally regenerating it);
-// the --table/--site-id/--wpcli-command/--config-file options switch to
-// the live-backup-copy (partial export) flow.
-func ExportSQLCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "sql",
-		Short: "Download a copy of the most recent database backup for an environment",
-		Long: "Download an archived copy of the most recent database backup for a VIP Platform " +
-			"environment, or generate and download a partial database export.",
-		Args: cobra.NoArgs,
-	}
-	cmd.Flags().StringP("output", "o", "", "Download the file to a specific local directory path with a custom file name.")
-	cmd.Flags().StringArrayP("table", "t", nil, "The name of a table to include in the partial database export. Accepts a string value and can be passed more than once with a different value, or add multiple values in a comma-separated list.")
-	cmd.Flags().StringArrayP("site-id", "s", nil, "The ID of a network site to include in the partial database export. Accepts an integer value and can be passed more than once with a different value, or add multiple values in a comma-separated list.")
-	cmd.Flags().StringP("wpcli-command", "w", "", "Run a custom WP-CLI command that has logic to retrieve specific data for the partial database export.")
-	cmd.Flags().StringP("config-file", "c", "", "A local configuration file that specifies the data to include in the partial database export. Accepts a relative or absolute path to the file.")
-	cmd.Flags().BoolP("generate-backup", "g", false, "Generate a fresh database backup and export an archived copy of that backup.")
-	cmd.Flags().Bool("skip-download", false, "Skip downloading the file.")
-
-	addAppEnvFlags(cmd)
-	cfg := GetConfig()
-	return appctx.Build(cmd,
-		appctx.WithAppContext(cfg.AppCtxConfig),
-		appctx.WithEnvContext(),
-	).WithRun(runExportSQL)
-}
-
-// exportPollInterval — VIP_EXPORT_SQL_INTERVAL_MS overrides the 1s Node
-// default for tests.
-func exportPollInterval() time.Duration {
-	if v := os.Getenv("VIP_EXPORT_SQL_INTERVAL_MS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil && n > 0 {
-			return time.Duration(n) * time.Millisecond
-		}
-	}
-	return sqlexport.DefaultPollInterval
-}
-
-// exportPollTimeout — VIP_EXPORT_SQL_TIMEOUT_MS overrides Node's 6h pollUntil
-// ceiling (export-sql.ts:547,555 → utils.ts:18) so the ceiling is reachable
-// in a test. Same knob shape as VIP_EXPORT_SQL_INTERVAL_MS.
-func exportPollTimeout() time.Duration {
-	if v := os.Getenv("VIP_EXPORT_SQL_TIMEOUT_MS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil && n > 0 {
-			return time.Duration(n) * time.Millisecond
-		}
-	}
-	return sqlexport.DefaultPollTimeout
-}
-
-// fetchBackupAndJobs flattens AppBackupAndJobStatus (export-sql.ts:103).
-func fetchBackupAndJobs(ctx context.Context, appID, envID int64) (*sqlexport.BackupAndJobs, error) {
-	cfg := GetConfig()
-	resp, err := gql.AppBackupAndJobStatus(ctx, cfg.GQLClient, appID, envID)
-	if err != nil {
-		return nil, err
-	}
-	st := &sqlexport.BackupAndJobs{}
-	if resp == nil || resp.App == nil || len(resp.App.Environments) == 0 || resp.App.Environments[0] == nil {
-		return st, nil
-	}
-	env := resp.App.Environments[0]
-	if env.BackupsSqlDumpTool != nil {
-		st.EnvSQLDumpTool = *env.BackupsSqlDumpTool
-	}
-	if lb := env.LatestBackup; lb != nil {
-		b := &sqlexport.Backup{}
-		if lb.Id != nil {
-			b.ID = int64(*lb.Id) // schema Backup.id is a Float
-		}
-		if lb.SqlDumpTool != nil {
-			b.SQLDumpTool = *lb.SqlDumpTool
-		}
-		if lb.CreatedAt != nil {
-			b.CreatedAt = *lb.CreatedAt
-		}
-		st.LatestBackup = b
-	}
-	for _, j := range env.Jobs {
-		if j == nil {
-			continue
-		}
-		job := *j
-		ej := sqlexport.ExportJob{StepStatus: map[string]string{}}
-		for _, m := range job.GetMetadata() {
-			if m == nil || m.Name == nil || m.Value == nil {
-				continue
-			}
-			switch *m.Name {
-			case "backupId":
-				if n, err := strconv.ParseInt(*m.Value, 10, 64); err == nil {
-					ej.BackupID = n
-				}
-			case "uploadPath":
-				ej.UploadPath = *m.Value
-			case "bytesWritten":
-				ej.BytesWritten = *m.Value
-			}
-		}
-		if p := job.GetProgress(); p != nil {
-			for _, s := range p.Steps {
-				if s == nil || s.Id == nil || s.Status == nil {
-					continue
-				}
-				ej.StepStatus[*s.Id] = *s.Status
-			}
-		}
-		st.Jobs = append(st.Jobs, ej)
-	}
-	return st, nil
-}
-
-// buildExportDeps assembles the M7 SQL-export side effects (backup status,
-// export job, download link, backup generation, live-copy) around the GQL
-// client. Shared by `export sql` and `dev-env sync sql` so both flows drive the
-// same platform machinery.
-func buildExportDeps(cmd *cobra.Command, appID, envID int64, out io.Writer) sqlexport.Deps {
-	cfg := GetConfig()
-	return sqlexport.Deps{
-		FetchStatus: func(ctx context.Context) (*sqlexport.BackupAndJobs, error) {
-			return fetchBackupAndJobs(ctx, appID, envID)
-		},
-		CreateExport: func(ctx context.Context, backupID int64) error {
-			bid := float64(backupID)
-			_, err := gql.BackupDBCopy(ctx, cfg.GQLClient, &gql.AppEnvironmentStartDBBackupCopyInput{
-				Id: &appID, EnvironmentId: &envID, BackupId: &bid,
-			})
-			return err
-		},
-		GenerateLink: func(ctx context.Context, backupID int64) (string, error) {
-			bid := float64(backupID)
-			resp, err := gql.GenerateDBBackupCopyUrl(ctx, cfg.GQLClient, &gql.AppEnvironmentGenerateDBBackupCopyUrlInput{
-				Id: &appID, EnvironmentId: &envID, BackupId: &bid,
-			})
-			if err != nil {
-				return "", err
-			}
-			if resp == nil || resp.GenerateDBBackupCopyUrl == nil || resp.GenerateDBBackupCopyUrl.Url == nil {
-				return "", nil // Node: response... ?? '' (export-sql.ts:179)
-			}
-			return *resp.GenerateDBBackupCopyUrl.Url, nil
-		},
-		RunBackup: func(ctx context.Context) error {
-			return backup.Run(ctx, backup.RunOpts{
-				Fetch: func(ctx context.Context) (*backup.Job, error) {
-					return fetchBackupJob(ctx, appID, envID)
-				},
-				Create: func(ctx context.Context) error {
-					input := &gql.AppEnvironmentTriggerDBBackupInput{Id: appID, EnvironmentId: envID}
-					_, err := gql.TriggerDatabaseBackup(ctx, cfg.GQLClient, input)
-					return err
-				},
-				Tracker: tui.NewProgressTracker([]tui.ProgressStep{
-					{ID: backup.StepPrepare, Name: "Preparing for backup generation"},
-					{ID: backup.StepGenerate, Name: "Generating backup"},
-				}),
-				Interval: backupPollInterval(),
-				Timeout:  backupPollTimeout(),
-				Log:      func(msg string) { fmt.Fprintln(out, msg) },
-			})
-		},
-		// lcfg is the finished JSON document for the `config: JSON` scalar —
-		// for --config-file it carries every key the user wrote, so it must
-		// go on the wire untouched.
-		StartLive: func(ctx context.Context, lcfg []byte) (string, error) {
-			rawMsg := jsonv1.RawMessage(lcfg)
-			resp, err := gql.StartLiveBackupCopy(ctx, cfg.GQLClient, &gql.LiveBackupCopyConfigInput{
-				Id: appID, EnvironmentId: envID, Config: &rawMsg,
-			})
-			if err != nil {
-				return "", err
-			}
-			if resp == nil || resp.StartLiveBackupCopy == nil || resp.StartLiveBackupCopy.CopyId == nil ||
-				*resp.StartLiveBackupCopy.CopyId == "" {
-				msg := "Unknown error"
-				if resp != nil && resp.StartLiveBackupCopy != nil && resp.StartLiveBackupCopy.Message != nil &&
-					*resp.StartLiveBackupCopy.Message != "" {
-					msg = *resp.StartLiveBackupCopy.Message
-				}
-				return "", fmt.Errorf("Failed to start partial database export: %s", msg)
-			}
-			return *resp.StartLiveBackupCopy.CopyId, nil
-		},
-		PollLiveURL: func(ctx context.Context, copyID string) (string, int64, error) {
-			return pollLiveBackupURL(ctx, appID, envID, copyID)
-		},
-		Confirm: func(message string) (bool, error) {
-			return importConfirmPrompt(cmd, message, false)
-		},
-		FreeBytes: func() (int64, error) {
-			return sqlexport.FreeBytesAt(sqlexport.VipDataPath())
-		},
-		Download: sqlexport.DownloadFile,
-	}
-}
-
-func runExportSQL(cmd *cobra.Command, args []string) error {
-	ae := appctx.FromContext(cmd.Context())
-	if ae == nil {
-		return errors.New("appctx not set; this is a wiring bug")
-	}
-	out := cmd.OutOrStdout()
-
-	output, _ := cmd.Flags().GetString("output")
-	tables, _ := cmd.Flags().GetStringArray("table")
-	siteIDs, _ := cmd.Flags().GetStringArray("site-id")
-	wpcliCommand, _ := cmd.Flags().GetString("wpcli-command")
-	configFile, _ := cmd.Flags().GetString("config-file")
-	generateBackup, _ := cmd.Flags().GetBool("generate-backup")
-	skipDownload, _ := cmd.Flags().GetBool("skip-download")
-
-	liveCopy, err := sqlexport.ParseLiveCopyCLIOptions(configFile, tables, siteIDs, wpcliCommand)
-	if err != nil {
-		return err
-	}
-
-	trackEvent("export_sql_execute", map[string]any{
-		"generate_backup": generateBackup, "live_backup_copy": liveCopy.UseLiveBackupCopy,
-	})
-
-	if output != "" {
-		// Node getAbsolutePath resolves ~ and relative paths (utils).
-		if strings.HasPrefix(output, "~"+string(filepath.Separator)) {
-			if home, herr := os.UserHomeDir(); herr == nil {
-				output = filepath.Join(home, output[2:])
-			}
-		}
-		if abs, aerr := filepath.Abs(output); aerr == nil {
-			output = abs
-		}
-	}
-
-	pt := tui.NewProgressTracker(sqlexport.Steps())
-	renderer := startImportProgressRenderer(cmd, pt)
-	defer renderer.stop(cmd, false)
-
-	pollCtx := gql.WithAllowGQLErrors(cmd.Context())
-	appID := ae.App.ID
-	envID := ae.Env.ID
-
-	deps := buildExportDeps(cmd, appID, envID, out)
-
-	savedPath, err := sqlexport.Run(pollCtx, pt, sqlexport.Options{
-		OutputFile:     output,
-		GenerateBackup: generateBackup,
-		SkipDownload:   skipDownload,
-		LiveCopy:       liveCopy,
-		Interval:       exportPollInterval(),
-		Timeout:        exportPollTimeout(),
-		AppID:          appID,
-		AppName:        ae.App.Name,
-		EnvUniqueLabel: ae.Env.UniqueLabel,
-	}, deps, out)
-	renderer.stop(cmd, true)
-	if err != nil {
-		return err
-	}
-	// Print AFTER stopping the renderer (export-sql.ts:480). Emitting it while
-	// the renderer is still animating would shift the cursor and duplicate the
-	// top progress line.
-	if savedPath != "" {
-		fmt.Fprintf(out, "File saved to %s\n", savedPath)
-	}
-	trackEvent("export_sql_success", nil)
-	return nil
-}
-
-// pollLiveBackupURL ports getDownloadURL (live-backup-copy.ts:166): poll
-// the mutation every 5s for up to 2h until url is set and processing is
-// false. VIP_EXPORT_SQL_INTERVAL_MS shrinks the interval in tests.
-func pollLiveBackupURL(ctx context.Context, appID, envID int64, copyID string) (string, int64, error) {
-	cfg := GetConfig()
-	interval := 5 * time.Second
-	if v := os.Getenv("VIP_EXPORT_SQL_INTERVAL_MS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil && n > 0 {
-			interval = time.Duration(n) * time.Millisecond
-		}
-	}
-	const timeoutSeconds = 2 * 60 * 60
-	deadline := time.Now().Add(timeoutSeconds * time.Second)
-
-	for {
-		resp, err := gql.GenerateLiveBackupCopyDownloadURL(ctx, cfg.GQLClient,
-			&gql.AppEnvironmentLiveBackupCopyDownloadURLInput{
-				Id: appID, EnvironmentId: envID, CopyId: copyID,
-			})
-		if err != nil {
-			return "", 0, fmt.Errorf("Failed to generate download URL: %s", err.Error())
-		}
-		r := resp.GenerateLiveBackupCopyDownloadURL
-		if r != nil && r.Url != nil && *r.Url != "" && !r.Processing {
-			if !r.Success || r.Size == nil || *r.Size == 0 {
-				return "", 0, fmt.Errorf("Failed to generate download URL: %s", *r.Url)
-			}
-			return *r.Url, *r.Size, nil
-		}
-		if time.Now().After(deadline) {
-			return "", 0, fmt.Errorf("Failed to generate download URL: Polling timed out after %d seconds", timeoutSeconds)
-		}
-		select {
-		case <-ctx.Done():
-			return "", 0, ctx.Err()
-		case <-time.After(interval):
-		}
-	}
-}

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

@@ -1,321 +0,0 @@
-package commands
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	json "encoding/json/v2"
-
-	"github.com/Khan/genqlient/graphql"
-
-	"github.com/Automattic/vip/internal/sqlexport"
-)
-
-// exportStub serves AppBackupAndJobStatus (sequenced), the copy/link
-// mutations, and a download target.
-type exportStub struct {
-	statusBodies []string
-	statusHits   atomic.Int32
-	copyHits     atomic.Int32
-	linkHits     atomic.Int32
-	downloadBody string
-	srvURL       string
-}
-
-func exportStatusBody(withJob bool, preflight, uploadBackup string) string {
-	jobs := "[]"
-	if withJob {
-		jobs = `[{"__typename":"Job","id":5,"type":"db_backup_copy","completedAt":null,"createdAt":"2026-06-11 10:05:00",
-			"inProgressLock":false,
-			"metadata":[{"name":"backupId","value":"11"},{"name":"bytesWritten","value":"2048"},{"name":"uploadPath","value":"exports/file.sql.gz"}],
-			"progress":{"status":"running","steps":[
-				{"id":"preflight","name":"Preflight","step":"preflight","status":"` + preflight + `"},
-				{"id":"upload_backup","name":"Upload","step":"upload_backup","status":"` + uploadBackup + `"}]}}]`
-	}
-	return `{"data":{"app":{"id":42,"environments":[{"id":7,"backupsSqlDumpTool":"mysqldump",
-		"latestBackup":{"id":11,"type":"daily","size":1024,"filename":"backup.sql.gz","sqlDumpTool":"mysqldump","createdAt":"2026-06-11 10:00:00"},
-		"jobs":` + jobs + `}]}}}`
-}
-
-func (s *exportStub) start(t *testing.T) *httptest.Server {
-	t.Helper()
-	mux := http.NewServeMux()
-	srv := httptest.NewServer(mux)
-	t.Cleanup(srv.Close)
-	s.srvURL = srv.URL
-
-	mux.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		body, _ := io.ReadAll(r.Body)
-		bs := string(body)
-		w.Header().Set("Content-Type", "application/json")
-		switch {
-		case strings.Contains(bs, `"operationName":"AppBackupAndJobStatus"`):
-			i := int(s.statusHits.Add(1) - 1)
-			if i >= len(s.statusBodies) {
-				i = len(s.statusBodies) - 1
-			}
-			_, _ = w.Write([]byte(s.statusBodies[i]))
-		case strings.Contains(bs, `"operationName":"BackupDBCopy"`):
-			s.copyHits.Add(1)
-			_, _ = w.Write([]byte(`{"data":{"startDBBackupCopy":{"message":"ok","success":true}}}`))
-		case strings.Contains(bs, `"operationName":"GenerateDBBackupCopyUrl"`):
-			s.linkHits.Add(1)
-			fmt.Fprintf(w, `{"data":{"generateDBBackupCopyUrl":{"url":"%s/download","success":true}}}`, s.srvURL)
-		default:
-			_, _ = w.Write([]byte(`{"data":null}`))
-		}
-	})
-	mux.HandleFunc("/download", func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Length", strconv.Itoa(len(s.downloadBody)))
-		_, _ = w.Write([]byte(s.downloadBody))
-	})
-	return srv
-}
-
-func setupExportTest(t *testing.T, stub *exportStub) {
-	t.Helper()
-	srv := stub.start(t)
-	SetConfig(Config{GQLClient: graphql.NewClient(srv.URL+"/graphql", srv.Client()), APIHost: srv.URL, Token: "tok"})
-	t.Cleanup(func() { SetConfig(Config{}) })
-	t.Setenv("NO_COLOR", "1")
-	t.Setenv("VIP_EXPORT_SQL_INTERVAL_MS", "1")
-}
-
-// TestExportPollTimeoutKnob: `vip export sql` inherits Node's 6h pollUntil
-// ceiling (export-sql.ts:547,555 pass no timeout), overridable with the same
-// VIP_*_MS knob shape as VIP_EXPORT_SQL_INTERVAL_MS.
-func TestExportPollTimeoutKnob(t *testing.T) {
-	if got := exportPollTimeout(); got != sqlexport.DefaultPollTimeout {
-		t.Errorf("exportPollTimeout() = %v, want %v", got, sqlexport.DefaultPollTimeout)
-	}
-	t.Setenv("VIP_EXPORT_SQL_TIMEOUT_MS", "25")
-	if got := exportPollTimeout(); got != 25*time.Millisecond {
-		t.Errorf("with VIP_EXPORT_SQL_TIMEOUT_MS=25: %v, want 25ms", got)
-	}
-}
-
-// TestExportSQLStopsAtPollCeiling drives the whole command against an export
-// job whose preflight step never succeeds. Before the ceiling was ported this
-// spun forever with nothing cancelling the context.
-func TestExportSQLStopsAtPollCeiling(t *testing.T) {
-	stub := &exportStub{
-		statusBodies: []string{exportStatusBody(true, "running", "running")},
-		downloadBody: "unused",
-	}
-	setupExportTest(t, stub)
-	t.Setenv("VIP_EXPORT_SQL_TIMEOUT_MS", "30")
-	restore := stubImportPrompts("unused", true)
-	defer restore()
-
-	cmd := ExportSQLCmd()
-	cmd.SetOut(io.Discard)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-
-	done := make(chan error, 1)
-	go func() { done <- runExportSQL(cmd, nil) }()
-	select {
-	case err := <-done:
-		if err == nil || !strings.Contains(err.Error(), "Polling timed out") {
-			t.Errorf("err = %v, want a %q failure", err, "Polling timed out")
-		}
-	case <-time.After(5 * time.Second):
-		t.Fatal("runExportSQL never returned: the poll loop is unbounded")
-	}
-}
-
-func TestExportSQLHappyPath(t *testing.T) {
-	stub := &exportStub{
-		statusBodies: []string{
-			exportStatusBody(false, "", ""),              // initial: no job → CreateExport
-			exportStatusBody(true, "success", "running"), // preflight done
-			exportStatusBody(true, "success", "success"), // upload done
-		},
-		downloadBody: "sql-archive-bytes",
-	}
-	setupExportTest(t, stub)
-	restore := stubImportPrompts("unused", true)
-	defer restore()
-
-	outPath := filepath.Join(t.TempDir(), "export.sql.gz")
-	cmd := ExportSQLCmd()
-	var stdout bytes.Buffer
-	cmd.SetOut(&stdout)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-	_ = cmd.Flags().Set("output", outPath)
-
-	if err := runExportSQL(cmd, nil); err != nil {
-		t.Fatalf("runExportSQL: %v\nstdout: %s", err, stdout.String())
-	}
-	if stub.copyHits.Load() != 1 || stub.linkHits.Load() != 1 {
-		t.Errorf("copy=%d link=%d", stub.copyHits.Load(), stub.linkHits.Load())
-	}
-	got, err := os.ReadFile(outPath) // #nosec G304
-	if err != nil || string(got) != "sql-archive-bytes" {
-		t.Errorf("downloaded = %q err=%v", got, err)
-	}
-	if !strings.Contains(stdout.String(), "File saved to "+outPath) {
-		t.Errorf("stdout = %q", stdout.String())
-	}
-}
-
-func TestExportSQLSkipDownload(t *testing.T) {
-	stub := &exportStub{
-		statusBodies: []string{exportStatusBody(true, "success", "success")},
-		downloadBody: "x",
-	}
-	setupExportTest(t, stub)
-
-	cmd := ExportSQLCmd()
-	var stdout bytes.Buffer
-	cmd.SetOut(&stdout)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-	_ = cmd.Flags().Set("skip-download", "true")
-
-	if err := runExportSQL(cmd, nil); err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(stdout.String(), "File saved to") {
-		t.Errorf("skip-download must not save: %q", stdout.String())
-	}
-	// Attaching message since the job already exists.
-	if stub.copyHits.Load() != 0 {
-		t.Error("BackupDBCopy must not fire when a matching export job exists")
-	}
-}
-
-func TestExportSQLConfigFileConflict(t *testing.T) {
-	stub := &exportStub{statusBodies: []string{exportStatusBody(false, "", "")}}
-	setupExportTest(t, stub)
-
-	cmd := ExportSQLCmd()
-	cmd.SetOut(io.Discard)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-	_ = cmd.Flags().Set("config-file", "cfg.json")
-	_ = cmd.Flags().Set("table", "wp_posts")
-
-	err := runExportSQL(cmd, nil)
-	if err == nil || !strings.Contains(err.Error(), "The --config-file option cannot be used with the --table, --site-id, or --wpcli-command options.") {
-		t.Errorf("err = %v", err)
-	}
-}
-
-// TestExportSQLConfigFileReachesTheWireIntact is the end-to-end half of
-// register 2.18. The unit tests prove BuildConfig keeps every key; this one
-// proves the plumbing between BuildConfig and
-// LiveBackupCopyConfigInput.config doesn't re-narrow it. If any key is lost
-// here the user gets a dump with the wrong scope AND exit 0 — nothing in the
-// output signals it, which is what makes this the highest-severity item in
-// the slice.
-func TestExportSQLConfigFileReachesTheWireIntact(t *testing.T) {
-	configJSON := `{
-		"type": "tables",
-		"tool": "mysqldump",
-		"tables": {"wp_posts": {"where": "ID > 100", "structure_only": true}},
-		"exclude_tables": ["wp_options"],
-		"limit": 500,
-		"site_ids": []
-	}`
-	cfgPath := filepath.Join(t.TempDir(), "db-export-config.json")
-	if err := os.WriteFile(cfgPath, []byte(configJSON), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	var sentConfig map[string]any
-	mux := http.NewServeMux()
-	srv := httptest.NewServer(mux)
-	defer srv.Close()
-	mux.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		body, _ := io.ReadAll(r.Body)
-		w.Header().Set("Content-Type", "application/json")
-		switch {
-		case strings.Contains(string(body), `"operationName":"StartLiveBackupCopy"`):
-			var req struct {
-				Variables struct {
-					Input struct {
-						Config map[string]any `json:"config"`
-					} `json:"input"`
-				} `json:"variables"`
-			}
-			if err := json.Unmarshal(body, &req); err != nil {
-				t.Errorf("decode request: %v", err)
-			}
-			sentConfig = req.Variables.Input.Config
-			_, _ = w.Write([]byte(`{"data":{"startLiveBackupCopy":{"message":"ok","copyId":"copy-9"}}}`))
-		case strings.Contains(string(body), `"operationName":"GenerateLiveBackupCopyDownloadURL"`):
-			fmt.Fprintf(w, `{"data":{"generateLiveBackupCopyDownloadURL":{"success":true,"url":"%s/download","processing":false,"size":17}}}`, srv.URL)
-		default:
-			_, _ = w.Write([]byte(`{"data":null}`))
-		}
-	})
-	mux.HandleFunc("/download", func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte("sql-archive-bytes"))
-	})
-
-	SetConfig(Config{GQLClient: graphql.NewClient(srv.URL+"/graphql", srv.Client()), APIHost: srv.URL, Token: "tok"})
-	t.Cleanup(func() { SetConfig(Config{}) })
-	t.Setenv("NO_COLOR", "1")
-	t.Setenv("VIP_EXPORT_SQL_INTERVAL_MS", "1")
-	restore := stubImportPrompts("unused", true)
-	defer restore()
-
-	dest := filepath.Join(t.TempDir(), "out.sql.gz")
-	cmd := ExportSQLCmd()
-	cmd.SetOut(io.Discard)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-	_ = cmd.Flags().Set("config-file", cfgPath)
-	_ = cmd.Flags().Set("output", dest)
-
-	if err := runExportSQL(cmd, nil); err != nil {
-		t.Fatalf("runExportSQL: %v", err)
-	}
-	if sentConfig == nil {
-		t.Fatal("StartLiveBackupCopy was never called")
-	}
-
-	if _, ok := sentConfig["exclude_tables"]; !ok {
-		t.Errorf("exclude_tables never reached the server: %v", sentConfig)
-	}
-	if sentConfig["limit"] != float64(500) {
-		t.Errorf("limit never reached the server: %v", sentConfig)
-	}
-	if _, ok := sentConfig["site_ids"]; !ok {
-		t.Errorf("explicit empty site_ids never reached the server: %v", sentConfig)
-	}
-	tables, _ := sentConfig["tables"].(map[string]any)
-	wpPosts, _ := tables["wp_posts"].(map[string]any)
-	if wpPosts["where"] != "ID > 100" || wpPosts["structure_only"] != true {
-		t.Errorf("per-table options never reached the server: %v", sentConfig)
-	}
-}
-
-func TestExportSQLNoBackup(t *testing.T) {
-	stub := &exportStub{statusBodies: []string{
-		`{"data":{"app":{"id":42,"environments":[{"id":7,"backupsSqlDumpTool":null,"latestBackup":null,"jobs":[]}]}}}`,
-	}}
-	setupExportTest(t, stub)
-
-	cmd := ExportSQLCmd()
-	cmd.SetOut(io.Discard)
-	cmd.SetErr(io.Discard)
-	cmd.SetContext(importCtx(42, 7, 2))
-
-	err := runExportSQL(cmd, nil)
-	if err == nil || err.Error() != "No backup found for site parityapp" {
-		t.Errorf("err = %v", err)
-	}
-}

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

@@ -1,17 +0,0 @@
-package commands
-
-import (
-	"github.com/Automattic/vip/internal/output"
-)
-
-// formatEnvironment mirrors Node's src/lib/cli/format.ts formatEnvironment:
-// production -> red("PRODUCTION") (uppercased), everything else -> blueBright
-// (lowercased). Used in inline prod-gate prompts so confirm wording matches
-// the Node CLI exactly. NO_COLOR is honored automatically by fatih/color.
-//
-// The implementation lives in internal/output alongside the rest of the
-// format.ts port, because appctx's confirmation info table needs it too and
-// cannot import this package.
-func formatEnvironment(envType string) string {
-	return output.FormatEnvironment(envType)
-}

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

@@ -1,19 +0,0 @@
-package commands
-
-import "github.com/spf13/cobra"
-
-// ImportCmd returns the `vip import` parent. Children attach in root.go;
-// the parent itself just prints help.
-//
-// M6b adds validate-sql; later milestones will add sql + media + the file
-// validators.
-func ImportCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "import",
-		Short: "Validate and import data into a VIP Platform environment",
-		Long:  "Validate and import data (SQL dumps, media files) into a VIP Platform environment.",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return cmd.Help()
-		},
-	}
-}