@automattic/vip 4.1.4 → 4.1.6

package/internal/appctx/prompts.go

@@ -1,70 +0,0 @@
-package appctx
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/spf13/cobra"
-)
-
-// ErrNonInteractive is returned when a prompt is requested in a non-interactive
-// context and no fallback is available. Callers typically use errors.Is to
-// detect this and convert to a "missing required flag" error.
-var ErrNonInteractive = errors.New("non-interactive context: cannot prompt")
-
-// Confirm asks a yes/no question. Returns ErrNonInteractive when the session
-// is non-interactive (caller decides whether to default-deny or fail).
-func Confirm(cmd *cobra.Command, message string, defaultYes bool) (bool, error) {
-	return confirmCore(IsInteractive(cmd), os.Stderr, message, defaultYes)
-}
-
-func confirmCore(interactive bool, stderr io.Writer, message string, defaultYes bool) (bool, error) {
-	if !interactive {
-		fmt.Fprintf(stderr, "Cannot prompt in non-interactive mode: %s\n", message)
-		return false, ErrNonInteractive
-	}
-	var out bool
-	prompt := &survey.Confirm{Message: message, Default: defaultYes}
-	if err := survey.AskOne(prompt, &out); err != nil {
-		return false, err
-	}
-	return out, nil
-}
-
-// Input asks for a free-form string. If non-interactive and fallback is
-// non-empty, returns the fallback; otherwise ErrNonInteractive.
-func Input(cmd *cobra.Command, message, fallback string) (string, error) {
-	if !IsInteractive(cmd) {
-		if fallback != "" {
-			return fallback, nil
-		}
-		return "", ErrNonInteractive
-	}
-	var out string
-	prompt := &survey.Input{Message: message, Default: fallback}
-	if err := survey.AskOne(prompt, &out); err != nil {
-		return "", err
-	}
-	return out, nil
-}
-
-// Select offers a list. options[0] is the default. Non-interactive with at
-// least one option returns options[0]; non-interactive with no options
-// returns ErrNonInteractive.
-func Select(cmd *cobra.Command, message string, options []string) (string, error) {
-	if !IsInteractive(cmd) {
-		if len(options) > 0 {
-			return options[0], nil
-		}
-		return "", ErrNonInteractive
-	}
-	var out string
-	prompt := &survey.Select{Message: message, Options: options, Default: options[0]}
-	if err := survey.AskOne(prompt, &out); err != nil {
-		return "", err
-	}
-	return out, nil
-}

package/internal/appctx/prompts_test.go

@@ -1,97 +0,0 @@
-package appctx
-
-import (
-	"bytes"
-	"errors"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-// makeNonInteractiveCmd builds a cobra command with --non-interactive=true
-// set via PersistentFlags (the bucket the flag was defined on — see Task 6
-// for why this matters in pre-Execute test scenarios).
-func makeNonInteractiveCmd(t *testing.T) *cobra.Command {
-	t.Helper()
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	if err := cmd.PersistentFlags().Set("non-interactive", "true"); err != nil {
-		t.Fatalf("set --non-interactive: %v", err)
-	}
-	return cmd
-}
-
-func TestConfirmNonInteractiveReturnsErr(t *testing.T) {
-	cmd := makeNonInteractiveCmd(t)
-	got, err := Confirm(cmd, "delete the world?", false)
-	if !errors.Is(err, ErrNonInteractive) {
-		t.Errorf("err = %v, want ErrNonInteractive", err)
-	}
-	if got != false {
-		t.Errorf("got = %v, want false", got)
-	}
-}
-
-func TestInputNonInteractiveErrorsWithoutDefault(t *testing.T) {
-	cmd := makeNonInteractiveCmd(t)
-	got, err := Input(cmd, "value?", "")
-	if !errors.Is(err, ErrNonInteractive) {
-		t.Errorf("err = %v, want ErrNonInteractive", err)
-	}
-	if got != "" {
-		t.Errorf("got = %q, want empty", got)
-	}
-}
-
-func TestInputNonInteractiveAllowsDefault(t *testing.T) {
-	cmd := makeNonInteractiveCmd(t)
-	got, err := Input(cmd, "value?", "fallback")
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if got != "fallback" {
-		t.Errorf("Input = %q, want fallback", got)
-	}
-}
-
-func TestSelectNonInteractiveReturnsFirst(t *testing.T) {
-	cmd := makeNonInteractiveCmd(t)
-	got, err := Select(cmd, "pick:", []string{"a", "b", "c"})
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if got != "a" {
-		t.Errorf("Select = %q, want a", got)
-	}
-}
-
-func TestSelectNonInteractiveEmptyOptionsErr(t *testing.T) {
-	cmd := makeNonInteractiveCmd(t)
-	got, err := Select(cmd, "pick:", nil)
-	if !errors.Is(err, ErrNonInteractive) {
-		t.Errorf("err = %v, want ErrNonInteractive", err)
-	}
-	if got != "" {
-		t.Errorf("got = %q, want empty", got)
-	}
-}
-
-// confirmCore must print to the provided writer in non-interactive mode and
-// return ErrNonInteractive. This pins the contract that the wrapper warns
-// the operator before failing.
-func TestConfirmCoreNonInteractiveWritesStderr(t *testing.T) {
-	var stderr bytes.Buffer
-	got, err := confirmCore(false /*interactive*/, &stderr, "test message", true)
-	if got != false {
-		t.Errorf("got = %v, want false", got)
-	}
-	if !errors.Is(err, ErrNonInteractive) {
-		t.Errorf("err = %v, want ErrNonInteractive", err)
-	}
-	if stderr.Len() == 0 {
-		t.Error("confirmCore non-interactive must write something to stderr")
-	}
-	if !bytes.Contains(stderr.Bytes(), []byte("test message")) {
-		t.Errorf("stderr = %q, want it to include the prompt message", stderr.String())
-	}
-}

package/internal/appctx/required_args.go

@@ -1,24 +0,0 @@
-package appctx
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-// WithRequiredArgs enforces an exact positional-arg count. On mismatch returns
-// a Node-parity error: "Please supply N argument(s): <command usage>".
-func WithRequiredArgs(n int) Middleware {
-	return func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			if len(args) != n {
-				word := "arguments"
-				if n == 1 {
-					word = "argument"
-				}
-				return fmt.Errorf("Please supply %d %s: %s", n, word, cmd.UseLine())
-			}
-			return next(cmd, args)
-		}
-	}
-}

package/internal/appctx/required_args_test.go

@@ -1,38 +0,0 @@
-package appctx
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func TestWithRequiredArgsAccepts(t *testing.T) {
-	cmd := &cobra.Command{Use: "get <NAME>"}
-	cmd.SetContext(context.Background())
-	mw := WithRequiredArgs(1)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		if len(args) != 1 || args[0] != "FOO" {
-			t.Errorf("args = %v", args)
-		}
-		return nil
-	})
-	if err := run(cmd, []string{"FOO"}); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-}
-
-func TestWithRequiredArgsRejects(t *testing.T) {
-	cmd := &cobra.Command{Use: "get <NAME>"}
-	cmd.SetContext(context.Background())
-	mw := WithRequiredArgs(1)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("handler must not run when arg count is wrong")
-		return nil
-	})
-	err := run(cmd, []string{})
-	if err == nil || !strings.Contains(err.Error(), "Please supply 1 argument") {
-		t.Errorf("err = %v, want Node-parity supply-argument error", err)
-	}
-}

package/internal/appctx/telemetry.go

@@ -1,22 +0,0 @@
-package appctx
-
-import "github.com/spf13/cobra"
-
-type CommandTracker interface {
-	MakeCommandTracker(command string, info map[string]any) func(eventType string, data map[string]any)
-}
-
-func WithTelemetry(tr CommandTracker, command string, info map[string]any) Middleware {
-	track := tr.MakeCommandTracker(command, info)
-	return func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			track("execute", nil)
-			if err := next(cmd, args); err != nil {
-				track("error", map[string]any{"error": err.Error()})
-				return err
-			}
-			track("success", nil)
-			return nil
-		}
-	}
-}

package/internal/appctx/telemetry_test.go

@@ -1,42 +0,0 @@
-package appctx
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-type fakeTracker struct {
-	events []string
-}
-
-func (f *fakeTracker) MakeCommandTracker(cmd string, info map[string]any) func(string, map[string]any) {
-	return func(eventType string, data map[string]any) {
-		f.events = append(f.events, cmd+"_"+eventType)
-	}
-}
-
-func TestWithTelemetryEmitsExecuteAndSuccess(t *testing.T) {
-	tr := &fakeTracker{}
-	cmd := &cobra.Command{Use: "demo"}
-	wrapped := Build(cmd, WithTelemetry(tr, "demo", nil)).WithRun(func(cmd *cobra.Command, args []string) error { return nil })
-	if err := wrapped.RunE(wrapped, nil); err != nil {
-		t.Fatalf("RunE: %v", err)
-	}
-	if len(tr.events) != 2 || tr.events[0] != "demo_execute" || tr.events[1] != "demo_success" {
-		t.Errorf("events = %v", tr.events)
-	}
-}
-
-func TestWithTelemetryEmitsErrorOnFailure(t *testing.T) {
-	tr := &fakeTracker{}
-	cmd := &cobra.Command{Use: "demo"}
-	wrapped := Build(cmd, WithTelemetry(tr, "demo", nil)).WithRun(func(cmd *cobra.Command, args []string) error {
-		return errors.New("boom")
-	})
-	wrapped.RunE(wrapped, nil)
-	if len(tr.events) != 2 || tr.events[1] != "demo_error" {
-		t.Errorf("events = %v, want [execute, error]", tr.events)
-	}
-}

package/internal/appctx/wildcard.go

@@ -1,29 +0,0 @@
-package appctx
-
-import (
-	"github.com/spf13/cobra"
-)
-
-// WithWildcardCommand registers a fallback handler on a Cobra parent. When the
-// parent is invoked with positional args whose first element is NOT the name
-// of a registered subcommand, the fallback runs with those args. Mirrors
-// Node's _opts.wildcardCommand pattern.
-//
-// MUST be called after all real subcommands are added to parent (snapshots
-// their names at call time).
-func WithWildcardCommand(parent *cobra.Command, fallback RunFunc) {
-	subNames := map[string]bool{}
-	for _, c := range parent.Commands() {
-		subNames[c.Name()] = true
-		for _, alias := range c.Aliases {
-			subNames[alias] = true
-		}
-	}
-	parent.Args = cobra.ArbitraryArgs
-	parent.RunE = func(cmd *cobra.Command, args []string) error {
-		if len(args) > 0 && subNames[args[0]] {
-			return cmd.Help()
-		}
-		return fallback(cmd, args)
-	}
-}

package/internal/appctx/wildcard_test.go

@@ -1,53 +0,0 @@
-package appctx
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func TestWithWildcardCommandRoutesUnknownToFallback(t *testing.T) {
-	parent := &cobra.Command{Use: "app"}
-	knownSub := &cobra.Command{Use: "list", RunE: func(cmd *cobra.Command, args []string) error { return nil }}
-	parent.AddCommand(knownSub)
-
-	var calledWith []string
-	WithWildcardCommand(parent, func(cmd *cobra.Command, args []string) error {
-		calledWith = args
-		return nil
-	})
-
-	parent.SetArgs([]string{"example-app"})
-	parent.SetContext(context.Background())
-	if err := parent.Execute(); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	if len(calledWith) != 1 || calledWith[0] != "example-app" {
-		t.Errorf("fallback received args=%v, want [example-app]", calledWith)
-	}
-}
-
-func TestWithWildcardCommandDispatchesKnownSubcommand(t *testing.T) {
-	parent := &cobra.Command{Use: "app"}
-	var listCalled bool
-	knownSub := &cobra.Command{Use: "list", RunE: func(cmd *cobra.Command, args []string) error {
-		listCalled = true
-		return nil
-	}}
-	parent.AddCommand(knownSub)
-
-	WithWildcardCommand(parent, func(cmd *cobra.Command, args []string) error {
-		t.Error("fallback must not run when a real subcommand is invoked")
-		return nil
-	})
-
-	parent.SetArgs([]string{"list"})
-	parent.SetContext(context.Background())
-	if err := parent.Execute(); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	if !listCalled {
-		t.Error("list subcommand was not dispatched")
-	}
-}

package/internal/auth/bypass.go

@@ -1,84 +0,0 @@
-package auth
-
-import (
-	"os"
-	"strings"
-)
-
-// ShouldBypassAuth reports whether this invocation may run WITHOUT an
-// interactive login. It is the port of the argv scan in src/bin/vip.js:190-212.
-//
-// Scope matters more than the token list: in Node this decides exactly one
-// thing — login flow, or not. Either way `runCmd()` gets full API access,
-// because src/lib/api/http.ts re-reads the keychain on every request. A true
-// return here therefore means "do not prompt", NOT "do not configure the API
-// client"; main.go must still hand the command whatever token is stored.
-//
-// Node's scan really is flat over the whole argv (doesArgvHaveAtLeastOneParam
-// is `argv.some(arg => params.includes(arg))`), so `config envvar get help`
-// takes this branch on both CLIs. That is only benign because of the rule
-// above.
-func ShouldBypassAuth(argv []string) bool {
-	hasHelp := contains(argv, "help", "-h", "--help")
-	hasVersion := contains(argv, "-v", "--version")
-	hasLogout := contains(argv, "logout")
-	hasLogin := contains(argv, "login")
-	hasDevEnv := contains(argv, "dev-env")
-	hasSync := contains(argv, "sync")
-	hasDeploy := contains(argv, "deploy")
-	hasAppEnv := containsAppEnvArgument(argv)
-	if hasHelp || hasVersion || hasLogout || hasLogin {
-		return true
-	}
-	// vip.js:196-198 — isDevEnvCommandWithoutEnv. `hasSync` is vip-next-only:
-	// `dev-env sync sql` pulls a production export, so it gets a login prompt
-	// instead of Node's bare 401.
-	if hasDevEnv && !hasAppEnv && !hasSync {
-		return true
-	}
-	if hasDeploy && os.Getenv("WPVIP_DEPLOY_TOKEN") != "" {
-		return true
-	}
-	return false
-}
-
-func contains(argv []string, needles ...string) bool {
-	set := map[string]struct{}{}
-	for _, n := range needles {
-		set[n] = struct{}{}
-	}
-	for _, a := range argv {
-		if _, ok := set[a]; ok {
-			return true
-		}
-	}
-	return false
-}
-
-// containsAppEnvArgument ports containsAppEnvArgument
-// (src/lib/cli/command.js:1128-1134):
-//
-//	parsedAlias.app || parsedAlias.env || argv.includes('--app') || argv.includes('--env')
-//
-// The two halves have deliberately different reach, and both are reproduced:
-// parseEnvAliasFromArgv only looks BEFORE `--` (envAlias.ts:41-47), while the
-// flag check is a plain exact-token scan of the whole argv. Consequences, all
-// Node's: `--app=example` is missed, and a `--app` after `--` counts.
-func containsAppEnvArgument(argv []string) bool {
-	if containsAlias(argv) {
-		return true
-	}
-	return contains(argv, "--app", "--env")
-}
-
-func containsAlias(argv []string) bool {
-	for _, a := range argv {
-		if a == "--" {
-			return false
-		}
-		if strings.HasPrefix(a, "@") && len(a) > 1 {
-			return true
-		}
-	}
-	return false
-}

package/internal/auth/bypass_test.go

@@ -1,97 +0,0 @@
-package auth
-
-import (
-	"os"
-	"testing"
-)
-
-func TestShouldBypassAuth(t *testing.T) {
-	tests := []struct {
-		name string
-		argv []string
-		env  map[string]string
-		want bool
-	}{
-		{"help short", []string{"--help"}, nil, true},
-		{"help long", []string{"app", "list", "--help"}, nil, true},
-		{"help word", []string{"help"}, nil, true},
-		{"-h", []string{"-h"}, nil, true},
-		{"version short", []string{"-v"}, nil, true},
-		{"version long", []string{"--version"}, nil, true},
-		{"logout", []string{"logout"}, nil, true},
-		{"dev-env no alias", []string{"dev-env", "start"}, nil, true},
-		{"dev-env with alias", []string{"dev-env", "@my-app", "destroy"}, nil, false},
-		{"deploy with env token", []string{"app", "deploy"}, map[string]string{"WPVIP_DEPLOY_TOKEN": "x"}, true},
-		{"deploy without env token", []string{"app", "deploy"}, nil, false},
-		{"plain command", []string{"app", "list"}, nil, false},
-		{name: "login bypasses", argv: []string{"login"}, want: true},
-		{name: "login with flags bypasses", argv: []string{"login", "--debug"}, want: true},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if _, set := tc.env["WPVIP_DEPLOY_TOKEN"]; !set {
-				os.Unsetenv("WPVIP_DEPLOY_TOKEN")
-			}
-			for k, v := range tc.env {
-				t.Setenv(k, v)
-			}
-			got := ShouldBypassAuth(tc.argv)
-			if got != tc.want {
-				t.Errorf("ShouldBypassAuth(%v) = %v, want %v", tc.argv, got, tc.want)
-			}
-		})
-	}
-}
-
-func TestDevEnvSyncRequiresAuth(t *testing.T) {
-	if ShouldBypassAuth([]string{"dev-env", "sync", "sql", "--slug", "x"}) {
-		t.Fatal("dev-env sync must NOT bypass auth (it calls the platform)")
-	}
-}
-
-// TestDevEnvWithAppEnvFlagsRequiresAuth pins Node's containsAppEnvArgument
-// (src/lib/cli/command.js:1128-1134), which counts BOTH the @app.env alias and
-// the bare --app/--env flags. vip-next only looked for the alias, so
-// `dev-env create --app example` skipped auth and the create wizard silently
-// lost every app-derived default.
-func TestDevEnvWithAppEnvFlagsRequiresAuth(t *testing.T) {
-	cases := [][]string{
-		{"dev-env", "create", "--app", "example"},
-		{"dev-env", "create", "--env", "develop"},
-	}
-	for _, argv := range cases {
-		if ShouldBypassAuth(argv) {
-			t.Errorf("ShouldBypassAuth(%v) = true; --app/--env is an app/env argument in Node", argv)
-		}
-	}
-}
-
-// TestDevEnvAppEnvArgumentMatchesNodeExactTokenScan pins the two ways Node's
-// containsAppEnvArgument is *sloppier* than the alias parser it wraps.
-// `argv.includes('--app')` is an exact-token, whole-argv scan, so:
-//
-//   - `--app=example` is NOT recognised (Node bug: the wizard bypasses login),
-//     whereas the alias half of the same function stops at `--`;
-//   - a `--app` token appearing AFTER `--` IS recognised.
-//
-// Both are Node's shipping behaviour. They are harmless in practice because a
-// bypassed invocation still gets a configured API client on both CLIs (Node
-// loads the token per request in api/http.ts) — it only decides whether an
-// unauthenticated user gets a login prompt or a 401.
-func TestDevEnvAppEnvArgumentMatchesNodeExactTokenScan(t *testing.T) {
-	if !ShouldBypassAuth([]string{"dev-env", "create", "--app=example"}) {
-		t.Error("Node's argv.includes('--app') does not match the --app=value form")
-	}
-	if ShouldBypassAuth([]string{"dev-env", "exec", "--", "wp", "option", "get", "--app"}) {
-		t.Error("Node's flag scan is not bounded by --; a later --app still counts")
-	}
-}
-
-func TestDevEnvNonSyncStillBypasses(t *testing.T) {
-	if !ShouldBypassAuth([]string{"dev-env", "start", "--slug", "x"}) {
-		t.Fatal("dev-env start should still bypass auth")
-	}
-	if !ShouldBypassAuth([]string{"dev-env", "import", "sql", "f.sql"}) {
-		t.Fatal("dev-env import should still bypass auth")
-	}
-}