@automattic/vip 4.1.3 → 4.1.5

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

@@ -0,0 +1,82 @@
+package commands
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Automattic/vip/internal/debuglog"
+)
+
+func TestSearchReplaceDiagnosticsKeepSQLOutputSeparate(t *testing.T) {
+	const namespace = "@automattic/vip:lib:search-and-replace"
+	for _, tc := range []struct {
+		name, selector      string
+		fileOutput, enabled bool
+	}{
+		{name: "disabled"},
+		{name: "library stdout", selector: namespace, enabled: true},
+		{name: "library file", selector: namespace, fileOutput: true, enabled: true},
+		{name: "wildcard", selector: "@automattic/vip:*", enabled: true},
+		{name: "excluded", selector: "*,-" + namespace},
+		{name: "unsafe bin omitted", selector: "@automattic/vip:bin:vip-search-replace"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("VIP_SEARCH_REPLACE_BIN", fakeSearchReplaceBinary(t))
+			dir := t.TempDir()
+			input := filepath.Join(dir, "sensitive-input.sql")
+			output := filepath.Join(dir, "sensitive-output.sql")
+			if err := os.WriteFile(input, []byte("private_sql_payload\n"), 0o600); err != nil {
+				t.Fatal(err)
+			}
+			var stdout, diagnostics bytes.Buffer
+			cmd := SearchReplaceCmd()
+			cmd.SetOut(&stdout)
+			cmd.SetErr(&diagnostics)
+			cmd.SetContext(debuglog.WithLogger(context.Background(), tc.selector, &diagnostics))
+			args := []string{input, "--search-replace=https://private-user:private-password@example.test,private-replacement"}
+			if tc.fileOutput {
+				args = append(args, "--output="+output)
+			}
+			cmd.SetArgs(args)
+			if err := cmd.Execute(); err != nil {
+				t.Fatal(err)
+			}
+			if tc.fileOutput {
+				got, err := os.ReadFile(output)
+				if err != nil || string(got) != "PRIVATE_SQL_PAYLOAD\n" || stdout.Len() != 0 {
+					t.Fatalf("file output=%q stdout=%q err=%v", got, stdout.String(), err)
+				}
+			} else if stdout.String() != "PRIVATE_SQL_PAYLOAD\n" {
+				t.Fatalf("SQL stdout contaminated: %q", stdout.String())
+			}
+			log := diagnostics.String()
+			if !tc.enabled {
+				if log != "" {
+					t.Fatalf("unexpected diagnostics: %q", log)
+				}
+				return
+			}
+			for _, want := range []string{namespace, "input=file", "stage=completed"} {
+				if !strings.Contains(log, want) {
+					t.Errorf("missing %q in %q", want, log)
+				}
+			}
+			route := "output=stdout"
+			if tc.fileOutput {
+				route = "output=file"
+			}
+			if !strings.Contains(log, route) {
+				t.Errorf("missing route %q in %q", route, log)
+			}
+			for _, secret := range []string{dir, "sensitive-input", "sensitive-output", "private-user", "private-password", "private-replacement", "example.test", "private_sql_payload", "PRIVATE_SQL_PAYLOAD", "--search-replace"} {
+				if strings.Contains(log, secret) {
+					t.Errorf("diagnostics expose %q: %q", secret, log)
+				}
+			}
+		})
+	}
+}

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

@@ -1,6 +1,7 @@
 package commands
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -58,6 +59,9 @@ func GetConfig() Config { return pkgConfig }
 const meQuery = `{"operationName":"Me","query":"query Me {\n  me {\n    id\n    displayName\n    isVIP\n  }\n}"}`
 
 type WhoamiDeps struct {
+	// Context carries invocation-scoped diagnostics and cancellation. Nil uses
+	// context.Background for callers predating command context propagation.
+	Context context.Context
 	APIHost string
 	Token   string
 	Client  *gql.Client
@@ -65,6 +69,9 @@ type WhoamiDeps struct {
 }
 
 func RunWhoami(deps WhoamiDeps) error {
+	if deps.Context == nil {
+		deps.Context = context.Background()
+	}
 	if deps.Stdout == nil {
 		deps.Stdout = os.Stdout
 	}
@@ -75,7 +82,7 @@ func RunWhoami(deps WhoamiDeps) error {
 			Middleware: pkgConfig.Middleware,
 		})
 	}
-	req, err := http.NewRequest("POST", deps.APIHost+"/graphql", strings.NewReader(meQuery))
+	req, err := http.NewRequestWithContext(deps.Context, "POST", deps.APIHost+"/graphql", strings.NewReader(meQuery))
 	if err != nil {
 		return err
 	}
@@ -137,8 +144,10 @@ func NewWhoamiCmd() *cobra.Command {
 				host = defaultAPIHost()
 			}
 			return RunWhoami(WhoamiDeps{
+				Context: cmd.Context(),
 				APIHost: host,
 				Token:   pkgConfig.Token,
+				Stdout:  cmd.OutOrStdout(),
 			})
 		},
 	}

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

@@ -0,0 +1,79 @@
+package commands
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/Automattic/vip/internal/debuglog"
+)
+
+func TestWhoamiCommandHTTPDebug(t *testing.T) {
+	t.Setenv("VIP_PROXY", "")
+	t.Setenv("WPVIP_DEPLOY_TOKEN", "")
+	previous := GetConfig()
+	t.Cleanup(func() { SetConfig(previous) })
+
+	for _, tc := range []struct {
+		name       string
+		namespaces string
+		wantDebug  bool
+	}{
+		{name: "enabled", namespaces: "@automattic/vip:http", wantDebug: true},
+		{name: "disabled"},
+		{name: "excluded", namespaces: "*,-@automattic/vip:http"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			const token = "whoami-test-bearer-secret"
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodPost || r.URL.Path != "/graphql" {
+					t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
+				}
+				if got := r.Header.Get("Authorization"); got != "Bearer "+token {
+					t.Error("request did not retain the configured bearer token")
+				}
+				body, err := io.ReadAll(r.Body)
+				if err != nil {
+					t.Errorf("read request: %v", err)
+				}
+				if string(body) != `{"operationName":"Me","query":"query Me {\n  me {\n    id\n    displayName\n    isVIP\n  }\n}"}` {
+					t.Errorf("unexpected request body: %s", body)
+				}
+				w.Header().Set("Content-Type", "application/json")
+				_, _ = io.WriteString(w, `{"data":{"me":{"id":42,"displayName":"private-user@example.test","isVIP":true}}}`)
+			}))
+			defer srv.Close()
+			SetConfig(Config{APIHost: srv.URL, Token: token})
+
+			var stdout, stderr bytes.Buffer
+			cmd := NewWhoamiCmd()
+			cmd.SetArgs(nil)
+			cmd.SetOut(&stdout)
+			cmd.SetErr(&stderr)
+			ctx := debuglog.WithLogger(context.Background(), tc.namespaces, &stderr)
+			if err := cmd.ExecuteContext(ctx); err != nil {
+				t.Fatalf("execute whoami: %v", err)
+			}
+			wantDebug := ""
+			if tc.wantDebug {
+				wantDebug = "@automattic/vip:http running fetch " + srv.URL + "/graphql\n"
+			}
+			if got := stderr.String(); got != wantDebug {
+				t.Errorf("diagnostics = %q, want %q", got, wantDebug)
+			}
+			const wantOutput = "- Howdy private-user@example.test!\n- Your user ID is 42\n- Your account has VIP Staff permissions\n"
+			if got := stdout.String(); got != wantOutput {
+				t.Errorf("stdout = %q, want %q", got, wantOutput)
+			}
+			for _, secret := range []string{token, "private-user@example.test", "displayName", "query Me", "Authorization"} {
+				if strings.Contains(stderr.String(), secret) {
+					t.Errorf("diagnostics exposed %q", secret)
+				}
+			}
+		})
+	}
+}

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

@@ -16,6 +16,7 @@ import (
 	"golang.org/x/term"
 
 	"github.com/Automattic/vip/internal/appctx"
+	"github.com/Automattic/vip/internal/debuglog"
 	"github.com/Automattic/vip/internal/exit"
 	"github.com/Automattic/vip/internal/gql"
 	"github.com/Automattic/vip/internal/output"
@@ -161,6 +162,7 @@ func dispatchWP(cmd *cobra.Command, ae *appctx.AppEnv, info *wpEnvInfo, args []s
 		Id:            &ae.App.ID,
 		EnvironmentId: &ae.Env.ID,
 	}
+	debuglog.Printf(cmd.Context(), "@automattic/vip:wp/ssh", "Requesting SSH authentication")
 	triggerCtx := gql.WithAllowGQLErrors(cmd.Context())
 	resp, err := gql.TriggerWPCLICommand(triggerCtx, cfg.GQLClient, triggerInput)
 	if err != nil {

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

@@ -0,0 +1,32 @@
+package commands
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/Automattic/vip/internal/debuglog"
+)
+
+func TestWPSSHAuthenticationDiagnosticsExcludeCommand(t *testing.T) {
+	stub := &wpStub{body: wpEnvInfoBodyWithStrategy(2, "ssh", "develop"), triggerBody: `{"data":null,"errors":[{"message":"secret-api-error"}]}`}
+	setupWPTest(t, stub)
+	cmd := WPCmd()
+	var stdout, diagnostics bytes.Buffer
+	cmd.SetOut(&stdout)
+	cmd.SetErr(&diagnostics)
+	cmd.SetContext(debuglog.WithLogger(wpCtx(42, 7, 2, "develop"), "@automattic/vip:wp/ssh", &diagnostics))
+	err := runWP(cmd, []string{"user", "update", "secret-user", "--user_pass=secret-password", "--debug"})
+	if err == nil {
+		t.Fatal("expected trigger error")
+	}
+	if !strings.Contains(diagnostics.String(), "Requesting SSH authentication") {
+		t.Fatalf("missing stage: %q", diagnostics.String())
+	}
+	if strings.Contains(diagnostics.String(), "secret-") || strings.Contains(diagnostics.String(), "--debug") {
+		t.Fatalf("private command or API data in diagnostics: %q", diagnostics.String())
+	}
+	if !strings.Contains(stdout.String(), "secret-api-error") {
+		t.Fatal("existing error output changed")
+	}
+}

package/cmd/vip-next/debug_args.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// Normalize debug's optional value before command discovery: otherwise Cobra
+// can mistake a separated namespace for a subcommand. Stop at raw passthrough
+// commands and --, and never consume the value of another flag.
+func normalizeDebugValues(root *cobra.Command, argv []string) []string {
+	target := root
+	out := make([]string, 0, len(argv))
+	child := func(name string) *cobra.Command {
+		for _, c := range target.Commands() {
+			if c.Name() == name || c.HasAlias(name) {
+				return c
+			}
+		}
+		return nil
+	}
+	for i := 0; i < len(argv); i++ {
+		arg := argv[i]
+		if arg == "--" {
+			return append(out, argv[i:]...)
+		}
+		if arg == "--debug" || arg == "-d" {
+			if i+1 < len(argv) && (argv[i+1] == "-" || !strings.HasPrefix(argv[i+1], "-")) && child(argv[i+1]) == nil {
+				i++
+				arg += "=" + argv[i]
+			}
+			out = append(out, arg)
+			continue
+		}
+		out = append(out, arg)
+		if !strings.HasPrefix(arg, "-") {
+			if c := child(arg); c != nil {
+				target = c
+				if c.DisableFlagParsing {
+					return append(out, argv[i+1:]...)
+				}
+			}
+			continue
+		}
+		if strings.Contains(arg, "=") {
+			continue
+		}
+		flags := target.Flags()
+		flags.AddFlagSet(target.InheritedFlags())
+		flags.AddFlagSet(target.PersistentFlags())
+		name := strings.TrimPrefix(arg, "--")
+		flag := flags.Lookup(name)
+		if len(arg) == 2 {
+			flag = flags.ShorthandLookup(arg[1:])
+		}
+		if flag != nil && flag.NoOptDefVal == "" && i+1 < len(argv) {
+			i++
+			out = append(out, argv[i])
+		}
+	}
+	return out
+}

package/cmd/vip-next/debug_test.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/Automattic/vip/cmd/vip-next/commands"
+	"github.com/Automattic/vip/internal/debuglog"
+	"github.com/spf13/cobra"
+)
+
+func TestDebugEnablesDiagnosticsOnStderr(t *testing.T) {
+	for _, tc := range []struct {
+		name    string
+		args    []string
+		env     string
+		enabled bool
+	}{
+		{"default", nil, "", false},
+		{"short", []string{"-d"}, "", true},
+		{"long", []string{"--debug"}, "", true},
+		{"equals", []string{"-d=@automattic/vip:http"}, "", true},
+		{"separate", []string{"--debug", "@automattic/vip:http"}, "", true},
+		{"separate nonmatching", []string{"--debug", "unrelated"}, "", false},
+		{"excluded", []string{"--debug=*,-@automattic/vip:http"}, "", false},
+		{"environment", nil, "@automattic/vip:*", true},
+		{"flag overrides environment", []string{"--debug=other"}, "*", false},
+		{"empty flag keeps environment", []string{"--debug="}, "*", true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("DEBUG", tc.env)
+			var stdout, stderr bytes.Buffer
+			root := newRootBase(&rootContext{})
+			root.SetOut(&stdout)
+			root.SetErr(&stderr)
+			root.AddCommand(&cobra.Command{Use: "probe", RunE: func(cmd *cobra.Command, args []string) error {
+				if len(args) != 0 {
+					t.Fatalf("namespace leaked into positional arguments: %q", args)
+				}
+				debuglog.Printf(cmd.Context(), "@automattic/vip:http", "running fetch")
+				_, err := fmt.Fprintln(cmd.OutOrStdout(), `{"ok":true}`)
+				return err
+			}})
+			root.SetArgs(prepareArgs(root, append([]string{"probe"}, tc.args...)))
+			if err := root.Execute(); err != nil {
+				t.Fatal(err)
+			}
+			if stdout.String() != "{\"ok\":true}\n" {
+				t.Fatalf("stdout polluted: %q", stdout.String())
+			}
+			if got := strings.Contains(stderr.String(), "running fetch"); got != tc.enabled {
+				t.Fatalf("diagnostics enabled=%v, want %v; stderr=%q", got, tc.enabled, stderr.String())
+			}
+		})
+	}
+}
+
+func TestWPDebugBeforeCommandPreservesPassthrough(t *testing.T) {
+	for _, tc := range []struct {
+		args    []string
+		want    []string
+		enabled bool
+	}{
+		{[]string{"-d", "wp", "option", "get", "secret", "--debug"}, []string{"option", "get", "secret", "--debug"}, true},
+		{[]string{"--debug=@automattic/vip:wp", "wp", "--", "--debug"}, []string{"--", "--debug"}, true},
+		{[]string{"--debug", "@automattic/vip:wp", "wp", "option", "get"}, []string{"option", "get"}, true},
+		{[]string{"--debug", "@automattic/vip:wp", "--", "wp", "user", "list"}, []string{"user", "list"}, true},
+		{[]string{"--debug", "@automattic/vip:wp", "--yes", "wp", "user", "list"}, []string{"user", "list"}, true},
+		{[]string{"wp", "--debug"}, []string{"--debug"}, false},
+	} {
+		t.Run(strings.Join(tc.args, " "), func(t *testing.T) {
+			t.Setenv("DEBUG", "")
+			var stderr bytes.Buffer
+			root := newRootBase(&rootContext{})
+			root.SetErr(&stderr)
+			wp := commands.WPCmd()
+			wp.RunE = func(cmd *cobra.Command, args []string) error {
+				if strings.Join(args, "|") != strings.Join(tc.want, "|") {
+					t.Fatalf("passthrough changed: %q", args)
+				}
+				debuglog.Printf(cmd.Context(), "@automattic/vip:wp", "connect")
+				return nil
+			}
+			root.AddCommand(wp)
+			normalized, _ := normalizeWPArgs(tc.args)
+			root.SetArgs(prepareArgs(root, normalized))
+			if err := root.Execute(); err != nil {
+				t.Fatal(err)
+			}
+			if (stderr.Len() > 0) != tc.enabled {
+				t.Fatalf("debug output=%q, enabled=%v", stderr.String(), tc.enabled)
+			}
+		})
+	}
+}
+
+func TestDebugSelectorPositions(t *testing.T) {
+	for _, argv := range [][]string{
+		{"--debug", "selected", "parent", "leaf"},
+		{"parent", "-d", "selected", "leaf"},
+		{"parent", "leaf", "--debug", "selected"},
+	} {
+		t.Run(strings.Join(argv, " "), func(t *testing.T) {
+			root := newRootBase(&rootContext{})
+			parent := &cobra.Command{Use: "parent"}
+			parent.AddCommand(&cobra.Command{Use: "leaf", RunE: func(cmd *cobra.Command, args []string) error {
+				selector, _ := cmd.Flags().GetString("debug")
+				if selector != "selected" || len(args) != 0 {
+					t.Fatalf("selector=%q args=%q", selector, args)
+				}
+				return nil
+			}})
+			root.AddCommand(parent)
+			root.SetArgs(prepareArgs(root, argv))
+			if err := root.Execute(); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}

package/cmd/vip-next/main.go

@@ -11,6 +11,7 @@
 package main
 
 import (
+	"context"
 	"errors"
 	"log/slog"
 	"os"
@@ -22,6 +23,7 @@ import (
 	"github.com/Automattic/vip/cmd/vip-next/commands"
 	"github.com/Automattic/vip/internal/appctx"
 	"github.com/Automattic/vip/internal/auth"
+	"github.com/Automattic/vip/internal/debuglog"
 	"github.com/Automattic/vip/internal/envalias"
 	"github.com/Automattic/vip/internal/exit"
 	"github.com/Automattic/vip/internal/gql"
@@ -82,6 +84,9 @@ func cliErrorHook(tracker *telemetry.Tracker) func(error) {
 }
 
 func runWithDeps(argv []string, deps runDeps) error {
+	// As in Node, DEBUG applies during login bootstrap; command flags take
+	// precedence once the command parser installs its invocation context.
+	deps.Tracker.SetContext(debuglog.WithLogger(context.Background(), os.Getenv("DEBUG"), os.Stderr))
 	rewritten, app, env, err := envalias.Rewrite(argv)
 	if err != nil {
 		return err
@@ -117,7 +122,7 @@ func runWithDeps(argv []string, deps runDeps) error {
 
 	var rootRef *cobra.Command
 	executeRoot := func() error {
-		rc := &rootContext{aliasApp: app, aliasEnv: env}
+		rc := &rootContext{aliasApp: app, aliasEnv: env, tracker: deps.Tracker}
 		rootRef = newRootCmd(rc)
 		rootRef.SetArgs(prepareArgs(rootRef, rewritten))
 		finish := installUpdateNotifier(rootRef, deps.StartUpdateNotice)
@@ -134,6 +139,7 @@ func runWithDeps(argv []string, deps runDeps) error {
 	apiHost := defaultAPIHost()
 	k := deps.NewKeychain(apiHost)
 	store := auth.NewStore(k)
+	deps.Tracker.SetPendoTokenSource(store.Load)
 	if !auth.ShouldBypassAuth(argv) {
 		return withAuthenticatedSession(!isNonInteractiveArgv(argv), authBootstrapDeps{
 			Keychain: k,
@@ -256,9 +262,54 @@ func defaultAPIHost() string {
 // its omitted-value default and drop the "n" on the floor, inverting Node,
 // where "n" DISABLES the service. See internal/nodeflags.
 func prepareArgs(root *cobra.Command, argv []string) []string {
+	argv = normalizeDebugValues(root, argv)
+	argv = prepareWPDebugArgs(root, argv)
 	return nodeflags.NormalizeOptionalValues(root, argv)
 }
 
+// WP-CLI owns every token after "wp". Cobra disables parsing for that command,
+// including flags before it, so consume only VIP's leading debug selector here.
+func prepareWPDebugArgs(root *cobra.Command, argv []string) []string {
+	var kept []string
+	selector := ""
+	found := false
+	for i := 0; i < len(argv); i++ {
+		tok := argv[i]
+		if tok == "wp" {
+			if !found {
+				return argv
+			}
+			_ = root.PersistentFlags().Set("debug", selector)
+			return append(kept, argv[i:]...)
+		}
+		if tok == "--" || !strings.HasPrefix(tok, "-") {
+			return argv
+		}
+		if tok == "-d" || tok == "--debug" {
+			selector, found = "*", true
+			if i+1 < len(argv) && argv[i+1] != "wp" && !strings.HasPrefix(argv[i+1], "-") {
+				i++
+				selector = argv[i]
+			}
+			continue
+		}
+		if strings.HasPrefix(tok, "--debug=") || strings.HasPrefix(tok, "-d=") {
+			_, selector, _ = strings.Cut(tok, "=")
+			found = true
+			continue
+		}
+		kept = append(kept, tok)
+		// Skip values of other leading global flags without changing them.
+		if tok == "--app" || tok == "--env" {
+			if i+1 < len(argv) {
+				i++
+				kept = append(kept, argv[i])
+			}
+		}
+	}
+	return argv
+}
+
 // normalizeWPArgs reshapes a post-envalias argv so cobra can route the
 // `vip wp` command. wp is special: everything after the `wp` token is a
 // raw WP-CLI command (with its own flags) that the wp command passes
@@ -276,7 +327,12 @@ func prepareArgs(root *cobra.Command, argv []string) []string {
 // non-"--" token is "wp"). Everything else passes through untouched.
 func normalizeWPArgs(argv []string) (out []string, yes bool) {
 	cmdIdx := -1
-	for i, tok := range argv {
+	for i := 0; i < len(argv); i++ {
+		tok := argv[i]
+		if (tok == "--debug" || tok == "-d") && i+1 < len(argv) && argv[i+1] != "wp" && !strings.HasPrefix(argv[i+1], "-") {
+			i++ // A separated debug namespace is not the command name.
+			continue
+		}
 		if tok == "--" || strings.HasPrefix(tok, "-") {
 			continue
 		}