@automattic/vip 4.1.4 → 4.1.6

package/cmd/vip-next/auth_bootstrap_test.go

@@ -1,379 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-
-	json "encoding/json/v2"
-
-	"github.com/Automattic/vip/internal/auth"
-	"github.com/Automattic/vip/internal/keychain"
-)
-
-type bootstrapBackend struct {
-	secrets map[string]string
-	getErr  error
-}
-
-func (b *bootstrapBackend) Set(service, user, secret string) error {
-	if b.secrets == nil {
-		b.secrets = make(map[string]string)
-	}
-	b.secrets[service+"\x00"+user] = secret
-	return nil
-}
-
-func (b *bootstrapBackend) Get(service, user string) (string, error) {
-	if b.getErr != nil {
-		return "", b.getErr
-	}
-	secret, ok := b.secrets[service+"\x00"+user]
-	if !ok {
-		return "", keychain.ErrNotFound
-	}
-	return secret, nil
-}
-
-func (b *bootstrapBackend) Delete(service, user string) error {
-	key := service + "\x00" + user
-	if _, ok := b.secrets[key]; !ok {
-		return keychain.ErrNotFound
-	}
-	delete(b.secrets, key)
-	return nil
-}
-
-func newBootstrapKeychain(backend *bootstrapBackend) *keychain.Keychain {
-	return &keychain.Keychain{
-		Backend:       backend,
-		Service:       "vip-next-bootstrap-test",
-		LegacyService: "vip-go-cli-bootstrap-test",
-	}
-}
-
-func validBootstrapRaw(t *testing.T, id int64) string {
-	t.Helper()
-	header, err := json.Marshal(map[string]any{"alg": "none", "typ": "JWT"})
-	if err != nil {
-		t.Fatalf("marshal JWT header: %v", err)
-	}
-	claims, err := json.Marshal(map[string]any{
-		"id":  id,
-		"iat": time.Now().Add(-time.Minute).Unix(),
-		"exp": time.Now().Add(time.Hour).Unix(),
-	})
-	if err != nil {
-		t.Fatalf("marshal JWT claims: %v", err)
-	}
-	enc := base64.RawURLEncoding
-	return enc.EncodeToString(header) + "." + enc.EncodeToString(claims) + "."
-}
-
-func parsedBootstrapToken(t *testing.T, raw string) *auth.Token {
-	t.Helper()
-	tok, err := auth.ParseToken(raw)
-	if err != nil {
-		t.Fatalf("parse token: %v", err)
-	}
-	return tok
-}
-
-func TestWithAuthenticatedSessionUsesValidStoredToken(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	backend := &bootstrapBackend{}
-	k := newBootstrapKeychain(backend)
-	store := auth.NewStore(k)
-	raw := validBootstrapRaw(t, 10000)
-	if err := store.Save(raw); err != nil {
-		t.Fatalf("save token: %v", err)
-	}
-	loginCalls := 0
-	nextCalls := 0
-
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    store,
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return nil, errors.New("login should not run")
-		},
-	}, func(session *authSession) error {
-		nextCalls++
-		if session.Raw != raw || session.Keychain != k || session.Store != store {
-			t.Fatalf("session = %#v, want stored-token dependencies", session)
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if loginCalls != 0 || nextCalls != 1 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 0, 1", loginCalls, nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionUsesLegacyTokenWhenPrimaryMissing(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	backend := &bootstrapBackend{}
-	k := newBootstrapKeychain(backend)
-	raw := validBootstrapRaw(t, 10000)
-	if err := backend.Set(k.LegacyService, k.LegacyService, raw); err != nil {
-		t.Fatalf("seed legacy token: %v", err)
-	}
-	loginCalls := 0
-
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return nil, errors.New("login should not run")
-		},
-	}, func(session *authSession) error {
-		if session.Raw != raw {
-			t.Fatalf("session token = %q, want legacy token", session.Raw)
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if loginCalls != 0 {
-		t.Fatalf("login calls = %d, want 0", loginCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionLogsInWhenMissingAndResumes(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	backend := &bootstrapBackend{}
-	k := newBootstrapKeychain(backend)
-	store := auth.NewStore(k)
-	freshRaw := validBootstrapRaw(t, 10000)
-	loginCalls := 0
-	nextCalls := 0
-
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    store,
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return parsedBootstrapToken(t, freshRaw), nil
-		},
-	}, func(session *authSession) error {
-		nextCalls++
-		if session.Raw != freshRaw {
-			t.Fatalf("continuation token = %q, want freshly returned token", session.Raw)
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if loginCalls != 1 || nextCalls != 1 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 1, 1", loginCalls, nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionRefreshesInvalidTokenAndResumes(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	backend := &bootstrapBackend{}
-	k := newBootstrapKeychain(backend)
-	store := auth.NewStore(k)
-	if err := store.Save("invalid-stored-token"); err != nil {
-		t.Fatalf("save invalid token: %v", err)
-	}
-	freshRaw := validBootstrapRaw(t, 10000)
-	loginCalls := 0
-	nextCalls := 0
-
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    store,
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return parsedBootstrapToken(t, freshRaw), nil
-		},
-	}, func(session *authSession) error {
-		nextCalls++
-		if session.Raw != freshRaw {
-			t.Fatalf("continuation token = %q, want freshly returned token", session.Raw)
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if loginCalls != 1 || nextCalls != 1 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 1, 1", loginCalls, nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionStopsCleanlyOnCancel(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	k := newBootstrapKeychain(&bootstrapBackend{})
-	nextCalls := 0
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login:    func() (*auth.Token, error) { return nil, auth.ErrLoginCancelled },
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if nextCalls != 0 {
-		t.Fatalf("continuation calls = %d, want 0", nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionStopsCleanlyOnHandledValidationError(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	k := newBootstrapKeychain(&bootstrapBackend{})
-	nextCalls := 0
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login:    func() (*auth.Token, error) { return nil, fmt.Errorf("wrapped: %w", auth.ErrTokenInvalid) },
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("withAuthenticatedSession: %v", err)
-	}
-	if nextCalls != 0 {
-		t.Fatalf("continuation calls = %d, want 0", nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionSurfacesUnexpectedLoginError(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	k := newBootstrapKeychain(&bootstrapBackend{})
-	want := errors.New("browser exploded")
-	nextCalls := 0
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login:    func() (*auth.Token, error) { return nil, want },
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if !errors.Is(err, want) {
-		t.Fatalf("error = %v, want %v", err, want)
-	}
-	if nextCalls != 0 {
-		t.Fatalf("continuation calls = %d, want 0", nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionNonInteractiveMissingFailsWithoutLogin(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	k := newBootstrapKeychain(&bootstrapBackend{})
-	loginCalls := 0
-	nextCalls := 0
-	err := withAuthenticatedSession(false, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return nil, nil
-		},
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if err == nil || !strings.Contains(err.Error(), "not logged in") {
-		t.Fatalf("error = %v, want not-logged-in error", err)
-	}
-	if loginCalls != 0 || nextCalls != 0 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 0, 0", loginCalls, nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionNonInteractiveInvalidFailsWithoutLogin(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	backend := &bootstrapBackend{}
-	k := newBootstrapKeychain(backend)
-	store := auth.NewStore(k)
-	if err := store.Save("invalid-stored-token"); err != nil {
-		t.Fatalf("save invalid token: %v", err)
-	}
-	loginCalls := 0
-	nextCalls := 0
-	err := withAuthenticatedSession(false, authBootstrapDeps{
-		Keychain: k,
-		Store:    store,
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return nil, nil
-		},
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if err == nil || !strings.Contains(err.Error(), "invalid or expired") {
-		t.Fatalf("error = %v, want invalid-token error", err)
-	}
-	if loginCalls != 0 || nextCalls != 0 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 0, 0", loginCalls, nextCalls)
-	}
-}
-
-func TestWithAuthenticatedSessionSurfacesKeychainLoadError(t *testing.T) {
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	want := errors.New("keychain unavailable")
-	k := newBootstrapKeychain(&bootstrapBackend{getErr: want})
-	loginCalls := 0
-	nextCalls := 0
-	err := withAuthenticatedSession(true, authBootstrapDeps{
-		Keychain: k,
-		Store:    auth.NewStore(k),
-		Login: func() (*auth.Token, error) {
-			loginCalls++
-			return nil, nil
-		},
-	}, func(*authSession) error {
-		nextCalls++
-		return nil
-	})
-	if !errors.Is(err, want) {
-		t.Fatalf("error = %v, want %v", err, want)
-	}
-	if loginCalls != 0 || nextCalls != 0 {
-		t.Fatalf("login calls = %d, continuation calls = %d; want 0, 0", loginCalls, nextCalls)
-	}
-}
-
-func TestIsNonInteractiveArgvBoundaries(t *testing.T) {
-	tests := []struct {
-		argv []string
-		want bool
-	}{
-		{[]string{"--non-interactive", "app", "list"}, true},
-		{[]string{"app", "list", "--non-interactive"}, true},
-		{[]string{"--non-interactive=true", "whoami"}, true},
-		{[]string{"--non-interactive=false", "whoami"}, false},
-		{[]string{"--", "--non-interactive"}, false},
-		{[]string{"wp", "option", "get", "home", "--non-interactive"}, false},
-		{[]string{"@app.env", "wp", "--non-interactive"}, false},
-		{[]string{"--non-interactive", "@app.env", "wp", "option", "get", "home"}, true},
-		{[]string{"--app", "wp", "app", "list", "--non-interactive"}, true},
-		{[]string{"app", "list", "--env", "wp", "--non-interactive"}, true},
-		{[]string{"app", "list", "--non-interactive=false", "--non-interactive"}, true},
-		{[]string{"--non-interactive=invalid", "whoami"}, true},
-	}
-	for _, tt := range tests {
-		t.Run(strings.Join(tt.argv, " "), func(t *testing.T) {
-			if got := isNonInteractiveArgv(tt.argv); got != tt.want {
-				t.Fatalf("isNonInteractiveArgv(%q) = %v, want %v", tt.argv, got, tt.want)
-			}
-		})
-	}
-}

package/cmd/vip-next/auth_bypass_wiring_test.go

@@ -1,162 +0,0 @@
-package main
-
-import (
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync"
-	"testing"
-
-	"github.com/Automattic/vip/internal/auth"
-	"github.com/Automattic/vip/internal/keychain"
-	"github.com/Automattic/vip/internal/telemetry"
-)
-
-// gqlOpRecorder is a GraphQL stub that dispatches on the operationName in the
-// request body and records which operations were asked for. It is deliberately
-// dumb: the responses are the minimum genqlient will unmarshal.
-type gqlOpRecorder struct {
-	mu   sync.Mutex
-	ops  []string
-	auth []string
-}
-
-func (r *gqlOpRecorder) server(t *testing.T, bodies map[string]string) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		raw, _ := io.ReadAll(req.Body)
-		op := ""
-		for name := range bodies {
-			if strings.Contains(string(raw), `"operationName":"`+name+`"`) {
-				op = name
-				break
-			}
-		}
-		r.mu.Lock()
-		r.ops = append(r.ops, op)
-		r.auth = append(r.auth, req.Header.Get("Authorization"))
-		r.mu.Unlock()
-		w.Header().Set("Content-Type", "application/json")
-		if op == "" {
-			w.WriteHeader(http.StatusInternalServerError)
-			_, _ = w.Write([]byte(`{"errors":[{"message":"unexpected operation: ` + string(raw) + `"}]}`))
-			return
-		}
-		_, _ = w.Write([]byte(bodies[op]))
-	}))
-}
-
-func (r *gqlOpRecorder) saw(op string) bool {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	for _, seen := range r.ops {
-		if seen == op {
-			return true
-		}
-	}
-	return false
-}
-
-const (
-	resolveAppByNameBody = `{"data":{"apps":{"edges":[{"id":1,"name":"example","type":"WordPress","typeId":2,` +
-		`"environments":[{"id":2,"appId":1,"name":"develop","type":"develop","uniqueLabel":"example-develop",` +
-		`"defaultDomain":"example-develop.go-vip.net","isMultisite":false}]}]}}}`
-	envVarsWithValuesBody = `{"data":{"app":{"id":1,"environments":[{"id":2,"environmentVariables":` +
-		`{"total":1,"nodes":[{"name":"HELP","value":"not-a-bypass"}]}}]}}}`
-)
-
-// TestBypassedArgvStillReachesTheAPI reproduces register item 2.13.
-//
-// Node's src/bin/vip.js decides only ONE thing with its argv scan: whether to
-// run the interactive login flow. When it skips it, runCmd() still has full API
-// access, because src/lib/api/http.ts loads the token from the keychain on every
-// request. vip-next conflated "skip login" with "skip API setup": a bypassed
-// argv got a commands.Config with no GQLClient, so any command whose argv merely
-// CONTAINED a bypass word ("help", "login", "logout", "-v", ...) died with
-// "appctx: GraphQL client not configured".
-//
-// `config envvar get help` is one of the three invocations the parity review
-// verified as broken. A stored, valid token exists here, so Node would have run
-// the command against the API — and so must vip-next.
-func TestBypassedArgvStillReachesTheAPI(t *testing.T) {
-	t.Setenv("DO_NOT_TRACK", "1")
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	t.Setenv("WPVIP_DEPLOY_TOKEN", "")
-
-	rec := &gqlOpRecorder{}
-	srv := rec.server(t, map[string]string{
-		"ResolveAppByName":                  resolveAppByNameBody,
-		"GetEnvironmentVariablesWithValues": envVarsWithValuesBody,
-	})
-	defer srv.Close()
-	t.Setenv("API_HOST", srv.URL)
-
-	raw := validBootstrapRaw(t, 10000)
-	backend := &bootstrapBackend{}
-	testKeychain := newBootstrapKeychain(backend)
-	if err := auth.NewStore(testKeychain).Save(raw); err != nil {
-		t.Fatalf("seed token: %v", err)
-	}
-
-	loginCalls := 0
-	err := runWithDeps(
-		[]string{"config", "envvar", "get", "help", "--app", "example", "--env", "develop"},
-		runDeps{
-			Tracker:     &telemetry.Tracker{Disabled: true},
-			NewKeychain: func(string) *keychain.Keychain { return testKeychain },
-			NewLogin: func(*auth.Store) func() (*auth.Token, error) {
-				return func() (*auth.Token, error) {
-					loginCalls++
-					return nil, auth.ErrLoginCancelled
-				}
-			},
-		})
-	if err != nil {
-		t.Fatalf("`config envvar get help` must run like any other command; got %v", err)
-	}
-	if loginCalls != 0 {
-		t.Fatalf("login flow ran %d times; a valid stored token must never trigger it", loginCalls)
-	}
-	if !rec.saw("ResolveAppByName") {
-		t.Errorf("app was never resolved — the GraphQL client was not configured (ops=%v)", rec.ops)
-	}
-	if !rec.saw("GetEnvironmentVariablesWithValues") {
-		t.Errorf("the envvar query never ran (ops=%v)", rec.ops)
-	}
-	for _, got := range rec.auth {
-		if got != "Bearer "+raw {
-			t.Errorf("Authorization = %q, want the stored token", got)
-		}
-	}
-}
-
-// TestHelpWithoutStoredTokenStillSkipsLogin pins the half of Node's rule that
-// must NOT regress: --help with an empty keychain prints help and never opens a
-// login prompt (vip.js:204-212, isHelpCommand short-circuits the login branch).
-func TestHelpWithoutStoredTokenStillSkipsLogin(t *testing.T) {
-	t.Setenv("DO_NOT_TRACK", "1")
-	t.Setenv("VIP_TOKEN_OVERRIDE", "")
-	t.Setenv("WPVIP_DEPLOY_TOKEN", "")
-	t.Setenv("API_HOST", "http://127.0.0.1:1")
-
-	backend := &bootstrapBackend{}
-	testKeychain := newBootstrapKeychain(backend)
-	loginCalls := 0
-	err := runWithDeps([]string{"--help"}, runDeps{
-		Tracker:     &telemetry.Tracker{Disabled: true},
-		NewKeychain: func(string) *keychain.Keychain { return testKeychain },
-		NewLogin: func(*auth.Store) func() (*auth.Token, error) {
-			return func() (*auth.Token, error) {
-				loginCalls++
-				return nil, auth.ErrLoginCancelled
-			}
-		},
-	})
-	if err != nil {
-		t.Fatalf("--help must exit 0 without a token; got %v", err)
-	}
-	if loginCalls != 0 {
-		t.Fatalf("--help triggered the login flow %d times", loginCalls)
-	}
-}

package/cmd/vip-next/cli_error_hook_test.go

@@ -1,91 +0,0 @@
-package main
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/telemetry"
-)
-
-type capturingClient struct {
-	events []capturedEvent
-}
-
-type capturedEvent struct {
-	name  string
-	props map[string]any
-}
-
-func (c *capturingClient) TrackEvent(name string, props map[string]any) error {
-	c.events = append(c.events, capturedEvent{name: name, props: props})
-	return nil
-}
-
-// TestCLIErrorHookScrubsThePayload is the end-to-end assertion for the one
-// telemetry event vip-next sends that Node has no counterpart for.
-//
-// exit.RegisterErrorHook fires on every non-zero exit, and the hook posts the
-// error text to public-api.wordpress.com. Before this change it sent
-// err.Error() verbatim, so an ordinary "open <path>: permission denied" carried
-// the user's home directory — account name and all — plus, on a failed
-// presigned download, a live credential.
-func TestCLIErrorHookScrubsThePayload(t *testing.T) {
-	t.Setenv("DO_NOT_TRACK", "")
-	t.Setenv("GO_ENV", "")
-	t.Setenv("NODE_ENV", "")
-
-	home, err := os.UserHomeDir()
-	if err != nil {
-		t.Skipf("no home directory available: %v", err)
-	}
-	secretPath := filepath.Join(home, "clients", "acme-corp", "db.sql")
-
-	client := &capturingClient{}
-	tracker := &telemetry.Tracker{Clients: []telemetry.Client{client}}
-
-	hook := cliErrorHook(tracker)
-	hook(errors.New("open " + secretPath + ": permission denied"))
-
-	if len(client.events) != 1 {
-		t.Fatalf("got %d events, want 1", len(client.events))
-	}
-	ev := client.events[0]
-	if ev.name != "cli_error" {
-		t.Errorf("event name = %q, want cli_error", ev.name)
-	}
-	text, _ := ev.props["error"].(string)
-	if strings.Contains(text, home) {
-		t.Errorf("cli_error payload carries the home directory off-box:\n\t%s", text)
-	}
-	if !strings.Contains(text, "permission denied") {
-		t.Errorf("cli_error payload lost the diagnostic part:\n\t%s", text)
-	}
-}
-
-// TestCLIErrorHookScrubsPresignedCredentials pins the credential case
-// specifically: a failed media-import report download returns a *url.Error
-// carrying the signature query string.
-func TestCLIErrorHookScrubsPresignedCredentials(t *testing.T) {
-	t.Setenv("DO_NOT_TRACK", "")
-	t.Setenv("GO_ENV", "")
-	t.Setenv("NODE_ENV", "")
-
-	client := &capturingClient{}
-	tracker := &telemetry.Tracker{Clients: []telemetry.Client{client}}
-
-	cliErrorHook(tracker)(errors.New(
-		`Get "https://vip.s3.amazonaws.com/report.json?X-Amz-Signature=abc123def456": i/o timeout`))
-
-	if len(client.events) != 1 {
-		t.Fatalf("got %d events, want 1", len(client.events))
-	}
-	text, _ := client.events[0].props["error"].(string)
-	for _, secret := range []string{"X-Amz-Signature", "abc123def456"} {
-		if strings.Contains(text, secret) {
-			t.Errorf("cli_error payload carries %q off-box:\n\t%s", secret, text)
-		}
-	}
-}

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

@@ -1,23 +0,0 @@
-package commands
-
-import "github.com/spf13/cobra"
-
-// AppCmd returns the `vip app` parent command. Subcommands and the wildcard
-// dispatcher are wired in main.go (so the wildcard sees the final subcommand
-// list).
-//
-// --format is registered on the parent because `vip app <name>` dispatches via
-// WithWildcardCommand — cobra parses flags against the matched command
-// (appCmd), so the parent must own --format for RunAppGet to read it.
-func AppCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "app",
-		Short: "Manage VIP Platform applications",
-		Long: "Manage VIP Platform applications.\n\n" +
-			"Run \"vip app list\" to list applications, or \"vip app <name>\" " +
-			"to view information about a specific application and its environments.",
-	}
-	cmd.Flags().StringP("format", "f", "table",
-		"Render output in a particular format. Accepts \"table\" (default), \"csv\", \"json\".")
-	return cmd
-}